From ed66de5ba232f8fc100e237629f8c0d9cb0eea36 Mon Sep 17 00:00:00 2001
From: Norton Andreev <norton@nortonandreev.com>
Date: Fri, 23 Oct 2026 15:26:58 +0300
Subject: [PATCH 1/4] app: Name what already-open agents pick up on the done
 step

Hooks load when an agent starts, so the line says that agents already open start sending sessions to the workspace (or recording on the machine, in local mode) after a restart. It is hidden when setup turned on no recording.
---
 .../Onboarding/DoneStepViewModel.cs           |  6 ++++++
 .../Views/Onboarding/DonePaneView.axaml       |  4 ++--
 .../DoneStepViewModelTests.cs                 | 20 +++++++++++++++++++
 3 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs b/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
index 4ebe7657a..48362e11e 100644
--- a/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
+++ b/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
@@ -103,6 +103,12 @@ public DoneStepViewModel(Func<DoneFacts> facts, IUrlOpener? opener = null) {
         : Import is null              ? "kcap import brings your existing history over whenever you want."
         :                               null;
 
+    /// Hooks load at agent start, so an agent open since before setup records nothing until it restarts.
+    public string? RestartLine =>
+        !CapturePromised ? null
+        : _current.Local ? $"New hooks load when an agent starts, so agents you already have open start recording on {_current.MachineName} after a restart."
+        :                  "New hooks load when an agent starts, so agents you already have open start sending sessions to your workspace after a restart.";
+
     public IReadOnlyList<CaptureItem> Capture => [.. _current.Recording.Select(label => new CaptureItem(label, _current.PathHazard))];
 
     public bool CaptureVisible => _current.Recording.Count > 0;
diff --git a/src/Capacitor.App/Views/Onboarding/DonePaneView.axaml b/src/Capacitor.App/Views/Onboarding/DonePaneView.axaml
index 0e8124f08..f43db997d 100644
--- a/src/Capacitor.App/Views/Onboarding/DonePaneView.axaml
+++ b/src/Capacitor.App/Views/Onboarding/DonePaneView.axaml
@@ -110,8 +110,8 @@
         </Border>
 
         <Grid ColumnDefinitions="*,Auto" ColumnSpacing="24">
-            <TextBlock Classes="onboardingNote" VerticalAlignment="Center"
-                       Text="Agents you already have open pick this up when they next start." />
+            <TextBlock Classes="onboardingNote" VerticalAlignment="Center" Text="{Binding RestartLine}"
+                       IsVisible="{Binding RestartLine, Converter={x:Static StringConverters.IsNotNullOrEmpty}}" />
             <Button Grid.Column="1" x:Name="OpenWorkspaceButton" Classes="onboardingLink"
                     AutomationProperties.Name="Open your workspace"
                     Command="{Binding OpenWorkspaceCommand}" IsVisible="{Binding WorkspaceVisible}">
diff --git a/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs b/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
index ed9caf236..e64c161eb 100644
--- a/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
+++ b/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
@@ -44,6 +44,26 @@ async Task<string> TitleFor(DoneFacts facts) {
         await Assert.That(blocked).IsEqualTo("No new recording connections");
     }
 
+    [Test]
+    [NotInParallel("AvaloniaSession")]
+    public async Task The_restart_line_shows_only_when_new_hooks_need_one() {
+        var (remote, local, nothing, blocked) = await AvaloniaSession.DispatchAsync(async () => {
+            async Task<string?> LineFor(DoneFacts facts) {
+                var vm = new DoneStepViewModel(() => facts);
+                await vm.OnEnterAsync(CancellationToken.None);
+                return vm.RestartLine;
+            }
+
+            return (await LineFor(Facts()), await LineFor(Facts() with { Local = true }),
+                await LineFor(Facts(recording: [])), await LineFor(Facts(hazard: true)));
+        });
+
+        await Assert.That(remote).Contains("your workspace after a restart");
+        await Assert.That(local).Contains("recording on test-mac after a restart");
+        await Assert.That(nothing).IsNull();
+        await Assert.That(blocked).IsNull();
+    }
+
     [Test]
     [NotInParallel("AvaloniaSession")]
     public async Task Failed_uploads_are_named_with_where_they_still_are() {

From f790dd096d4be8c157c0513a1b58ce9c3ee3a2a6 Mon Sep 17 00:00:00 2001
From: Norton Andreev <norton@nortonandreev.com>
Date: Fri, 23 Oct 2026 16:14:44 +0300
Subject: [PATCH 2/4] app: Split the done step's restart line into the reason
 and the action

---
 src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs | 5 +----
 test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs      | 4 ++--
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs b/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
index 48362e11e..fd06d281c 100644
--- a/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
+++ b/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
@@ -104,10 +104,7 @@ public DoneStepViewModel(Func<DoneFacts> facts, IUrlOpener? opener = null) {
         :                               null;
 
     /// Hooks load at agent start, so an agent open since before setup records nothing until it restarts.
-    public string? RestartLine =>
-        !CapturePromised ? null
-        : _current.Local ? $"New hooks load when an agent starts, so agents you already have open start recording on {_current.MachineName} after a restart."
-        :                  "New hooks load when an agent starts, so agents you already have open start sending sessions to your workspace after a restart.";
+    public string? RestartLine => CapturePromised ? "Agents load new hooks when they start. Restart any that are already open." : null;
 
     public IReadOnlyList<CaptureItem> Capture => [.. _current.Recording.Select(label => new CaptureItem(label, _current.PathHazard))];
 
diff --git a/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs b/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
index e64c161eb..17315794d 100644
--- a/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
+++ b/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
@@ -58,8 +58,8 @@ public async Task The_restart_line_shows_only_when_new_hooks_need_one() {
                 await LineFor(Facts(recording: [])), await LineFor(Facts(hazard: true)));
         });
 
-        await Assert.That(remote).Contains("your workspace after a restart");
-        await Assert.That(local).Contains("recording on test-mac after a restart");
+        await Assert.That(remote).Contains("Restart any that are already open");
+        await Assert.That(local).IsEqualTo(remote);
         await Assert.That(nothing).IsNull();
         await Assert.That(blocked).IsNull();
     }

From d8fd310ea7d40af58efe20761309b10d3e9d0dde Mon Sep 17 00:00:00 2001
From: Norton Andreev <norton@nortonandreev.com>
Date: Fri, 23 Oct 2026 16:20:11 +0300
Subject: [PATCH 3/4] app: Name the agent in the done step's restart line

---
 src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs | 2 +-
 test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs b/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
index fd06d281c..c14f9940f 100644
--- a/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
+++ b/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
@@ -104,7 +104,7 @@ public DoneStepViewModel(Func<DoneFacts> facts, IUrlOpener? opener = null) {
         :                               null;
 
     /// Hooks load at agent start, so an agent open since before setup records nothing until it restarts.
-    public string? RestartLine => CapturePromised ? "Agents load new hooks when they start. Restart any that are already open." : null;
+    public string? RestartLine => CapturePromised ? "Agents load new hooks at startup. Restart any agent you already have open." : null;
 
     public IReadOnlyList<CaptureItem> Capture => [.. _current.Recording.Select(label => new CaptureItem(label, _current.PathHazard))];
 
diff --git a/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs b/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
index 17315794d..074c4062a 100644
--- a/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
+++ b/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
@@ -58,7 +58,7 @@ public async Task The_restart_line_shows_only_when_new_hooks_need_one() {
                 await LineFor(Facts(recording: [])), await LineFor(Facts(hazard: true)));
         });
 
-        await Assert.That(remote).Contains("Restart any that are already open");
+        await Assert.That(remote).Contains("Restart any agent you already have open");
         await Assert.That(local).IsEqualTo(remote);
         await Assert.That(nothing).IsNull();
         await Assert.That(blocked).IsNull();

From d2f4168b4da592fba380084c83b6c0964d90f979 Mon Sep 17 00:00:00 2001
From: Norton Andreev <norton@nortonandreev.com>
Date: Fri, 23 Oct 2026 16:59:17 +0300
Subject: [PATCH 4/4] app: Register the CLI before setup opens the dashboard
 (#1882)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #1853 — AI-4262

Stacked on #1881 (same done-step row); retargets to `main` once that
merges.

## What & why

**Open your workspace** opened the dashboard before the server had the
cli-setup report, which the app sent only after setup closed, so the
website offered a CLI download the app already includes. The Done step
now brings the daemon up and sends the report first, showing "Getting
your workspace ready…" until it lands. If either fails, a warning card
says why and offers **Try again**. The report is bounded at 30 s, so a
silent server never leaves a spinner.

## Where to look

Ready is never revoked once reached. A failed daemon run is repeated
only on Try again, so a declined service takeover is not asked again. No
website change is needed: kcap-server clears its install-cli step on
`POST /api/users/me/cli-setup`.

## Verification

Full `Capacitor.App.Tests.Unit` after the rebase: 4,245 passed, 10
skipped, 0 failed. Headless renders of the real Done view:

| | Workspace | Local |
|---|---|---|
| Before | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/before-cloud.png"
width="340"> | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/before-local.png"
width="340"> |
| Preparing | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/after-cloud-preparing.png"
width="340"> | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/after-local-preparing.png"
width="340"> |
| Ready | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/after-cloud-ready.png"
width="340"> | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/after-local-ready.png"
width="340"> |
| Report failed | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/after-cloud-unreported.png"
width="340"> | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/after-local-unreported.png"
width="340"> |
| Daemon not running | <img
src="https://raw.githubusercontent.com/kurrent-io/kcap-cli/9fe9ce4f91025c497885a36ce7219fcf9b303d3e/1853/after-cloud-daemon-not-running.png"
width="340"> | |
---
 src/Capacitor.App/App.axaml.cs                |  59 ++++++---
 .../Services/Onboarding/WizardComposition.cs  |  19 ++-
 .../Onboarding/DoneStepViewModel.cs           | 106 ++++++++++++++--
 .../Onboarding/WorkspaceReadiness.cs          |   5 +
 .../Views/Onboarding/DonePaneView.axaml       |  26 ++++
 .../DoneStepViewModelTests.cs                 | 117 ++++++++++++++++++
 .../WizardCompositionTests.cs                 |  50 ++++++++
 7 files changed, 355 insertions(+), 27 deletions(-)
 create mode 100644 src/Capacitor.App/ViewModels/Onboarding/WorkspaceReadiness.cs

diff --git a/src/Capacitor.App/App.axaml.cs b/src/Capacitor.App/App.axaml.cs
index 6c1a9a455..6320dcb9a 100644
--- a/src/Capacitor.App/App.axaml.cs
+++ b/src/Capacitor.App/App.axaml.cs
@@ -703,8 +703,7 @@ void BuildDaemonGraph(
         _modelCatalog = modelCatalog;
         _ = modelCatalog.LoadAsync(_shutdown.Token);
 
-        var reportCliSetup = ServerCliSetupReport.Sender(
-            sessionHttp, profiles, typeof(CapacitorVersion).Assembly.GetName().Version?.ToString());
+        var reportCliSetup = ServerCliSetupReport.Sender(sessionHttp, profiles, ReportedCliVersion);
         _ = reportCliSetup(_shutdown.Token);
 
         // After the directory, which feeds it the session→agent map: a server-lane item names a
@@ -1237,7 +1236,8 @@ async Task<bool> RunWizardModeAsync(
             ConfiguredDaemonName: () => ResolveConfiguredDaemonName(_config, _serverEnv, _localRoot),
             HeldDaemonNames: HeldDaemonNamesAsync,
             ProfileOverride: _serverEnv.Profile,
-            UsageNotice: _usageNotice);
+            UsageNotice: _usageNotice,
+            ReportCliSetup: ReportWizardCliSetupAsync);
         _localInstall ??= WizardComposition.NewInstallController(options);
         var graph = WizardComposition.BuildGraph(options with { Install = _localInstall });
 
@@ -1738,25 +1738,33 @@ internal static (string Profile, string Server, string DaemonName)? ResolveWizar
     }
 
     // A throwaway lane over a fresh resolution: the cached ServerLane is bound to the first profile it
-    // saw, and the wizard has only just signed in.
+    // saw, and the wizard has only just signed in. Null when the profile names no server.
+    async Task<(ServiceProvider Lane, ProfileContext Profiles)?> FreshServerLaneAsync(CancellationToken ct) {
+        var (_, profiles) = await ResolveAndEvaluateGateAsync(
+            _config, _foreignHttp.GetRequiredService<TokenStore>(), _serverEnv, _localRoot, _time, ct).ConfigureAwait(false);
+        if (profiles?.Resolution.ServerUrl is not { Length: > 0 } url) return null;
+
+        var lane = new ServiceCollection()
+            .AddSingleton(_config)
+            .AddSingleton(profiles)
+            .AddSingleton(new CapacitorServer(url, _config, profiles, _localRoot))
+            .AddCapacitorHttp(_serverEnv, _machineEnv)
+            .BuildValidated();
+
+        return (lane, profiles);
+    }
+
     async Task<IReadOnlyDictionary<string, DaemonNameHolding>> HeldDaemonNamesAsync(CancellationToken ct) {
         try {
-            var (_, profiles) = await ResolveAndEvaluateGateAsync(
-                _config, _foreignHttp.GetRequiredService<TokenStore>(), _serverEnv, _localRoot, _time, ct).ConfigureAwait(false);
-            if (profiles?.Resolution.ServerUrl is not { Length: > 0 } url) return FrozenDictionary<string, DaemonNameHolding>.Empty;
-
-            await using var lane = new ServiceCollection()
-                .AddSingleton(_config)
-                .AddSingleton(profiles)
-                .AddSingleton(new CapacitorServer(url, _config, profiles, _localRoot))
-                .AddCapacitorHttp(_serverEnv, _machineEnv)
-                .BuildValidated();
+            if (await FreshServerLaneAsync(ct).ConfigureAwait(false) is not ({ } lane, { } profiles))
+                return FrozenDictionary<string, DaemonNameHolding>.Empty;
+            await using var _ = lane;
 
             var (client, status, _, _) = await lane.GetRequiredService<ICapacitorHttpClient>().ForWaitAsync(ct).ConfigureAwait(false);
             using (client) {
                 if (status is not (AuthStatus.Ok or AuthStatus.NoAuthRequired)) return FrozenDictionary<string, DaemonNameHolding>.Empty;
 
-                return await DaemonNameHolder.HeldElsewhereAsync(client, url, _config, ct).ConfigureAwait(false);
+                return await DaemonNameHolder.HeldElsewhereAsync(client, profiles.Resolution.ServerUrl!, _config, ct).ConfigureAwait(false);
             }
         } catch (Exception ex) when (!ct.IsCancellationRequested) {
             Console.Error.WriteLine($"kcap: daemon name lookup failed — offering the configured name: {ex.Message}");
@@ -1764,6 +1772,27 @@ async Task<IReadOnlyDictionary<string, DaemonNameHolding>> HeldDaemonNamesAsync(
         }
     }
 
+    // Sent from the wizard so the dashboard it opens already knows this install. Bounded, so a
+    // server that never answers leaves the Done page on a retry rather than a spinner.
+    async Task<bool> ReportWizardCliSetupAsync(CancellationToken ct) {
+        using var timeout = new CancellationTokenSource(WizardCliSetupReportTimeout, _time);
+        using var bounded = CancellationTokenSource.CreateLinkedTokenSource(ct, timeout.Token);
+        try {
+            if (await FreshServerLaneAsync(bounded.Token).ConfigureAwait(false) is not ({ } lane, { } profiles)) return false;
+            await using var _ = lane;
+
+            return await ServerCliSetupReport.Sender(lane.GetRequiredService<ICapacitorHttpClient>(), profiles, ReportedCliVersion)(bounded.Token)
+                .ConfigureAwait(false);
+        } catch (Exception ex) when (!ct.IsCancellationRequested) {
+            Console.Error.WriteLine($"kcap: cli-setup report from setup failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    static readonly TimeSpan WizardCliSetupReportTimeout = TimeSpan.FromSeconds(30);
+
+    static string? ReportedCliVersion => typeof(CapacitorVersion).Assembly.GetName().Version?.ToString();
+
     // Delegates to the ONE shared validator: must agree with OnboardingGate on what counts as a
     // valid server_url (e.g. both reject file://), or a gate-incomplete machine could still pass
     // this precondition into the normal daemon graph.
diff --git a/src/Capacitor.App/Services/Onboarding/WizardComposition.cs b/src/Capacitor.App/Services/Onboarding/WizardComposition.cs
index 16cde0594..2a73f7e52 100644
--- a/src/Capacitor.App/Services/Onboarding/WizardComposition.cs
+++ b/src/Capacitor.App/Services/Onboarding/WizardComposition.cs
@@ -94,7 +94,9 @@ internal sealed record WizardGraphOptions(
     // The app's one install controller, shared by every wizard it shows; null builds a graph-local one.
     LocalInstallController?                                                      Install = null,
     // Null, or already acknowledged, leaves the Privacy page out of the run.
-    UsageDataNotice?                                                             UsageNotice = null);
+    UsageDataNotice?                                                             UsageNotice = null,
+    // Tells the configured server this machine has kcap installed; true once it accepted.
+    Func<CancellationToken, Task<bool>>?                                         ReportCliSetup = null);
 
 /// The wizard half of the composition root, split out of App so it can be driven
 /// with fakes: nothing here touches a daemon, a socket or the network until a step is used.
@@ -262,7 +264,7 @@ [.. recording.Select(r => r.Label)],
                 daemon.Problem,
                 local,
                 local ? LocalEndpoints.Read(root).Active?.ServerUrl : null);
-        }, options.UrlOpener);
+        }, options.UrlOpener, PrepareWorkspaceAsync);
         IWizardStep[] steps = [edition, installStep, signIn, harnesses, history, new UsageDataStepViewModel(options.UsageNotice), done];
 
         // Before a server is connected the app has nothing to show, so deferring is offered only for the optional steps after.
@@ -290,6 +292,19 @@ [.. recording.Select(r => r.Label)],
         return new WizardGraph(wizard, auth, steps, history, connect, daemon, install, pathFix);
 
         bool Connected() => signIn.Satisfied || Installed() || CommittedLocal();
+
+        // A run already in flight is waited out, never queued behind: a second run straight after a
+        // declined takeover would ask again. A failed run is repeated only when the user retries.
+        async Task<WorkspaceReadiness> PrepareWorkspaceAsync(bool retry) {
+            await daemon.QuiescedAsync().ConfigureAwait(true);
+            if (!daemon.Satisfied && (retry || daemon.Problem is null))
+                await daemon.EnsureAsync(options.ShutdownToken).ConfigureAwait(true);
+            if (!daemon.Satisfied) return WorkspaceReadiness.DaemonNotRunning;
+
+            return options.ReportCliSetup is null || await options.ReportCliSetup(options.ShutdownToken).ConfigureAwait(true)
+                ? WorkspaceReadiness.Ready
+                : WorkspaceReadiness.Unreported;
+        }
     }
 
     /// Why this machine cannot take the local edition, or null when it can. A cloud profile anywhere
diff --git a/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs b/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
index c14f9940f..7235466ee 100644
--- a/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
+++ b/src/Capacitor.App/ViewModels/Onboarding/DoneStepViewModel.cs
@@ -1,6 +1,7 @@
 using System.ComponentModel;
 using System.Globalization;
 using System.Reactive;
+using System.Reactive.Linq;
 using Capacitor.App.Services;
 using ReactiveUI.Reactive;
 
@@ -14,15 +15,25 @@ namespace Capacitor.App.ViewModels.Onboarding;
 public sealed class DoneStepViewModel : ReactiveObject, IWizardStep {
     readonly Func<DoneFacts> _facts;
     readonly IUrlOpener?     _opener;
+    readonly Func<bool, Task<WorkspaceReadiness>>? _prepare;
 
     DoneFacts _current = DoneFacts.Empty;
-
-    public DoneStepViewModel(Func<DoneFacts> facts, IUrlOpener? opener = null) {
-        _facts  = facts;
-        _opener = opener;
-
-        OpenWorkspaceCommand = ReactiveCommand.Create(OpenWorkspace);
-        OpenDashboardCommand = ReactiveCommand.Create(OpenDashboard);
+    WorkspaceReadiness _readiness;
+    bool _preparing;
+    string? _readyFor;
+
+    /// <param name="prepare">Brings the daemon up and reports the install, answering whether the
+    /// dashboard may open; true asks it to try again. Null when there is nothing to wait for.</param>
+    public DoneStepViewModel(Func<DoneFacts> facts, IUrlOpener? opener = null, Func<bool, Task<WorkspaceReadiness>>? prepare = null) {
+        _facts     = facts;
+        _opener    = opener;
+        _prepare   = prepare;
+        _readiness = prepare is null ? WorkspaceReadiness.Ready : WorkspaceReadiness.Preparing;
+
+        var ready = this.WhenAnyValue(x => x.Readiness).Select(r => r == WorkspaceReadiness.Ready);
+        OpenWorkspaceCommand = ReactiveCommand.Create(OpenWorkspace, ready);
+        OpenDashboardCommand = ReactiveCommand.Create(OpenDashboard, ready);
+        RetryCommand         = ReactiveCommand.CreateFromTask(() => PrepareAsync(retry: true));
     }
 
     public WizardStepId Id         => WizardStepId.Done;
@@ -120,22 +131,95 @@ public DoneStepViewModel(Func<DoneFacts> facts, IUrlOpener? opener = null) {
             ? $"{problem} The app tries again once setup closes."
             : $"The daemon is being set up as a service on {_current.MachineName}. The app keeps it running from here.";
 
-    public bool WorkspaceVisible => !_current.Local && !string.IsNullOrEmpty(_current.WorkspaceUrl);
+    public WorkspaceReadiness Readiness {
+        get => _readiness;
+        private set {
+            if (_readiness == value) return;
+            _readiness = value;
+            this.RaisePropertyChanged();
+            Restate();
+        }
+    }
+
+    bool WorkspaceKnown => !_current.Local && !string.IsNullOrEmpty(_current.WorkspaceUrl);
+
+    bool DashboardKnown => _current.Local && !string.IsNullOrEmpty(_current.DashboardUrl);
+
+    bool Opens => WorkspaceKnown || DashboardKnown;
+
+    public bool WorkspaceVisible => WorkspaceKnown && Readiness == WorkspaceReadiness.Ready;
 
-    public bool DashboardVisible => _current.Local && !string.IsNullOrEmpty(_current.DashboardUrl);
+    public bool DashboardVisible => DashboardKnown && Readiness == WorkspaceReadiness.Ready;
+
+    public bool PreparingVisible => Opens && Readiness == WorkspaceReadiness.Preparing;
+
+    public string PreparingLine => _current.Local ? "Getting your dashboard ready…" : "Getting your workspace ready…";
+
+    public bool NotReadyVisible => Opens && Readiness is WorkspaceReadiness.DaemonNotRunning or WorkspaceReadiness.Unreported;
+
+    public string NotReadyTitle => _current.Local ? "The dashboard can't open yet" : "Your workspace can't open yet";
+
+    public string NotReadyBody => Readiness == WorkspaceReadiness.DaemonNotRunning
+        ? $"It opens once the daemon is running on {_current.MachineName}."
+        : _current.Local
+            ? "kcap couldn't reach the local server to register this machine."
+            : "kcap couldn't reach your workspace to register this machine. Check your connection.";
 
     public ReactiveCommand<Unit, Unit> OpenWorkspaceCommand { get; }
 
     public ReactiveCommand<Unit, Unit> OpenDashboardCommand { get; }
 
+    public ReactiveCommand<Unit, Unit> RetryCommand { get; }
+
     /// Re-read on every entry: Back-then-forward can change what the earlier pages did.
     public Task OnEnterAsync(CancellationToken ct) {
+        Refresh();
+        // Back to sign-in can switch to a server that has not had this install's report.
+        if (_prepare is not null && Readiness == WorkspaceReadiness.Ready && _readyFor != Target) Readiness = WorkspaceReadiness.Preparing;
+        if (Readiness != WorkspaceReadiness.Ready) _ = PrepareAsync(retry: false);
+
+        return Task.CompletedTask;
+    }
+
+    // What the link opens, and so which server must have the report.
+    string? Target => _current.Local ? _current.DashboardUrl : _current.WorkspaceUrl;
+
+    void Refresh() {
         if (_current.Import is INotifyPropertyChanged before) before.PropertyChanged -= OnImportChanged;
         _current = _facts();
         if (_current.Import is INotifyPropertyChanged after) after.PropertyChanged += OnImportChanged;
         Restate();
+    }
 
-        return Task.CompletedTask;
+    /// Ready holds for the server that took the report: a later failure cannot make it ask again,
+    /// but a different server has to be prepared afresh.
+    async Task PrepareAsync(bool retry) {
+        if (_prepare is null || _preparing || Readiness == WorkspaceReadiness.Ready) return;
+
+        _preparing = true;
+        Readiness  = WorkspaceReadiness.Preparing;
+        var target = Target;
+        WorkspaceReadiness result;
+        try {
+            result = await _prepare(retry).ConfigureAwait(true);
+        } catch (Exception ex) {
+            Console.Error.WriteLine($"kcap: could not get the workspace ready: {ex.Message}");
+            result = WorkspaceReadiness.Unreported;
+        } finally {
+            _preparing = false;
+        }
+
+        // The daemon line reads the run that just settled.
+        Refresh();
+
+        // Sign-in moved to another server while this ran; its answer says nothing about that one.
+        if (Target != target) {
+            await PrepareAsync(retry: false).ConfigureAwait(true);
+            return;
+        }
+
+        Readiness = result == WorkspaceReadiness.Preparing ? WorkspaceReadiness.Unreported : result;
+        if (Readiness == WorkspaceReadiness.Ready) _readyFor = target;
     }
 
     // Next finishes the wizard — the shell's own last-step handling raises CloseRequested.
@@ -144,6 +228,7 @@ public Task OnEnterAsync(CancellationToken ct) {
     void OnImportChanged(object? sender, PropertyChangedEventArgs e) => Restate();
 
     void OpenWorkspace() {
+        if (Readiness != WorkspaceReadiness.Ready) return;
         if (_current.WorkspaceUrl is not { Length: > 0 } url || _opener is null) return;
         try {
             _opener.Open(url);
@@ -153,6 +238,7 @@ void OpenWorkspace() {
     }
 
     void OpenDashboard() {
+        if (Readiness != WorkspaceReadiness.Ready) return;
         if (_current.DashboardUrl is not { Length: > 0 } url || _opener is null) return;
         try {
             _opener.Open(url);
diff --git a/src/Capacitor.App/ViewModels/Onboarding/WorkspaceReadiness.cs b/src/Capacitor.App/ViewModels/Onboarding/WorkspaceReadiness.cs
new file mode 100644
index 000000000..473203060
--- /dev/null
+++ b/src/Capacitor.App/ViewModels/Onboarding/WorkspaceReadiness.cs
@@ -0,0 +1,5 @@
+namespace Capacitor.App.ViewModels.Onboarding;
+
+/// Whether the Done page may open the dashboard: the daemon must be running and the server must
+/// have recorded this install, or the dashboard asks for an install the app already includes.
+public enum WorkspaceReadiness { Preparing, Ready, DaemonNotRunning, Unreported }
diff --git a/src/Capacitor.App/Views/Onboarding/DonePaneView.axaml b/src/Capacitor.App/Views/Onboarding/DonePaneView.axaml
index f43db997d..295a7e79e 100644
--- a/src/Capacitor.App/Views/Onboarding/DonePaneView.axaml
+++ b/src/Capacitor.App/Views/Onboarding/DonePaneView.axaml
@@ -109,9 +109,35 @@
             </StackPanel>
         </Border>
 
+        <!-- The dashboard opens only once this machine is registered with the server. -->
+        <Border x:Name="NotReadyPanel" Classes="onboardingWarning" IsVisible="{Binding NotReadyVisible}">
+            <Grid ColumnDefinitions="Auto,*,Auto" ColumnSpacing="9">
+                <views:AppIcon Kind="TriangleAlert" Size="14" VerticalAlignment="Top" Margin="0,2,0,0"
+                               Foreground="{StaticResource KcapDangerBrush}" />
+                <StackPanel Grid.Column="1" Spacing="5">
+                    <TextBlock x:Name="NotReadyTitleText" Classes="onboardingLabel" FontSize="12.5" Text="{Binding NotReadyTitle}" />
+                    <TextBlock Classes="onboardingDetail" Foreground="{StaticResource OnboardingMutedBrush}" Text="{Binding NotReadyBody}" />
+                </StackPanel>
+                <Button Grid.Column="2" x:Name="RetryButton" Classes="onboardingLink" Margin="15,0,0,0" VerticalAlignment="Center"
+                        AutomationProperties.Name="Try again" Command="{Binding RetryCommand}">
+                    <StackPanel Orientation="Horizontal" Spacing="6">
+                        <views:AppIcon Kind="RefreshCw" Size="13" />
+                        <TextBlock Text="Try again" VerticalAlignment="Center" />
+                    </StackPanel>
+                </Button>
+            </Grid>
+        </Border>
+
         <Grid ColumnDefinitions="*,Auto" ColumnSpacing="24">
             <TextBlock Classes="onboardingNote" VerticalAlignment="Center" Text="{Binding RestartLine}"
                        IsVisible="{Binding RestartLine, Converter={x:Static StringConverters.IsNotNullOrEmpty}}" />
+            <StackPanel Grid.Column="1" x:Name="PreparingRow" Orientation="Horizontal" Spacing="8" Margin="0,6"
+                        IsVisible="{Binding PreparingVisible}">
+                <views:AppIcon Kind="LoaderCircle" Size="14" Classes.kcapSpinning="{Binding PreparingVisible}"
+                               Foreground="{StaticResource OnboardingAccentBrush}" VerticalAlignment="Center" />
+                <TextBlock x:Name="PreparingLineText" Classes="onboardingDetail" VerticalAlignment="Center"
+                           Foreground="{StaticResource OnboardingMutedBrush}" Text="{Binding PreparingLine}" />
+            </StackPanel>
             <Button Grid.Column="1" x:Name="OpenWorkspaceButton" Classes="onboardingLink"
                     AutomationProperties.Name="Open your workspace"
                     Command="{Binding OpenWorkspaceCommand}" IsVisible="{Binding WorkspaceVisible}">
diff --git a/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs b/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
index 074c4062a..a0357275a 100644
--- a/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
+++ b/test/Capacitor.App.Tests.Unit/DoneStepViewModelTests.cs
@@ -1,3 +1,5 @@
+using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
 using Avalonia.Threading;
 using Capacitor.App.Services;
 using Capacitor.App.ViewModels.Onboarding;
@@ -149,6 +151,121 @@ public async Task Open_your_workspace_opens_the_signed_in_server() {
         await Assert.That(opened).IsEquivalentTo(["https://acme.kcap.ai"]);
     }
 
+    [Test]
+    [NotInParallel("AvaloniaSession")]
+    public async Task The_workspace_opens_only_once_this_machine_is_registered() {
+        var (preparing, early, openedEarly, ready, opened, prepares) = await AvaloniaSession.DispatchAsync(async () => {
+            var opener = new RecordingUrlOpener();
+            var registered = new TaskCompletionSource<WorkspaceReadiness>();
+            var calls = 0;
+            var vm = new DoneStepViewModel(() => Facts(), opener, _ => {
+                calls++;
+                return registered.Task;
+            });
+            await vm.OnEnterAsync(CancellationToken.None);
+            var (preparingVisible, workspaceVisible) = (vm.PreparingVisible, vm.WorkspaceVisible);
+            vm.OpenWorkspaceCommand.Execute().Subscribe(_ => { }, _ => { });
+            Dispatcher.UIThread.RunJobs();
+            var before = opener.Opened.Count;
+
+            registered.SetResult(WorkspaceReadiness.Ready);
+            await vm.WhenAnyValue(x => x.Readiness).FirstAsync(r => r == WorkspaceReadiness.Ready).ToTask();
+            await vm.OnEnterAsync(CancellationToken.None);
+            vm.OpenWorkspaceCommand.Execute().Subscribe();
+            Dispatcher.UIThread.RunJobs();
+
+            return (preparingVisible, workspaceVisible, before, vm.WorkspaceVisible && !vm.PreparingVisible, opener.Opened.ToList(), calls);
+        });
+
+        await Assert.That(preparing).IsTrue();
+        await Assert.That(early).IsFalse();
+        await Assert.That(openedEarly).IsEqualTo(0);
+        await Assert.That(ready).IsTrue();
+        await Assert.That(opened).IsEquivalentTo(["https://acme.kcap.ai"]);
+        await Assert.That(prepares).IsEqualTo(1);
+    }
+
+    [Test]
+    [NotInParallel("AvaloniaSession")]
+    public async Task A_machine_that_is_not_registered_offers_a_retry() {
+        var (notReady, title, body, linkWhileFailed, linkAfterRetry, calls) = await AvaloniaSession.DispatchAsync(async () => {
+            var calls = new List<bool>();
+            var vm = new DoneStepViewModel(() => Facts(), new RecordingUrlOpener(), retry => {
+                calls.Add(retry);
+                return Task.FromResult(calls.Count == 1 ? WorkspaceReadiness.DaemonNotRunning : WorkspaceReadiness.Ready);
+            });
+            await vm.OnEnterAsync(CancellationToken.None);
+            await vm.WhenAnyValue(x => x.Readiness).FirstAsync(r => r != WorkspaceReadiness.Preparing).ToTask();
+            var failed = (vm.NotReadyVisible, vm.NotReadyTitle, vm.NotReadyBody, vm.WorkspaceVisible);
+
+            await vm.RetryCommand.Execute().ToTask();
+
+            return (failed.NotReadyVisible, failed.NotReadyTitle, failed.NotReadyBody, failed.WorkspaceVisible, vm.WorkspaceVisible, calls);
+        });
+
+        await Assert.That(notReady).IsTrue();
+        await Assert.That(title).IsEqualTo("Your workspace can't open yet");
+        await Assert.That(body).Contains("daemon is running on test-mac");
+        await Assert.That(linkWhileFailed).IsFalse();
+        await Assert.That(linkAfterRetry).IsTrue();
+        await Assert.That(calls).IsEquivalentTo([false, true]);
+    }
+
+    [Test]
+    [NotInParallel("AvaloniaSession")]
+    public async Task Signing_in_to_another_workspace_registers_this_machine_again() {
+        var (linkBeforeReport, opened, calls) = await AvaloniaSession.DispatchAsync(async () => {
+            var opener = new RecordingUrlOpener();
+            var url = "https://acme.kcap.ai";
+            var reports = new List<TaskCompletionSource<WorkspaceReadiness>>();
+            var vm = new DoneStepViewModel(() => Facts() with { WorkspaceUrl = url }, opener, _ => {
+                reports.Add(new TaskCompletionSource<WorkspaceReadiness>());
+                return reports[^1].Task;
+            });
+            await vm.OnEnterAsync(CancellationToken.None);
+            reports[0].SetResult(WorkspaceReadiness.Ready);
+            await vm.WhenAnyValue(x => x.Readiness).FirstAsync(r => r == WorkspaceReadiness.Ready).ToTask();
+
+            url = "https://other.kcap.ai";
+            await vm.OnEnterAsync(CancellationToken.None);
+            var link = vm.WorkspaceVisible;
+            reports[1].SetResult(WorkspaceReadiness.Ready);
+            await vm.WhenAnyValue(x => x.Readiness).FirstAsync(r => r == WorkspaceReadiness.Ready).ToTask();
+            vm.OpenWorkspaceCommand.Execute().Subscribe();
+            Dispatcher.UIThread.RunJobs();
+
+            return (link, opener.Opened.ToList(), reports.Count);
+        });
+
+        await Assert.That(linkBeforeReport).IsFalse();
+        await Assert.That(opened).IsEquivalentTo(["https://other.kcap.ai"]);
+        await Assert.That(calls).IsEqualTo(2);
+    }
+
+    [Test]
+    [NotInParallel("AvaloniaSession")]
+    public async Task A_report_for_the_previous_workspace_does_not_open_the_new_one() {
+        var (readyAfterStaleReport, calls) = await AvaloniaSession.DispatchAsync(async () => {
+            var url = "https://acme.kcap.ai";
+            var reports = new List<TaskCompletionSource<WorkspaceReadiness>>();
+            var vm = new DoneStepViewModel(() => Facts() with { WorkspaceUrl = url }, new RecordingUrlOpener(), _ => {
+                reports.Add(new TaskCompletionSource<WorkspaceReadiness>());
+                return reports[^1].Task;
+            });
+            await vm.OnEnterAsync(CancellationToken.None);
+
+            url = "https://other.kcap.ai";
+            await vm.OnEnterAsync(CancellationToken.None);
+            reports[0].SetResult(WorkspaceReadiness.Ready);
+            Dispatcher.UIThread.RunJobs();
+
+            return (vm.Readiness == WorkspaceReadiness.Ready, reports.Count);
+        });
+
+        await Assert.That(readyAfterStaleReport).IsFalse();
+        await Assert.That(calls).IsEqualTo(2);
+    }
+
     static DoneFacts LocalFacts(string? dashboardUrl = "http://localhost:5050", HistoryImportRun? import = null) =>
         new(["Claude Code"], false, false, import, true, "test-mac", null, null, true, dashboardUrl);
 
diff --git a/test/Capacitor.App.Tests.Unit/WizardCompositionTests.cs b/test/Capacitor.App.Tests.Unit/WizardCompositionTests.cs
index 3586bd711..7439485fd 100644
--- a/test/Capacitor.App.Tests.Unit/WizardCompositionTests.cs
+++ b/test/Capacitor.App.Tests.Unit/WizardCompositionTests.cs
@@ -89,6 +89,56 @@ public async Task Resuming_an_authenticated_setup_enables_the_daemon_without_a_s
         await Assert.That(satisfied).IsTrue();
     }
 
+    [Test]
+    public async Task The_done_page_reports_the_install_once_the_daemon_runs_and_only_then_opens() {
+        using var harness = new WizardFixtures.GraphHarness(Config.Root);
+        harness.Cli.StatusBehavior = _ => Task.FromResult<ServiceSnapshot?>(
+            new ServiceSnapshot("daemon-a", false, "not_installed", null, "/opt/kcap/kcapd", null, null, false, false));
+        bool? daemonRanFirst = null;
+
+        var readiness = await AvaloniaSession.DispatchAsync(async () => {
+            WizardGraph? graph = null;
+            graph = WizardComposition.BuildGraph(harness.Options() with {
+                AlreadyAuthenticated = true,
+                ReportCliSetup = _ => {
+                    daemonRanFirst = graph!.Daemon.Satisfied;
+                    return Task.FromResult(true);
+                },
+            });
+            var done = graph.Steps.OfType<DoneStepViewModel>().Single();
+            await done.OnEnterAsync(CancellationToken.None);
+
+            return await done.WhenAnyValue(x => x.Readiness).FirstAsync(r => r != WorkspaceReadiness.Preparing).ToTask();
+        });
+
+        await Assert.That(readiness).IsEqualTo(WorkspaceReadiness.Ready);
+        await Assert.That(daemonRanFirst).IsTrue();
+    }
+
+    [Test]
+    public async Task The_done_page_does_not_report_an_install_whose_daemon_cannot_run() {
+        using var harness = new WizardFixtures.GraphHarness(Config.Root);
+        harness.Cli.CliPath = null;
+        var reports = 0;
+
+        var readiness = await AvaloniaSession.DispatchAsync(async () => {
+            var graph = WizardComposition.BuildGraph(harness.Options() with {
+                AlreadyAuthenticated = true,
+                ReportCliSetup = _ => {
+                    reports++;
+                    return Task.FromResult(true);
+                },
+            });
+            var done = graph.Steps.OfType<DoneStepViewModel>().Single();
+            await done.OnEnterAsync(CancellationToken.None);
+
+            return await done.WhenAnyValue(x => x.Readiness).FirstAsync(r => r != WorkspaceReadiness.Preparing).ToTask();
+        });
+
+        await Assert.That(readiness).IsEqualTo(WorkspaceReadiness.DaemonNotRunning);
+        await Assert.That(reports).IsEqualTo(0);
+    }
+
     [Test]
     public async Task A_configured_name_another_machine_holds_is_saved_as_its_free_variant_before_the_install() {
         WizardCompositionFixtures.WriteConfig(Config.Root,