fix(verify): publish what Verify finds, and give the user a way to fix it

Clicking "Verify all" reported a drifted setting while the Status page kept
showing 0, and there was nothing to click to put the setting back.

Two independent causes.

Verify never published what it found. It ran its own CheckDrift loop, logged a
snapshot and showed a count in a MessageBox, and never touched MonitorService.
The Status page reads MonitorService.CurrentDrift, so it kept showing whatever
the last background poll published -- up to ten minutes stale for a stable
setting. Verify is a full re-read of every monitor, so its findings are now
published as a full scan via PublishManualScan. Nothing is applied and no
notification is raised: Verify still only reports.

Verify and Status were also counting different populations. The background scan
filters CheckDrift on IsMonitored; Verify did not, so it counted unmonitored
settings too. That is the reported case exactly -- on the reporter's machine all
ten drifted settings are unmonitored, so Verify counted ten and Status correctly
counted zero. Only monitored drift is published (the Status count is defined as
monitored settings), and the window now states the split in words rather than
leaving the user to reconcile two numbers.

A third defect in the same family, found while fixing these: RecordVerifiedApplies
seeded _lastVerified but left the published snapshot alone, so fixing a setting by
hand left it in the count until its tier was next scanned. The auto-apply path
already dropped verified ids via appliedAndVerified; the manual path did not.
Verified applies now leave the snapshot too, which is what makes the new Fix
button move the number.

Publishing is no longer single-writer, so the read-modify-write takes a lock and
the event is raised outside it -- a UI handler that marshals to the dispatcher
would otherwise deadlock the next publisher.

VerifyResultsWindow replaces the MessageBox: every drifted setting with its
current and desired value, where it lives, how it is enforced, and a badge on the
unmonitored ones. "Fix these settings" runs the same verified-apply path as the
Settings Apply button -- apply, re-read, log, ApplyResultsWindow, and the shared
unowned RebootPrompt.

Verified by opening the window in the running app, not only by the suite. The
construction test deliberately does not claim to cover the row template: with a
broken StaticResource in it the test still passed under construction,
Measure/Arrange, Show(), and a drained dispatcher queue, because an ItemsControl
never generates containers in that host. That limitation is written into the test
rather than left implied.

739 stable / 721 beta tests pass.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: carterscode

src/GamerGuardian/Services/MonitorService.cs

@@ -93,11 +93,20 @@ public sealed class MonitorService : IDisposable
 
     /// <summary>Published snapshot, and also the accumulator across ticks (each
     /// publish replaces it with a freshly built dictionary, so it is never mutated
-    /// in place). Single-writer: only <see cref="TickAsync"/> publishes, and the
-    /// <see cref="_running"/> guard means ticks never overlap. Volatile so a reader
-    /// on another thread sees the newest one.</summary>
+    /// in place). Volatile so a reader on another thread sees the newest one.
+    ///
+    /// <para>Three writers, not one: the poll tick, a manual Verify
+    /// (<see cref="PublishManualScan"/>), and a verified apply
+    /// (<see cref="RecordVerifiedApplies"/>). The latter two run on the UI thread
+    /// and can land mid-tick, so every publish takes <see cref="_publishLock"/> —
+    /// the <see cref="_running"/> guard only serialises ticks against each
+    /// other.</para></summary>
     private volatile IReadOnlyDictionary<string, DriftItem> _publishedDrift = EmptyDrift;
 
+    /// <summary>Serialises the read-modify-write in <see cref="Publish"/>. Distinct
+    /// from <see cref="_lock"/>, which guards the tick re-entrancy flag.</summary>
+    private readonly object _publishLock = new();
+
     public void SetPaused(bool paused)
     {
         if (_userPaused == paused) return;
@@ -205,15 +214,43 @@ private void OnDisplaySettingsChanged(object? sender, EventArgs e)
     /// Without this, the very first background tick after a manual Apply would
     /// misread "no prior verified value" and skip the EXTRESET detection until
     /// the second tick after the eventual revert.
+    ///
+    /// <para>Also drops the verified ids from the published drift snapshot. A
+    /// setting the user just fixed is not drifting any more, and leaving it in the
+    /// snapshot meant the Status count kept reporting it until that setting's tier
+    /// was next scanned — up to ten minutes for a stable setting. The auto-apply
+    /// path already did this via <c>appliedAndVerified</c>; the manual path did
+    /// not.</para>
     /// </summary>
     public void RecordVerifiedApplies(IEnumerable<ApplyResult> results)
     {
         var now = DateTimeOffset.UtcNow;
+        var verified = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
         foreach (var r in results)
         {
             if (!r.Verified) continue;
             _lastVerified[r.SettingId] = new LastVerified(r.RawAfter, r.After, now);
+            verified.Add(r.SettingId);
         }
+
+        if (verified.Count > 0) Publish(previous => WithoutResolved(previous, verified));
+    }
+
+    /// <summary>
+    /// The snapshot minus the settings just fixed. Pure so it can be unit-tested
+    /// without timers or the registry, like <see cref="MergeDrift"/>.
+    ///
+    /// <para>Deliberately not expressed as a <see cref="MergeDrift"/> call: that
+    /// takes a tier and would either replace the whole snapshot (<c>tier: null</c>)
+    /// or only the matching tier. This removes ids and keeps everything else,
+    /// whatever tier it belongs to.</para>
+    /// </summary>
+    public static Dictionary<string, DriftItem> WithoutResolved(
+        IReadOnlyDictionary<string, DriftItem> previous, IReadOnlySet<string> resolvedIds)
+    {
+        var merged = new Dictionary<string, DriftItem>(previous, StringComparer.OrdinalIgnoreCase);
+        foreach (var id in resolvedIds) merged.Remove(id);
+        return merged;
     }
 
     /// <summary>
@@ -449,20 +486,65 @@ private async Task TickAsync(MonitorTier? tier)
     ///
     /// <para>Pure bookkeeping: it observes the scan, it never influences it.</para>
     /// </summary>
-    private void PublishDrift(MonitorTier? tier, List<DriftItem> drifted, HashSet<string> appliedAndVerified)
+    private void PublishDrift(MonitorTier? tier, List<DriftItem> drifted, HashSet<string> appliedAndVerified) =>
+        Publish(previous => MergeDrift(previous, tier, drifted, appliedAndVerified));
+
+    /// <summary>
+    /// Swaps in a new snapshot and raises <see cref="DriftChanged"/> when the set of
+    /// drifted ids actually changed.
+    ///
+    /// <para>The read-modify-write is locked because a manual Verify or a verified
+    /// apply can publish from the UI thread while a poll tick is publishing from the
+    /// timer thread; without it one of the two updates is silently lost. The event is
+    /// raised <b>outside</b> the lock — a handler that marshals to the dispatcher and
+    /// blocks would otherwise deadlock the next publisher.</para>
+    /// </summary>
+    private void Publish(Func<IReadOnlyDictionary<string, DriftItem>, Dictionary<string, DriftItem>> mutate)
     {
-        var previous = _publishedDrift;
-        var snapshot = MergeDrift(previous, tier, drifted, appliedAndVerified);
+        IReadOnlyDictionary<string, DriftItem> snapshot;
+        bool changed;
+        lock (_publishLock)
+        {
+            var previous = _publishedDrift;
+            snapshot = mutate(previous);
 
-        // A count surface only cares about which ids are drifting, so an unchanged
-        // id set raises nothing and the UI doesn't re-render on every quiet poll.
-        bool changed = snapshot.Count != previous.Count
-                       || !snapshot.Keys.All(previous.ContainsKey);
+            // A count surface only cares about which ids are drifting, so an
+            // unchanged id set raises nothing and the UI doesn't re-render on every
+            // quiet poll.
+            changed = snapshot.Count != previous.Count
+                      || !snapshot.Keys.All(previous.ContainsKey);
 
-        _publishedDrift = snapshot;
+            _publishedDrift = snapshot;
+        }
         if (changed) DriftChanged?.Invoke(snapshot);
     }
 
+    /// <summary>
+    /// Publishes the findings of a manual, full re-read of every monitor — the
+    /// "Verify all" button.
+    ///
+    /// <para>Verify checks every setting, so this is a full scan and replaces the
+    /// snapshot wholesale, exactly as a <c>tier: null</c> tick does. Nothing is
+    /// applied and no notification is raised: Verify's contract is that it reports
+    /// and never changes anything.</para>
+    ///
+    /// <para>Without this the two surfaces disagreed. Verify ran its own drift check
+    /// and told the user a setting had drifted, while the Status count kept showing
+    /// whatever the last poll published — reporting 0 for up to ten minutes after
+    /// Verify had just said otherwise.</para>
+    /// </summary>
+    /// <param name="monitoredDrift">Drifted items that are monitored. Unmonitored
+    /// settings must not be passed: the published set is what the Status count
+    /// reports, and that count is defined as monitored settings only.</param>
+    public void PublishManualScan(IEnumerable<DriftItem> monitoredDrift)
+    {
+        var drifted = monitoredDrift.Where(d => d.IsMonitored).ToList();
+        Publish(previous => MergeDrift(previous, tier: null, drifted, EmptyApplied));
+    }
+
+    private static readonly IReadOnlySet<string> EmptyApplied =
+        new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
     /// <summary>
     /// The merge rule, pure so it can be unit-tested without timers or the registry
     /// (same approach as <see cref="SelectNotifiable"/>). Returns a new dictionary;

src/GamerGuardian/UI/SettingsWindow.xaml.cs

@@ -1935,16 +1935,24 @@ private async Task RunCpuActionAsync(
     }
 
     /// <summary>
-    /// Re-reads every monitored setting against the committed config and
-    /// writes a [SNAPSHOT] entry to changes.log. Nothing is applied. A status
-    /// popup tells the user where to look.
+    /// Re-reads every setting against the committed config and writes a [SNAPSHOT]
+    /// entry to changes.log. Nothing is applied here.
+    ///
+    /// <para>Verify is a full re-read of every monitor, so its monitored findings are
+    /// published to the <see cref="MonitorService"/> as a full scan. Without that the
+    /// two surfaces contradicted each other: Verify would report a drifted setting
+    /// while the Status count kept showing the last poll's number — 0, for up to ten
+    /// minutes.</para>
+    ///
+    /// <para>When something has drifted the user gets a list and a way to fix it,
+    /// rather than a count in a MessageBox with nowhere to go.</para>
     /// </summary>
     private void VerifyAllButton_Click(object sender, RoutedEventArgs e)
     {
         try
         {
             var rows = new List<(string, string, string, string, bool)>();
-            int drifting = 0;
+            var drifted = new List<DriftItem>();
             foreach (var m in _monitors)
             {
                 IEnumerable<DriftItem> items;
@@ -1953,16 +1961,27 @@ private void VerifyAllButton_Click(object sender, RoutedEventArgs e)
                 foreach (var d in items)
                 {
                     rows.Add((d.SettingId, d.DisplayLabel, d.CurrentValue, d.DesiredValue, false));
-                    drifting++;
+                    drifted.Add(d);
                 }
             }
             ChangeLogger.LogStateSnapshot(rows);
-            var msg = drifting == 0
-                ? "All monitored settings match your preferences. Snapshot written to changes.log."
-                : $"{drifting} setting(s) currently drifting from your preferences. Snapshot written to changes.log -- nothing was applied.";
-            System.Windows.MessageBox.Show(this, msg, "GamerGuardian -- Verify all",
-                System.Windows.MessageBoxButton.OK,
-                drifting == 0 ? System.Windows.MessageBoxImage.Information : System.Windows.MessageBoxImage.Warning);
+
+            // Only monitored drift is published: the Status count is defined as
+            // monitored settings, and Verify checks everything.
+            _monitorService?.PublishManualScan(drifted);
+
+            if (drifted.Count == 0)
+            {
+                System.Windows.MessageBox.Show(this,
+                    "Everything matches your preferences. Snapshot written to changes.log.",
+                    "GamerGuardian -- Verify all",
+                    System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Information);
+                return;
+            }
+
+            var win = new VerifyResultsWindow(drifted, _monitors, _config, _monitorService) { Owner = this };
+            win.Fixed += OnVerifyFixApplied;
+            win.ShowDialog();
         }
         catch (Exception ex)
         {
@@ -1971,6 +1990,24 @@ private void VerifyAllButton_Click(object sender, RoutedEventArgs e)
         }
     }
 
+    /// <summary>Reload the form after a Verify fix — the values on screen were read
+    /// before the apply and are now stale.</summary>
+    private void OnVerifyFixApplied()
+    {
+        try
+        {
+            RebaseDraftFromConfig();
+            LoadGlobals();
+            LoadDisplays();
+            LoadServices();
+            LoadWindowsAi();
+            LoadCpuTabs();
+            UpdatePendingStatus();
+            Saved?.Invoke();
+        }
+        catch { /* a refresh failure must not break the fix that already succeeded */ }
+    }
+
     private void CancelButton_Click(object sender, RoutedEventArgs e)
     {
         // Discards the draft entirely. _config (and on-disk config.json) are

src/GamerGuardian/UI/VerifyResultsWindow.xaml

@@ -0,0 +1,102 @@
+<ui:FluentWindow x:Class="GamerGuardian.UI.VerifyResultsWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
+        Title="Verify results"
+        Width="660" Height="600"
+        MinWidth="520" MinHeight="380"
+        WindowStartupLocation="CenterOwner"
+        ResizeMode="CanResize"
+        ShowInTaskbar="True"
+        WindowBackdropType="None"
+        ExtendsContentIntoTitleBar="True"
+        WindowCornerPreference="Round">
+    <!-- The window background is not usable here: WPF-UI overwrites
+         FluentWindow.Background at load to let the backdrop show through, so a
+         value set in XAML is discarded. Painting the root panel is what actually
+         puts the palette behind the title bar and the footer. -->
+    <Grid Background="{DynamicResource ApplicationBackgroundBrush}"
+          TextElement.Foreground="{DynamicResource TextFillColorPrimaryBrush}">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+
+        <ui:TitleBar Grid.Row="0" Title="Verify results">
+            <ui:TitleBar.Icon>
+                <ui:SymbolIcon Symbol="ClipboardCheckmark24"/>
+            </ui:TitleBar.Icon>
+        </ui:TitleBar>
+
+        <DockPanel Grid.Row="1" Margin="20,8,20,16" LastChildFill="True">
+            <Grid DockPanel.Dock="Bottom" Margin="0,12,0,0">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="Auto"/>
+                </Grid.ColumnDefinitions>
+                <ui:Button Grid.Column="0" Content="Open change log" MinWidth="140" Click="OpenLogButton_Click"/>
+                <StackPanel Grid.Column="2" Orientation="Horizontal" HorizontalAlignment="Right">
+                    <!-- The whole point of the window: Verify used to report a count
+                         and leave the user with nowhere to go. -->
+                    <ui:Button x:Name="FixButton" Content="Fix these settings"
+                               Appearance="Primary" MinWidth="150" Margin="0,0,8,0"
+                               Click="FixButton_Click"/>
+                    <ui:Button x:Name="CloseButton" Content="Close" MinWidth="90" Click="CloseButton_Click"/>
+                </StackPanel>
+            </Grid>
+
+            <StackPanel DockPanel.Dock="Top" Margin="0,0,0,12">
+                <TextBlock x:Name="HeaderText" FontSize="16" FontWeight="SemiBold" TextWrapping="Wrap"/>
+                <TextBlock x:Name="SubText"
+                           Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                           FontSize="12" Margin="0,3,0,0"
+                           TextWrapping="Wrap"/>
+            </StackPanel>
+
+            <ScrollViewer VerticalScrollBarVisibility="Auto">
+                <ItemsControl x:Name="ItemsList">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate>
+                            <ui:Card Padding="14" Margin="0,0,0,8">
+                                <StackPanel>
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="*"/>
+                                            <ColumnDefinition Width="Auto"/>
+                                        </Grid.ColumnDefinitions>
+                                        <TextBlock Grid.Column="0" Text="{Binding Description}"
+                                                   FontWeight="SemiBold" VerticalAlignment="Center"
+                                                   TextWrapping="Wrap"/>
+                                        <!-- An unmonitored setting is exactly the case that made
+                                             Verify and the Status count disagree, so it is labelled
+                                             rather than silently mixed in. -->
+                                        <Border Grid.Column="1" Visibility="{Binding UnmonitoredBadgeVisibility}"
+                                                Background="{DynamicResource SystemFillColorNeutralBackgroundBrush}"
+                                                CornerRadius="3" Padding="6,1" Margin="8,0,0,0"
+                                                VerticalAlignment="Center">
+                                            <TextBlock Text="not monitored"
+                                                       Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                                                       FontSize="10" FontWeight="SemiBold"/>
+                                        </Border>
+                                    </Grid>
+                                    <TextBlock Margin="0,4,0,0" FontSize="12">
+                                        <Run Text="Now: "/><Run Text="{Binding CurrentValue, Mode=OneWay}"
+                                             Foreground="{DynamicResource SystemFillColorCautionBrush}" FontWeight="SemiBold"/>
+                                        <Run Text="    →    "/>
+                                        <Run Text="You want: "/><Run Text="{Binding DesiredValue, Mode=OneWay}"
+                                             Foreground="{DynamicResource TextFillColorSecondaryBrush}"/>
+                                    </TextBlock>
+                                    <TextBlock Margin="0,6,0,0" FontSize="11"
+                                               Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                                               TextWrapping="Wrap"
+                                               Text="{Binding SectionNote}"/>
+                                </StackPanel>
+                            </ui:Card>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+            </ScrollViewer>
+        </DockPanel>
+    </Grid>
+</ui:FluentWindow>