Fixed configuration-managed settings remaining active after their configuration plugin was removed (#892)

Co-authored-by: Thorsten Sommer <SommerEngineering@users.noreply.github.com>

app/MindWork AI Studio/Settings/ConfigMeta.cs

@@ -11,7 +11,7 @@ namespace AIStudio.Settings;
 /// <typeparam name="TValue">The type of the configuration property value.</typeparam>
 public record ConfigMeta<TClass, TValue> : ConfigMetaBase
 {
-    public ConfigMeta(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression)
+    public ConfigMeta(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression) : base(SettingsManager.ToSettingName(propertyExpression))
     {
         this.ConfigSelection = configSelection;
         this.PropertyExpression = propertyExpression;
@@ -26,106 +26,17 @@ public record ConfigMeta<TClass, TValue> : ConfigMetaBase
     /// The expression to select the property within the configuration class.
     /// </summary>
     private Expression<Func<TClass, TValue>> PropertyExpression { get; }
-	
-    /// <summary>
-    /// Indicates whether the configuration is locked by a configuration plugin.
-    /// </summary>
-    public bool IsLocked { get; private set; }
 
-    /// <summary>
-    /// The ID of the plugin that locked this configuration.
-    /// </summary>
-    public Guid LockedByConfigPluginId { get; private set; }
-
-    /// <summary>
-    /// How this setting is managed by a configuration plugin, if at all.
-    /// </summary>
-    public ManagedConfigurationMode? ManagedMode { get; private set; }
-
-    /// <summary>
-    /// The ID of the plugin that currently provides an editable default value.
-    /// </summary>
-    public Guid EditableDefaultByConfigPluginId { get; private set; }
-    
     /// <summary>
     /// The default value for the configuration property. This is used when resetting the property to its default state.
     /// </summary>
     public required TValue Default { get; init; }
 
-    /// <summary>
-    /// Indicates whether a plugin contribution is available.
-    /// </summary>
-    public bool HasPluginContribution { get; private set; }
-
     /// <summary>
     /// The additive value contribution provided by a configuration plugin.
     /// </summary>
     public TValue PluginContribution { get; private set; } = default!;
 
-    /// <summary>
-    /// The ID of the plugin that provided the additive value contribution.
-    /// </summary>
-    public Guid PluginContributionByConfigPluginId { get; private set; }
-
-    /// <summary>
-    /// Locks the configuration state, indicating that it is controlled by a specific plugin.
-    /// </summary>
-    /// <param name="pluginId">The ID of the plugin that is locking this configuration.</param>
-    public void LockConfiguration(Guid pluginId)
-    {
-        this.IsLocked = true;
-        this.LockedByConfigPluginId = pluginId;
-        this.ManagedMode = ManagedConfigurationMode.LOCKED;
-        this.EditableDefaultByConfigPluginId = Guid.Empty;
-    }
-    
-    /// <summary>
-    /// Resets the locked state of the configuration, allowing it to be modified again.
-    /// This will also reset the property to its default value.
-    /// </summary>
-    public void ResetLockedConfiguration()
-    {
-        this.IsLocked = false;
-        this.LockedByConfigPluginId = Guid.Empty;
-        if (this.ManagedMode is ManagedConfigurationMode.LOCKED)
-            this.ManagedMode = null;
-
-        this.Reset();
-    }
-
-    /// <summary>
-    /// Unlocks the configuration state without changing the current value.
-    /// </summary>
-    public void UnlockConfiguration()
-    {
-        this.IsLocked = false;
-        this.LockedByConfigPluginId = Guid.Empty;
-        if (this.ManagedMode is ManagedConfigurationMode.LOCKED)
-            this.ManagedMode = null;
-    }
-
-    /// <summary>
-    /// Marks the setting as having an editable default provided by a configuration plugin.
-    /// </summary>
-    public void SetEditableDefaultConfiguration(Guid pluginId)
-    {
-        this.IsLocked = false;
-        this.LockedByConfigPluginId = Guid.Empty;
-        this.ManagedMode = ManagedConfigurationMode.EDITABLE_DEFAULT;
-        this.EditableDefaultByConfigPluginId = pluginId;
-    }
-
-    /// <summary>
-    /// Clears the editable-default state without changing the current value.
-    /// </summary>
-    public void ClearEditableDefaultConfiguration()
-    {
-        if (this.ManagedMode is ManagedConfigurationMode.EDITABLE_DEFAULT)
-            this.ManagedMode = null;
-
-        this.EditableDefaultByConfigPluginId = Guid.Empty;
-    }
-
     /// <summary>
     /// Stores an additive plugin contribution.
     /// </summary>
@@ -136,20 +47,15 @@ public record ConfigMeta<TClass, TValue> : ConfigMetaBase
         this.HasPluginContribution = true;
     }
 
-    /// <summary>
-    /// Clears the additive plugin contribution without changing the current value.
-    /// </summary>
-    public void ClearPluginContribution()
+    /// <inheritdoc/>
+    public override void ClearPluginContribution()
     {
         this.PluginContribution = default!;
-        this.PluginContributionByConfigPluginId = Guid.Empty;
-        this.HasPluginContribution = false;
+        base.ClearPluginContribution();
     }
-    
-    /// <summary>
-    /// Resets the configuration property to its default value.
-    /// </summary>
-    private void Reset()
+
+    /// <inheritdoc/>
+    protected override void Reset()
     {
         var configInstance = this.ConfigSelection.Compile().Invoke(SettingsManagerAccess.ConfigurationData);
         var memberExpression = this.PropertyExpression.GetMemberExpression();

app/MindWork AI Studio/Settings/ConfigMetaBase.cs

@@ -1,6 +1,148 @@
 namespace AIStudio.Settings;
 
-public abstract record ConfigMetaBase : IConfig
+/// <summary>
+/// The type-independent part of the configuration metadata: which configuration plugin manages
+/// the setting, and in which way.
+/// </summary>
+/// <remarks>
+/// The managed state lives here so that it can be processed without knowing the setting's type,
+/// e.g. when cleaning up settings whose configuration plugin was removed.
+/// </remarks>
+public abstract record ConfigMetaBase(string SettingName) : IConfig
 {
     protected static SettingsManager SettingsManagerAccess => Program.SERVICE_PROVIDER.GetRequiredService<SettingsManager>();
+
+    /// <summary>
+    /// The persisted name of the configuration setting.
+    /// </summary>
+    public string SettingName { get; } = SettingName;
+
+    /// <summary>
+    /// Indicates whether the configuration is locked by a configuration plugin.
+    /// </summary>
+    public bool IsLocked { get; private set; }
+
+    /// <summary>
+    /// The ID of the plugin that locked this configuration.
+    /// </summary>
+    public Guid LockedByConfigPluginId { get; private set; }
+
+    /// <summary>
+    /// How this setting is managed by a configuration plugin, if at all.
+    /// </summary>
+    public ManagedConfigurationMode? ManagedMode { get; private set; }
+
+    /// <summary>
+    /// The ID of the plugin that currently provides an editable default value.
+    /// </summary>
+    public Guid EditableDefaultByConfigPluginId { get; private set; }
+
+    /// <summary>
+    /// Indicates whether a plugin contribution is available.
+    /// </summary>
+    public bool HasPluginContribution { get; protected set; }
+
+    /// <summary>
+    /// The ID of the plugin that provided the additive value contribution.
+    /// </summary>
+    public Guid PluginContributionByConfigPluginId { get; protected set; }
+
+    /// <summary>
+    /// Locks the configuration state, indicating that it is controlled by a specific plugin.
+    /// </summary>
+    /// <param name="pluginId">The ID of the plugin that is locking this configuration.</param>
+    public void LockConfiguration(Guid pluginId)
+    {
+        this.IsLocked = true;
+        this.LockedByConfigPluginId = pluginId;
+        this.ManagedMode = ManagedConfigurationMode.LOCKED;
+        this.EditableDefaultByConfigPluginId = Guid.Empty;
+        SettingsManagerAccess.ConfigurationData.ManagedLockedConfigurations[this.SettingName] = pluginId;
+    }
+
+    /// <summary>
+    /// Restores persisted locked configuration metadata after settings were loaded.
+    /// </summary>
+    public void RestoreLockedConfiguration()
+    {
+        if (this.IsLocked || this.ManagedMode is not null)
+            return;
+
+        if (!SettingsManagerAccess.ConfigurationData.ManagedLockedConfigurations.TryGetValue(this.SettingName, out var pluginId) || pluginId == Guid.Empty)
+            return;
+
+        this.IsLocked = true;
+        this.LockedByConfigPluginId = pluginId;
+        this.ManagedMode = ManagedConfigurationMode.LOCKED;
+        this.EditableDefaultByConfigPluginId = Guid.Empty;
+    }
+
+    /// <summary>
+    /// Resets the locked state of the configuration, allowing it to be modified again.
+    /// This will also reset the property to its default value.
+    /// </summary>
+    public void ResetLockedConfiguration()
+    {
+        SettingsManagerAccess.ConfigurationData.ManagedLockedConfigurations.Remove(this.SettingName);
+        
+        this.IsLocked = false;
+        this.LockedByConfigPluginId = Guid.Empty;
+        
+        if (this.ManagedMode is ManagedConfigurationMode.LOCKED)
+            this.ManagedMode = null;
+
+        this.Reset();
+    }
+
+    /// <summary>
+    /// Unlocks the configuration state without changing the current value.
+    /// </summary>
+    public void UnlockConfiguration()
+    {
+        SettingsManagerAccess.ConfigurationData.ManagedLockedConfigurations.Remove(this.SettingName);
+        
+        this.IsLocked = false;
+        this.LockedByConfigPluginId = Guid.Empty;
+        
+        if (this.ManagedMode is ManagedConfigurationMode.LOCKED)
+            this.ManagedMode = null;
+    }
+
+    /// <summary>
+    /// Marks the setting as having an editable default provided by a configuration plugin.
+    /// </summary>
+    public void SetEditableDefaultConfiguration(Guid pluginId)
+    {
+        SettingsManagerAccess.ConfigurationData.ManagedLockedConfigurations.Remove(this.SettingName);
+        
+        this.IsLocked = false;
+        this.LockedByConfigPluginId = Guid.Empty;
+        this.ManagedMode = ManagedConfigurationMode.EDITABLE_DEFAULT;
+        this.EditableDefaultByConfigPluginId = pluginId;
+    }
+
+    /// <summary>
+    /// Clears the editable-default state without changing the current value.
+    /// </summary>
+    public void ClearEditableDefaultConfiguration()
+    {
+        if (this.ManagedMode is ManagedConfigurationMode.EDITABLE_DEFAULT)
+            this.ManagedMode = null;
+
+        this.EditableDefaultByConfigPluginId = Guid.Empty;
+    }
+
+    /// <summary>
+    /// Clears the additive plugin contribution without changing the current value.
+    /// </summary>
+    public virtual void ClearPluginContribution()
+    {
+        this.PluginContributionByConfigPluginId = Guid.Empty;
+        this.HasPluginContribution = false;
+    }
+
+    /// <summary>
+    /// Resets the configuration property to its default value.
+    /// </summary>
+    protected abstract void Reset();
 }

app/MindWork AI Studio/Settings/DataModel/Data.cs

@@ -63,6 +63,11 @@ public sealed class Data
     /// </summary>
     public Dictionary<string, ManagedEditableDefaultState> ManagedEditableDefaults { get; set; } = [];
 
+    /// <summary>
+    /// The configuration plugin that owns each locked managed setting.
+    /// </summary>
+    public Dictionary<string, Guid> ManagedLockedConfigurations { get; set; } = [];
+
     /// <summary>
     /// Cached audit results for assistant plugins.
     /// </summary>

app/MindWork AI Studio/Settings/ManagedConfiguration.Parsing.cs

@@ -924,8 +924,8 @@ public static partial class ManagedConfiguration
                 // case only when the setting was locked and managed by the same configuration plugin.
                 //
                 // The other case, when the setting was locked and managed by a different configuration plugin,
-                // is handled by the IsConfigurationLeftOver method, which checks if the configuration plugin
-                // is still available. If it is not available, it resets the locked state of the
+                // is handled by the CleanupLeftOverManagedConfigurations method, which checks if the configuration
+                // plugin is still available. If it is not available, it resets the locked state of the
                 // configuration setting, allowing it to be reconfigured by a different plugin or left unchanged.
                 //
                 configMeta.ResetLockedConfiguration();

app/MindWork AI Studio/Settings/ManagedConfiguration.Register.cs

@@ -19,10 +19,7 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
     /// <returns>The default value.</returns>
-    public static TValue Register<TClass, TValue>(
-        Expression<Func<Data, TClass>>? configSelection,
-        Expression<Func<TClass, TValue>> propertyExpression,
-        TValue defaultValue)
+    public static TValue Register<TClass, TValue>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, TValue>> propertyExpression, TValue defaultValue)
         where TValue : struct
     {
         // When called from the JSON deserializer by using the standard constructor,
@@ -57,10 +54,7 @@ public static partial class ManagedConfiguration
     /// <param name="defaultValue">The default value to use when the setting is not configured.</param>
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <returns>The default value.</returns>
-    public static string Register<TClass>(
-        Expression<Func<Data, TClass>>? configSelection,
-        Expression<Func<TClass, string>> propertyExpression,
-        string defaultValue)
+    public static string Register<TClass>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, string>> propertyExpression, string defaultValue)
     {
         // When called from the JSON deserializer by using the standard constructor,
         // we ignore the register call and return the default value:
@@ -95,10 +89,7 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the elements in the list within the configuration class.</typeparam>
     /// <returns>A list containing the default value.</returns>
-    public static List<TValue> Register<TClass, TValue>(
-        Expression<Func<Data, TClass>>? configSelection,
-        Expression<Func<TClass, IList<TValue>>> propertyExpression,
-        TValue defaultValue)
+    public static List<TValue> Register<TClass, TValue>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, IList<TValue>>> propertyExpression, TValue defaultValue)
     {
         // When called from the JSON deserializer by using the standard constructor,
         // we ignore the register call and return the default value:
@@ -133,10 +124,7 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the elements within the property list.</typeparam>
     /// <returns>The list of default values.</returns>
-    public static List<TValue> Register<TClass, TValue>(
-        Expression<Func<Data, TClass>>? configSelection,
-        Expression<Func<TClass, IList<TValue>>> propertyExpression,
-        IList<TValue> defaultValues)
+    public static List<TValue> Register<TClass, TValue>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, IList<TValue>>> propertyExpression, IList<TValue> defaultValues)
     {
         // When called from the JSON deserializer by using the standard constructor,
         // we ignore the register call and return the default value:
@@ -170,10 +158,7 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the values within the set.</typeparam>
     /// <returns>A set containing the default value.</returns>
-    public static HashSet<TValue> Register<TClass, TValue>(
-        Expression<Func<Data, TClass>>? configSelection,
-        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
-        TValue defaultValue)
+    public static HashSet<TValue> Register<TClass, TValue>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, ISet<TValue>>> propertyExpression, TValue defaultValue)
     {
         // When called from the JSON deserializer by using the standard constructor,
         // we ignore the register call and return the default value:
@@ -208,10 +193,7 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class from which the property is selected.</typeparam>
     /// <typeparam name="TValue">The type of the elements in the collection associated with the configuration property.</typeparam>
     /// <returns>A set containing the default values.</returns>
-    public static HashSet<TValue> Register<TClass, TValue>(
-        Expression<Func<Data, TClass>>? configSelection,
-        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
-        IList<TValue> defaultValues)
+    public static HashSet<TValue> Register<TClass, TValue>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, ISet<TValue>>> propertyExpression, IList<TValue> defaultValues)
     {
         // When called from the JSON deserializer by using the standard constructor,
         // we ignore the register call and return the default value:
@@ -246,10 +228,7 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class from which the property is selected.</typeparam>
     /// <typeparam name="TDict">>The type of the dictionary within the configuration class.</typeparam>
     /// <returns>A dictionary containing the default values.</returns>
-    public static TDict Register<TClass, TDict>(
-        Expression<Func<Data, TClass>>? configSelection,
-        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
-        TDict defaultValues)
+    public static TDict Register<TClass, TDict>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, IDictionary<string, string>>> propertyExpression, TDict defaultValues)
         where TDict : IDictionary<string, string>, new()
     {
         // When called from the JSON deserializer by using the standard constructor,
@@ -286,10 +265,7 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TKey">The enum type of the dictionary keys.</typeparam>
     /// <typeparam name="TValue">The enum type of the dictionary values.</typeparam>
     /// <returns>A dictionary containing the default values.</returns>
-    public static Dictionary<TKey, TValue> Register<TClass, TKey, TValue>(
-        Expression<Func<Data, TClass>>? configSelection,
-        Expression<Func<TClass, Dictionary<TKey, TValue>>> propertyExpression,
-        Dictionary<TKey, TValue> defaultValues)
+    public static Dictionary<TKey, TValue> Register<TClass, TKey, TValue>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, Dictionary<TKey, TValue>>> propertyExpression, Dictionary<TKey, TValue> defaultValues)
         where TKey : struct, Enum
         where TValue : struct, Enum
     {

app/MindWork AI Studio/Settings/ManagedConfiguration.cs

@@ -9,7 +9,10 @@ namespace AIStudio.Settings;
 public static partial class ManagedConfiguration
 {
     private static readonly ConcurrentDictionary<string, IConfig> METADATA = new();
+    
     private static SettingsManager SettingsManagerAccess => Program.SERVICE_PROVIDER.GetRequiredService<SettingsManager>();
+    
+    private static ILogger Log => Program.LOGGER_FACTORY.CreateLogger(nameof(ManagedConfiguration));
 
     /// <summary>
     /// Attempts to retrieve the configuration metadata for a given configuration selection and
@@ -28,15 +31,13 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
-    public static bool TryGet<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, TValue>> propertyExpression,
-        out ConfigMeta<TClass, TValue> configMeta)
+    public static bool TryGet<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression, out ConfigMeta<TClass, TValue> configMeta)
         where TValue : Enum
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, TValue> meta)
         {
+            meta.RestoreLockedConfiguration();
             configMeta = meta;
             return true;
         }
@@ -65,14 +66,12 @@ public static partial class ManagedConfiguration
     /// if found.</param>
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
-    public static bool TryGet<TClass>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, string>> propertyExpression,
-        out ConfigMeta<TClass, string> configMeta)
+    public static bool TryGet<TClass>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, string>> propertyExpression, out ConfigMeta<TClass, string> configMeta)
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, string> meta)
         {
+            meta.RestoreLockedConfiguration();
             configMeta = meta;
             return true;
         }
@@ -104,16 +103,13 @@ public static partial class ManagedConfiguration
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
 
     // ReSharper disable MethodOverloadWithOptionalParameter
-    public static bool TryGet<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, TValue>> propertyExpression,
-        out ConfigMeta<TClass, TValue> configMeta,
-        ISpanParsable<TValue>? _ = null)
+    public static bool TryGet<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression, out ConfigMeta<TClass, TValue> configMeta, ISpanParsable<TValue>? _ = null)
         where TValue : struct, ISpanParsable<TValue>
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, TValue> meta)
         {
+            meta.RestoreLockedConfiguration();
             configMeta = meta;
             return true;
         }
@@ -143,14 +139,12 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
-    public static bool TryGet<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, IList<TValue>>> propertyExpression,
-        out ConfigMeta<TClass, IList<TValue>> configMeta)
+    public static bool TryGet<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, IList<TValue>>> propertyExpression, out ConfigMeta<TClass, IList<TValue>> configMeta)
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, IList<TValue>> meta)
         {
+            meta.RestoreLockedConfiguration();
             configMeta = meta;
             return true;
         }
@@ -178,14 +172,12 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
-    public static bool TryGet<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
-        out ConfigMeta<TClass, ISet<TValue>> configMeta)
+    public static bool TryGet<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, ISet<TValue>>> propertyExpression, out ConfigMeta<TClass, ISet<TValue>> configMeta)
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, ISet<TValue>> meta)
         {
+            meta.RestoreLockedConfiguration();
             configMeta = meta;
             return true;
         }
@@ -212,14 +204,12 @@ public static partial class ManagedConfiguration
     /// if found.</param>
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
-    public static bool TryGet<TClass>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
-        out ConfigMeta<TClass, IDictionary<string, string>> configMeta)
+    public static bool TryGet<TClass>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, IDictionary<string, string>>> propertyExpression, out ConfigMeta<TClass, IDictionary<string, string>> configMeta)
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, IDictionary<string, string>> meta)
         {
+            meta.RestoreLockedConfiguration();
             configMeta = meta;
             return true;
         }
@@ -248,16 +238,14 @@ public static partial class ManagedConfiguration
     /// <typeparam name="TKey">The enum type of the dictionary keys.</typeparam>
     /// <typeparam name="TValue">The enum type of the dictionary values.</typeparam>
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
-    public static bool TryGet<TClass, TKey, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, Dictionary<TKey, TValue>>> propertyExpression,
-        out ConfigMeta<TClass, Dictionary<TKey, TValue>> configMeta)
+    public static bool TryGet<TClass, TKey, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, Dictionary<TKey, TValue>>> propertyExpression, out ConfigMeta<TClass, Dictionary<TKey, TValue>> configMeta)
         where TKey : struct, Enum
         where TValue : struct, Enum
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, Dictionary<TKey, TValue>> meta)
         {
+            meta.RestoreLockedConfiguration();
             configMeta = meta;
             return true;
         }
@@ -270,211 +258,106 @@ public static partial class ManagedConfiguration
     }
 
     /// <summary>
-    /// Checks if a configuration setting is left over from a configuration plugin that is no longer available.
-    /// If the configuration setting is locked and managed by a configuration plugin that is not available,
-    /// it resets the managed state of the configuration setting and returns true.
-    /// Otherwise, it returns false.
+    /// Removes all managed states whose configuration plugin is not available anymore.
     /// </summary>
-    /// <param name="configSelection">The expression to select the configuration class.</param>
-    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <remarks>
+    /// This covers every registered setting, regardless of its type: locked settings, editable
+    /// defaults, and additive plugin contributions. Settings do not need to be listed anywhere for
+    /// this cleanup to work, so adding a new managed setting cannot be forgotten here.<br/><br/>
+    /// A locked setting whose plugin is gone is reset to its default value. That is intended: the
+    /// value belonged to the organization, not to the user, and the user might not be able to
+    /// change it at all.
+    /// </remarks>
     /// <param name="availablePlugins">The collection of available plugins to check against.</param>
-    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
-    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
-    /// <returns>True if the configuration setting is left over and was reset, otherwise false.</returns>
-    public static bool IsConfigurationLeftOver<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, TValue>> propertyExpression,
-        IReadOnlyList<IAvailablePlugin> availablePlugins)
-        where TValue : Enum
+    /// <param name="deployedConfigPluginIds">
+    /// The IDs of all configuration plugins which are deployed on this machine, including those which
+    /// could not be loaded. A deployed plugin was not removed, so its settings must stay untouched.
+    /// </param>
+    /// <returns>True when at least one setting was changed, otherwise false.</returns>
+    public static bool CleanupLeftOverManagedConfigurations(IReadOnlyCollection<IAvailablePlugin> availablePlugins, IReadOnlySet<Guid> deployedConfigPluginIds)
     {
-        if (!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
+        var wasChanged = false;
+        var registeredSettingNames = new HashSet<string>(StringComparer.Ordinal);
 
-        if (configMeta.LockedByConfigPluginId != Guid.Empty && configMeta.IsLocked)
+        foreach (var config in METADATA.Values)
         {
-            var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.LockedByConfigPluginId);
-            if (plugin is null)
+            if (config is not ConfigMetaBase configMeta)
+                continue;
+
+            registeredSettingNames.Add(configMeta.SettingName);
+
+            //
+            // Restore the persisted ownership first. Otherwise, we would not recognize a left-over
+            // lock when nobody has read this setting since the settings were loaded:
+            //
+            configMeta.RestoreLockedConfiguration();
+
+            // Check the locked state:
+            if (configMeta.IsLocked && configMeta.LockedByConfigPluginId != Guid.Empty && !IsPluginPresent(configMeta.LockedByConfigPluginId, availablePlugins, deployedConfigPluginIds))
             {
+                Log.LogInformation($"Resetting the setting '{configMeta.SettingName}': it was locked by the configuration plugin '{configMeta.LockedByConfigPluginId}', which is not available anymore.");
                 configMeta.ResetLockedConfiguration();
-                return true;
+                wasChanged = true;
+            }
+
+            // Check the editable default state:
+            if (CleanupEditableDefaultState(configMeta, availablePlugins, deployedConfigPluginIds))
+                wasChanged = true;
+
+            // Check the additive plugin contribution:
+            if (configMeta.HasPluginContribution && configMeta.PluginContributionByConfigPluginId != Guid.Empty && !IsPluginPresent(configMeta.PluginContributionByConfigPluginId, availablePlugins, deployedConfigPluginIds))
+            {
+                Log.LogInformation($"Clearing the plugin contribution for the setting '{configMeta.SettingName}': the configuration plugin '{configMeta.PluginContributionByConfigPluginId}' is not available anymore.");
+                configMeta.ClearPluginContribution();
+                wasChanged = true;
             }
         }
 
-        return CleanupEditableDefaultState(configMeta, SettingName(propertyExpression), availablePlugins);
-    }
+        // Remove persisted states which belong to settings that do not exist anymore:
+        if (RemoveUnknownManagedStates(registeredSettingNames))
+            wasChanged = true;
 
-    public static bool IsConfigurationLeftOver<TClass>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, string>> propertyExpression,
-        IReadOnlyList<IAvailablePlugin> availablePlugins)
-    {
-        if (!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
-
-        if (configMeta.LockedByConfigPluginId != Guid.Empty && configMeta.IsLocked)
-        {
-            var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.LockedByConfigPluginId);
-            if (plugin is null)
-            {
-                configMeta.ResetLockedConfiguration();
-                return true;
-            }
-        }
-
-        return CleanupEditableDefaultState(configMeta, SettingName(propertyExpression), availablePlugins);
-    }
-
-    // ReSharper disable MethodOverloadWithOptionalParameter
-    public static bool IsConfigurationLeftOver<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, TValue>> propertyExpression,
-        IReadOnlyList<IAvailablePlugin> availablePlugins,
-        ISpanParsable<TValue>? _ = null)
-        where TValue : struct, ISpanParsable<TValue>
-    {
-        if (!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
-
-        if (configMeta.LockedByConfigPluginId != Guid.Empty && configMeta.IsLocked)
-        {
-            var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.LockedByConfigPluginId);
-            if (plugin is null)
-            {
-                configMeta.ResetLockedConfiguration();
-                return true;
-            }
-        }
-
-        return CleanupEditableDefaultState(configMeta, SettingName(propertyExpression), availablePlugins);
-    }
-
-    // ReSharper restore MethodOverloadWithOptionalParameter
-
-    public static bool IsConfigurationLeftOver<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, IList<TValue>>> propertyExpression,
-        IEnumerable<IAvailablePlugin> availablePlugins)
-    {
-        if (!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
-
-        if (configMeta.ManagedMode is ManagedConfigurationMode.EDITABLE_DEFAULT)
-            return CleanupEditableDefaultState(configMeta, SettingName(propertyExpression), availablePlugins.ToList());
-
-        if (configMeta.LockedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
-            return false;
-
-        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.LockedByConfigPluginId);
-        if (plugin is not null)
-            return false;
-
-        configMeta.ResetLockedConfiguration();
-        return true;
-    }
-
-    public static bool IsConfigurationLeftOver<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
-        IEnumerable<IAvailablePlugin> availablePlugins)
-    {
-        if (!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
-
-        if (configMeta.LockedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
-            return false;
-
-        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.LockedByConfigPluginId);
-        if (plugin is null)
-        {
-            configMeta.ResetLockedConfiguration();
-            return true;
-        }
-
-        return false;
+        return wasChanged;
     }
 
     /// <summary>
-    /// Checks if a plugin contribution is left over from a configuration plugin that is no longer available.
-    /// If so, it clears the contribution and returns true.
+    /// Checks whether a configuration plugin is still present on this machine.
     /// </summary>
-    public static bool IsPluginContributionLeftOver<TClass, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
-        IEnumerable<IAvailablePlugin> availablePlugins)
+    /// <remarks>
+    /// A plugin counts as present when it was loaded, or when it is deployed but could not be loaded.
+    /// The latter matters for organizations: a broken configuration plugin is still in charge, so we
+    /// must not treat its settings as left over.
+    /// </remarks>
+    private static bool IsPluginPresent(Guid configPluginId, IReadOnlyCollection<IAvailablePlugin> availablePlugins, IReadOnlySet<Guid> deployedConfigPluginIds) => deployedConfigPluginIds.Contains(configPluginId) || availablePlugins.Any(x => x.Id == configPluginId);
+
+    /// <summary>
+    /// Removes persisted managed states which belong to settings that are not registered anymore.
+    /// </summary>
+    /// <remarks>
+    /// Without this, states of removed or renamed settings would stay in the settings file forever.
+    /// </remarks>
+    private static bool RemoveUnknownManagedStates(IReadOnlySet<string> registeredSettingNames)
     {
-        if (!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
+        var wasChanged = false;
+        var configurationData = SettingsManagerAccess.ConfigurationData;
 
-        if (!configMeta.HasPluginContribution || configMeta.PluginContributionByConfigPluginId == Guid.Empty)
-            return false;
-
-        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.PluginContributionByConfigPluginId);
-        if (plugin is null)
+        foreach (var settingName in configurationData.ManagedLockedConfigurations.Keys.Where(x => !registeredSettingNames.Contains(x)).ToList())
         {
-            configMeta.ClearPluginContribution();
-            return true;
+            Log.LogInformation($"Removing the persisted lock of the setting '{settingName}': this setting does not exist anymore.");
+            configurationData.ManagedLockedConfigurations.Remove(settingName);
+            wasChanged = true;
         }
 
-        return false;
+        foreach (var settingName in configurationData.ManagedEditableDefaults.Keys.Where(x => !registeredSettingNames.Contains(x)).ToList())
+        {
+            Log.LogInformation($"Removing the persisted editable default of the setting '{settingName}': this setting does not exist anymore.");
+            configurationData.ManagedEditableDefaults.Remove(settingName);
+            wasChanged = true;
+        }
+
+        return wasChanged;
     }
 
-    public static bool IsConfigurationLeftOver<TClass>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
-        IEnumerable<IAvailablePlugin> availablePlugins)
-    {
-        if (!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
-
-        if (configMeta.LockedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
-            return false;
-
-        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.LockedByConfigPluginId);
-        if (plugin is null)
-        {
-            configMeta.ResetLockedConfiguration();
-            return true;
-        }
-
-        return false;
-    }
-
-    public static bool IsConfigurationLeftOver<TClass, TKey, TValue>(
-        Expression<Func<Data, TClass>> configSelection,
-        Expression<Func<TClass, Dictionary<TKey, TValue>>> propertyExpression,
-        IEnumerable<IAvailablePlugin> availablePlugins)
-        where TKey : struct, Enum
-        where TValue : struct, Enum
-    {
-        if (!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
-
-        if (configMeta.ManagedMode is ManagedConfigurationMode.EDITABLE_DEFAULT)
-        {
-            var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.EditableDefaultByConfigPluginId);
-            if (plugin is null)
-            {
-                configMeta.ClearEditableDefaultConfiguration();
-                ClearEditableDefaultState(SettingName(propertyExpression));
-                return true;
-            }
-
-            return false;
-        }
-
-        if (configMeta.LockedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
-            return false;
-
-        var lockedPlugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.LockedByConfigPluginId);
-        if (lockedPlugin is null)
-        {
-            configMeta.ResetLockedConfiguration();
-            return true;
-        }
-
-        return false;
-    }
-    
     private static string Path<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression)
     {
         var className = typeof(TClass).Name;
@@ -507,12 +390,9 @@ public static partial class ManagedConfiguration
 
     private static bool ClearEditableDefaultState(string settingName) => SettingsManagerAccess.ConfigurationData.ManagedEditableDefaults.Remove(settingName);
 
-    private static bool CleanupEditableDefaultState<TClass, TValue>(
-        ConfigMeta<TClass, TValue> configMeta,
-        string settingName,
-        IReadOnlyList<IAvailablePlugin> availablePlugins)
+    private static bool CleanupEditableDefaultState(ConfigMetaBase configMeta, IReadOnlyCollection<IAvailablePlugin> availablePlugins, IReadOnlySet<Guid> deployedConfigPluginIds)
     {
-        if (!TryGetEditableDefaultState(settingName, out var editableDefaultState))
+        if (!TryGetEditableDefaultState(configMeta.SettingName, out var editableDefaultState))
         {
             if (configMeta.ManagedMode is not ManagedConfigurationMode.EDITABLE_DEFAULT)
                 return false;
@@ -521,11 +401,11 @@ public static partial class ManagedConfiguration
             return true;
         }
 
-        var plugin = availablePlugins.FirstOrDefault(x => x.Id == editableDefaultState.ConfigPluginId);
-        if (plugin is not null)
+        if (IsPluginPresent(editableDefaultState.ConfigPluginId, availablePlugins, deployedConfigPluginIds))
             return false;
 
+        Log.LogInformation($"Clearing the editable default of the setting '{configMeta.SettingName}': the configuration plugin '{editableDefaultState.ConfigPluginId}' is not available anymore.");
         configMeta.ClearEditableDefaultConfiguration();
-        return ClearEditableDefaultState(settingName);
+        return ClearEditableDefaultState(configMeta.SettingName);
     }
 }