Merge main into the desktop redesign branch

Four conflicts. Three were two people adding to the same spot, and one was a
real collision: main gave the connect bar a REMEMBER tick in the same pass that
this branch took the connect bar off the hosts screen.

REMEMBER is now in the drawer, beside the password box it qualifies. Nothing
about the feature changed — RemembersConnectPassword, its refusal to fire until
the remote has accepted the password, and the six tests over it are main's
untouched — only where it is drawn. The move improves it slightly and it is
worth saying why rather than claiming a merge was neutral: the bar had one row
and had to fit the box, the tick, the authentication note and CONNECT along it,
which is why the tick was a bare "REMEMBER" in tracked capitals. A column has
room to put it under the box as a sentence, where it reads as a property of the
password rather than as a fourth control in a row.

MainWindowViewModel: both sides added members after ShowTerminal — the desktop's
three fixed tabs here, the phone's connect menu on main. They do not interact,
so both are kept, each under its own heading.

TeamsScreen: main added the team's own RENAME, HAND OVER and ARCHIVE, a member's
LastActive, the role a new member arrives as, and the KEY HOLDERS list. This
branch had only bumped the file's font sizes a point. Resolved by taking main's
file whole and re-running the bump over it, so the new controls join the scale
rather than sitting a point below everything around them.

README: both sides described a different head's third pass in the same
paragraph. Both kept.

Two things checked rather than assumed, because this branch moved the furniture
the merged commits sit on. The chrome heights main's terminal work touched are
the phone's, not the desktop's — 44, 42 and 24 are unchanged, so the layout
harness's budget still describes the window. And main's keychain DELETE did not
reach VaultScreen.axaml, whose header this branch rearranged, so the five
buttons that overflowed at the larger type are still five.

2415 tests pass, up from 2369 by the 46 main brought.

tests/DodoSSH.Client.App.Layout.Tests/ScreenLayoutTests.cs

@@ -1495,6 +1495,88 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
             failure)));
 
     /// <summary>Lays the vault screen out at the width it gets once the nav rail has taken its column.</summary>
+    /// <remarks>
+    /// <para>
+    /// The teams screen had no entry in this suite at all until it grew four sections — a rename form, an
+    /// armed confirmation, an invitations list and a key-holders list — plus a second line in the member
+    /// row. Its right-hand column is the narrowest measured here: the window's minimum is 1016, the nav
+    /// rail takes 190 and the team list 268, leaving 558 for everything above.
+    /// </para>
+    /// <para>
+    /// Every list is seeded, and seeded with the long rows rather than the convenient ones — see
+    /// <see cref="StubTeamServer"/>. The two states that hide half the screen, the rename form and the
+    /// confirmation, are measured in their own tests below rather than here, because a control that is
+    /// collapsed when the window is laid out is a control this suite has not checked.
+    /// </para>
+    /// </remarks>
+    [Fact]
+    public Task TheTeamsScreen_FitsWithEveryListPopulated() =>
+        OnTheTeamsScreenAsync(
+            teams => { },
+            window => LayoutHarness.Unreachable(window)
+                .ShouldBeEmpty("the teams screen with members, invitations and key holders"));
+
+    /// <remarks>
+    /// The rename form is drawn in place, above the members list, and pushes everything below it down.
+    /// </remarks>
+    [Fact]
+    public Task TheTeamsScreen_FitsWhileRenamingATeam() =>
+        OnTheTeamsScreenAsync(
+            teams => teams.RenameTeamCommand.Execute(null),
+            window => LayoutHarness.Unreachable(window)
+                .ShouldBeEmpty("the teams screen with the rename form open"));
+
+    /// <remarks>
+    /// The armed confirmation carries two sentences of prose and replaces the header's buttons. It is the
+    /// tallest thing that can appear above the members list, so it is the case most likely to push the
+    /// key-holders list off the bottom.
+    /// </remarks>
+    [Fact]
+    public Task TheTeamsScreen_FitsWhileConfirmingAnArchive() =>
+        OnTheTeamsScreenAsync(
+            teams => teams.ArchiveTeamCommand.Execute(null),
+            window => LayoutHarness.Unreachable(window)
+                .ShouldBeEmpty("the teams screen with the archive confirmation armed"));
+
+    /// <remarks>
+    /// A real <c>TeamsViewModel</c> over a stub server rather than the unlocked vault the rest of this
+    /// suite uses, because nothing on this screen is vault content: it is read from the server on open.
+    /// The session function answers null, which is the state a member is in before anybody has wrapped
+    /// them a key — and it is also the one that draws the most text, since every vault row then carries
+    /// the "waiting for a key" sentence.
+    /// </remarks>
+    private static async Task OnTheTeamsScreenAsync(
+        Action<TeamsViewModel> arrange,
+        Action<Window> assert)
+    {
+        using var teamServer = new StubTeamServer();
+
+        var teams = new TeamsViewModel(() => teamServer, () => null);
+
+        await teams.LoadAsync(Token);
+
+        await LayoutHarness.OnTheUiThreadAsync(
+            () =>
+            {
+                arrange(teams);
+
+                var screen = new TeamsScreen { DataContext = teams };
+
+                var window = LayoutHarness.HostAtMinimumSize(
+                    screen, LayoutHarness.ScreenWidth, LayoutHarness.ScreenHeight);
+
+                try
+                {
+                    assert(window);
+                }
+                finally
+                {
+                    window.Close();
+                }
+            },
+            Token);
+    }
+
     private Task MeasureVaultAsync(Action<IReadOnlyList<string>> assert) =>
         OnTheVaultAsync((_, window) => assert(LayoutHarness.Unreachable(window)));
 

tests/DodoSSH.Client.App.Layout.Tests/StubTeamServer.cs

@@ -0,0 +1,235 @@
+using DodoSSH.Client.Api;
+using DodoSSH.Client.Auth;
+using DodoSSH.Client.Session;
+using DodoSSH.Client.Sync;
+using DodoSSH.Contracts;
+
+namespace DodoSSH.Client.App.Layout.Tests;
+
+/// <summary>
+/// The least server a <c>TeamsViewModel</c> needs in order to be laid out with something in it.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The teams screen is the one screen in this suite whose content cannot come from an unlocked vault,
+/// because none of it is vault content: a team, its members, its invitations and who holds a key to a
+/// vault are all read from the server on open, and the suite's <c>FakeAccountServer</c> implements
+/// <see cref="IAccountApi"/> and nothing else. Rather than teach that fake five more interfaces for one
+/// screen, this serves fixed rows and refuses everything a layout test has no business calling.
+/// </para>
+/// <para>
+/// The rows are deliberately the <em>long</em> ones. A layout suite that measured "Bob" in a column sized
+/// for an email address would certify a shape no real team produces — so the names, addresses and status
+/// sentences here are at or near the length the interface can really be handed, which is what makes an
+/// overflow show up at the minimum window rather than on somebody's screen.
+/// </para>
+/// </remarks>
+internal sealed class StubTeamServer : IVaultServer, ITeamApi, IVaultGrantApi
+{
+    private static readonly Guid OwnerId = Guid.CreateVersion7();
+    private static readonly Guid ColleagueId = Guid.CreateVersion7();
+    private static readonly Guid TeamId = Guid.CreateVersion7();
+    private static readonly Guid VaultId = Guid.CreateVersion7();
+
+    /// <inheritdoc />
+    public Uri ServerUrl { get; } = new("https://dodossh.example");
+
+    /// <inheritdoc />
+    public ITeamApi Teams => this;
+
+    /// <inheritdoc />
+    public IVaultGrantApi Grants => this;
+
+    /// <inheritdoc />
+    public IAccountApi Account => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public ISyncApi Sync => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public IDirectoryApi Directory => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public IKeyBindingAuthorizer KeyBinding => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public SyncOptions SyncOptions => new();
+
+    /// <inheritdoc />
+    public string? RefreshToken => null;
+
+    /// <summary>The vault whose key holders are listed, so a test can select it.</summary>
+    internal static Guid TeamVaultId => VaultId;
+
+    /// <inheritdoc />
+    public Task<IReadOnlyList<TeamSummary>> ListTeamsAsync(CancellationToken cancellationToken) =>
+        Task.FromResult<IReadOnlyList<TeamSummary>>(
+        [
+            new TeamSummary(
+                TeamId,
+                "Platform Engineering",
+                "platform-engineering",
+                "Everything that runs the estate.",
+                TeamMemberRole.Owner,
+                MemberCount: 2,
+                VaultCount: 1,
+                DateTimeOffset.UnixEpoch),
+        ]);
+
+    /// <inheritdoc />
+    public Task<IReadOnlyList<TeamMemberSummary>> ListTeamMembersAsync(
+        Guid teamId,
+        CancellationToken cancellationToken) =>
+        Task.FromResult<IReadOnlyList<TeamMemberSummary>>(
+        [
+            new TeamMemberSummary(
+                OwnerId,
+                "alexandra.hollingsworth@dodotech.example",
+                "Alexandra Hollingsworth",
+                TeamMemberRole.Owner,
+                TeamMemberStatus.Active,
+                IsEnrolled: true,
+                DateTimeOffset.UnixEpoch,
+                DateTimeOffset.UnixEpoch),
+
+            // The unenrolled case on purpose: its key-state phrase is the longest the column ever
+            // carries, and it is the row that decides whether that column is wide enough.
+            new TeamMemberSummary(
+                ColleagueId,
+                "bartholomew.fotheringay@dodotech.example",
+                "Bartholomew Fotheringay",
+                TeamMemberRole.Member,
+                TeamMemberStatus.Active,
+                IsEnrolled: false,
+                DateTimeOffset.UnixEpoch,
+                LastActiveAt: null),
+        ]);
+
+    /// <inheritdoc />
+    public Task<IReadOnlyList<TeamInvitationSummary>> ListTeamInvitationsAsync(
+        Guid teamId,
+        CancellationToken cancellationToken) =>
+        Task.FromResult<IReadOnlyList<TeamInvitationSummary>>(
+        [
+            // Pending, because its sentence is the long one — it has to carry the whole mechanism,
+            // since nothing was sent and there is nothing else on the screen that could say so.
+            new TeamInvitationSummary(
+                Guid.CreateVersion7(),
+                "wilhelmina.ashworth-blake@dodotech.example",
+                TeamMemberRole.Admin,
+                TeamInvitationState.Pending,
+                OwnerId,
+                DateTimeOffset.UnixEpoch,
+                DateTimeOffset.UnixEpoch.AddDays(14),
+                AcceptedAt: null),
+        ]);
+
+    /// <inheritdoc />
+    public Task<VaultGrantsResponse> ListVaultGrantsAsync(
+        Guid vaultId,
+        CancellationToken cancellationToken) =>
+        Task.FromResult(new VaultGrantsResponse(
+            vaultId,
+            KeyGeneration: 2,
+            RekeyRequired: true,
+            Grants:
+            [
+                new VaultGrantSummary(
+                    OwnerId,
+                    "alexandra.hollingsworth@dodotech.example",
+                    "Alexandra Hollingsworth",
+                    KeyGeneration: 2,
+                    VaultGrantState.Active,
+                    OwnerId,
+                    DateTimeOffset.UnixEpoch,
+                    RevokedAt: null),
+
+                // A generation behind, so the "stale" phrasing is the one being measured rather than
+                // the two-word happy case.
+                new VaultGrantSummary(
+                    ColleagueId,
+                    "bartholomew.fotheringay@dodotech.example",
+                    "Bartholomew Fotheringay",
+                    KeyGeneration: 1,
+                    VaultGrantState.Active,
+                    OwnerId,
+                    DateTimeOffset.UnixEpoch,
+                    RevokedAt: null),
+            ]));
+
+    /// <inheritdoc />
+    public Task<TeamSummary> CreateTeamAsync(
+        CreateTeamRequest request,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<TeamSummary> UpdateTeamAsync(
+        Guid teamId,
+        UpdateTeamRequest request,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<bool> ArchiveTeamAsync(Guid teamId, CancellationToken cancellationToken) =>
+        throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task TransferTeamOwnershipAsync(
+        Guid teamId,
+        TransferTeamOwnershipRequest request,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<TeamMemberSummary> AddTeamMemberAsync(
+        Guid teamId,
+        AddTeamMemberRequest request,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<TeamMemberSummary> ChangeTeamMemberRoleAsync(
+        Guid teamId,
+        Guid userId,
+        ChangeTeamMemberRoleRequest request,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<bool> RemoveTeamMemberAsync(
+        Guid teamId,
+        Guid userId,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<TeamInvitationSummary> CreateTeamInvitationAsync(
+        Guid teamId,
+        CreateTeamInvitationRequest request,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<bool> RevokeTeamInvitationAsync(
+        Guid teamId,
+        Guid invitationId,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<VaultSummary> CreateTeamVaultAsync(
+        Guid teamId,
+        CreateTeamVaultRequest request,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task IssueVaultGrantAsync(
+        Guid vaultId,
+        IssueVaultGrantRequest request,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public Task<bool> RevokeVaultGrantAsync(
+        Guid vaultId,
+        Guid userId,
+        CancellationToken cancellationToken) => throw new NotSupportedException();
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        // Nothing held.
+    }
+}