Address Gemini review feedback

- Close truncated string literals before appending missing brackets
  in TryFixBraces (fixes recovery of JSON cut mid-string)
- Remove ineffective ToJsonString() validation loop since JsonNode.Parse
  already validates syntax; the typed deserializer handles type mismatches
  via Settings property initializer defaults
- Extract duplicated recovery logic from LoadSettings/LoadSettingsAsync
  into shared DeserializeOrRecoverSettings helper
- Add test for truncated-inside-string recovery

https://claude.ai/code/session_01Gej4ey7eUsbPRDqFWwxKyZ

Author: claude

StabilityMatrix.Core/Services/SettingsJsonSanitizer.cs

@@ -118,8 +118,17 @@ public static string TryFixBraces(string jsonText)
             }
         }
 
-        // Append missing closing brackets in correct LIFO order
         var sb = new StringBuilder(trimmed);
+
+        // If truncated inside a string literal, close it first
+        if (inString)
+        {
+            if (escaped)
+                sb.Append('\\');
+            sb.Append('"');
+        }
+
+        // Append missing closing brackets in correct LIFO order
         while (stack.Count > 0)
         {
             sb.Append('\n').Append(stack.Pop());
@@ -208,38 +217,17 @@ public static string TryFixBraces(string jsonText)
             return null;
         }
 
-        // Remove properties that can't be individually serialized back
-        var propsToRemove = new List<string>();
-        foreach (var (key, value) in rootObject)
-        {
-            try
-            {
-                // Validate each property by serializing it to a string
-                _ = value?.ToJsonString();
-            }
-            catch (Exception)
-            {
-                propsToRemove.Add(key);
-            }
-        }
-
-        foreach (var key in propsToRemove)
-        {
-            logger?.LogWarning("Removing corrupt property from settings: {Key}", key);
-            rootObject.Remove(key);
-        }
-
-        // Re-serialize the cleaned node tree and attempt typed deserialization
+        // Re-serialize the cleaned node tree and attempt typed deserialization.
+        // JsonNode.Parse with lenient options may accept JSON that the typed deserializer
+        // can handle, and any properties with incompatible types will get their defaults
+        // from the Settings class property initializers.
         try
         {
             var cleanedJson = rootObject.ToJsonString();
             var settings = JsonSerializer.Deserialize(cleanedJson, SettingsSerializerContext.Default.Settings);
             if (settings is not null)
             {
-                logger?.LogInformation(
-                    "Settings recovered via property-level recovery ({RemovedCount} properties removed)",
-                    propsToRemove.Count
-                );
+                logger?.LogInformation("Settings recovered via property-level recovery");
                 return settings;
             }
         }

StabilityMatrix.Core/Services/SettingsManager.cs

@@ -477,41 +477,7 @@ protected virtual void LoadSettings(CancellationToken cancellationToken = defaul
                 return;
             }
 
-            // Try normal deserialization first
-            try
-            {
-                var loadedSettings = JsonSerializer.Deserialize(
-                    rawBytes,
-                    SettingsSerializerContext.Default.Settings
-                );
-
-                if (loadedSettings is not null)
-                {
-                    Settings = loadedSettings;
-                    return;
-                }
-            }
-            catch (JsonException ex)
-            {
-                logger.LogWarning(ex, "Failed to deserialize settings, attempting recovery");
-            }
-
-            // Recovery path
-            BackupCorruptedFile(rawBytes);
-
-            var jsonText = Encoding.UTF8.GetString(SettingsJsonSanitizer.SanitizeBytes(rawBytes));
-            var recovered = SettingsJsonSanitizer.TryDeserializeWithRecovery(jsonText, logger);
-
-            if (recovered is not null)
-            {
-                Settings = recovered;
-                logger.LogInformation("Settings recovered from corrupted file");
-            }
-            else
-            {
-                logger.LogWarning("Could not recover settings from corrupted file, using defaults");
-                Settings = new Settings();
-            }
+            Settings = DeserializeOrRecoverSettings(rawBytes);
         }
         finally
         {
@@ -546,50 +512,56 @@ protected virtual async Task LoadSettingsAsync(CancellationToken cancellationTok
                 return;
             }
 
-            // Try normal deserialization first
-            try
-            {
-                var loadedSettings = JsonSerializer.Deserialize(
-                    rawBytes,
-                    SettingsSerializerContext.Default.Settings
-                );
+            Settings = DeserializeOrRecoverSettings(rawBytes);
+        }
+        finally
+        {
+            fileLock.Release();
 
-                if (loadedSettings is not null)
-                {
-                    Settings = loadedSettings;
-                    return;
-                }
-            }
-            catch (JsonException ex)
-            {
-                logger.LogWarning(ex, "Failed to deserialize settings, attempting recovery");
-            }
+            isLoaded = true;
 
-            // Recovery path
-            BackupCorruptedFile(rawBytes);
+            Loaded?.Invoke(this, EventArgs.Empty);
+        }
+    }
 
-            var jsonText = Encoding.UTF8.GetString(SettingsJsonSanitizer.SanitizeBytes(rawBytes));
-            var recovered = SettingsJsonSanitizer.TryDeserializeWithRecovery(jsonText, logger);
+    /// <summary>
+    /// Attempts to deserialize settings from raw bytes, falling back to sanitization
+    /// and recovery if the JSON is corrupted. Returns default settings as a last resort.
+    /// </summary>
+    private Settings DeserializeOrRecoverSettings(byte[] rawBytes)
+    {
+        // Try normal deserialization first
+        try
+        {
+            var loadedSettings = JsonSerializer.Deserialize(
+                rawBytes,
+                SettingsSerializerContext.Default.Settings
+            );
 
-            if (recovered is not null)
-            {
-                Settings = recovered;
-                logger.LogInformation("Settings recovered from corrupted file");
-            }
-            else
+            if (loadedSettings is not null)
             {
-                logger.LogWarning("Could not recover settings from corrupted file, using defaults");
-                Settings = new Settings();
+                return loadedSettings;
             }
         }
-        finally
+        catch (JsonException ex)
         {
-            fileLock.Release();
+            logger.LogWarning(ex, "Failed to deserialize settings, attempting recovery");
+        }
 
-            isLoaded = true;
+        // Recovery path: backup corrupted file, sanitize, and attempt recovery
+        BackupCorruptedFile(rawBytes);
 
-            Loaded?.Invoke(this, EventArgs.Empty);
+        var jsonText = Encoding.UTF8.GetString(SettingsJsonSanitizer.SanitizeBytes(rawBytes));
+        var recovered = SettingsJsonSanitizer.TryDeserializeWithRecovery(jsonText, logger);
+
+        if (recovered is not null)
+        {
+            logger.LogInformation("Settings recovered from corrupted file");
+            return recovered;
         }
+
+        logger.LogWarning("Could not recover settings from corrupted file, using defaults");
+        return new Settings();
     }
 
     private void BackupCorruptedFile(byte[] rawBytes)

StabilityMatrix.Tests/Core/SettingsJsonSanitizerTests.cs

@@ -81,6 +81,18 @@ public void TryFixBraces_MixedBrackets_ClosesInCorrectOrder()
         Assert.IsTrue(result.TrimEnd().EndsWith('}'));
     }
 
+    [TestMethod]
+    public void TryFixBraces_TruncatedInsideString_ClosesStringAndBraces()
+    {
+        // JSON truncated in the middle of a string value
+        var input = """{"Theme": "Da""";
+
+        var result = SettingsJsonSanitizer.TryFixBraces(input);
+
+        // Should close the string literal, then the brace
+        Assert.IsNotNull(JsonDocument.Parse(result));
+    }
+
     [TestMethod]
     public void TryDeserializeWithRecovery_ValidJson_ReturnsSettings()
     {