feat(installer): add Diagnose section to SettingsWindow

Re-runs the environment checks against the installed configuration
(worker.config.json + detected install dir) without blocking navigation
and without auto-running on window open, only on a "Recheck" click.

Extracted the check-row rendering and check-run logic (busy state,
summary, Recheck command) out of SystemCheckPage into a shared
Checks/CheckListViewModel + Checks/CheckListView, composed by both
SystemCheckPage (wizard) and the new DiagnosePage (settings) instead
of duplicating it.

tests/ClaudeDo.Installer.Tests/PageResolverTests.cs

@@ -1,4 +1,6 @@
+using ClaudeDo.Installer.Checks;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Pages.DiagnosePage;
 using ClaudeDo.Installer.Pages.PathsPage;
 using ClaudeDo.Installer.Pages.ServicePage;
 using ClaudeDo.Installer.Pages.SystemCheckPage;
@@ -40,4 +42,33 @@ public class PageResolverTests
 
         Assert.False(page.ShowInSettings);
     }
+
+    [Fact]
+    public void DiagnosePage_is_shown_in_settings_but_not_in_the_wizard()
+    {
+        var context = new InstallContext();
+        var page = new DiagnosePageViewModel(context, () => throw new InvalidOperationException(), () => new InstallerWorkerConfig());
+
+        Assert.True(page.ShowInSettings);
+        Assert.False(page.ShowInWizard);
+    }
+
+    [Fact]
+    public void DiagnosePage_appears_in_the_settings_sidebar_after_the_other_settings_pages()
+    {
+        var context = new InstallContext();
+        var pages = new IInstallerPage[]
+        {
+            new PathsPageViewModel(context),
+            new ServicePageViewModel(context),
+            new UiSettingsPageViewModel(context),
+            new DiagnosePageViewModel(context, () => throw new InvalidOperationException(), () => new InstallerWorkerConfig()),
+        };
+
+        var resolver = new PageResolver(pages);
+        var settingsPages = resolver.SettingsPages.ToList();
+
+        Assert.Equal(4, settingsPages.Count);
+        Assert.IsType<DiagnosePageViewModel>(settingsPages[^1]);
+    }
 }

tests/ClaudeDo.Installer.Tests/Pages/DiagnosePage/DiagnosePageViewModelTests.cs

@@ -0,0 +1,125 @@
+using System.Net;
+using System.Net.Sockets;
+using ClaudeDo.Installer.Checks;
+using ClaudeDo.Installer.Checks.Interfaces;
+using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Tests.Pages.SystemCheckPage;
+using Vm = ClaudeDo.Installer.Pages.DiagnosePage.DiagnosePageViewModel;
+
+namespace ClaudeDo.Installer.Tests.Pages.DiagnosePage;
+
+public sealed class DiagnosePageViewModelTests
+{
+    private sealed class FakeOwnerResolver : IPortOwnerResolver
+    {
+        private readonly string? _owner;
+        public FakeOwnerResolver(string? owner) => _owner = owner;
+        public Task<string?> FindOwningProcessNameAsync(int port, CancellationToken ct) => Task.FromResult(_owner);
+    }
+
+    private static int GetFreePort()
+    {
+        var listener = new TcpListener(IPAddress.Loopback, 0);
+        listener.Start();
+        var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+        listener.Stop();
+        return port;
+    }
+
+    [Fact]
+    public async Task Loading_the_page_does_not_run_checks()
+    {
+        var check = FakeEnvironmentCheck.Ok("a");
+        var vm = new Vm(
+            new InstallContext(),
+            () => new EnvironmentCheckService(new IEnvironmentCheck[] { check }),
+            () => new InstallerWorkerConfig());
+
+        await vm.LoadAsync();
+
+        Assert.Equal(0, check.CallCount);
+        Assert.False(vm.Checks.HasRun);
+        Assert.Empty(vm.Checks.Rows);
+    }
+
+    [Fact]
+    public async Task Clicking_check_runs_once_and_a_second_click_during_the_run_starts_no_new_run()
+    {
+        var gate = new TaskCompletionSource();
+        var slow = new FakeEnvironmentCheck("slow", CheckSeverity.Error, async (_, _) =>
+        {
+            await gate.Task;
+            return CheckResult.Ok("slow", CheckSeverity.Error, "checks.slow.title", "ok");
+        });
+
+        var factoryCalls = 0;
+        var vm = new Vm(
+            new InstallContext(),
+            () =>
+            {
+                factoryCalls++;
+                return new EnvironmentCheckService(new IEnvironmentCheck[] { slow });
+            },
+            () => new InstallerWorkerConfig());
+
+        await vm.LoadAsync();
+
+        var firstRun = vm.Checks.RunChecksCommand.ExecuteAsync(null);
+        Assert.True(vm.Checks.IsRunning);
+
+        await vm.Checks.RunChecksCommand.ExecuteAsync(null); // second click while the first run is still in flight
+
+        Assert.Equal(1, factoryCalls);
+        Assert.Equal(1, slow.CallCount);
+
+        gate.SetResult();
+        await firstRun;
+
+        Assert.False(vm.Checks.IsRunning);
+    }
+
+    [Fact]
+    public async Task Checks_run_against_the_installed_configuration_not_context_defaults()
+    {
+        InstallContext? capturedCtx = null;
+        var probe = new FakeEnvironmentCheck("probe", CheckSeverity.Warning, (ctx, _) =>
+        {
+            capturedCtx = ctx;
+            return Task.FromResult(CheckResult.Ok("probe", CheckSeverity.Warning, "checks.probe.title", "ok"));
+        });
+
+        var sharedContext = new InstallContext { InstallDirectory = @"C:\Program Files\ClaudeDo" };
+        var vm = new Vm(
+            sharedContext,
+            () => new EnvironmentCheckService(new IEnvironmentCheck[] { probe }),
+            () => new InstallerWorkerConfig { ClaudeBin = @"C:\installed\claude.exe", SignalRPort = 55555 });
+
+        await vm.LoadAsync();
+        await vm.Checks.RunChecksCommand.ExecuteAsync(null);
+
+        Assert.NotNull(capturedCtx);
+        Assert.Equal(@"C:\installed\claude.exe", capturedCtx!.ClaudeBin);
+        Assert.Equal(55555, capturedCtx.SignalRPort);
+        Assert.Equal(@"C:\Program Files\ClaudeDo", capturedCtx.InstallDirectory);
+    }
+
+    [Fact]
+    public async Task Worker_already_running_on_the_installed_signalr_port_reports_ok()
+    {
+        var port = GetFreePort();
+        using var occupying = new TcpListener(IPAddress.Loopback, port);
+        occupying.Start();
+
+        var sharedContext = new InstallContext { ExternalMcpPort = GetFreePort() };
+        var vm = new Vm(
+            sharedContext,
+            () => new EnvironmentCheckService(new IEnvironmentCheck[] { new PortCheck(new FakeOwnerResolver("ClaudeDo.Worker")) }),
+            () => new InstallerWorkerConfig { SignalRPort = port });
+
+        await vm.LoadAsync();
+        await vm.Checks.RunChecksCommand.ExecuteAsync(null);
+
+        var row = Assert.Single(vm.Checks.Rows);
+        Assert.Equal(CheckStatus.Ok, row.Status);
+    }
+}