Say how far a connection has got while it is still being made

The connecting card set its status string once, when the tab was created, and
never touched it again. Every connection therefore looked identical from the
outside: one three seconds into a key exchange, one waiting out a fifteen-second
timeout against a machine that is asleep, and one that had hung all drew the
same "connecting…". The card now draws the five steps of getting there, each lit
at the moment the handshake reports reaching it, over an amber track that fills
as they finish.

◆ NOTHING ON THE LIST IS INVENTED. Every row changes state because a layer below
it said so, at the instant the thing it names actually began.

That is the whole reason it is worth showing, and it is why most of this commit
is plumbing rather than XAML: there was no progress reporting anywhere in the
stack to hook a step list onto, and a card animating plausible progress would
have been indistinguishable from one that had stopped receiving any.

SshConnectionPhase names four phases and deliberately not more. SSH.NET runs the
entire handshake inside one ConnectAsync and raises exactly one event from the
middle of it — HostKeyReceived, once the key exchange has produced a key to show
— so that event is the only interior moment there is to report. Everything
before it is Reaching and everything after it is Authenticating. A fifth phase
in that assembly would have to be a timer, so there is not one. OpeningShell is
reported by TerminalWorkspace instead, because that is where it happens: the
factory's work ends with an authenticated connection, and asking for a
pseudo-terminal on one is a separate round trip. The SFTP path passes null — a
second connection opened behind an already-open shell has nobody watching a step
list for it.

The card's fifth step, "Starting the terminal", is the renderer wait and lives
in the shell rather than in the SSH assembly, which has never heard of a
renderer. On the first connection after a cold start it is a real wait with a
real failure mode of its own — a missing WebView2 runtime — so a list that began
at "reaching the host" would leave the one wait most likely to hang unnamed.

Amber for the step in flight, and that follows the palette's rule rather than
bending it. Green is what is true and purple is what you can press; a step still
happening is neither, and it is exactly the caveat-worth-reading that amber
exists for. Steps behind it go green as they become true. Nothing animates,
which is the argument TransfersScreen.axaml already makes for its own track,
reaching a screen with far more reason to want a spinner: a spinner is furniture
invented to fill a state nobody measured, and these states are measured, so the
track fills to what has finished and then waits there.

A refusal keeps the step it stopped on, in red, with the ones behind it still
green. That is the half a progress bar could not do, and it is the difference
between "that host is not there" and "that host is there and would not have me"
— a question the reason sentence alone frequently does not settle.

The strip's dot goes amber while a tab is connecting, on both heads. It was
grey, and so is a tab whose shell has exited: the two states in that strip with
the least in common, one worth waiting for and one over. PhoneShell's own
comment already recorded half of this — the dot stopped being green before
anything had answered — and this is the other half.

Progress is raised inline rather than through System.Progress<T>, which captures
whatever synchronisation context it was constructed on and posts to it. That
reads like a convenience and is really a second place the marshalling decision
gets made: silently, differently under a test with no context, and out of order
with respect to the failure that follows a phase. The shell marshals once, in
one handler, through a new optional post parameter on MainWindowViewModel — the
same seam TransfersViewModel already uses, and for the reason its own remark
gives. The three Dispatcher.UIThread.Post calls that predate it are the ones
this suite's comments record as out of reach; they are left alone rather than
swept in here.

Both heads draw the list. They differ in one place: Phone.axaml's mono class
sets a colour and a size along with the family, so the caption rule names its
own family instead of composing the two and asking two rules for one Foreground.
The desktop's mono sets the family alone, which is why ConnectingCard does
compose them. Each head also gains SHOW LOGS beside the button that gives up —
the step list is this attempt and the log is every other one, which is what a
connection taking too long actually raises.

Seven tests, and the two that matter most run against the container rather than
a fake: a real handshake reports its phases in order, and a host-key refusal
never claims to have authenticated. A fake asserting what it was written to
assert would have established nothing about either. The rest cover the tab
advancing while the connection is gated, the step a refusal stops on, and a
phase reported after the user has given up on the tab. 1,861 tests, none
failing.

The Android head's layout is not verified by anything. It compiles, and
compiled bindings mean every new binding path resolves, but that project is not
in DodoSSH.slnx, there is no test project for it and no device here — so unlike
the desktop card, whose shapes the layout harness measures, these rows have not
been drawn. Vertical fit is reasoned, not observed.

src/DodoSSH.Client.Shell/ViewModels/MainWindowViewModel.cs

@@ -328,6 +328,9 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
     /// </remarks>
     private readonly Func<string, Task>? copyToClipboard;
 
+    /// <inheritdoc cref="MainWindowViewModel(ClientPaths, ClientCacheFactory, TerminalWorkspace, VaultKnownHostStore, IDeviceKeyStore, SignInHandler, TimeProvider, ISftpSessionFactory, Argon2Profile?, ResumeHandler?, Func{string, Task}?, string?, IUpdateChannel?, Action{Action}?)" path="/param[@name='post']" />
+    private readonly Action<Action> post;
+
     /// <remarks>
     /// Created once and kept for the life of the process, like <see cref="workspace"/> and for the same
     /// reason: file transfer opens its own authenticated connection, and locking the vault must not destroy
@@ -470,6 +473,19 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
     /// absence of a line rather than by a line somebody has to remember to keep a no-op; and ADR 0011 settles
     /// the Android head's distribution separately, so it must never acquire one by accident.
     /// </param>
+    /// <param name="post">
+    /// Runs an action on the thread this shell's view models are read from. Defaults to the UI thread's
+    /// dispatcher, which is the answer in every real head.
+    /// <para>
+    /// A delegate rather than <c>Dispatcher.UIThread</c> reached directly, for exactly the reason
+    /// <c>TransfersViewModel</c>'s is one — see the remark there. It is process-wide and belongs to whichever
+    /// thread touched it first, so a suite that runs with no window has no way to drain it and no way to
+    /// know whose it is. This one exists because connection phases are reported from the handshake's own
+    /// thread, which is the first thing in this class that has to cross onto the UI thread and also has to
+    /// be assertable: the three <c>Dispatcher.UIThread.Post</c> calls that predate it are the ones this
+    /// suite's own comments record as out of reach, and they are left alone rather than swept in here.
+    /// </para>
+    /// </param>
     internal MainWindowViewModel(
         ClientPaths paths,
         ClientCacheFactory caches,
@@ -483,8 +499,11 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
         ResumeHandler? resume = null,
         Func<string, Task>? copyToClipboard = null,
         string? deviceName = null,
-        IUpdateChannel? updates = null)
+        IUpdateChannel? updates = null,
+        Action<Action>? post = null)
     {
+        this.post = post ?? (action => Dispatcher.UIThread.Post(action));
+
         this.paths = paths;
         this.caches = caches;
         this.workspace = workspace;
@@ -3243,7 +3262,7 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
             oldValue.PropertyChanged -= OnVaultPropertyChanged;
             oldValue.Hosts.CollectionChanged -= OnVaultHostsChanged;
 
-            // The three connection events are kept while an attempt is still in flight, and that is not an
+            // The four connection events are kept while an attempt is still in flight, and that is not an
             // oversight. Locking does not end a handshake any more than it ends a shell — the workspace is
             // what holds both, and it outlives every vault — so a connection started just before a lock still
             // has an answer coming, and the tab standing in for it is still in the strip afterwards, because
@@ -3257,6 +3276,7 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
             if (attempts.Count == 0)
             {
                 oldValue.ConnectionStarting -= OnVaultConnectionStarting;
+                oldValue.ConnectionProgress -= OnVaultConnectionProgress;
                 oldValue.ConnectionFailed -= OnVaultConnectionFailed;
                 oldValue.SessionOpened -= OnVaultSessionOpened;
             }
@@ -3265,6 +3285,7 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
         if (newValue is not null)
         {
             newValue.ConnectionStarting += OnVaultConnectionStarting;
+            newValue.ConnectionProgress += OnVaultConnectionProgress;
             newValue.ConnectionFailed += OnVaultConnectionFailed;
             newValue.SessionOpened += OnVaultSessionOpened;
             newValue.PropertyChanged += OnVaultPropertyChanged;
@@ -3406,6 +3427,41 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
         AdoptTab(tab);
     }
 
+    /// <summary>
+    /// Moves a connecting tab's step list on, from the handshake's own report.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The one place the phases raised by <c>VaultViewModel.ConnectionProgress</c> are marshalled, and the
+    /// reason that event does not marshal for itself: doing it here means it happens once, visibly, at the
+    /// only boundary that cares — everything this touches is a view model an Avalonia binding is attached to.
+    /// </para>
+    /// <para>
+    /// Posted unconditionally rather than applied inline when it looks safe. Some phases really do arrive
+    /// on this thread — the first is reported before the handshake has yielded at all — and a
+    /// <c>CheckAccess</c> fast path for them would buy one dispatcher turn on a card that is up for seconds,
+    /// at the price of the two orderings existing at once and only one of them being the one a test runs.
+    /// </para>
+    /// <para>
+    /// A step that arrives after the attempt has settled is harmless and needs no guard here:
+    /// <see cref="TerminalTabViewModel.Advance"/> ignores anything reported to a tab that is no longer
+    /// connecting, which is what a posted phase landing behind its own <see cref="OnVaultSessionOpened"/>
+    /// looks like.
+    /// </para>
+    /// <para>
+    /// A report for an attempt with no tab is dropped, exactly as the other two handlers drop one: the user
+    /// closed the connecting tab and there is nothing left to draw a step on. The handshake is not affected
+    /// and its session is still adopted if it opens.
+    /// </para>
+    /// </remarks>
+    private void OnVaultConnectionProgress(object? sender, ConnectionProgressEventArgs e) => post(() =>
+    {
+        if (attempts.TryGetValue(e.AttemptId, out var tab))
+        {
+            tab.Advance(e.Step);
+        }
+    });
+
     /// <summary>
     /// Redraws the vault menu after a synchronisation pass found a vault this account had not seen.
     /// </summary>

src/DodoSSH.Client.Shell/ViewModels/TerminalTabViewModel.cs

@@ -1,7 +1,129 @@
 using CommunityToolkit.Mvvm.ComponentModel;
+using DodoSSH.Client.Ssh;
 
 namespace DodoSSH.Client.Shell.ViewModels;
 
+/// <summary>
+/// One named part of making a connection, in the order they happen.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <see cref="SshConnectionPhase"/> with one more at the front. The SSH assembly reports four phases and
+/// knows about no others, which is correct for it — it has never heard of a renderer. But the first thing a
+/// connection here waits on is the terminal page attaching its socket, and on the first connection after a
+/// cold start that is a real wait with a real failure mode of its own: a missing WebView2 runtime. A step
+/// list that began at "reaching the host" would leave the one wait most likely to hang unnamed.
+/// </para>
+/// <para>
+/// Declared here rather than shared with the SSH layer for that reason, and the mapping between the two is
+/// one <c>switch</c> in <c>VaultViewModel</c>. The numbering is the order and the order is load-bearing:
+/// <see cref="TerminalTabViewModel.Advance"/> compares these values to decide what is already behind it.
+/// </para>
+/// </remarks>
+internal enum ConnectionStep
+{
+    /// <summary>Waiting for the renderer to attach, before anything is dialled.</summary>
+    PreparingTerminal = 0,
+
+    /// <inheritdoc cref="SshConnectionPhase.Reaching" />
+    Reaching = 1,
+
+    /// <inheritdoc cref="SshConnectionPhase.CheckingHostKey" />
+    CheckingHostKey = 2,
+
+    /// <inheritdoc cref="SshConnectionPhase.Authenticating" />
+    Authenticating = 3,
+
+    /// <inheritdoc cref="SshConnectionPhase.OpeningShell" />
+    OpeningShell = 4,
+}
+
+/// <summary>How one step of a connection is getting on.</summary>
+/// <remarks>
+/// Four states rather than a bool per row, because a step list is read as a sequence and the reader's
+/// question at each row is which of the four this is: behind us, happening, not yet, or where it stopped.
+/// <see cref="Stopped"/> exists only for the row a failure landed on — see
+/// <see cref="TerminalTabViewModel.Failed"/> — and is what turns the list from a progress bar into an
+/// account of how far the attempt got.
+/// </remarks>
+internal enum ConnectionStepState
+{
+    /// <summary>Not started. Nothing is known about it yet.</summary>
+    Pending = 0,
+
+    /// <summary>Happening now.</summary>
+    Running = 1,
+
+    /// <summary>Finished, because something after it started.</summary>
+    Done = 2,
+
+    /// <summary>Where the attempt stopped. There is no step after this one.</summary>
+    Stopped = 3,
+}
+
+/// <summary>One row of the connecting card's step list.</summary>
+/// <remarks>
+/// A view model per step rather than an index the view compares against, because each row draws its own
+/// state and an <c>ItemsControl</c> has no way to ask "am I before the current one?" — the alternative was a
+/// converter taking two bindings, which is the same comparison written somewhere it cannot be tested.
+/// </remarks>
+internal sealed partial class ConnectionStepViewModel : ObservableObject
+{
+    internal ConnectionStepViewModel(ConnectionStep step, string caption)
+    {
+        Step = step;
+        Caption = caption;
+    }
+
+    /// <summary>Which step this is.</summary>
+    internal ConnectionStep Step { get; }
+
+    /// <summary>What the row says, in the present tense of the thing being waited on.</summary>
+    internal string Caption { get; }
+
+    /// <inheritdoc cref="ConnectionStepState" />
+    [ObservableProperty]
+    private ConnectionStepState state;
+
+    /// <summary>Whether this step is the one happening now.</summary>
+    internal bool IsRunning => State is ConnectionStepState.Running;
+
+    /// <summary>Whether this step finished.</summary>
+    internal bool IsDone => State is ConnectionStepState.Done;
+
+    /// <summary>Whether the attempt stopped on this step.</summary>
+    internal bool IsStopped => State is ConnectionStepState.Stopped;
+
+    /// <summary>
+    /// The character drawn beside the caption for whichever state this is in.
+    /// </summary>
+    /// <remarks>
+    /// Here rather than in a converter for the reason <c>TransferRowViewModel.StatusWord</c> is: the mapping
+    /// is four cases with no arithmetic, and a converter would put it in a file the shell's tests cannot
+    /// reach. The colours stay in the view, where the palette is.
+    /// <para>
+    /// Four distinguishable shapes rather than one recoloured, because the difference between a step that
+    /// finished and a step still running has to survive somebody who cannot tell this design's green from
+    /// its amber.
+    /// </para>
+    /// </remarks>
+    internal string Mark => State switch
+    {
+        ConnectionStepState.Done => "✓",
+        ConnectionStepState.Running => "●",
+        ConnectionStepState.Stopped => "✕",
+        _ => "○",
+    };
+
+    partial void OnStateChanged(ConnectionStepState value)
+    {
+        OnPropertyChanged(nameof(IsRunning));
+        OnPropertyChanged(nameof(IsDone));
+        OnPropertyChanged(nameof(IsStopped));
+        OnPropertyChanged(nameof(Mark));
+    }
+}
+
 /// <summary>
 /// How far along a tab's connection is.
 /// </summary>
@@ -57,8 +179,23 @@ internal sealed partial class TerminalTabViewModel : ObservableObject
     {
         Label = label;
         Address = address;
-        status = "connecting…";
         isLive = false;
+
+        Steps =
+        [
+            new ConnectionStepViewModel(ConnectionStep.PreparingTerminal, "Starting the terminal"),
+            new ConnectionStepViewModel(ConnectionStep.Reaching, "Reaching the host"),
+            new ConnectionStepViewModel(ConnectionStep.CheckingHostKey, "Checking the host key"),
+            new ConnectionStepViewModel(ConnectionStep.Authenticating, "Signing in"),
+            new ConnectionStepViewModel(ConnectionStep.OpeningShell, "Opening the shell"),
+        ];
+
+        // The first step is running before anything is awaited, because it is: the tab is created in the
+        // same turn as the click and the renderer wait starts immediately after. A list that opened with
+        // every row pending would show a connection that had not begun, which is one turn of the dispatcher
+        // away from being untrue and is the turn the card is first drawn in.
+        status = Steps[0].Caption;
+        Steps[0].State = ConnectionStepState.Running;
     }
 
     /// <summary>A tab for a session that is already open.</summary>
@@ -72,6 +209,12 @@ internal sealed partial class TerminalTabViewModel : ObservableObject
         state = TerminalTabState.Open;
         status = string.Empty;
         isLive = true;
+
+        // A session that already exists got through every step by definition, even though this tab watched
+        // none of them happen — an adopted session is one whose connecting tab the user closed. The list is
+        // never drawn for a tab in this state; it is filled in so that nothing downstream has to treat "open"
+        // as a fourth answer to "how far did it get".
+        CompleteSteps();
     }
 
     /// <summary>
@@ -128,6 +271,36 @@ internal sealed partial class TerminalTabViewModel : ObservableObject
     /// </remarks>
     internal string? IdentityLabel { get; set; }
 
+    /// <summary>
+    /// How far this connection got, step by step, for the card that stands in for the pane.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Fixed at construction and never added to or removed from — the steps of a connection are known before
+    /// it starts, and only their state changes — so a plain array is enough and the view needs no collection
+    /// change notification for it.
+    /// </para>
+    /// <para>
+    /// <b>Every row here is reported, not guessed.</b> The states come from
+    /// <see cref="SshConnectionPhase"/>, raised by the handshake itself at the moment each part of it begins.
+    /// Nothing on this list is a timer, a fraction, or a step this view model decided had probably finished
+    /// by now. That is the whole reason it is worth showing: a card that invented plausible progress would be
+    /// indistinguishable from one that had stopped receiving any.
+    /// </para>
+    /// </remarks>
+    internal IReadOnlyList<ConnectionStepViewModel> Steps { get; }
+
+    /// <summary>How many steps are behind the attempt, for the card's track.</summary>
+    /// <remarks>
+    /// Counted rather than stored, and it counts <see cref="ConnectionStepState.Done"/> alone: the running
+    /// step is deliberately not half a step. The track fills to where the attempt has actually got to and
+    /// stops there, which is the same promise the list itself makes.
+    /// </remarks>
+    internal int StepsDone => Steps.Count(step => step.IsDone);
+
+    /// <summary>How many steps there are, for the card's track.</summary>
+    internal int StepCount => Steps.Count;
+
     /// <inheritdoc cref="TerminalTabState" />
     [ObservableProperty]
     private TerminalTabState state;
@@ -187,6 +360,54 @@ internal sealed partial class TerminalTabViewModel : ObservableObject
     /// <summary>Whether this tab is a connection that never happened.</summary>
     internal bool IsFailed => State is TerminalTabState.Failed;
 
+    /// <summary>
+    /// Records that the connection has reached a named step.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Everything before <paramref name="step"/> is marked done, because a phase that has begun is proof the
+    /// ones before it ended — the handshake is a sequence and there is no way to be at one point in it
+    /// without having passed the earlier ones. That is also what covers a step too fast to observe: it is
+    /// closed by its successor rather than needing a report of its own.
+    /// </para>
+    /// <para>
+    /// Monotonic, and silently so. A report that has already been passed is ignored rather than rewinding
+    /// the list, because the one thing that can produce one is a retry after the host-key question, and a
+    /// card that jumped backwards would read as the connection having come undone.
+    /// </para>
+    /// </remarks>
+    internal void Advance(ConnectionStep step)
+    {
+        if (State is not TerminalTabState.Connecting)
+        {
+            // Nothing to draw and nothing to correct. A late report from a handshake that has since
+            // finished or been given up on is not worth reopening a settled tab for.
+            return;
+        }
+
+        var reached = Steps.FirstOrDefault(row => row.Step == step);
+
+        if (reached is null || reached.IsDone)
+        {
+            return;
+        }
+
+        foreach (var row in Steps)
+        {
+            if (row.Step < step)
+            {
+                row.State = ConnectionStepState.Done;
+            }
+            else if (row.Step == step)
+            {
+                row.State = ConnectionStepState.Running;
+            }
+        }
+
+        Status = reached.Caption;
+        OnPropertyChanged(nameof(StepsDone));
+    }
+
     /// <summary>Takes ownership of the session that has just opened for this tab.</summary>
     internal void Opened(uint sessionId)
     {
@@ -194,6 +415,8 @@ internal sealed partial class TerminalTabViewModel : ObservableObject
         Status = string.Empty;
         IsLive = true;
         State = TerminalTabState.Open;
+
+        CompleteSteps();
     }
 
     /// <summary>
@@ -208,9 +431,33 @@ internal sealed partial class TerminalTabViewModel : ObservableObject
     {
         Status = reason;
         IsLive = false;
+
+        // Before the state change, so the list is already correct the first time a view asks. The step that
+        // was running is where it stopped, and the ones behind it stay done: how far a refused connection
+        // got is the most useful thing the card still knows, and it is the difference between "that host is
+        // not there" and "that host is there and would not have me".
+        foreach (var row in Steps)
+        {
+            if (row.IsRunning)
+            {
+                row.State = ConnectionStepState.Stopped;
+            }
+        }
+
         State = TerminalTabState.Failed;
     }
 
+    /// <summary>Marks every step done, for a connection that is no longer being waited on.</summary>
+    private void CompleteSteps()
+    {
+        foreach (var row in Steps)
+        {
+            row.State = ConnectionStepState.Done;
+        }
+
+        OnPropertyChanged(nameof(StepsDone));
+    }
+
     partial void OnStateChanged(TerminalTabState value)
     {
         OnPropertyChanged(nameof(HasSession));

src/DodoSSH.Client.Shell/ViewModels/VaultViewModel.cs

@@ -943,6 +943,31 @@ internal sealed class ConnectionAttemptEventArgs(Guid attemptId, string label, s
     internal string Address { get; } = address;
 }
 
+/// <summary>A connection that has got as far as a named step.</summary>
+/// <param name="attemptId">The attempt this is about.</param>
+/// <param name="step">The step that has just begun.</param>
+/// <remarks>
+/// <para>
+/// The fourth of the attempt events, and the only one that can be raised more than once for an attempt. It
+/// exists because the other three say a connection started and then, seconds later, whether it worked — and
+/// the seconds in between are the whole of what a user staring at a connecting card is trying to find out.
+/// </para>
+/// <para>
+/// <b>Raised on whichever thread the handshake is on.</b> SSH.NET reports the interior of a connection from
+/// its own thread, and this event is that report forwarded rather than a copy made on a timer, so a
+/// subscriber that touches a view model must marshal for itself. <c>MainWindowViewModel</c> does; see the
+/// handler.
+/// </para>
+/// </remarks>
+internal sealed class ConnectionProgressEventArgs(Guid attemptId, ConnectionStep step) : EventArgs
+{
+    /// <inheritdoc cref="ConnectionAttemptEventArgs.AttemptId" />
+    internal Guid AttemptId { get; } = attemptId;
+
+    /// <inheritdoc cref="ConnectionProgressEventArgs" path="/param[@name='step']" />
+    internal ConnectionStep Step { get; } = step;
+}
+
 /// <summary>A connection that was asked for and did not happen.</summary>
 /// <param name="attemptId">The attempt that has just ended.</param>
 /// <param name="reason">What to say about it, in the tab.</param>
@@ -4127,6 +4152,15 @@ internal sealed partial class VaultViewModel(
     /// </remarks>
     internal event EventHandler<ConnectionAttemptEventArgs>? ConnectionStarting;
 
+    /// <summary>Raised as a connection this vault announced gets from one step to the next.</summary>
+    /// <remarks>
+    /// Between <see cref="ConnectionStarting"/> and whichever of the other two ends the attempt, any number
+    /// of times including none — a handshake fast enough to finish inside one turn reports nothing, which is
+    /// the honest account of it. See <see cref="ConnectionProgressEventArgs"/> for the threading, which is
+    /// the one way this event differs from its three neighbours.
+    /// </remarks>
+    internal event EventHandler<ConnectionProgressEventArgs>? ConnectionProgress;
+
     /// <summary>Raised when a connection this vault announced does not become a session.</summary>
     /// <inheritdoc cref="ConnectionStarting" path="/remarks" />
     internal event EventHandler<ConnectionFailedEventArgs>? ConnectionFailed;
@@ -10889,6 +10923,53 @@ internal sealed partial class VaultViewModel(
         return true;
     }
 
+    /// <summary>Turns the handshake's phases into this attempt's progress events.</summary>
+    /// <remarks>
+    /// <para>
+    /// Forwarded rather than accumulated, because the tab is the thing that knows what has already happened
+    /// and this object deliberately does not: a connection here is one straight line from renderer to
+    /// session, and a running total of where it had got to would be a second copy of the state the card
+    /// already draws from the first.
+    /// </para>
+    /// <para>
+    /// <b>Deliberately not <c>System.Progress&lt;T&gt;</c></b>, which captures whatever synchronisation
+    /// context it happens to be constructed on and posts to it. That reads like a convenience and is really
+    /// a second place the marshalling decision gets made: silently, differently under a test with no
+    /// context, and — because a post is a later turn — out of order with respect to the failure or the
+    /// session that follows the phase. Raised inline instead, and the shell marshals once where it can be
+    /// seen. See <c>MainWindowViewModel.OnVaultConnectionProgress</c>.
+    /// </para>
+    /// </remarks>
+    private PhaseReporter ReporterFor(ConnectionAttemptEventArgs attempt) => new(phase =>
+        ConnectionProgress?.Invoke(this, new ConnectionProgressEventArgs(attempt.AttemptId, StepFor(phase))));
+
+    /// <summary>The step a handshake phase is reported to the shell as.</summary>
+    /// <remarks>
+    /// The whole of the mapping between the SSH assembly's four phases and the card's five steps, in one
+    /// place. <see cref="ConnectionStep.PreparingTerminal"/> is not here because nothing reports it: the tab
+    /// starts on it, and the first phase to arrive is what closes it.
+    /// </remarks>
+    private static ConnectionStep StepFor(SshConnectionPhase phase) => phase switch
+    {
+        SshConnectionPhase.Reaching => ConnectionStep.Reaching,
+        SshConnectionPhase.CheckingHostKey => ConnectionStep.CheckingHostKey,
+        SshConnectionPhase.Authenticating => ConnectionStep.Authenticating,
+        SshConnectionPhase.OpeningShell => ConnectionStep.OpeningShell,
+        _ => ConnectionStep.Reaching,
+    };
+
+    /// <summary>Hands each phase straight to a delegate, on the thread that reported it.</summary>
+    /// <remarks>
+    /// The whole type, and it exists to be the thing <c>System.Progress&lt;T&gt;</c> is not — see the remark
+    /// at its one use. A lambda cannot implement an interface, and the alternative was widening the
+    /// workspace's parameter to <c>Action&lt;T&gt;</c>, which would have put a non-standard progress
+    /// contract into three assemblies to save one class here.
+    /// </remarks>
+    private sealed class PhaseReporter(Action<SshConnectionPhase> report) : IProgress<SshConnectionPhase>
+    {
+        public void Report(SshConnectionPhase value) => report(value);
+    }
+
     /// <summary>What a manual target reads as, once it has been taken apart.</summary>
     /// <remarks>
     /// Separate from <see cref="ConnectionTarget"/> because a keychain host has no username of its own at
@@ -11238,6 +11319,8 @@ internal sealed partial class VaultViewModel(
         HostAuthentication authentication,
         CancellationToken cancellationToken)
     {
+        // Not reported before the await: the tab is constructed with this step already running — see
+        // TerminalTabViewModel — because there is no moment between the two worth telling anybody about.
         await workspace.WaitForRendererAsync(cancellationToken).ConfigureAwait(true);
 
         var request = new SshConnectionRequest(
@@ -11247,7 +11330,7 @@ internal sealed partial class VaultViewModel(
             authentication.Credential);
 
         var sessionId = await workspace
-            .OpenSessionAsync(request, TerminalSize.Default, cancellationToken)
+            .OpenSessionAsync(request, TerminalSize.Default, ReporterFor(attempt), cancellationToken)
             .ConfigureAwait(true);
 
         // The workspace has already opened a ticket for this session, with the address and the moment it