fix: persist preference toggles + log them to changes.log

Two issues the user reported on Fullscreen Optimizations: (1) had to
re-enable Monitor and AutoApply (they didn't stick), (2) the change
log only recorded registry writes, not the user's UI toggles.

Persistence fix:
- Each GlobalToggleRow setter (Monitor / DesiredOn / AutoApply) now
  invokes an onPrefChanged callback that immediately calls
  _store.Save(_config). So toggling a checkbox writes to disk
  on the spot — no need to remember to click Save.
- SettingsWindow.OnWindowClosing also persists the form (covers any
  edge cases where a control wasn't routed through a row callback,
  and any path that closes via the X button).
- Cancel button explicitly suppresses save-on-close so its discard
  semantics still work for users who want to bail on a change.

Logging fix:
- ChangeLogger.LogPreferenceChange writes a single line:
    [2026-05-06 22:42:15] [ui    ] PREF   Fullscreen optimizations (global)  |  Monitor: False -> True
  Lives in the same %APPDATA%\GamerGuardian\changes.log alongside
  the multi-line registry-write entries; sources are distinguishable
  by the [ui] / [manual] / [auto] tag.
- Every Monitor / Want / AutoApply toggle on the 11 global toggle
  rows fires a log entry. Same source name as shown in Settings
  (so the entry says "Fullscreen optimizations (global)" not
  "fso").

Net effect for the user: toggling Monitor=true on FSO is persisted
on the click, regardless of how Settings is closed; the log shows
the toggle clearly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: carterscode

src/GamerGuardian/Services/ChangeLogger.cs

@@ -37,6 +37,23 @@ public static void LogApplyResults(IEnumerable<ApplyResult> results, string sour
         catch { /* logging is best-effort */ }
     }
 
+    /// <summary>
+    /// Records a preference toggle (Monitor / AutoApply / Want) made in the Settings UI.
+    /// Single line per change so the log stays scannable.
+    /// </summary>
+    public static void LogPreferenceChange(string settingName, string field, string before, string after)
+    {
+        try
+        {
+            var dir = Path.GetDirectoryName(LogPath);
+            if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
+            RotateIfNeeded();
+            var line = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] [ui    ] PREF   {settingName}  |  {field}: {before} -> {after}";
+            File.AppendAllText(LogPath, line + Environment.NewLine, Encoding.UTF8);
+        }
+        catch { }
+    }
+
     private static string Format(ApplyResult r, string source)
     {
         var status = r.Verified ? "OK" : "FAILED";

src/GamerGuardian/UI/SettingsWindow.xaml

@@ -3,6 +3,7 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
         Title="GamerGuardian - Settings"
+        Closing="OnWindowClosing"
         Width="780" Height="760"
         MinWidth="640" MinHeight="500"
         WindowStartupLocation="CenterScreen"

src/GamerGuardian/UI/SettingsWindow.xaml.cs

@@ -89,15 +89,17 @@ private void LoadGlobals()
             currentText: $"Current: {OnOffText(SafeRead(GameModeMonitor.ReadCurrent))}",
             defaultText: "Default: Enabled",
             onLabel: "Enabled", offLabel: "Disabled",
-            pref: g.GameMode, groupName: "gm"));
+            pref: g.GameMode, groupName: "gm",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "Game DVR background recording",
             description: "Always-on game capture. Costs CPU/GPU during gameplay; off is gaming-recommended.",
             currentText: $"Current: {OnOffText(SafeRead(GameDvrMonitor.ReadCurrent))}",
             defaultText: "Default: Enabled",
             onLabel: "Enabled", offLabel: "Disabled",
-            pref: g.GameDvr, groupName: "dvr"));
+            pref: g.GameDvr, groupName: "dvr",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "Hardware-accelerated GPU Scheduling (HAGS)",
@@ -106,7 +108,8 @@ private void LoadGlobals()
             defaultText: "Default: Enabled (Win11)",
             onLabel: "Enabled", offLabel: "Disabled",
             requiresReboot: true,
-            pref: g.Hags, groupName: "hags"));
+            pref: g.Hags, groupName: "hags",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "Memory Integrity / VBS (Core Isolation)",
@@ -115,7 +118,8 @@ private void LoadGlobals()
             defaultText: "Default: Enabled (Win11)",
             onLabel: "Enabled", offLabel: "Disabled",
             requiresReboot: true,
-            pref: g.MemoryIntegrity, groupName: "memint"));
+            pref: g.MemoryIntegrity, groupName: "memint",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "System Responsiveness",
@@ -124,15 +128,17 @@ private void LoadGlobals()
             defaultText: "Default: 20    Gaming: 10",
             onLabel: "Gaming", offLabel: "Default",
             requiresReboot: true,
-            pref: g.SystemResponsiveness, groupName: "sysresp"));
+            pref: g.SystemResponsiveness, groupName: "sysresp",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "Network Throttling",
             description: "Multimedia packet pacing. Disabling reduces network jitter for online games.",
             currentText: $"Current: {GamingDefaultText(SafeRead(NetworkThrottlingMonitor.ReadCurrent))}",
             defaultText: "Default: 10    Gaming: Disabled",
             onLabel: "Gaming", offLabel: "Default",
-            pref: g.NetworkThrottling, groupName: "netthr"));
+            pref: g.NetworkThrottling, groupName: "netthr",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "USB Selective Suspend (global)",
@@ -141,39 +147,44 @@ private void LoadGlobals()
             defaultText: "Default: Enabled    Gaming: Disabled",
             onLabel: "Gaming", offLabel: "Default",
             requiresReboot: true,
-            pref: g.UsbSelectiveSuspend, groupName: "usbsus"));
+            pref: g.UsbSelectiveSuspend, groupName: "usbsus",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "Games multimedia task profile",
             description: "Priority + scheduling values for processes registered with the Games multimedia class.",
             currentText: $"Current: {GamingDefaultText(SafeRead(GamesTaskProfileMonitor.ReadCurrent))}",
             defaultText: "Default: standard    Gaming: boosted",
             onLabel: "Gaming", offLabel: "Default",
-            pref: g.GamesTaskProfile, groupName: "gtask"));
+            pref: g.GamesTaskProfile, groupName: "gtask",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "Mouse \"Enhance pointer precision\"",
             description: "Acceleration curve applied to mouse movement. Most gamers want this off for consistent aim.",
             currentText: $"Current: {OnOffText(SafeRead(MousePrecisionMonitor.ReadCurrent))}",
             defaultText: "Default: Enabled",
             onLabel: "Enabled", offLabel: "Disabled",
-            pref: g.MousePrecision, groupName: "mp"));
+            pref: g.MousePrecision, groupName: "mp",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "Fullscreen optimizations (global)",
             description: "Borderless-windowed compositing layer. Generally fine; some titles prefer it off.",
             currentText: $"Current: {OnOffText(SafeRead(FullscreenOptimizationsMonitor.ReadCurrent))}",
             defaultText: "Default: Enabled",
             onLabel: "Enabled", offLabel: "Disabled",
-            pref: g.FullscreenOptimizations, groupName: "fso"));
+            pref: g.FullscreenOptimizations, groupName: "fso",
+            onPrefChanged: OnRowPrefChanged));
 
         GlobalToggleRows.Add(new GlobalToggleRow(
             name: "Variable Refresh Rate (DirectX)",
             description: "G-Sync / FreeSync compatibility flag (Settings → Display → Graphics). Not the same as Dynamic Refresh Rate (DRR) in Advanced Display.",
             currentText: $"Current: {OnOffText(SafeRead(VrrMonitor.ReadCurrent))}",
             defaultText: "Default: not set",
             onLabel: "Enabled", offLabel: "Disabled",
-            pref: g.Vrr, groupName: "vrr"));
+            pref: g.Vrr, groupName: "vrr",
+            onPrefChanged: OnRowPrefChanged));
 
         var planNames = PowerPlanMonitor.ListAvailablePlans();
         var active = SafeRunGuid(PowerPlanMonitor.GetActivePlan);
@@ -393,12 +404,36 @@ private void PersistFormToConfig()
         foreach (var row in DisplayRows) row.WriteTo(_config);
     }
 
-    private void CancelButton_Click(object sender, RoutedEventArgs e) => Close();
+    private bool _suppressSaveOnClose = false;
+
+    private void OnWindowClosing(object? sender, CancelEventArgs e)
+    {
+        if (_suppressSaveOnClose) return;
+        try
+        {
+            PersistFormToConfig();
+            _store.Save(_config);
+        }
+        catch { }
+    }
+
+    private void OnRowPrefChanged(string settingName, string field, string before, string after)
+    {
+        try { _store.Save(_config); } catch { }
+        ChangeLogger.LogPreferenceChange(settingName, field, before, after);
+    }
+
+    private void CancelButton_Click(object sender, RoutedEventArgs e)
+    {
+        _suppressSaveOnClose = true;
+        Close();
+    }
 }
 
 public sealed class GlobalToggleRow : INotifyPropertyChanged
 {
     private readonly ToggleSettingPref _pref;
+    private readonly Action<string, string, string, string>? _onPrefChanged;
     public string Name { get; }
     public string Description { get; }
     public string CurrentText { get; }
@@ -409,23 +444,54 @@ public sealed class GlobalToggleRow : INotifyPropertyChanged
     public bool RequiresReboot { get; }
     public Visibility RebootBadgeVisibility => RequiresReboot ? Visibility.Visible : Visibility.Collapsed;
 
-    public bool Monitor { get => _pref.Monitor; set { _pref.Monitor = value; OnPropertyChanged(); } }
+    public bool Monitor
+    {
+        get => _pref.Monitor;
+        set
+        {
+            if (_pref.Monitor == value) return;
+            var before = _pref.Monitor;
+            _pref.Monitor = value;
+            OnPropertyChanged();
+            _onPrefChanged?.Invoke(Name, "Monitor", before.ToString(), value.ToString());
+        }
+    }
     public bool DesiredOn
     {
         get => _pref.DesiredOn;
-        set { if (_pref.DesiredOn != value) { _pref.DesiredOn = value; OnPropertyChanged(); OnPropertyChanged(nameof(DesiredOff)); } }
+        set
+        {
+            if (_pref.DesiredOn == value) return;
+            var before = _pref.DesiredOn;
+            _pref.DesiredOn = value;
+            OnPropertyChanged();
+            OnPropertyChanged(nameof(DesiredOff));
+            _onPrefChanged?.Invoke(Name, "Want", before ? OnLabel : OffLabel, value ? OnLabel : OffLabel);
+        }
     }
     public bool DesiredOff
     {
         get => !_pref.DesiredOn;
-        set { if (value && _pref.DesiredOn) { _pref.DesiredOn = false; OnPropertyChanged(); OnPropertyChanged(nameof(DesiredOn)); } }
+        set { if (value && _pref.DesiredOn) DesiredOn = false; }
+    }
+    public bool AutoApply
+    {
+        get => _pref.AutoApply;
+        set
+        {
+            if (_pref.AutoApply == value) return;
+            var before = _pref.AutoApply;
+            _pref.AutoApply = value;
+            OnPropertyChanged();
+            _onPrefChanged?.Invoke(Name, "AutoApply", before.ToString(), value.ToString());
+        }
     }
-    public bool AutoApply { get => _pref.AutoApply; set { _pref.AutoApply = value; OnPropertyChanged(); } }
 
     public GlobalToggleRow(string name, string description, string currentText, string defaultText,
                            string onLabel, string offLabel,
                            ToggleSettingPref pref, string groupName,
-                           bool requiresReboot = false)
+                           bool requiresReboot = false,
+                           Action<string, string, string, string>? onPrefChanged = null)
     {
         Name = name;
         Description = description;
@@ -436,6 +502,7 @@ public GlobalToggleRow(string name, string description, string currentText, stri
         _pref = pref;
         GroupName = groupName;
         RequiresReboot = requiresReboot;
+        _onPrefChanged = onPrefChanged;
     }
 
     public void WriteBack() { /* mutations are direct; nothing to do */ }