diff --git a/src/DodoSSH.Client.App/Views/HostsScreen.axaml b/src/DodoSSH.Client.App/Views/HostsScreen.axaml
index c90d250..36ada41 100644
--- a/src/DodoSSH.Client.App/Views/HostsScreen.axaml
+++ b/src/DodoSSH.Client.App/Views/HostsScreen.axaml
@@ -6,34 +6,88 @@
              x:DataType="vm:VaultViewModel">
 
   <!--
-    The hosts screen: every group, then every host, as cards — and a drawer for whichever one is selected.
+    The monogram converters, as resources rather than through x:Static: MonogramBrushConverter's own remarks
+    call for "a StaticResource-shaped reference" naming which half a card wants, and a resource entry is
+    what makes that literal — the markup below reads {StaticResource MonogramBg} and
+    {StaticResource MonogramFg} rather than a converter parameter that would mean nothing without reading
+    that file. Constructed with x:Arguments because the type takes its "which half" as a constructor
+    parameter, not a settable property — there is nothing to set once the instance exists.
+  -->
+  <UserControl.Resources>
+    <views:MonogramBrushConverter x:Key="MonogramBg">
+      <x:Arguments>
+        <x:Boolean>True</x:Boolean>
+      </x:Arguments>
+    </views:MonogramBrushConverter>
+    <views:MonogramBrushConverter x:Key="MonogramFg">
+      <x:Arguments>
+        <x:Boolean>False</x:Boolean>
+      </x:Arguments>
+    </views:MonogramBrushConverter>
+  </UserControl.Resources>
 
-    ── IT WAS A 268-PIXEL LIST BESIDE A MOSTLY EMPTY COLUMN. ────────────────────────────────────────────
-    That list was doing two jobs at two-thirds size. It had to be narrow so the editor beneath it could be
-    a column, and being narrow is what made forty machines a scroll rather than a glance: a host row was a
-    name, an address and an auth word stacked in 268 pixels, and the column beside it repeated all three
-    for the one that happened to be selected.
+  <!--
+    The hosts screen: every group as a heading, every host under it as a card, and a drawer for whichever one
+    is selected.
 
-    Cards split the two jobs. The grid is about all of them — how many groups there are, which machines are
-    in one, which have a shell open — and it gets the full width to say so. The drawer is about one, and it
-    is only there when it has been asked for. See HostDrawer and VaultViewModel.IsDrawerOpen.
+    ── v5: THE BOARD IS FLAT SECTIONS NOW, NOT A GRID OF GROUP CARDS ONE LEVEL AT A TIME. ──────────────────
+    The v4 shape was a directory pane: a wrap of group cards above the hosts, opened by a double-click, with
+    a breadcrumb trail above it saying where you were. That model traded a real cost for it — a keychain
+    filed under three groups took three clicks to see all of, and "where is everything" had no answer at
+    all, only "where am I right now". v5 draws every group at once, in label order, "No group" first, exactly
+    the flattening the phone's SidebarRows has always drawn — see VaultViewModel.HostSections and
+    VaultViewModel.FlattenIntoSections. A host is filed under a group through its own editor, or through the
+    chosen-hosts menu's "Change group…"; dragging a card onto a group card is gone with the cards it used to
+    land on. See HostsScreen.axaml.cs for the gestures this shape now needs — a shift-click's run and a
+    band's rectangle both have to reach across however many sections are on screen, where a single ListBox
+    used to answer both on its own.
 
-    ◆ ASKED FOR, AND IT USED TO ARRIVE WITH THE SELECTION. Touching any card opened the drawer, so choosing
-    a host cost 304 pixels of grid every time — including for every card passed over on the way to the one
+    ── ONE SECTION, ONE ListBox, AND "Board" IS THE ItemsControl OF SECTIONS. ────────────────────────────────
+    Each HostSectionViewModel draws its own heading and its own ListBox of cards (Classes="sectioncards"),
+    which is what lets the wrap of cards stay an ordinary WrapPanel-of-cards-only rather than a single list
+    fighting to make a header row pretend to be as wide as the cards it sits above. "Board" is the outer
+    ItemsControl holding every section — named because the code-behind needs one focusable ancestor of every
+    card to hang KeyDown, tunnelled PointerPressed/ContextRequested and DoubleTapped from; see the remarks on
+    HostsScreen for why nothing here can be a single ListBox's own SelectedItem any more.
+
+    ◆ WHY EVERY COMMAND REACHED FROM INSIDE A SECTION OR A CARD GOES THROUGH "#Board" RATHER THAN A PLAIN
+    {Binding}. This markup nests two DataTemplates deep by the time it reaches a card — HostSections's own
+    item template (x:DataType HostSectionViewModel) and then, inside that, a second ListBox's item template
+    (x:DataType HostRowViewModel) — so the ambient DataContext by the time a pencil button or a context menu
+    item is declared is a section or a row, never the vault. $parent[ItemsControl] cannot walk past the
+    inner ListBox to reach the outer one, because a ListBox answers "is this an ItemsControl" as truly as the
+    real target does and $parent stops at the nearest match; and a ContextMenu or MenuFlyout's content sits
+    in its own popup, inheriting whatever DataContext the control that opened it already has rather than
+    anything further up a visual chain. "#Board" sidesteps both: Avalonia's NameScope is the whole document's,
+    not each template's own, so an ElementName reference resolves the same way from inside a WrapPanel's card
+    or from inside a MenuFlyout's popup — see #Board.((vm:VaultViewModel)DataContext).SomeCommand throughout
+    this file. Kept as one idiom rather than mixing it with $parent[ItemsControl] where a single level of
+    nesting would technically allow it (the toolbar's Group ▾ and Tag ▾ flyouts are exactly that case),
+    because two techniques answering the same question is one more thing to get right per binding.
+
+    Cards split the two jobs the old 268-pixel list used to do at two-thirds size. The board is about all of
+    them — how many groups there are, which machines are in one, which have a shell open — and it gets the
+    full width to say so. The drawer is about one, and it is only there when it has been asked for. See
+    HostDrawer and VaultViewModel.IsDrawerOpen.
+
+    ◆ ASKED FOR, AND IT USED TO ARRIVE WITH THE SELECTION. Touching any card opened the drawer, so choosing a
+    host cost 304 pixels of board every time — including for every card passed over on the way to the one
     somebody wanted. The pencil on a card is what opens it now; selecting is free again. See the item
     template below and VaultViewModel.IsHostPaneOpen.
 
     ── WHAT IS DELIBERATELY NOT HERE ────────────────────────────────────────────────────────────────────
-    The design this was drawn from puts a view-mode switch, a tag filter, a calendar and a share control in
-    the toolbar, and offers Serial beside Terminal. None of the five exists: there is one view, no saved
-    filters, nothing dated, no sharing outside a team vault, and no serial transport in the SSH layer. Five
-    disabled controls would teach nobody anything. See docs/design-import-gaps.md.
+    The design this was drawn from puts a view-mode switch, a calendar and a share control in the toolbar,
+    and offers Serial beside Terminal, and colours the status dot amber for "reachable but not connected".
+    None of the four exists: there is one view, nothing dated, no sharing outside a team vault, no serial
+    transport in the SSH layer, and nothing here ever pings a host — a third dot colour would be a claim this
+    application does not check. See docs/design-import-gaps.md and hosts-v5-design-spec.md's deviations.
 
     ── ITS DATA CONTEXT IS THE VAULT, and it used to be the shell. ──────────────────────────────────────
     The shell was needed only so that the old sidebar could be handed the vault on its own element while
     everything around it bound Vault.*. The drawer needs no such thing — it is a child of this control and
     inherits what this control has — so the indirection went with the sidebar, and every binding in this
-    file is now a property of the vault.
+    file is now a property of the vault (directly at the root, or through #Board once a DataTemplate has
+    changed what is ambient).
 
     That is worth more than the tidiness: a control whose data context is the shell cannot be laid out by
     the layout harness without building an entire MainWindowViewModel, and this is the screen with the most
@@ -47,73 +101,148 @@
     <Grid Grid.Column="0" RowDefinitions="Auto,Auto,Auto,*">
 
       <!--
-        ============ FIND ============
-        One wide box, which is what the width bought. It narrows the grid below and nothing else — the
-        connect path, the selection and the pinned host key list all read the unfiltered collection — so a
-        filter left in the box can hide a host but can never break one.
+        ============ THE TOOLBAR ============
+        "Hosts" and the count chip on the left, the two narrowing flyouts and + New host on the right. EDIT
+        and DELETE are not here: they act on one host, and one host is what the drawer is about — a pair of
+        buttons over a board of forty is a pair whose subject the user has to work out. The group's own
+        Edit/Move/Delete sit on its own heading's menu for the same reason.
+      -->
+      <Grid Grid.Row="0" Margin="16,20,16,16" ColumnDefinitions="Auto,Auto,*,Auto,Auto,Auto">
 
-        ◆ IT IS ALSO THE WAY OUT OF THE GROUPS. The grid below holds one level of the tree, and typing here
-        searches that level and everything under it — every machine in the keychain while nothing is open.
-        That is the one thing on this screen that crosses a group boundary, and it has to be: a search that
-        looked only where you happen to be standing would say "no host matches that" about a host this
-        keychain has got. See VaultViewModel.Matches.
+        <TextBlock Grid.Column="0" Text="Hosts" FontSize="33" FontWeight="Bold" LetterSpacing="-0.5"
+                   Foreground="{StaticResource Text}" VerticalAlignment="Center" />
+
+        <!--
+          The count chip: every host in a shown vault, unfiltered — see HostBoardTotalCount. Deliberately not
+          narrowed by the find box or the two flyouts below, which already say "how many cards are on screen
+          right now" on each section's own heading; this says how big the keychain is.
+        -->
+        <Border Grid.Column="1" Margin="10,0,0,0" MinWidth="34" Height="30" CornerRadius="9" Padding="8,0"
+                Background="{StaticResource Chip}" VerticalAlignment="Center">
+          <TextBlock Classes="mono" Text="{Binding HostBoardTotalCount}" FontSize="12.5"
+                     Foreground="{StaticResource TextDim}" HorizontalAlignment="Center"
+                     VerticalAlignment="Center" />
+        </Border>
+
+        <!--
+          ============ Group ▾ ============
+          Chips rather than checkable menu items, the same idiom the tab strip's vault menu uses and for the
+          same reason: nothing in this application uses a checkable MenuItem, and a chip that fills when worn
+          is this window's own vocabulary for on-and-off already. A host passes by being in a ticked group;
+          empty means every group. "New group…" lives at the foot rather than being a control of its own,
+          because the mock has no group-creation control and this is the nearest thing to where the design
+          put it — see hosts-v5-design-spec.md's deviations.
+        -->
+        <Button Grid.Column="3" Classes="ghost" Height="40" Margin="0,0,8,0" Content="Group ▾"
+                ToolTip.Tip="Narrow the board to one or more groups">
+          <Button.Flyout>
+            <Flyout Placement="BottomEdgeAlignedLeft">
+              <StackPanel Width="240" Spacing="8">
+                <TextBlock Classes="label" Text="FILTER BY GROUP" />
+
+                <ItemsControl ItemsSource="{Binding GroupFilterChoices}">
+                  <ItemsControl.ItemTemplate>
+                    <DataTemplate x:DataType="vm:GroupFilterChoice">
+                      <Button Classes="chiptoggle" Classes.worn="{Binding IsChecked}" Margin="0,0,0,4"
+                              HorizontalAlignment="Stretch" HorizontalContentAlignment="Left"
+                              Command="{Binding #Board.((vm:VaultViewModel)DataContext).ToggleGroupFilterCommand}"
+                              CommandParameter="{Binding}">
+                        <TextBlock Text="{Binding Label}" FontSize="11" TextTrimming="CharacterEllipsis" />
+                      </Button>
+                    </DataTemplate>
+                  </ItemsControl.ItemTemplate>
+                </ItemsControl>
+
+                <Button Classes="ghost" HorizontalAlignment="Stretch" HorizontalContentAlignment="Left"
+                        Content="All groups" IsVisible="{Binding HasActiveGroupFilter}"
+                        Command="{Binding ResetGroupFilterCommand}" />
+
+                <Border Height="1" Background="{StaticResource BorderSubtle}" />
+
+                <Button Classes="ghost" HorizontalAlignment="Stretch" HorizontalContentAlignment="Left"
+                        Content="New group…" Command="{Binding NewGroupCommand}"
+                        ToolTip.Tip="A heading for the board, and the port, username and key the hosts under it inherit." />
+              </StackPanel>
+            </Flyout>
+          </Button.Flyout>
+        </Button>
+
+        <!--
+          ============ Tag ▾ ============
+          A host passes by wearing ANY ticked tag, not all of them — the same reading MatchesHostBoardFilters
+          gives it. No footer control: a tag is made from a host's own editor, not from this flyout.
+        -->
+        <Button Grid.Column="4" Classes="ghost" Height="40" Margin="0,0,8,0" Content="Tag ▾"
+                ToolTip.Tip="Narrow the board to one or more tags">
+          <Button.Flyout>
+            <Flyout Placement="BottomEdgeAlignedLeft">
+              <StackPanel Width="240" Spacing="8">
+                <TextBlock Classes="label" Text="FILTER BY TAG" />
+
+                <ItemsControl ItemsSource="{Binding TagFilterChoices}">
+                  <ItemsControl.ItemTemplate>
+                    <DataTemplate x:DataType="vm:TagFilterChoice">
+                      <Button Classes="chiptoggle" Classes.worn="{Binding IsChecked}" Margin="0,0,0,4"
+                              HorizontalAlignment="Stretch" HorizontalContentAlignment="Left"
+                              Command="{Binding #Board.((vm:VaultViewModel)DataContext).ToggleTagFilterCommand}"
+                              CommandParameter="{Binding}">
+                        <TextBlock Text="{Binding Label}" FontSize="11" TextTrimming="CharacterEllipsis" />
+                      </Button>
+                    </DataTemplate>
+                  </ItemsControl.ItemTemplate>
+                </ItemsControl>
+
+                <Button Classes="ghost" HorizontalAlignment="Stretch" HorizontalContentAlignment="Left"
+                        Content="All tags" IsVisible="{Binding HasActiveTagFilter}"
+                        Command="{Binding ResetTagFilterCommand}" />
+              </StackPanel>
+            </Flyout>
+          </Button.Flyout>
+        </Button>
+
+        <Button Grid.Column="5" Classes="accent" Height="40" FontSize="13.5" Content="+ New host"
+                Command="{Binding NewHostCommand}" />
+
+      </Grid>
+
+      <!--
+        ============ FIND ============
+        One wide box, restyled but doing exactly what it always has: it narrows the board below and nothing
+        else — the connect path, the selection and the pinned host key list all read the unfiltered
+        collection — so a filter left in the box can hide a host but can never break one.
+
+        ◆ IT IS ALSO THE WAY OUT OF THE SECTIONS. Typing here searches every section at once, whatever a
+        collapse fold or the two flyouts above have done to the board — the one thing on this screen that
+        crosses a group boundary, and it has to be: a search that looked only at what happens to be expanded
+        would say "no host matches that" about a host this keychain has got. See VaultViewModel.Matches.
 
         Ctrl+K is named on it because the palette is the other way to reach a host by typing, and somebody
         who has found this box should know about the one that also connects on Enter.
-
-        The connect bar that used to be this row — password box, REMEMBER, the note, CONNECT — is in the
-        drawer now, beside the host it is about. See HostDrawer.
       -->
-      <Border Grid.Row="0" Padding="16,12" Background="{StaticResource Panel}"
-              BorderBrush="{StaticResource BorderSubtle}" BorderThickness="0,0,0,1">
-        <TextBox x:Name="HostFilter" Text="{Binding HostFilter}"
+      <Border Grid.Row="1" Margin="16,0,16,16">
+        <TextBox x:Name="HostFilter" Text="{Binding HostFilter}" Height="40" CornerRadius="10"
                  FontFamily="{StaticResource MonoFont}"
                  PlaceholderText="Find a host by name, address or note…   ·   Ctrl+K searches and connects" />
       </Border>
 
       <!--
-        ============ THE TOOLBAR ============
-        Only what makes something new. EDIT and DELETE are not here: they act on one host, and one host is
-        what the drawer is about — a pair of buttons over a grid of forty is a pair whose subject the user
-        has to work out. The group's own EDIT and DELETE sit beside the group cards for the same reason.
+        ============ THE PANELS ============
+        At most one of these is up at any moment — the view model disarms the others on the way up, see
+        MoveChosenHostsToVault, RegroupChosenHosts, DeleteChosenHosts, MoveGroup and DeleteGroup — and every
+        one of them sits here, above the board, rather than laid over it: a card over the cards would hide
+        the very ticks or the very group it is asking about.
       -->
-      <Border Grid.Row="1" Padding="16,8" BorderBrush="{StaticResource BorderSubtle}"
-              BorderThickness="0,0,0,1">
-        <StackPanel Orientation="Horizontal" Spacing="6">
-          <Button Classes="accent" Content="+ NEW HOST" Command="{Binding NewHostCommand}" />
-          <Button Classes="ghost" Content="+ NEW GROUP" Command="{Binding NewGroupCommand}"
-                  ToolTip.Tip="A heading for this grid, and the port, username and key the hosts under it inherit." />
-        </StackPanel>
-      </Border>
-
-      <StackPanel Grid.Row="2">
-
-        <!--
-          ◆ THE TWO HOST KEY PROMPTS WERE HERE, and they are now drawn over the window instead.
-
-          They were banners on this screen, so the shell navigated to this screen before letting the vault
-          raise one — because a connection can be started from the palette on any screen, and a question
-          behind whatever somebody is looking at is a question nobody can answer. That covered the palette
-          and charged everybody else for it: it took the user off the screen they were working on, and for a
-          machine typed into the phone's connect box by hand it asked about it on the list it is deliberately
-          not on. The decision is over the surface now, both heads, and nothing has to move. See
-          HostKeyCard.axaml and MainWindowViewModel.OnVaultConnectionFailed.
-
-          Not copied into both places, deliberately. One prompt in two markups is two copies of the most
-          safety-critical wording in the product, and the second is the one that goes stale.
-        -->
+      <StackPanel Grid.Row="2" Margin="16,0,16,12" Spacing="10">
 
         <!--
           The conflict log. The merge is only allowed to pick a winner because the value it overrode is kept
           and shown; without this panel it would be last-writer-wins with a longer explanation.
 
-          Bounded and scrollable. It sits on an Auto row above a star row, and an ItemsControl with no
-          ceiling grows without limit — so a pass that merged twenty items would push the grid off the
-          bottom of a screen nobody could scroll.
+          Bounded and scrollable, on an Auto row rather than growing without limit — a pass that merged
+          twenty items must not push the board off the bottom of a screen nobody can scroll to.
         -->
-        <Border Padding="16,10" Background="{StaticResource Panel}"
-                BorderBrush="{StaticResource Border}" BorderThickness="0,0,0,1"
-                IsVisible="{Binding HasConflicts}">
+        <Border Padding="14,10" Background="{StaticResource Panel}" CornerRadius="10"
+                BorderBrush="{StaticResource Border}" BorderThickness="1" IsVisible="{Binding HasConflicts}">
           <StackPanel Spacing="6">
             <TextBlock Text="Some changes could not be merged automatically."
                        Foreground="{StaticResource Info}" FontWeight="SemiBold" />
@@ -121,8 +250,7 @@
               <ItemsControl ItemsSource="{Binding Conflicts}">
                 <ItemsControl.ItemTemplate>
                   <DataTemplate x:DataType="vm:ConflictRowViewModel">
-                    <Border Margin="0,4" Padding="8" Background="{StaticResource Raised}"
-                            CornerRadius="4">
+                    <Border Margin="0,4" Padding="8" Background="{StaticResource Raised}" CornerRadius="6">
                       <StackPanel Spacing="4">
                         <TextBlock Text="{Binding Summary}" Foreground="{StaticResource Text}"
                                    TextWrapping="Wrap" />
@@ -140,700 +268,504 @@
           </StackPanel>
         </Border>
 
+        <!--
+          ◆ ONE GROUP'S DELETION QUESTION, arrived at from a heading's own menu rather than from a card — the
+          group cards this used to sit under are gone, and Edit/Move/Delete moved to the heading. See
+          EditGroupFromHeading, MoveGroupFromHeading and DeleteGroupFromHeading.
+        -->
+        <Border Padding="10" Background="{StaticResource DangerWash}" CornerRadius="10"
+                IsVisible="{Binding IsConfirmingGroupDeletion}">
+          <views:ConfirmDeleteCard />
+        </Border>
+
+        <!--
+          ◆ MOVING THE GROUP TO ANOTHER VAULT. A picker and two buttons rather than a question with a yes:
+          what is being asked is which vault, and a move is undone by moving it back — so it is not drawn in
+          the danger colours the deletion question above uses. It sits beside that question and never with
+          it: MoveGroup disarms a pending deletion and DeleteGroup folds this away, so at most one is drawn.
+
+          The sentence is what the panel is for. A group cannot go anywhere alone: the machines under it are
+          items of the vault it is leaving, and so are the groups nested inside it, so all of them are
+          re-sealed under the destination's key and all of them take new ids. What cannot come is the group
+          it is nested under, which is why it arrives at the top level.
+        -->
+        <Border Padding="10" Background="{StaticResource Panel}" CornerRadius="10"
+                BorderBrush="{StaticResource Border}" BorderThickness="1" IsVisible="{Binding IsMovingGroup}">
+          <StackPanel Spacing="8">
+            <TextBlock Classes="label" Text="MOVE GROUP TO VAULT" />
+            <ComboBox HorizontalAlignment="Stretch" ItemsSource="{Binding MoveGroupVaultChoices}"
+                      SelectedItem="{Binding SelectedMoveGroupVault}">
+              <ComboBox.ItemTemplate>
+                <DataTemplate x:DataType="vm:VaultChoiceViewModel">
+                  <TextBlock Text="{Binding Display}" FontSize="12" />
+                </DataTemplate>
+              </ComboBox.ItemTemplate>
+            </ComboBox>
+            <TextBlock Classes="hint" FontSize="10.5" TextWrapping="Wrap"
+                       Text="The group goes with the groups inside it and every host filed under them, all re-encrypted with the other vault's key. Any group it is nested under stays behind, so it arrives at the top level, and the hosts' tags stay behind with it." />
+            <StackPanel Orientation="Horizontal" Spacing="6">
+              <Button Classes="accent" Content="MOVE" Command="{Binding ConfirmMoveGroupCommand}"
+                      IsEnabled="{Binding !IsBusy}" />
+              <Button Classes="ghost" Content="CANCEL" Command="{Binding CancelMoveGroupCommand}" />
+            </StackPanel>
+          </StackPanel>
+        </Border>
+
+        <!--
+          ============ ◆ WHAT SAYS A SET IS UP ============
+          Ctrl, Shift and a band dragged across the board tick cards — see HostsScreen.axaml.cs — and this is
+          the whole of the chrome that arrives with them: how many, the way out, and where the actions are.
+          The phone raises a contextual action bar in the vault header's place for the same state; a window
+          with room for a context menu does not need one, and a strip of eight buttons over the board would
+          be a second home for entries the menu already has.
+        -->
+        <Grid ColumnDefinitions="Auto,Auto,*" IsVisible="{Binding IsChoosingHosts}">
+          <Border Grid.Column="0" Classes="chip accent" Padding="6,1" VerticalAlignment="Center">
+            <TextBlock Text="{Binding ChosenHostsSummary}" FontSize="9.5" />
+          </Border>
+          <Button Grid.Column="1" Classes="flat" Margin="6,0,0,0" Padding="5,1" FontSize="9.5"
+                  Content="CLEAR" Command="{Binding ClearHostChoiceCommand}"
+                  ToolTip.Tip="Takes the ticks off every card  ·  Esc, or a click on the space around them" />
+          <TextBlock Grid.Column="2" Classes="hint" FontSize="10" Margin="8,0,0,0"
+                     VerticalAlignment="Center" TextTrimming="CharacterEllipsis"
+                     Text="right-click one of them for what can be done to all of them" />
+        </Grid>
+
+        <!--
+          ◆ MOVING OR COPYING THEM TO ANOTHER VAULT. One panel for both verbs, because they differ in one
+          word and in the sentence under the picker; what varies is bound rather than duplicated. See
+          VaultViewModel.ChosenHostVaultPanelTitle and its two siblings.
+        -->
+        <Border Padding="10" Background="{StaticResource Panel}" CornerRadius="10"
+                BorderBrush="{StaticResource Border}" BorderThickness="1"
+                IsVisible="{Binding IsSendingChosenHostsToAVault}">
+          <StackPanel Spacing="8">
+            <Grid ColumnDefinitions="Auto,*">
+              <TextBlock Grid.Column="0" Classes="label" Text="{Binding ChosenHostVaultPanelTitle}" />
+              <TextBlock Grid.Column="1" Classes="mono" Margin="8,0,0,0" FontSize="11"
+                         Foreground="{StaticResource TextFaint}" VerticalAlignment="Center"
+                         Text="{Binding ChosenHostsSummary}" />
+            </Grid>
+
+            <ComboBox HorizontalAlignment="Stretch" ItemsSource="{Binding ChosenHostVaultChoices}"
+                      SelectedItem="{Binding SelectedChosenHostVault}">
+              <ComboBox.ItemTemplate>
+                <DataTemplate x:DataType="vm:VaultChoiceViewModel">
+                  <TextBlock Text="{Binding Display}" FontSize="12" />
+                </DataTemplate>
+              </ComboBox.ItemTemplate>
+            </ComboBox>
+
+            <TextBlock Classes="hint" FontSize="10.5" TextWrapping="Wrap"
+                       Text="{Binding ChosenHostVaultPanelNote}" />
+
+            <!--
+              ◆ THE KEY, and only for a move of exactly one host — which key to carry is a fact about one
+              machine, and a copy that took it away would leave the original unable to connect. Unticked,
+              because moving a key into a team's vault hands it to everybody holding that vault's key.
+            -->
+            <CheckBox IsVisible="{Binding HasAChosenBindingToBring}"
+                      IsChecked="{Binding BringsTheChosenBindingAlong}">
+              <TextBlock FontSize="11.5" TextWrapping="Wrap" Text="{Binding ChosenBindingToBringQuestion}" />
+            </CheckBox>
+            <TextBlock Classes="hint" FontSize="10.5" TextWrapping="Wrap"
+                       IsVisible="{Binding HasAChosenBindingToBring}"
+                       Text="{Binding ChosenBindingToBringNote}" />
+
+            <StackPanel Orientation="Horizontal" Spacing="6">
+              <Button Classes="accent" Content="{Binding ChosenHostVaultPanelVerb}"
+                      Command="{Binding ConfirmSendChosenHostsToAVaultCommand}"
+                      IsEnabled="{Binding !IsBusy}" />
+              <Button Classes="ghost" Content="CANCEL" Command="{Binding CancelSendChosenHostsToAVaultCommand}" />
+            </StackPanel>
+          </StackPanel>
+        </Border>
+
+        <!--
+          ◆ FILING THEM UNDER A GROUP, which is what "Change group…" on the chosen-hosts menu offers instead
+          of a drag now that there is no group card to drop one on.
+        -->
+        <Border Padding="10" Background="{StaticResource Panel}" CornerRadius="10"
+                BorderBrush="{StaticResource Border}" BorderThickness="1"
+                IsVisible="{Binding IsRegroupingChosenHosts}">
+          <StackPanel Spacing="8">
+            <Grid ColumnDefinitions="Auto,*">
+              <TextBlock Grid.Column="0" Classes="label" Text="CHANGE GROUP" />
+              <TextBlock Grid.Column="1" Classes="mono" Margin="8,0,0,0" FontSize="11"
+                         Foreground="{StaticResource TextFaint}" VerticalAlignment="Center"
+                         Text="{Binding ChosenHostsSummary}" />
+            </Grid>
+
+            <ComboBox HorizontalAlignment="Stretch" ItemsSource="{Binding ChosenHostGroupChoices}"
+                      SelectedItem="{Binding SelectedChosenHostGroup}">
+              <ComboBox.ItemTemplate>
+                <DataTemplate x:DataType="vm:GroupChoice">
+                  <TextBlock Text="{Binding Label}" FontSize="12" />
+                </DataTemplate>
+              </ComboBox.ItemTemplate>
+            </ComboBox>
+
+            <TextBlock Classes="hint" FontSize="10.5" TextWrapping="Wrap"
+                       Text="A group lends its port, its account and its key to every host filed under it that says nothing itself, so this can change what these machines dial. Nothing else about them moves." />
+
+            <StackPanel Orientation="Horizontal" Spacing="6">
+              <Button Classes="accent" Content="FILE" Command="{Binding ConfirmRegroupChosenHostsCommand}"
+                      IsEnabled="{Binding !IsBusy}" />
+              <Button Classes="ghost" Content="CANCEL" Command="{Binding CancelRegroupChosenHostsCommand}" />
+            </StackPanel>
+          </StackPanel>
+        </Border>
+
+        <!--
+          ◆ THE DELETION QUESTION, naming a count rather than a machine — which is the reason
+          DeletionTarget.ChosenHosts exists: six copies of "delete prod-db?" is not a confirmation anybody
+          reads. The shared card draws it, as it does for a group above and for one host in the drawer.
+        -->
+        <Border Padding="10" Background="{StaticResource DangerWash}" CornerRadius="10"
+                IsVisible="{Binding IsConfirmingChosenHostDeletion}">
+          <views:ConfirmDeleteCard />
+        </Border>
+
       </StackPanel>
 
       <!--
-        ============ THE GRID ============
-
-        A drop target that takes nothing itself. Everything the pointer can be over during a drag is inside
-        this control, and it has to accept one so that the group cards at the top of it stay reachable from
-        the bottom of a long grid: a host dragged off the fortieth card cannot be dropped on a group card
-        that has scrolled out of sight, so a drag held at either edge scrolls this while it is in flight.
-        See HostsScreen.axaml.cs.
+        ============ THE BOARD ============
+        A drop target that takes nothing itself — no group cards left to receive a drag. See
+        HostsScreen.axaml.cs.
       -->
-      <ScrollViewer Grid.Row="3" x:Name="Scroll" HorizontalScrollBarVisibility="Disabled"
-                    DragDrop.AllowDrop="True">
-        <StackPanel Margin="16,14" Spacing="16">
+      <ScrollViewer Grid.Row="3" x:Name="Scroll" HorizontalScrollBarVisibility="Disabled">
+        <StackPanel Margin="16,0,16,20" Spacing="16">
 
-          <!-- ============ GROUPS ============ -->
           <!--
-            Absent entirely from a vault nobody has filed anything in, which is what makes groups cost
-            nothing to ignore — the same rule the host list has always followed for its headings.
+            Named because it is where keyboard focus lands when the terminal gives it back, and because
+            every gesture on it is wired in the code-behind.
+
+            Focusable, which an ItemsControl is not by default. Without it the release-the-keyboard path is
+            a measured no-op: it takes Win32 focus off the terminal's child window and then calls Focus() on
+            something that refuses it, leaving the window with nothing focused and the keystrokes going
+            nowhere.
+
+            ◆ EVERY GROUP, ONE AFTER ANOTHER, "No group" FIRST. Binds HostSections rather than VisibleHosts:
+            the old grid held one level of a tree at a time, and this holds every group's cards at once, the
+            way SidebarRows always has for the phone. A keychain nobody has filed anything in draws one
+            section with no heading at all — see HostSectionViewModel.HasHeader — which is what makes the
+            feature invisible until it is used.
           -->
-          <StackPanel Spacing="8" IsVisible="{Binding HasGroups}">
+          <ItemsControl x:Name="Board" Focusable="True" ItemsSource="{Binding HostSections}">
+            <ItemsControl.ItemsPanel>
+              <ItemsPanelTemplate><StackPanel Spacing="22" /></ItemsPanelTemplate>
+            </ItemsControl.ItemsPanel>
 
-            <!--
-              ============ WHERE YOU ARE ============
-              The trail, drawn exactly as the transfers screen draws a directory path, because it is the same
-              control answering the same question — and a window with two breadcrumbs that look different has
-              two ideas of what a path is. See TransfersScreen.axaml.
+            <ItemsControl.ItemTemplate>
+              <DataTemplate x:DataType="vm:HostSectionViewModel">
+                <StackPanel Spacing="10">
 
-              It exists because the cards below are one level of a tree rather than every group at once, and
-              a level nobody can name is a grid that has quietly hidden things. The first crumb is always
-              there and always goes back to every host, which is what the SHOW ALL button used to be: a
-              button that only says "stop" beside a trail that says where you are is the second control for
-              the same job, and this one also gets you halfway back rather than all the way.
+                  <!--
+                    ============ THE SECTION HEADING ============
+                    "{label} · {count}", the vault name beside it when more than one vault is in play, a
+                    per-section collapse toggle, Collapse All / Expand All on the FIRST heading only — see
+                    SidebarGroupHeader.IsFirstBoardSection — and a menu for Edit…/Move to another vault…/
+                    Delete…, in that order, with no Open: the board draws every group at once now, so there
+                    is nothing left to open one INTO. Absent entirely for the headerless section a groupless
+                    keychain draws — see HasHeader on the type, and the remark on the item template above.
+                  -->
+                  <Grid IsVisible="{Binding HasHeader}" ColumnDefinitions="Auto,*,Auto,Auto">
+
+                    <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="6" VerticalAlignment="Center">
+                      <Button Classes="flat" Padding="2"
+                              Command="{Binding #Board.((vm:VaultViewModel)DataContext).ToggleGroupCommand}"
+                              CommandParameter="{Binding Header}"
+                              ToolTip.Tip="{Binding Header.CollapseLabel}">
+                        <TextBlock Text="{Binding Header.Chevron}" FontSize="11"
+                                   Foreground="{StaticResource TextGhost}" />
+                      </Button>
+                      <TextBlock FontSize="12.5" FontWeight="Medium" Foreground="{StaticResource TextGhost}">
+                        <Run Text="{Binding Header.Label}" /><Run Text=" · " /><Run Text="{Binding Header.Count}" />
+                      </TextBlock>
+                      <TextBlock Classes="mono" Text="{Binding Header.VaultBadge}" FontSize="10.5"
+                                 Foreground="{StaticResource TextFaint}" TextTrimming="CharacterEllipsis"
+                                 IsVisible="{Binding Header.HasVaultBadge}" />
+                    </StackPanel>
 
-              ◆ ABOVE THE GROUPS LABEL, and deliberately not under it as the transfers screen's is. That one
-              sits below its heading because it describes the one list beneath it; this one describes two.
-              Opening a group narrows the hosts as well as the cards, so a trail drawn under GROUPS would
-              read as one more thing about the groups while it is also the reason the grid at the bottom of
-              the screen is showing eleven machines instead of forty. First in the section, and both headings
-              below belong to it.
-            -->
-            <ItemsControl ItemsSource="{Binding GroupTrail}">
-              <ItemsControl.ItemsPanel>
-                <ItemsPanelTemplate><WrapPanel Orientation="Horizontal" /></ItemsPanelTemplate>
-              </ItemsControl.ItemsPanel>
-              <ItemsControl.ItemTemplate>
-                <DataTemplate x:DataType="vm:GroupCrumbViewModel">
-                  <StackPanel Orientation="Horizontal">
                     <!--
-                      The command is the vault's and the item is a crumb, so it is reached through the
-                      ItemsControl's data context — the same way every other templated command on the
-                      desktop is bound.
+                      Bound on every heading and shown on the first, rather than a control of the board's
+                      own above the sections — a virtualised ItemsControl has no clean way for one realized
+                      row to ask "am I first", so HostSectionViewModel's own header carries the answer. See
+                      VaultViewModel.RebuildHostSections and CollapseAllLabel.
                     -->
-                    <Button Classes="flat" Padding="3,1"
-                            Command="{Binding $parent[ItemsControl].((vm:VaultViewModel)DataContext).OpenGroupCommand}"
-                            CommandParameter="{Binding Group}">
-                      <TextBlock Classes="mono" Text="{Binding Name}" FontSize="11"
-                                 Foreground="{StaticResource TextDim}" />
+                    <Button Grid.Column="2" Classes="flat" Padding="6,2" Margin="0,0,10,0"
+                            FontSize="12" Foreground="{StaticResource TextGhost}"
+                            IsVisible="{Binding Header.IsFirstBoardSection}"
+                            Content="{Binding #Board.((vm:VaultViewModel)DataContext).CollapseAllLabel}"
+                            Command="{Binding #Board.((vm:VaultViewModel)DataContext).ToggleAllGroupsCommand}" />
+
+                    <!--
+                      Nothing to edit, move or delete about "No group" — it names no item, so the menu is
+                      left off that heading altogether rather than opened onto three commands that would
+                      each resolve to nothing. See VaultViewModel.GroupOf.
+                    -->
+                    <Button Grid.Column="3" Classes="flat paneicon" Content="⋯" Width="24" Height="24"
+                            IsVisible="{Binding Header.GroupId, Converter={x:Static ObjectConverters.IsNotNull}}"
+                            ToolTip.Tip="Edit, move or delete this group">
+                      <Button.Flyout>
+                        <MenuFlyout>
+                          <MenuItem Header="Edit…"
+                                    Command="{Binding #Board.((vm:VaultViewModel)DataContext).EditGroupFromHeadingCommand}"
+                                    CommandParameter="{Binding Header}" />
+                          <MenuItem Header="Move to another vault…"
+                                    Command="{Binding #Board.((vm:VaultViewModel)DataContext).MoveGroupFromHeadingCommand}"
+                                    CommandParameter="{Binding Header}" />
+                          <Separator />
+                          <MenuItem Header="Delete…"
+                                    Command="{Binding #Board.((vm:VaultViewModel)DataContext).DeleteGroupFromHeadingCommand}"
+                                    CommandParameter="{Binding Header}" />
+                        </MenuFlyout>
+                      </Button.Flyout>
                     </Button>
-                    <TextBlock Classes="mono" Text="›" FontSize="11"
-                               Foreground="{StaticResource TextFaint}" VerticalAlignment="Center" />
-                  </StackPanel>
-                </DataTemplate>
-              </ItemsControl.ItemTemplate>
-            </ItemsControl>
+                  </Grid>
 
-            <!--
-              The heading and nothing else. This used to be a row with EDIT and DELETE at the far end of it,
-              and the card's own menu is where those live now — see the note on it below. They were a second
-              control for the job that menu already does, and the harder of the two to read: a button beside
-              a heading has to say which card it means, and with none selected it meant the group the trail
-              ends with rather than anything on screen. Moving a group is on that menu and never had a button
-              here, for the same reason and without the intervening mistake.
-            -->
-            <TextBlock Classes="label" Text="GROUPS" Foreground="{StaticResource TextDim}" />
-
-            <Border Padding="10" Background="{StaticResource DangerWash}" CornerRadius="6"
-                    IsVisible="{Binding IsConfirmingGroupDeletion}">
-              <views:ConfirmDeleteCard />
-            </Border>
-
-            <!--
-              ◆ MOVING THE GROUP TO ANOTHER VAULT. The host drawer's move panel, one level up, and under
-              the heading rather than in the drawer because a group has no drawer of its own. A picker and
-              two buttons rather than a question with a yes: what is being asked is which vault, and a move
-              is undone by moving it back — so it is not drawn in the danger colours the deletion question
-              above it uses. It sits beside that question and never with it: MoveGroup disarms a pending
-              deletion and DeleteGroup folds this away, so the section draws at most one of the two.
-
-              The sentence is what the panel is for. A group cannot go anywhere alone: the machines under it
-              are items of the vault it is leaving, and so are the groups nested inside it, so all of them
-              are re-sealed under the destination's key and all of them take new ids. What cannot come is
-              the group it is nested under, which is why it arrives at the top level. Saying that here
-              rather than only in the status line afterwards is the difference between a warning and a
-              surprise.
-            -->
-            <Border Padding="10" Background="{StaticResource Panel}" CornerRadius="6"
-                    BorderBrush="{StaticResource Border}" BorderThickness="1"
-                    IsVisible="{Binding IsMovingGroup}">
-              <StackPanel Spacing="8">
-                <TextBlock Classes="label" Text="MOVE GROUP TO VAULT" />
-                <ComboBox HorizontalAlignment="Stretch" ItemsSource="{Binding MoveGroupVaultChoices}"
-                          SelectedItem="{Binding SelectedMoveGroupVault}">
-                  <ComboBox.ItemTemplate>
-                    <DataTemplate x:DataType="vm:VaultChoiceViewModel">
-                      <TextBlock Text="{Binding Display}" FontSize="12" />
-                    </DataTemplate>
-                  </ComboBox.ItemTemplate>
-                </ComboBox>
-                <TextBlock Classes="hint" FontSize="10.5" TextWrapping="Wrap"
-                           Text="The group goes with the groups inside it and every host filed under them, all re-encrypted with the other vault's key. Any group it is nested under stays behind, so it arrives at the top level, and the hosts' tags stay behind with it." />
-                <StackPanel Orientation="Horizontal" Spacing="6">
-                  <Button Classes="accent" Content="MOVE" Command="{Binding ConfirmMoveGroupCommand}"
-                          IsEnabled="{Binding !IsBusy}" />
-                  <Button Classes="ghost" Content="CANCEL" Command="{Binding CancelMoveGroupCommand}" />
-                </StackPanel>
-              </StackPanel>
-            </Border>
-
-            <!--
-              A ListBox rather than an ItemsControl of buttons, and that is what marks the chosen group for
-              free: selection is a state the control already has, and the tile style draws it the same way
-              every other list in this application draws a selected row. Buttons would have needed a
-              Classes.active binding per card and a second copy of "which one".
-
-              ◆ ONE CLICK SELECTS, TWO OPEN. SelectedItem is the selection and nothing else now — the
-              gesture that opens a group is a double-click, wired in the code-behind beside the one that
-              opens a shell on a host. One click used to mean both, and a card was then the only place a
-              group could be named while also being the control that threw the rest of the grid away.
-
-              ◆ ONE SELECTION, TWO LISTS. Selecting a card here takes the mark off the host grid below, and
-              selecting a host takes it off this one. Two controls each keep their own SelectedItem, so the
-              vault is what joins them — see VaultViewModel.OnSelectedHostChanged. Without it both grids
-              could be lit at once, which is two chosen things under two pairs of buttons.
-
-              ◆ THIS IS ONE LEVEL, NOT EVERY GROUP. It binds VisibleGroups: what is inside the group the
-              trail above ends with, or the outermost groups when it ends at ALL HOSTS. Folded away entirely
-              at a group with nothing inside it, which is an ordinary thing to open — the trail stays, and
-              it is also the way back to the level where that group has a card of its own to be edited from.
-
-              ◆ THESE CARDS ARE THE DROP TARGET. A host card dragged onto one is filed under that group, and
-              that is the whole of what a drag does on this screen. It used to be a heading inside the host
-              grid, and the headings are gone — see the note on the host grid below. A group is a thing that
-              is drawn once, at the top, where the eye already goes; a target that is also the label of what
-              you are aiming at needs no explaining. See the code-behind for the gesture.
-            -->
-            <ListBox Classes="tiles" x:Name="GroupGrid"
-                     DragDrop.AllowDrop="True"
-                     IsVisible="{Binding HasVisibleGroups}"
-                     ItemsSource="{Binding VisibleGroups}"
-                     SelectedItem="{Binding SelectedGroup}"
-                     ToolTip.Tip="Press a group to select it, double-press to open it. Drag a host card onto one to file it there.">
-              <ListBox.ItemsPanel>
-                <ItemsPanelTemplate><WrapPanel /></ItemsPanelTemplate>
-              </ListBox.ItemsPanel>
-
-              <!--
-                The three things you can do to a group, on the group itself — the same menu the host grid
-                below has, for the same reasons. On the list rather than in the item template, because the
-                commands are the vault's and a menu inside a DataTemplate would have the row for its data
-                context; the code-behind selects whatever was right-clicked before the menu opens, and
-                cancels it outright over the space around the cards.
-
-                Open is here as well as on the double-click, which is not a duplicate for its own sake: a
-                gesture is unreachable without a pointer. Edit and Delete are here and nowhere else — they
-                were also a pair of buttons beside the heading above, which acted on GroupTarget and so with
-                no card selected meant the group the trail ends with rather than any card on screen. All
-                three act on the card that was right-clicked, which is the whole of what this menu is for.
-
-                Only Open takes a parameter, because OpenGroupCommand's null means ALL HOSTS rather than
-                nothing; the other three read GroupTarget, which the selection the code-behind has just made
-                is the first half of.
-
-                Moving is above the separator that Delete sits below, exactly as it is in the host pane's
-                menu, and for the same reason: it is not a field of the group and it is not a deletion
-                either. The two vaults are encrypted under different keys, so it is a re-seal of the whole
-                shelf into one and a tombstone per item in the other.
-              -->
-              <ListBox.ContextMenu>
-                <ContextMenu>
-                  <MenuItem Header="Open" Command="{Binding OpenGroupCommand}"
-                            CommandParameter="{Binding SelectedGroup}" />
-                  <MenuItem Header="Edit…" Command="{Binding EditGroupCommand}" />
-                  <MenuItem Header="Move to another vault…" Command="{Binding MoveGroupCommand}" />
-                  <Separator />
-                  <MenuItem Header="Delete…" Command="{Binding DeleteGroupCommand}" />
-                </ContextMenu>
-              </ListBox.ContextMenu>
-
-              <ListBox.ItemTemplate>
-                <DataTemplate x:DataType="vm:HostGroupRowViewModel">
-                  <Border Classes="tile">
-                    <Grid ColumnDefinitions="Auto,*">
-                      <Border Grid.Column="0" Classes="tileicon" Background="{StaticResource Accent}">
-                        <TextBlock Text="▤" FontSize="14" Foreground="{StaticResource AccentInk}"
-                                   HorizontalAlignment="Center" VerticalAlignment="Center" />
-                      </Border>
-                      <StackPanel Grid.Column="1" Margin="10,0,0,0" VerticalAlignment="Center"
-                                  Spacing="2">
-                        <!-- A Grid rather than a horizontal StackPanel; see the note on the host card. -->
-                        <Grid ColumnDefinitions="*,Auto">
-                          <TextBlock Grid.Column="0" Text="{Binding Label}" FontWeight="Medium"
-                                     Foreground="{StaticResource Text}"
-                                     TextTrimming="CharacterEllipsis" />
-                          <Border Grid.Column="1" Classes="chip warn" Padding="4,0" Margin="6,0,0,0"
-                                  IsVisible="{Binding Badge, Converter={x:Static StringConverters.IsNotNullOrEmpty}}">
-                            <TextBlock Text="{Binding Badge}" FontSize="9.5" />
-                          </Border>
-                        </Grid>
-                        <TextBlock Text="{Binding Description}" FontSize="11"
-                                   Foreground="{StaticResource TextFaint}" />
-                        <!--
-                          Which vault this group is in, on the same rule and in the same place as the host
-                          card's: only where there is more than one vault to be in. It matters more on a
-                          folder than on a machine — two vaults may each hold a "production", and without
-                          this the cards are two identical folders side by side, one of which a colleague
-                          can read. It is also what says a group is shared at all.
-                        -->
-                        <TextBlock Classes="mono" Text="{Binding VaultBadge}" FontSize="10"
-                                   Foreground="{StaticResource TextFaint}"
-                                   TextTrimming="CharacterEllipsis"
-                                   IsVisible="{Binding HasVaultBadge}" />
-                      </StackPanel>
-                    </Grid>
-                  </Border>
-                </DataTemplate>
-              </ListBox.ItemTemplate>
-            </ListBox>
-
-          </StackPanel>
-
-          <!-- ============ HOSTS ============ -->
-          <StackPanel Spacing="8">
-
-            <Grid ColumnDefinitions="Auto,*,Auto">
-              <TextBlock Grid.Column="0" Classes="label" Text="HOSTS"
-                         Foreground="{StaticResource TextDim}" VerticalAlignment="Center" />
-
-              <!--
-                ============ ◆ WHAT SAYS A SET IS UP ============
-                Ctrl, Shift and a band dragged across the grid tick cards — see HostsScreen.axaml.cs — and
-                this is the whole of the chrome that arrives with them: how many, the way out, and where the
-                actions are. The phone raises a contextual action bar in the vault header's place for the
-                same state; a window with room for a context menu does not need one, and a strip of eight
-                buttons over the grid would be a second home for entries the menu already has.
-
-                ◆ THE MENU IS WHERE THE ACTIONS ARE, and the sentence says so because there is no other way
-                to find that out. Everything else on this screen can be reached by looking at it.
-
-                A Grid rather than a horizontal StackPanel, for the reason the host card carries at length: a
-                horizontal StackPanel measures its children with infinite width, so the sentence would never
-                learn it is short of room and would run out over the count at the far end instead of
-                trimming. At the window's minimum with the drawer open there is not room for all of it.
-              -->
-              <Grid Grid.Column="1" Margin="12,0" ColumnDefinitions="Auto,Auto,*"
-                    IsVisible="{Binding IsChoosingHosts}">
-                <Border Grid.Column="0" Classes="chip accent" Padding="6,1" VerticalAlignment="Center">
-                  <TextBlock Text="{Binding ChosenHostsSummary}" FontSize="9.5" />
-                </Border>
-                <Button Grid.Column="1" Classes="flat" Margin="6,0,0,0" Padding="5,1" FontSize="9.5"
-                        Content="CLEAR" Command="{Binding ClearHostChoiceCommand}"
-                        ToolTip.Tip="Takes the ticks off every card  ·  Esc, or a click on the space around them" />
-                <TextBlock Grid.Column="2" Classes="hint" FontSize="10" Margin="8,0,0,0"
-                           VerticalAlignment="Center" TextTrimming="CharacterEllipsis"
-                           Text="right-click one of them for what can be done to all of them" />
-              </Grid>
-
-              <!-- The collection's own count, so it follows both filters with no second number to keep in step. -->
-              <TextBlock Grid.Column="2" Classes="mono" Text="{Binding VisibleHosts.Count}"
-                         FontSize="11" Foreground="{StaticResource TextFaint}"
-                         VerticalAlignment="Center" />
-            </Grid>
-
-            <!--
-              ============ ◆ WHAT THE SET'S MENU ASKED ============
-              Three panels, at most one of them up, all three above the grid rather than over it — the same
-              arrangement the GROUPS section uses and the phone's list uses, for the reason written there: a
-              card laid over the cards hides the ticked ones, and which hosts are ticked is the information
-              the question exists to give. The grid shortens instead.
-
-              Which of the three is showing is decided in the view model, because each disarms the other two
-              on the way up. See MoveChosenHostsToVault, RegroupChosenHosts and DeleteChosenHosts.
-            -->
-
-            <!--
-              ◆ MOVING OR COPYING THEM TO ANOTHER VAULT. One panel for both verbs, because they differ in one
-              word and in the sentence under the picker; what varies is bound rather than duplicated. See
-              VaultViewModel.ChosenHostVaultPanelTitle and its two siblings.
-
-              The sentence is not decoration: groups and tags are items of the vault being left, so neither
-              can come along, and a host that arrived carrying either would point at something the
-              destination does not contain.
-            -->
-            <Border Padding="10" Background="{StaticResource Panel}" CornerRadius="6"
-                    BorderBrush="{StaticResource Border}" BorderThickness="1"
-                    IsVisible="{Binding IsSendingChosenHostsToAVault}">
-              <StackPanel Spacing="8">
-                <Grid ColumnDefinitions="Auto,*">
-                  <TextBlock Grid.Column="0" Classes="label"
-                             Text="{Binding ChosenHostVaultPanelTitle}" />
-                  <TextBlock Grid.Column="1" Classes="mono" Margin="8,0,0,0" FontSize="11"
-                             Foreground="{StaticResource TextFaint}" VerticalAlignment="Center"
-                             Text="{Binding ChosenHostsSummary}" />
-                </Grid>
-
-                <ComboBox HorizontalAlignment="Stretch" ItemsSource="{Binding ChosenHostVaultChoices}"
-                          SelectedItem="{Binding SelectedChosenHostVault}">
-                  <ComboBox.ItemTemplate>
-                    <DataTemplate x:DataType="vm:VaultChoiceViewModel">
-                      <TextBlock Text="{Binding Display}" FontSize="12" />
-                    </DataTemplate>
-                  </ComboBox.ItemTemplate>
-                </ComboBox>
-
-                <TextBlock Classes="hint" FontSize="10.5" TextWrapping="Wrap"
-                           Text="{Binding ChosenHostVaultPanelNote}" />
-
-                <!--
-                  ◆ THE KEY, and only for a move of exactly one host — which key to carry is a fact about one
-                  machine, and a copy that took it away would leave the original unable to connect. Unticked,
-                  because moving a key into a team's vault hands it to everybody holding that vault's key.
-                  See VaultViewModel.BringsTheChosenBindingAlong.
-                -->
-                <CheckBox IsVisible="{Binding HasAChosenBindingToBring}"
-                          IsChecked="{Binding BringsTheChosenBindingAlong}">
-                  <TextBlock FontSize="11.5" TextWrapping="Wrap"
-                             Text="{Binding ChosenBindingToBringQuestion}" />
-                </CheckBox>
-                <TextBlock Classes="hint" FontSize="10.5" TextWrapping="Wrap"
-                           IsVisible="{Binding HasAChosenBindingToBring}"
-                           Text="{Binding ChosenBindingToBringNote}" />
-
-                <StackPanel Orientation="Horizontal" Spacing="6">
-                  <Button Classes="accent" Content="{Binding ChosenHostVaultPanelVerb}"
-                          Command="{Binding ConfirmSendChosenHostsToAVaultCommand}"
-                          IsEnabled="{Binding !IsBusy}" />
-                  <Button Classes="ghost" Content="CANCEL"
-                          Command="{Binding CancelSendChosenHostsToAVaultCommand}" />
-                </StackPanel>
-              </StackPanel>
-            </Border>
-
-            <!--
-              ◆ FILING THEM UNDER A GROUP, which is what dragging the set onto a group card does without the
-              picker. Both exist for the reason the single-host gesture and the host editor both do: a
-              gesture is unreachable without a pointer, and a card that has scrolled out of sight cannot be
-              dragged onto.
-
-              One keychain's groups. A selection spanning two is refused before this panel is drawn at all —
-              see VaultViewModel.RegroupChosenHosts, which is the same refusal the drop makes.
-            -->
-            <Border Padding="10" Background="{StaticResource Panel}" CornerRadius="6"
-                    BorderBrush="{StaticResource Border}" BorderThickness="1"
-                    IsVisible="{Binding IsRegroupingChosenHosts}">
-              <StackPanel Spacing="8">
-                <Grid ColumnDefinitions="Auto,*">
-                  <TextBlock Grid.Column="0" Classes="label" Text="CHANGE GROUP" />
-                  <TextBlock Grid.Column="1" Classes="mono" Margin="8,0,0,0" FontSize="11"
-                             Foreground="{StaticResource TextFaint}" VerticalAlignment="Center"
-                             Text="{Binding ChosenHostsSummary}" />
-                </Grid>
-
-                <ComboBox HorizontalAlignment="Stretch" ItemsSource="{Binding ChosenHostGroupChoices}"
-                          SelectedItem="{Binding SelectedChosenHostGroup}">
-                  <ComboBox.ItemTemplate>
-                    <DataTemplate x:DataType="vm:GroupChoice">
-                      <TextBlock Text="{Binding Label}" FontSize="12" />
-                    </DataTemplate>
-                  </ComboBox.ItemTemplate>
-                </ComboBox>
-
-                <TextBlock Classes="hint" FontSize="10.5" TextWrapping="Wrap"
-                           Text="A group lends its port, its account and its key to every host filed under it that says nothing itself, so this can change what these machines dial. Nothing else about them moves." />
-
-                <StackPanel Orientation="Horizontal" Spacing="6">
-                  <Button Classes="accent" Content="FILE"
-                          Command="{Binding ConfirmRegroupChosenHostsCommand}"
-                          IsEnabled="{Binding !IsBusy}" />
-                  <Button Classes="ghost" Content="CANCEL"
-                          Command="{Binding CancelRegroupChosenHostsCommand}" />
-                </StackPanel>
-              </StackPanel>
-            </Border>
-
-            <!--
-              ◆ THE DELETION QUESTION, naming a count rather than a machine — which is the reason
-              DeletionTarget.ChosenHosts exists: six copies of "delete prod-db?" is not a confirmation
-              anybody reads. The shared card draws it, as it does for a group above and for one host in the
-              drawer; see ConfirmDeleteCard.
-            -->
-            <Border Padding="10" Background="{StaticResource DangerWash}" CornerRadius="6"
-                    IsVisible="{Binding IsConfirmingChosenHostDeletion}">
-              <views:ConfirmDeleteCard />
-            </Border>
-
-            <!--
-              Named because it is where keyboard focus lands when the terminal gives it back, and because
-              every gesture on it is wired in the code-behind.
-
-              Focusable, which a ListBox is not by default — Avalonia leaves focus to the items and an empty
-              list has none. Without it the release-the-keyboard path is a measured no-op: it takes Win32
-              focus off the terminal's child window and then calls Focus() on something that refuses it,
-              leaving the window with nothing focused and the keystrokes going nowhere.
-
-              ◆ CARDS ONLY, AND NO HEADINGS. It binds VisibleHosts rather than SidebarRows, which is the
-              collection with the group headings folded into it. Those headings were a full-width fold-away
-              bar between the cards — a chevron, a name and a count — and in a wrap of cards they read as a
-              collapsed dropdown that had somehow been dealt the hosts: the moment a first group existed the
-              grid stopped being a grid. Two controls saying "group" on one screen was one too many, and the
-              cards above are the better of the two. SidebarRows and the fold are still the phone's, whose
-              list has no room for a row of group cards; see Android's HostsScreen.
-
-              What a heading also was is the drop target, and that moved to the group cards rather than
-              going away with it — see the note on them above, and the code-behind for the gesture. A host is
-              taken back out of a group through its own editor, which is the one place "no group" can be said
-              plainly.
-
-              ◆ ONE LEVEL, AS A DIRECTORY PANE IS. A host filed under a group is inside that group and is
-              not also here — the cards above are the way into it, and this grid holds what is loose at
-              whatever level the trail names. It used to hold every host at once with the groups drawn as
-              headings over them, which made opening a group an operation that could only ever subtract.
-              See VaultViewModel.Matches, and the note on the find box above for the one thing that crosses
-              a group boundary.
-
-              Which group a card is in is on the card, as a chip. That is what the heading above it used to
-              say, and one chip per card says it without an accordion — and it is what tells a search result
-              from a host that lives at this level, since searching is the one way a card from inside a
-              group reaches this grid.
-
-              SelectedItem is still SelectedSidebarRow and deliberately not SelectedHost, though every item
-              here is now a host. That property swallows the null the ListBox writes back whenever the
-              collection is rebuilt — which is every filter keystroke and every background sync — where
-              binding the host selection directly would let that null through, and a null host selection
-              closes the drawer and disarms a delete somebody is in the middle of confirming. See the
-              property, and RebuildVisibleHosts on where the real clearing is done.
-            -->
-            <ListBox Classes="tiles" x:Name="HostGrid" Focusable="True"
-                     ItemsSource="{Binding VisibleHosts}"
-                     SelectedItem="{Binding SelectedSidebarRow}"
-                     ToolTip.Tip="Double-press a card for a shell. Ctrl or Shift picks out several, and so does a band dragged across the space between them; right-click any of them for what can be done to the set.">
-
-              <ListBox.ItemsPanel>
-                <ItemsPanelTemplate><WrapPanel /></ItemsPanelTemplate>
-              </ListBox.ItemsPanel>
-
-              <!--
-                The three things you can do to a host, on the host itself.
-
-                On the list rather than in the item template, and that is what makes it one menu rather than
-                one per card: a ContextMenu inside a DataTemplate would have the row for its data context,
-                and the commands here are the vault's. The code-behind selects whatever was right-clicked
-                before the menu opens, so the selection-based commands act on the card under the pointer,
-                and cancels the menu outright over the space around the cards, where there is no host to act
-                on.
-              -->
-              <!--
-                Details is here as well as on the pencil, and that is not a duplicate for its own sake: the
-                pencil appears on hover, so it is unreachable without a pointer, and this menu is what a
-                keyboard and the context key can get to. It passes no parameter — the code-behind has
-                already selected whatever was right-clicked, which is exactly what OpenHostPane falls back
-                to.
-              -->
-              <!--
-                ◆ TWO MENUS IN ONE, AND WHICH OF THEM IS DRAWN IS WHETHER ANYTHING IS TICKED.
-
-                Once Ctrl, Shift or a band has ticked cards, this menu is about the set and nothing else —
-                and it has to be, because the entries above act on the vault's *selection*, which is one
-                host. A Delete… that asked about the card under the pointer while six sat ticked behind the
-                menu is the exact mistake the whole of OnContextRequested exists to prevent, arrived at from
-                the other direction. Right-clicking a card that is not in the set drops the set first, so
-                these entries and the ones above are never both about something; see the code-behind.
-
-                This is the only home for the seven, which is why it says what each of them takes: a set from
-                two keychains, a set with a host in it that a newer version wrote, and a set of one are three
-                different answers. The three single-host entries are collapsed rather than greyed for the
-                reason the phone's sheet collapses them — a terminal, an SFTP session and a form are each
-                about one machine, and there is no reading of "edit these six".
-
-                Delete is under a separator, as it is above and as the phone's sheet has it.
-              -->
-              <ListBox.ContextMenu>
-                <ContextMenu>
-                  <MenuItem Header="Connect" IsVisible="{Binding !IsChoosingHosts}"
-                            Command="{Binding ConnectCommand}" />
-                  <MenuItem Header="Details…" IsVisible="{Binding !IsChoosingHosts}"
-                            Command="{Binding OpenHostPaneCommand}" />
-                  <MenuItem Header="Edit…" IsVisible="{Binding !IsChoosingHosts}"
-                            Command="{Binding EditSelectedHostCommand}" />
-                  <Separator IsVisible="{Binding !IsChoosingHosts}" />
-                  <MenuItem Header="Delete…" IsVisible="{Binding !IsChoosingHosts}"
-                            Command="{Binding DeleteHostCommand}" />
-
-                  <MenuItem Header="Connect" IsVisible="{Binding HasOneChosenHost}"
-                            Command="{Binding ConnectToChosenHostCommand}" />
-                  <MenuItem Header="Browse files" IsVisible="{Binding HasOneChosenHost}"
-                            Command="{Binding BrowseChosenHostCommand}" />
-                  <MenuItem Header="Edit…" IsVisible="{Binding HasOneChosenHost}"
-                            Command="{Binding EditChosenHostCommand}" />
-                  <MenuItem Header="Change group…" IsVisible="{Binding IsChoosingHosts}"
-                            Command="{Binding RegroupChosenHostsCommand}" />
-                  <MenuItem Header="Move to another vault…" IsVisible="{Binding IsChoosingHosts}"
-                            Command="{Binding MoveChosenHostsToVaultCommand}" />
-                  <MenuItem Header="Copy to another vault…" IsVisible="{Binding IsChoosingHosts}"
-                            Command="{Binding CopyChosenHostsToVaultCommand}" />
-                  <MenuItem Header="Duplicate" IsVisible="{Binding IsChoosingHosts}"
-                            Command="{Binding DuplicateChosenHostsCommand}" />
-                  <Separator IsVisible="{Binding IsChoosingHosts}" />
-                  <MenuItem Header="Delete…" IsVisible="{Binding IsChoosingHosts}"
-                            Command="{Binding DeleteChosenHostsCommand}" />
-                </ContextMenu>
-              </ListBox.ContextMenu>
-
-              <ListBox.ItemTemplate>
-
-                <DataTemplate x:DataType="vm:HostRowViewModel">
                   <!--
-                    The address is on the tooltip and nowhere else on the card. It used to be the subtitle;
-                    see the note on the summary line below for what took its place and why it is not lost.
+                    ============ THE CARDS ============
+                    A ListBox of its own per section — Classes="sectioncards" is what the code-behind finds
+                    every card container through, across however many of these are realized. See the type
+                    remarks on HostSectionViewModel for why this is a second list per group rather than one
+                    list for the whole board.
+
+                    ◆ SELECTED IS ONE-WAY, WRITTEN BY HAND ON THE WAY OUT. See HostsScreen's own remarks:
+                    a two-way binding shared by several independently-rebuilt lists would have each list's
+                    Reset racing to null the one property every filter keystroke and every sync pass.
                   -->
-                  <!--
-                    ◆ Classes.chosen is the tick on the card, and it is a class rather than the list's own
-                    selection because they are two different things: the list holds one card, which is what
-                    the drawer and CONNECT are about, and the set is what Ctrl, Shift and the band build. A
-                    card can be in the set without being the selected one, which is what a run of six looks
-                    like. See VaultViewModel.ChooseHosts and Border.tile.chosen in App.axaml.
-                  -->
-                  <Border Classes="tile" Classes.chosen="{Binding IsChosen}"
-                          ToolTip.Tip="{Binding Address}">
+                  <ListBox Classes="sectioncards" ItemsSource="{Binding Hosts}"
+                           SelectedItem="{Binding #Board.((vm:VaultViewModel)DataContext).SelectedSidebarRow, Mode=OneWay}"
+                           ToolTip.Tip="Double-press a card for a shell. Ctrl or Shift picks out several, and so does a band dragged across the space between them; right-click any of them for what can be done to the set.">
+
+                    <ListBox.ItemsPanel>
+                      <ItemsPanelTemplate><WrapPanel /></ItemsPanelTemplate>
+                    </ListBox.ItemsPanel>
+
                     <!--
-                      A Panel so the pencil below can be drawn *over* the card rather than in a column of
-                      its own. A column would have cost the name 30 pixels of a 232-pixel tile — permanently,
-                      for a control that is only there while the pointer is — and the name is the thing the
-                      grid exists to be scanned by.
+                      ◆ TWO MENUS IN ONE, AND WHICH OF THEM IS DRAWN IS WHETHER ANYTHING IS TICKED. See
+                      HostsScreen.axaml.cs's OnContextRequested for the half of this rule that lives in code:
+                      a right click outside the ticked set drops the set first, so these entries and the
+                      ones above are never both meaningful at once.
                     -->
-                    <Panel>
-                      <StackPanel Spacing="6">
-                        <Grid ColumnDefinitions="Auto,*,Auto">
+                    <ListBox.ContextMenu>
+                      <ContextMenu>
+                        <MenuItem Header="Connect" IsVisible="{Binding !#Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).ConnectCommand}" />
+                        <MenuItem Header="Details…" IsVisible="{Binding !#Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).OpenHostPaneCommand}" />
+                        <MenuItem Header="Edit…" IsVisible="{Binding !#Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).EditSelectedHostCommand}" />
+                        <Separator IsVisible="{Binding !#Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}" />
+                        <MenuItem Header="Delete…" IsVisible="{Binding !#Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).DeleteHostCommand}" />
 
-                          <Border Grid.Column="0" Classes="tileicon" Background="{StaticResource Chip}">
-                            <TextBlock Classes="mono" Text="&gt;_" FontSize="11" FontWeight="Bold"
-                                       Foreground="{StaticResource AccentText}"
-                                       HorizontalAlignment="Center" VerticalAlignment="Center" />
-                          </Border>
+                        <MenuItem Header="Connect" IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).HasOneChosenHost}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).ConnectToChosenHostCommand}" />
+                        <MenuItem Header="Browse files" IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).HasOneChosenHost}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).BrowseChosenHostCommand}" />
+                        <MenuItem Header="Edit…" IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).HasOneChosenHost}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).EditChosenHostCommand}" />
+                        <MenuItem Header="Change group…" IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).RegroupChosenHostsCommand}" />
+                        <MenuItem Header="Move to another vault…" IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).MoveChosenHostsToVaultCommand}" />
+                        <MenuItem Header="Copy to another vault…" IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).CopyChosenHostsToVaultCommand}" />
+                        <MenuItem Header="Duplicate" IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).DuplicateChosenHostsCommand}" />
+                        <Separator IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}" />
+                        <MenuItem Header="Delete…" IsVisible="{Binding #Board.((vm:VaultViewModel)DataContext).IsChoosingHosts}"
+                                  Command="{Binding #Board.((vm:VaultViewModel)DataContext).DeleteChosenHostsCommand}" />
+                      </ContextMenu>
+                    </ListBox.ContextMenu>
 
-                          <StackPanel Grid.Column="1" Margin="10,0,0,0" VerticalAlignment="Center"
-                                      Spacing="2">
-                            <!--
-                              ◆ A GRID AND NOT A HORIZONTAL StackPanel, on both of these rows, and the two
-                              look interchangeable until the text is too long for the card.
+                    <ListBox.ItemTemplate>
+                      <DataTemplate x:DataType="vm:HostRowViewModel">
 
-                              A horizontal StackPanel measures every child with infinite width, so a
-                              TextBlock inside one never learns it is short of room and TextTrimming never
-                              fires — the text simply runs on past the card's border and over the card beside
-                              it. The card is a fixed 248 and a host name is not, so that is the ordinary
-                              case rather than the edge one.
+                        <!--
+                          The full address is on the tooltip and nowhere else on the card — the design's own
+                          rule, kept: a card read while scanning a section is read for its name and whether
+                          it is live, and an address is what somebody reads once they have found the machine,
+                          which the tooltip and the drawer both still say.
 
-                              The star column is the part that gives way and the Auto column is the part that
-                              must not: a badge saying "not synced" and the word that says how a host
-                              authenticates are both short and both meaningless trimmed, where a hostname
-                              with its tail cut is still the machine you were looking for.
-                            -->
-                            <Grid ColumnDefinitions="*,Auto">
-                              <TextBlock Grid.Column="0" Text="{Binding Label}" FontWeight="Medium"
-                                         Foreground="{StaticResource Text}"
-                                         TextTrimming="CharacterEllipsis" />
-                              <Border Grid.Column="1" Classes="chip warn" Padding="4,0" Margin="6,0,0,0"
-                                      IsVisible="{Binding Badge, Converter={x:Static StringConverters.IsNotNullOrEmpty}}">
-                                <TextBlock Text="{Binding Badge}" FontSize="9.5" />
-                              </Border>
+                          MinHeight rather than a fixed Height, unlike the mock's own 120: this codebase's
+                          Border.tile is deliberately a fixed width and a free height (see App.axaml), so a
+                          card wearing four tags grows a second line rather than clipping the fourth one — a
+                          silent truncation is exactly the kind of thing the honesty rule in
+                          HANDOFF-hosts-v5.md exists to catch, and it costs nothing here to avoid.
+                        -->
+                        <Border Classes="tile" Classes.chosen="{Binding IsChosen}" MinHeight="120"
+                                ToolTip.Tip="{Binding Address}">
+                          <Panel>
+                            <Grid RowDefinitions="Auto,*,Auto">
+
+                              <Grid Grid.Row="0" ColumnDefinitions="Auto,*">
+
+                                <!--
+                                  The monogram avatar: two letters, stable-hashed into one of the mock's four
+                                  hue pairs — see HostRowViewModel.Monogram/MonogramHue and
+                                  MonogramBrushConverter, which holds the four pairs themselves. Kept beside
+                                  this one screen rather than in the shared palette, because a monogram's
+                                  colour is a fact about this card and nothing else in the theme reads it.
+                                -->
+                                <Border Grid.Column="0" Width="32" Height="32" CornerRadius="9"
+                                        Background="{Binding MonogramHue, Converter={StaticResource MonogramBg}}">
+                                  <TextBlock Classes="mono" Text="{Binding Monogram}" FontWeight="Bold"
+                                             FontSize="12.5" HorizontalAlignment="Center"
+                                             VerticalAlignment="Center"
+                                             Foreground="{Binding MonogramHue, Converter={StaticResource MonogramFg}}" />
+                                </Border>
+
+                                <StackPanel Grid.Column="1" Margin="10,0,0,0" VerticalAlignment="Center"
+                                            Spacing="3">
+
+                                  <!--
+                                    A Grid rather than a horizontal StackPanel, on both of these rows — a
+                                    horizontal StackPanel measures its children with infinite width, so
+                                    TextTrimming never fires and the name would run on past the card's own
+                                    border instead of trimming. See the longer note this carried in v4.
+                                  -->
+                                  <Grid ColumnDefinitions="*,Auto,Auto">
+                                    <TextBlock Grid.Column="0" Text="{Binding Label}" FontSize="17"
+                                               FontWeight="Bold" Foreground="{StaticResource Text}"
+                                               TextTrimming="CharacterEllipsis" />
+
+                                    <!--
+                                      The tick sits beside the dot rather than in place of it, the same
+                                      arrangement the phone's row uses: the dot says whether a shell is open
+                                      on this machine, and swapping it for the tick would hide that fact the
+                                      moment a card is chosen.
+                                    -->
+                                    <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="4"
+                                                Margin="6,0,0,0" VerticalAlignment="Center">
+                                      <TextBlock Text="✓" FontSize="11" IsVisible="{Binding IsChosen}"
+                                                 Foreground="{StaticResource AccentText}" />
+                                      <!--
+                                        Two states, deliberately: green means a terminal is open on this host
+                                        right now, grey means there is not one. Never amber — nothing here
+                                        pings anything, and a third colour would be a claim this application
+                                        does not check. See Ellipse.dot in App.axaml and
+                                        hosts-v5-design-spec.md's deviations.
+                                      -->
+                                      <Ellipse Classes="dot" Classes.live="{Binding IsConnected}"
+                                               Width="9" Height="9" />
+                                    </StackPanel>
+
+                                    <Border Grid.Column="2" Classes="chip warn" Padding="4,0" Margin="6,0,0,0"
+                                            IsVisible="{Binding Badge, Converter={x:Static StringConverters.IsNotNullOrEmpty}}">
+                                      <TextBlock Text="{Binding Badge}" FontSize="9.5" />
+                                    </Border>
+                                  </Grid>
+
+                                  <TextBlock Classes="mono" Text="{Binding Address}" FontSize="12.5"
+                                             Foreground="{StaticResource TextGhost}"
+                                             TextTrimming="CharacterEllipsis" />
+
+                                  <!--
+                                    Which vault this host is in, and only when there is more than one to be
+                                    in. It decides who else can see the host and where an edit goes back to,
+                                    so on a board spanning several vaults it is not decoration.
+                                  -->
+                                  <TextBlock Classes="mono" Text="{Binding VaultBadge}" FontSize="10"
+                                             Foreground="{StaticResource TextFaint}"
+                                             TextTrimming="CharacterEllipsis"
+                                             IsVisible="{Binding HasVaultBadge}" />
+                                </StackPanel>
+                              </Grid>
+
+                              <Grid Grid.Row="2" ColumnDefinitions="*,Auto" VerticalAlignment="Bottom"
+                                    Margin="0,8,0,0">
+
+                                <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="4"
+                                            VerticalAlignment="Bottom">
+
+                                  <!--
+                                    The pin badge: how many folders are pinned on this host, reading
+                                    HostRowViewModel.PinCount — which is Host.PinnedPaths.Count, see that
+                                    property's own remarks. Only when there is at least one; a badge reading
+                                    zero would be a fact nobody asked for.
+                                  -->
+                                  <Border Classes="chip" Height="19" CornerRadius="5" Padding="6,2"
+                                          IsVisible="{Binding HasPins}">
+                                    <StackPanel Orientation="Horizontal" Spacing="3">
+                                      <TextBlock Text="&#xE946;" FontFamily="{StaticResource IconFont}"
+                                                 FontSize="11" Foreground="{StaticResource TextFaint}" />
+                                      <TextBlock Classes="mono" Text="{Binding PinCount}" FontSize="10.5"
+                                                 Foreground="{StaticResource TextFaint}" />
+                                    </StackPanel>
+                                  </Border>
+
+                                  <!--
+                                    Tag chips, bottom-left. Templated over plain strings rather than a typed
+                                    row, so no x:DataType is declared on this inner template — TagLabels is
+                                    already resolved names, not ids, see HostRowViewModel.TagLabels.
+                                  -->
+                                  <ItemsControl ItemsSource="{Binding TagLabels}" IsVisible="{Binding HasTags}">
+                                    <ItemsControl.ItemsPanel>
+                                      <ItemsPanelTemplate><WrapPanel /></ItemsPanelTemplate>
+                                    </ItemsControl.ItemsPanel>
+                                    <ItemsControl.ItemTemplate>
+                                      <DataTemplate>
+                                        <Border Classes="chip" Height="21" CornerRadius="5" Padding="6,2"
+                                                Margin="0,0,4,4">
+                                          <TextBlock Text="{Binding}" FontSize="11"
+                                                     Foreground="{StaticResource TextFaint}" />
+                                        </Border>
+                                      </DataTemplate>
+                                    </ItemsControl.ItemTemplate>
+                                  </ItemsControl>
+                                </StackPanel>
+
+                                <!--
+                                  HostRowViewModel.LastConnectedText is filled from the connection log on
+                                  the hosts screen's activation and on SessionEnded, and restrung on a
+                                  one-minute tick while this screen is visible — see that property's own
+                                  remarks and VaultViewModel.RefreshLastConnectedAsync. This reads it as-is
+                                  rather than formatting anything here, and draws nothing while it is empty
+                                  rather than a dash that would claim "never connected" — a host never seen
+                                  in the log and a host whose vault this has not read yet look the same from
+                                  here, and neither is a claim this card can make. A connected host prints
+                                  nothing too, per decision 4: the dot above already says "right now".
+                                -->
+                                <TextBlock Grid.Column="1" Text="{Binding LastConnectedText}" FontSize="12"
+                                           Foreground="{StaticResource TextGhost}" VerticalAlignment="Bottom"
+                                           IsVisible="{Binding LastConnectedText, Converter={x:Static StringConverters.IsNotNullOrEmpty}}" />
+                              </Grid>
                             </Grid>
+
                             <!--
-                              ◆ ONE COMMA-SEPARATED LINE: the transport, the account, and every tag this host
-                              wears. It replaces two things — the address-and-authentication row that was here,
-                              and the row of tag chips that used to sit under the whole card.
-
-                              What went is the address, and it went to the tooltip above rather than nowhere.
-                              A card is read while scanning forty machines, and at that moment the name and
-                              what kind of machine it is are what is being looked for; an address is what you
-                              read once you have found it, which is what the drawer is for. The word saying
-                              how it authenticates went with it, for a smaller reason: it was there to warn
-                              that a password box would be needed, and the box is in the pane beside that
-                              warning now.
-
-                              See HostRowViewModel.Summary, and the remark there on why "ssh" is printed at
-                              all when every host in this product is one.
+                              ◆ THE PENCIL, AND THE ONLY WAY THE DRAWER OPENS FROM THIS BOARD. See the note
+                              on this in v4's own markup, kept: selecting a card does not open it any more,
+                              and this is where the asking is. Bound through #Board rather than the old
+                              $parent[ListBox] — see the remark at the top of this file for why a ListBox one
+                              level further in than the old grid changes what that path would resolve to.
                             -->
-                            <TextBlock Text="{Binding Summary}" FontSize="10.5"
-                                       Foreground="{StaticResource TextFaint}"
-                                       TextTrimming="CharacterEllipsis" />
-                            <!--
-                              Which vault this host is in, and only when there is more than one to be in. It
-                              decides who else can see the host and where an edit goes back to, so on a grid
-                              spanning several vaults it is not decoration.
-                            -->
-                            <TextBlock Classes="mono" Text="{Binding VaultBadge}" FontSize="10.5"
-                                       Foreground="{StaticResource TextFaint}"
-                                       IsVisible="{Binding HasVaultBadge}" />
-                          </StackPanel>
-
-                          <!--
-                            Connected, and nothing more. Green means a terminal is open on this host right
-                            now; grey means there is not one. It is deliberately not reachability — nothing
-                            here pings anything, and a dot that meant "up" would be a claim this application
-                            never checks.
-
-                            ◆ The tick sits beside it rather than in place of it, which is the arrangement
-                            the phone's row uses and for the same reason: the dot says whether a shell is
-                            open on this machine, and swapping it for the tick would make choosing a host
-                            hide a fact about it. It takes no width while it is collapsed, so a grid with
-                            nothing ticked is laid out exactly as it was.
-                          -->
-                          <StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="4"
-                                      VerticalAlignment="Top" Margin="6,2,0,0">
-                            <TextBlock Text="✓" FontSize="11" IsVisible="{Binding IsChosen}"
-                                       Foreground="{StaticResource AccentText}"
-                                       VerticalAlignment="Center" />
-                            <Ellipse Classes="dot" Classes.live="{Binding IsConnected}"
-                                     VerticalAlignment="Center" Margin="0,1,0,0" />
-                          </StackPanel>
-                        </Grid>
-
-                        <!--
-                          The group this host is filed under, and only when it is filed under one — which is
-                          the same rule the group cards above follow, and the reason a keychain nobody has
-                          filed anything in looks exactly as it did before groups existed.
-
-                          This is what the fold-away heading over a run of cards used to say. A chip on the
-                          card says it per host instead, which is the shape the rest of this card already is
-                          and the shape a wrap of cards can carry: it survives the cards being reflowed, it
-                          needs no row of its own, and it is what changes when a card is dropped onto a group.
-
-                          Accent rather than plain, so the one chip that is a *place* is not read as another
-                          tag. A group whose name the vault cannot resolve leaves this empty rather than
-                          printing an id, for the reason a tag does. See HostRowViewModel.GroupLabel.
-                        -->
-                        <Border Classes="chip accent" Padding="5,0" HorizontalAlignment="Left"
-                                IsVisible="{Binding HasGroup}">
-                          <TextBlock Text="{Binding GroupLabel}" FontSize="9.5"
-                                     TextTrimming="CharacterEllipsis" />
+                            <Button Classes="flat rowedit" Content="✎"
+                                    HorizontalAlignment="Right" VerticalAlignment="Bottom"
+                                    Command="{Binding #Board.((vm:VaultViewModel)DataContext).OpenHostPaneCommand}"
+                                    CommandParameter="{Binding}"
+                                    ToolTip.Tip="Opens this host's pane beside the board" />
+                          </Panel>
                         </Border>
+                      </DataTemplate>
+                    </ListBox.ItemTemplate>
+                  </ListBox>
 
-                        <!--
-                          A wrapped row of tag chips was here. The tags are in the summary line above now,
-                          after the account, which is what took the card from three rows and a wrap down to
-                          two: a chip and a comma-separated name say the same thing, and only one of them
-                          needs a row of its own. Chips are still what a tag looks like where it is *chosen* —
-                          the editor's picker in the drawer, and the phone's own list. See
-                          HostRowViewModel.Summary.
-                        -->
-                      </StackPanel>
+                </StackPanel>
+              </DataTemplate>
+            </ItemsControl.ItemTemplate>
+          </ItemsControl>
 
-                    <!--
-                      ◆ THE PENCIL, AND THE ONLY WAY THE DRAWER OPENS FROM THIS GRID.
-
-                      Selecting a card no longer opens it. That used to be automatic, which meant the grid
-                      gave up 304 pixels the moment anybody touched a card — including every card arrowed
-                      past on the way to the one they wanted. Opening the pane is a thing you ask for now,
-                      and this is where the asking is. See VaultViewModel.IsHostPaneOpen.
-
-                      Bottom right, under the status dot rather than beside it, and over the card rather
-                      than in a column: the two marks a card can carry on that edge are "a shell is open
-                      here" and "open this one's pane", and stacking them is what keeps both out of the
-                      name's width. It appears on hover and on the selected card; see Button.rowedit in
-                      App.axaml for why that is IsVisible rather than an opacity.
-
-                      The row is the command's parameter rather than being left to the selection. A button
-                      inside a ListBoxItem takes the press itself, and whether the item is also selected by
-                      it is the theme's business — so a command reading SelectedHost would open the pane on
-                      whichever card happened to be lit, which on the first click of a session is none of
-                      them.
-                    -->
-                    <Button Classes="flat rowedit" Content="✎"
-                            HorizontalAlignment="Right" VerticalAlignment="Bottom"
-                            Command="{Binding $parent[ListBox].((vm:VaultViewModel)DataContext).OpenHostPaneCommand}"
-                            CommandParameter="{Binding}"
-                            ToolTip.Tip="Opens this host's pane beside the grid" />
-                    </Panel>
-                  </Border>
-                </DataTemplate>
-
-              </ListBox.ItemTemplate>
-            </ListBox>
-
-            <!--
-              Nothing to show, and the two reasons it can happen are different questions. An empty keychain
-              is an invitation; a filter that matches nothing is a filter that has gone too far, and saying
-              "add a host" to somebody who has thirty would be answering the wrong one.
-            -->
-            <TextBlock Classes="hint" FontSize="12" TextWrapping="Wrap" MaxWidth="480"
-                       HorizontalAlignment="Left" Margin="0,4,0,0"
-                       IsVisible="{Binding !HasVisibleHosts}"
-                       Text="{Binding NoVisibleHostsMessage}" />
-
-          </StackPanel>
+          <!--
+            Nothing to show, and the reasons it can happen are different questions — see
+            VaultViewModel.NoHostBoardMessage for the one answered here per reason.
+          -->
+          <TextBlock Classes="hint" FontSize="12" TextWrapping="Wrap" MaxWidth="480"
+                     HorizontalAlignment="Left" Margin="0,4,0,0"
+                     IsVisible="{Binding !HasHostBoardEntries}"
+                     Text="{Binding NoHostBoardMessage}" />
 
         </StackPanel>
       </ScrollViewer>
@@ -843,7 +775,7 @@
 
         It is a rectangle the pointer is dragging out right now, so it belongs in the viewport's coordinates
         and not in the scrolling content's: a band drawn inside the stack would slide away from the pointer
-        the moment the grid scrolled under it. Same row as the ScrollViewer and after it, which is what puts
+        the moment the board scrolled under it. Same row as the ScrollViewer and after it, which is what puts
         it on top — a Grid cell stacks its children in declaration order.
 
         IsHitTestVisible="False" is the whole of why the gesture works while it is up. The band is under the
@@ -861,7 +793,7 @@
     </Grid>
 
     <!--
-      The drawer, and it takes its 304 pixels only while it has been opened — which is what gives the grid
+      The drawer, and it takes its 320 pixels only while it has been opened — which is what gives the board
       the full width for most of the time anybody is looking at it, now including all the time somebody is
       choosing between forty machines.
 
diff --git a/tests/DodoSSH.Client.App.Layout.Tests/HostGridTests.cs b/tests/DodoSSH.Client.App.Layout.Tests/HostGridTests.cs
index 7b97749..ac0cef1 100644
--- a/tests/DodoSSH.Client.App.Layout.Tests/HostGridTests.cs
+++ b/tests/DodoSSH.Client.App.Layout.Tests/HostGridTests.cs
@@ -18,26 +18,36 @@ using NSubstitute;
 namespace DodoSSH.Client.App.Layout.Tests;
 
 /// <summary>
-/// How the grid of host cards answers a pointer.
+/// How the board of host cards answers a pointer.
 /// </summary>
 /// <remarks>
 /// <para>
-/// This was <c>HostSidebarTests</c>, and it moved with the list: the cards are on
-/// <see cref="HostsScreen"/> now, and so is every handler that was wired to them. See
-/// <c>HostsScreen.axaml.cs</c>.
+/// This was <c>HostSidebarTests</c>, and it moved with the list: the cards are on <see cref="HostsScreen"/>
+/// now, and so is every handler that was wired to them. See <c>HostsScreen.axaml.cs</c>.
+/// </para>
+/// <para>
+/// ◆ v5: THE GROUP-CARD HALF OF THIS SUITE IS GONE, AND IT IS NOT REPLACED HERE. The desktop used to hold a
+/// wrap of group cards above the hosts — one level of the tree at a time, opened by a double-click, filed
+/// into by dragging a host card onto one. All of that left with the cards: v5 draws every group as a
+/// section heading instead, see <c>VaultViewModel.HostSections</c>, and a host is filed through its own
+/// editor or the chosen-hosts menu's "Change group…" rather than a drag. The card-navigation surface this
+/// was written against — <c>OpenGroupCommand</c>, <c>VisibleGroups</c>, <c>GroupTrail</c>,
+/// <c>SelectedGroup</c>, <c>GroupCrumbViewModel</c>, and the drag command <c>MoveHostToGroupCommand</c> dragged
+/// onto — is no longer reached from either head's markup; <c>GroupFilter</c> stays, since group-heading
+/// commands still fall back to it. Section-level
+/// coverage — flattening order, the headerless invariant, per-section collapse, filter composition, monogram
+/// stability — is in <c>HostSectionsTests</c> instead, which is where a heading now belongs.
 /// </para>
 /// <para>
 /// Separate from <see cref="ScreenLayoutTests"/>, which measures these controls rather than driving them.
-/// What is here is the one gesture that cannot be expressed as a binding and cannot be checked by
-/// measuring: a right click has to move the selection <em>before</em> the menu opens, because the commands
-/// on both of that screen's menus read the vault's selection. A menu that quietly acted on whichever host
-/// happened to be selected would delete the wrong machine, which is the version of this mistake worth a
-/// suite — and the group cards have the same menu with a fallback behind it that makes getting it wrong
-/// quieter still.
+/// What is here is the one gesture that cannot be expressed as a binding and cannot be checked by measuring:
+/// a right click has to move the selection <em>before</em> the menu opens, because the commands on both of
+/// that menu's halves read the vault's selection. A menu that quietly acted on whichever host happened to be
+/// selected would delete the wrong machine, which is the version of this mistake worth a suite.
 /// </para>
 /// <para>
 /// A real <see cref="VaultViewModel"/> over a real unlocked vault, for the reason the other suites here use
-/// one: compiled bindings resolve against the declared type, and the grid is built out of the vault's own
+/// one: compiled bindings resolve against the declared type, and the board is built out of the vault's own
 /// hosts and groups.
 /// </para>
 /// </remarks>
@@ -102,27 +112,24 @@ public sealed class HostGridTests : IAsyncLifetime
     [Fact]
     public async Task ARightClickSelectsTheHostUnderThePointer()
     {
-        await OnTheGridAsync((screen, window) =>
+        await OnTheBoardAsync((screen, window) =>
         {
             var first = Row(vault, "prod-db");
             var other = Row(vault, "stage-web");
 
             vault.SelectedHost = first;
 
-            RightClick(CardFor(screen, other), window);
+            var card = CardFor(screen, other);
+            RightClick(card, window);
 
             vault.SelectedHost.ShouldBeSameAs(other);
 
-            var menu = screen.HostGrid.ContextMenu.ShouldNotBeNull();
+            var menu = SectionMenuFor(card).ShouldNotBeNull();
             menu.IsOpen.ShouldBeTrue();
 
-            // The commands are the vault's, which is the other half of putting the menu on the list rather
-            // than in the item template: a menu inside the template would have the row for its data context,
-            // and every one of these would silently bind to nothing.
-            //
-            // Drawn rather than merely present, because this menu carries a second Edit… that is about the
-            // ticked set rather than about the selection; with nothing ticked that one is collapsed. See
-            // TheMenuIsAboutTheSetWhileOneIsUpAndAboutTheCardOtherwise.
+            // The commands are the vault's, which is the other half of putting the menu on each section's
+            // own list rather than in the card's item template: a menu inside the template would have the
+            // row for its data context, and every one of these would silently bind to nothing.
             var edit = menu.Items.OfType<MenuItem>()
                 .Single(item => item.IsVisible && item.Header is "Edit…");
             edit.Command.ShouldBeSameAs(vault.EditSelectedHostCommand);
@@ -135,388 +142,38 @@ public sealed class HostGridTests : IAsyncLifetime
     }
 
     /// <remarks>
-    /// <para>
-    /// The space around the cards is part of the same <c>ListBox</c>, and a menu offering Connect, Edit and
-    /// Delete over it would be three entries acting on whichever machine happened to be selected — which is
-    /// the whole mistake this handler exists to prevent, reached by clicking nothing at all.
-    /// </para>
-    /// <para>
-    /// Raised on the list itself rather than clicked at a point known to be empty. What the handler reads is
-    /// the event's source, and a source that is the list rather than an item is exactly what the empty space
-    /// produces; a coordinate would additionally be asserting where the wrap put the cards.
-    /// </para>
+    /// The space around the cards and below them is part of <c>Board</c> rather than of any one section's
+    /// list, and a menu offering Connect, Edit and Delete over it would be three entries acting on whichever
+    /// machine happened to be selected — which is the whole mistake this handler exists to prevent, reached
+    /// by clicking nothing at all. Raised on <c>Board</c> itself, which is where the code-behind's tunnelled
+    /// handler is attached; see <c>HostsScreen.axaml.cs</c>.
     /// </remarks>
     [Fact]
     public async Task ARightClickOffAnyCardOpensNothingAndMovesNothing()
     {
-        await OnTheGridAsync((screen, _) =>
+        await OnTheBoardAsync((screen, _) =>
         {
             var selected = Row(vault, "prod-db");
             vault.SelectedHost = selected;
 
-            screen.HostGrid.RaiseEvent(new ContextRequestedEventArgs
+            screen.Board.RaiseEvent(new ContextRequestedEventArgs
             {
                 RoutedEvent = Control.ContextRequestedEvent,
-                Source = screen.HostGrid,
+                Source = screen.Board,
             });
 
             vault.SelectedHost.ShouldBeSameAs(selected, "the selection the menu would have acted on");
-            screen.HostGrid.ContextMenu.ShouldNotBeNull().IsOpen.ShouldBeFalse();
+
+            screen.GetVisualDescendants().OfType<ListBox>()
+                .Where(list => list.Classes.Contains("sectioncards"))
+                .Select(list => list.ContextMenu)
+                .OfType<ContextMenu>()
+                .ShouldAllBe(menu => !menu.IsOpen, "no section's menu opened over the empty space");
         });
     }
 
     /// <summary>
-    /// The same rule on the cards above, where getting it wrong is quieter and worse.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The host grid's menu acts on nothing when it is not aimed; this one acts on the <em>wrong group</em>.
-    /// <c>GroupTarget</c> falls back to the group whose contents are on screen when no card is selected, and
-    /// a menu that opened on a card would then offer to delete a group the pointer is nowhere near. It is
-    /// also the only way to Edit or Delete a group on the desktop, so this is the only place it is aimed.
-    /// </para>
-    /// <para>
-    /// Open is the one entry that takes a parameter, because <c>OpenGroupCommand</c>'s null is a real
-    /// argument — it is ALL HOSTS. That makes its <c>CommandParameter</c> binding the half most likely to
-    /// rot: a path that resolves to nothing compiles, draws, and quietly leaves the grid at the top level.
-    /// </para>
-    /// </remarks>
-    [Fact]
-    public async Task ARightClickSelectsTheGroupUnderThePointer()
-    {
-        await AddGroupAsync("staging");
-
-        await OnTheGridAsync((screen, window) =>
-        {
-            var first = GroupRow(vault, "production");
-            var other = GroupRow(vault, "staging");
-
-            vault.SelectedGroup = first;
-
-            RightClick(CardFor(screen, other), window);
-
-            vault.SelectedGroup.ShouldBeSameAs(other);
-
-            var menu = screen.GroupGrid.ContextMenu.ShouldNotBeNull();
-            menu.IsOpen.ShouldBeTrue();
-
-            var items = menu.Items.OfType<MenuItem>().ToList();
-
-            var open = items.Single(item => item.Header is "Open");
-            open.Command.ShouldBeSameAs(vault.OpenGroupCommand);
-            open.CommandParameter.ShouldBeSameAs(other, "the card under the pointer, not ALL HOSTS");
-
-            var edit = items.Single(item => item.Header is "Edit…");
-            edit.Command.ShouldBeSameAs(vault.EditGroupCommand);
-
-            edit.Command!.Execute(null);
-
-            vault.IsEditingGroup.ShouldBeTrue();
-            vault.GroupEditorLabel.ShouldBe(
-                other.Label, "the card that was right-clicked, not the one selected before");
-        });
-    }
-
-    /// <remarks>
-    /// The space around the group cards, where a menu would be at its most misleading: nothing is under the
-    /// pointer, so an unguarded one would open against the fallback and offer Delete about the group the
-    /// trail ends with — which, once it is open, is not a card on screen at all.
-    /// </remarks>
-    [Fact]
-    public async Task ARightClickOffAnyGroupCardOpensNothingAndMovesNothing()
-    {
-        await OnTheGridAsync((screen, _) =>
-        {
-            var selected = GroupRow(vault, "production");
-            vault.SelectedGroup = selected;
-
-            screen.GroupGrid.RaiseEvent(new ContextRequestedEventArgs
-            {
-                RoutedEvent = Control.ContextRequestedEvent,
-                Source = screen.GroupGrid,
-            });
-
-            vault.SelectedGroup.ShouldBeSameAs(selected, "the selection the menu would have acted on");
-            screen.GroupGrid.ContextMenu.ShouldNotBeNull().IsOpen.ShouldBeFalse();
-        });
-    }
-
-    /// <summary>
-    /// A host held over a group card would be filed there, and one held over another host card would not.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The group headings that used to sit between the cards are gone — see
-    /// <c>ScreenLayoutTests.TheHostsGridHoldsCardsAndNoGroupHeadings</c> — and with them went the thing a
-    /// dragged host was dropped onto. This holds the replacement in place, and the refusal with it: a card
-    /// dropped onto another card used to file it beside that one, which was legible while a heading said
-    /// which group the band of cards belonged to and is guesswork now that none does.
-    /// </para>
-    /// <para>
-    /// What is <em>not</em> here is the platform's half — picking the card up, the cursor, the drop itself.
-    /// Headless Avalonia has no native window and can synthesise none of it. The write at the end of the
-    /// gesture is <c>ShellFlowTests.MovingAHostToAGroup_FilesItAndLeavesItSelected</c>, and what neither
-    /// covers is in docs/manual-checks.md 7.6.
-    /// </para>
-    /// </remarks>
-    [Fact]
-    public async Task TheGroupCardsAreWhatAcceptsADroppedHost()
-    {
-        await OnTheGridAsync((screen, _) =>
-        {
-            var carried = new DataTransfer();
-            carried.Add(DataTransferItem.Create(HostFormat, (IReadOnlyList<HostRowViewModel>)[Row(vault, "prod-db")]));
-
-            var onto = screen.GroupGrid
-                .GetVisualDescendants()
-                .OfType<ListBoxItem>()
-                .Single(item => item.DataContext is HostGroupRowViewModel);
-
-            var over = Over(onto, carried);
-
-            onto.Classes.ShouldContain("droptarget", "the card says it would take the host");
-            over.DragEffects.ShouldBe(DragDropEffects.Move);
-
-            var refused = Over(CardFor(screen, Row(vault, "stage-web")), carried);
-
-            refused.Handled.ShouldBeTrue("the screen answered rather than leaving it to the platform");
-            refused.DragEffects.ShouldBe(
-                DragDropEffects.None,
-                "a card dropped onto another card would be filed somewhere nothing on screen names");
-
-            // And the group card it was over a moment ago stops offering to take it, which is the half of
-            // this that is wrong far more often than the mark appearing at all.
-            onto.Classes.ShouldNotContain("droptarget");
-        });
-    }
-
-    /// <remarks>
-    /// <para>
-    /// The rule one press was split into two gestures for. Selecting a group marks it and does nothing else;
-    /// opening one is what narrows the grid, and the trail is the way back out of it. While a single press
-    /// meant both, a group could not be named without every host outside it leaving the screen at the same
-    /// moment.
-    /// </para>
-    /// <para>
-    /// Driven through the properties the cards bind rather than through a click, because what is worth
-    /// holding here is the rule; the pointer is put on the gesture itself in the test below. A click would
-    /// otherwise be testing Avalonia's <c>SelectedItem</c> binding, which is not this application's code.
-    /// </para>
-    /// </remarks>
-    [Fact]
-    public async Task SelectingAGroupMarksItAndOpeningOneNarrowsTheGrid()
-    {
-        await vault.MoveHostToGroupCommand.ExecuteAsync(
-            new HostGroupMove(Row(vault, "prod-db"), vault.Groups.Single().EntityId));
-
-        // Re-found after the move, because the reload it ends with replaces every row in the list.
-        var production = vault.VisibleGroups.Single();
-
-        vault.SelectedGroup = production;
-
-        vault.GroupFilter.ShouldBeNull("one press selects a group and does not open it");
-        vault.VisibleHosts.Select(row => row.Label)
-            .ShouldBe(["stage-web"], "so the grid is still the outermost level, and prod-db is inside a group");
-        vault.GroupTarget.ShouldBeSameAs(production, "what a group command with no argument acts on");
-
-        vault.OpenGroupCommand.Execute(production);
-
-        vault.VisibleHosts.Select(row => row.Label)
-            .ShouldBe(["prod-db"], "only what is filed under the group that is open");
-
-        vault.GroupTrail.Select(crumb => crumb.Name).ShouldBe(["ALL HOSTS", "production"]);
-
-        vault.SelectedGroup.ShouldBeNull("the card it was on is not one of the cards on screen any more");
-        vault.GroupTarget.ShouldBeSameAs(
-            production, "so an unaimed command falls back to the group whose contents are showing");
-
-        // Back out, which is the trail's first crumb and nothing else: SHOW ALL was a second control for the
-        // same job and went with the change.
-        vault.OpenGroupCommand.Execute(vault.GroupTrail[0].Group);
-
-        vault.VisibleHosts.Select(row => row.Label)
-            .ShouldBe(["stage-web"], "ALL HOSTS is the outermost level, not every host in the keychain");
-        vault.GroupTarget.ShouldBeNull("and nothing is aimed at once no group is open or selected");
-    }
-
-    /// <summary>
-    /// The two grids share one selection, so at most one card on the screen is ever lit.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// They are two <c>ListBox</c>es, each holding a selection of its own and each drawing it the same way.
-    /// Left to themselves both stay marked — a group above and a host below — under two pairs of buttons of
-    /// which only one acts on whichever card the eye has settled on. The vault is what joins them.
-    /// </para>
-    /// <para>
-    /// Driven on the screen rather than on the view model alone, because half of the rule lives in the
-    /// controls: clearing the property has to reach the list that is drawing the card, and a selection
-    /// nulled in the view model while the card stays highlighted is the exact failure this is about.
-    /// </para>
-    /// </remarks>
-    [Fact]
-    public async Task TheHostAndGroupGridsShareOneSelection()
-    {
-        await OnTheGridAsync((screen, _) =>
-        {
-            var host = Row(vault, "stage-web");
-
-            vault.OpenHostPaneCommand.Execute(host);
-            Dispatcher.UIThread.RunJobs();
-
-            vault.SelectedGroup = vault.VisibleGroups.Single();
-            Dispatcher.UIThread.RunJobs();
-
-            vault.SelectedHost.ShouldBeNull("choosing a group is choosing something else");
-            vault.SelectedSidebarRow.ShouldBeNull("and the list that draws the hosts is told");
-            screen.HostGrid.SelectedItem.ShouldBeNull();
-            CardFor(screen, host).IsSelected.ShouldBeFalse("the card the pointer left has to go dark");
-            vault.IsDrawerOpen.ShouldBeFalse("a pane about one host cannot stand beside a marked group");
-
-            vault.SelectedHost = host;
-            Dispatcher.UIThread.RunJobs();
-
-            vault.SelectedGroup.ShouldBeNull("and the same in the other direction");
-            screen.GroupGrid.SelectedItem.ShouldBeNull();
-            GroupCard(screen).IsSelected.ShouldBeFalse();
-        });
-    }
-
-    /// <remarks>
-    /// A pair of EDIT and DELETE buttons used to sit beside the GROUPS heading, and the card's own menu is
-    /// the whole of both now — the menu came second and did the same job better, since it acts on the card
-    /// under the pointer rather than on <c>GroupTarget</c>. Held here because a button coming back is not a
-    /// compile error and barely a visible one: it would draw itself in place, aimed with no card selected at
-    /// the group the trail ends with, which is the mistake the two menu tests above exist to catch.
-    /// </remarks>
-    [Fact]
-    public async Task AGroupsEditAndDeleteAreOnItsCardsMenuAndNowhereElse()
-    {
-        await OnTheGridAsync((screen, _) =>
-        {
-            vault.SelectedGroup = vault.VisibleGroups.Single();
-            Dispatcher.UIThread.RunJobs();
-
-            screen.GetVisualDescendants()
-                .OfType<Button>()
-                .Where(button => ReferenceEquals(button.Command, vault.EditGroupCommand)
-                    || ReferenceEquals(button.Command, vault.DeleteGroupCommand))
-                .ShouldBeEmpty("a selected group card puts no buttons on the screen");
-        });
-    }
-
-    /// <remarks>
-    /// The half of the shared selection that is nobody's gesture. A reload falls back to the first host when
-    /// nothing is selected, which is what puts a target under CONNECT on a fresh unlock — and with one mark
-    /// between the two grids that fallback would quietly unselect a group card every time a sync landed.
-    /// </remarks>
-    [Fact]
-    public async Task ASyncDoesNotTakeTheSelectionOffAGroupCard()
-    {
-        var production = vault.VisibleGroups.Single();
-
-        vault.SelectedGroup = production;
-        vault.SelectedHost.ShouldBeNull("the seed's load left a host selected, and the group took the mark");
-
-        await vault.LoadAsync(Token);
-
-        vault.SelectedHost.ShouldBeNull("the reload invented none under the card that was chosen");
-        vault.SelectedGroup
-            .ShouldNotBeNull("re-found by id, since the reload replaces every row object in the list")
-            .EntityId.ShouldBe(production.EntityId);
-    }
-
-    /// <remarks>
-    /// The gesture, performed. It is wired in the control rather than bound in the markup — which is exactly
-    /// the sort of wiring that compiles whether or not it is connected to anything — and the first half of
-    /// what it asserts is the half that would go unnoticed: one press must still only select, or the split
-    /// bought nothing.
-    /// </remarks>
-    [Fact]
-    public async Task DoubleClickingAGroupCardOpensIt()
-    {
-        // One press, in a window of its own, because a second pair of clicks in the same one is the gesture
-        // this is separating that press from.
-        await OnTheGridAsync((screen, window) =>
-        {
-            var centre = Centre(GroupCard(screen), window);
-
-            window.MouseDown(centre, MouseButton.Left);
-            window.MouseUp(centre, MouseButton.Left);
-
-            Dispatcher.UIThread.RunJobs();
-
-            vault.SelectedGroup.ShouldNotBeNull("one press selects the card");
-            vault.GroupFilter.ShouldBeNull("and opens nothing");
-        });
-
-        await OnTheGridAsync((screen, window) =>
-        {
-            var centre = Centre(GroupCard(screen), window);
-
-            window.MouseDown(centre, MouseButton.Left);
-            window.MouseUp(centre, MouseButton.Left);
-            window.MouseDown(centre, MouseButton.Left);
-            window.MouseUp(centre, MouseButton.Left);
-
-            Dispatcher.UIThread.RunJobs();
-
-            vault.GroupFilter.ShouldNotBeNull().Label.ShouldBe("production");
-            vault.GroupTrail.Select(crumb => crumb.Name).ShouldBe(["ALL HOSTS", "production"]);
-
-            // And out again through the trail as it is actually drawn, rather than through the command. A
-            // crumb is an item in a template and the command it presses is the vault's, so the two are
-            // joined by a $parent binding — which is a string that compiles whether or not it resolves, and
-            // would leave a trail of buttons that do nothing.
-            var back = screen.GetVisualDescendants()
-                .OfType<Button>()
-                .First(button => button.DataContext is GroupCrumbViewModel { Group: null });
-
-            back.Command.ShouldNotBeNull("the crumb reached the vault's command").Execute(back.CommandParameter);
-
-            vault.GroupFilter.ShouldBeNull("ALL HOSTS is the way back out");
-            vault.VisibleHosts.Count.ShouldBe(2);
-        });
-    }
-
-    /// <summary>
-    /// The cards are one level of the tree, and the trail is how that level was reached.
-    /// </summary>
-    /// <remarks>
-    /// The grid used to draw every group at once, which was the only honest thing to do while a card was a
-    /// filter: a filter nobody can see is a filter nobody can turn off. Once opening a group became
-    /// navigation the cards became its contents — and a level with no name and no way back is a grid that
-    /// has quietly hidden things, which is what the trail is for.
-    /// </remarks>
-    [Fact]
-    public async Task OpeningANestedGroupShowsWhatIsInsideItAndTheWayBack()
-    {
-        await AddGroupAsync("estate");
-        await FileGroupUnderAsync("production", "estate");
-
-        vault.VisibleGroups.Select(row => row.Label)
-            .ShouldBe(["estate"], "the outermost groups, and production is not one of them any more");
-
-        vault.OpenGroupCommand.Execute(vault.VisibleGroups.Single());
-
-        vault.VisibleGroups.Select(row => row.Label).ShouldBe(["production"], "what is inside estate");
-        vault.GroupTrail.Select(crumb => crumb.Name).ShouldBe(["ALL HOSTS", "estate"]);
-
-        vault.OpenGroupCommand.Execute(vault.VisibleGroups.Single());
-
-        vault.HasVisibleGroups.ShouldBeFalse("production has nothing inside it, so the cards fold away");
-        vault.GroupTrail.Select(crumb => crumb.Name).ShouldBe(["ALL HOSTS", "estate", "production"]);
-
-        // A middle crumb goes back one level rather than all the way out, which is the whole reason the
-        // trail is a row of buttons instead of a sentence saying where you are.
-        vault.OpenGroupCommand.Execute(vault.GroupTrail[1].Group);
-
-        vault.VisibleGroups.Select(row => row.Label).ShouldBe(["production"]);
-        vault.GroupTrail.Select(crumb => crumb.Name).ShouldBe(["ALL HOSTS", "estate"]);
-    }
-
-    /// <summary>
-    /// Choosing a host costs nothing, and the pencil on its card is what spends the 304 pixels.
+    /// Choosing a host costs nothing, and the pencil on its card is what spends the 320 pixels.
     /// </summary>
     /// <remarks>
     /// <para>
@@ -527,13 +184,14 @@ public sealed class HostGridTests : IAsyncLifetime
     /// <para>
     /// Driven through the card's own button rather than by executing the command, since the thing most
     /// likely to rot is the binding that reaches out of the item template to the vault's command — a
-    /// <c>$parent[ListBox]</c> path that resolves to nothing compiles, draws, and does nothing when pressed.
+    /// <c>#Board</c> path that resolves to nothing compiles, draws, and does nothing when pressed. See the
+    /// remark on that idiom at the top of <c>HostsScreen.axaml</c>.
     /// </para>
     /// </remarks>
     [Fact]
     public async Task TheDrawerOpensOnThePencilRatherThanOnTheSelection()
     {
-        await OnTheGridAsync((screen, _) =>
+        await OnTheBoardAsync((screen, _) =>
         {
             var host = Row(vault, "stage-web");
 
@@ -559,14 +217,12 @@ public sealed class HostGridTests : IAsyncLifetime
 
     /// <remarks>
     /// The pane follows the selection once it is open — see <c>VaultViewModel.IsHostPaneOpen</c> — but a
-    /// selection that goes away entirely has to take it with it. Without that the flag would survive a
-    /// filter matching nothing, and the drawer would spring open again on the next card merely selected,
-    /// which is the behaviour the pencil exists to remove.
+    /// selection that goes away entirely has to take it with it.
     /// </remarks>
     [Fact]
     public async Task LosingTheSelectionClosesTheDrawerAndDoesNotArmItAgain()
     {
-        await OnTheGridAsync((_, _) =>
+        await OnTheBoardAsync((_, _) =>
         {
             vault.OpenHostPaneCommand.Execute(Row(vault, "prod-db"));
             vault.IsDrawerOpen.ShouldBeTrue();
@@ -583,15 +239,15 @@ public sealed class HostGridTests : IAsyncLifetime
     //
     // The set is the phone's — the same ids, the same seven actions, the same tick on the row — built here
     // with a pointer instead of a long press. What these hold is the half that belongs to this head: which
-    // gesture means what, and the rule that keeps the list's own selection and the set from ever both being
-    // about something at the same moment. See HostsScreen.axaml.cs.
+    // gesture means what, and the rule that keeps a section list's own selection and the set from ever both
+    // being about something at the same moment. See HostsScreen.axaml.cs.
 
     /// <remarks>
     /// <para>
     /// The modifier click, and the assertion that matters is the one about the selection: a Ctrl-click that
-    /// also moved the <c>ListBox</c>'s own mark would light the card it had just unticked and open the drawer
-    /// on a machine somebody is removing from a set. Stopping that is why the press is handled on the way
-    /// down rather than acted on as it bubbles.
+    /// also moved a section's own <c>ListBox</c> mark would light the card it had just unticked and open the
+    /// drawer on a machine somebody is removing from a set. Stopping that is why the press is handled on the
+    /// way down rather than acted on as it bubbles.
     /// </para>
     /// <para>
     /// And a plain click is the way out, which is the other half of the same rule: after one, exactly one
@@ -601,7 +257,7 @@ public sealed class HostGridTests : IAsyncLifetime
     [Fact]
     public async Task CtrlClickingCardsTicksThemWithoutMovingTheSelection()
     {
-        await OnTheGridAsync((screen, window) =>
+        await OnTheBoardAsync((screen, window) =>
         {
             var first = Row(vault, "prod-db");
             var second = Row(vault, "stage-web");
@@ -614,7 +270,7 @@ public sealed class HostGridTests : IAsyncLifetime
             vault.ChosenHostCount.ShouldBe(1);
             second.IsChosen.ShouldBeTrue("the tick is drawn on the card");
             vault.SelectedHost.ShouldBeSameAs(first, "ticking a card is not selecting it");
-            screen.HostGrid.SelectedItem.ShouldBeSameAs(first, "and the list was never told otherwise");
+            vault.SelectedSidebarRow.ShouldBeSameAs(first, "and the section lists were never told otherwise");
 
             Click(CardFor(screen, first), window, RawInputModifiers.Control);
             vault.ChosenHostCount.ShouldBe(2);
@@ -632,16 +288,17 @@ public sealed class HostGridTests : IAsyncLifetime
     /// <remarks>
     /// The run is measured from the anchor every time rather than added to, which is what makes a Shift-click
     /// that overshot recoverable by clicking nearer — the behaviour every list of this kind has. The order is
-    /// the grid's own, so "between" means between as the cards are laid out.
+    /// the board's own — <c>VaultViewModel.HostBoardOrder</c> — so "between" means between as the cards are
+    /// laid out, across sections if the run crosses one.
     /// </remarks>
     [Fact]
     public async Task ShiftClickingTicksTheRunBetweenTheTwoCards()
     {
         await AddHostAsync("dev-box");
 
-        await OnTheGridAsync((screen, window) =>
+        await OnTheBoardAsync((screen, window) =>
         {
-            var order = vault.VisibleHosts.ToList();
+            var order = vault.HostBoardOrder.ToList();
 
             order.Count.ShouldBe(3, "three cards, so a run can have something in the middle of it");
 
@@ -665,8 +322,7 @@ public sealed class HostGridTests : IAsyncLifetime
     /// <para>
     /// It starts below the cards rather than on one, which is the whole rule: a press on a card is a
     /// selection or the start of a drag of that host, and the band is what the space between and below them
-    /// is for. The rectangle ticks what it touches rather than what it swallows — a card is 232 pixels wide,
-    /// and a band that had to contain one would tick nothing at all when drawn down a column.
+    /// is for. The rectangle ticks what it touches rather than what it swallows.
     /// </para>
     /// <para>
     /// The second half is the same press without the drag: a click on the empty space is how somebody who
@@ -676,7 +332,7 @@ public sealed class HostGridTests : IAsyncLifetime
     [Fact]
     public async Task ABandDraggedOverTheCardsTicksThemAndAClickOnNothingDropsThem()
     {
-        await OnTheGridAsync((screen, window) =>
+        await OnTheBoardAsync((screen, window) =>
         {
             var first = CardFor(screen, Row(vault, "prod-db"));
             var last = CardFor(screen, Row(vault, "stage-web"));
@@ -718,23 +374,24 @@ public sealed class HostGridTests : IAsyncLifetime
     /// <remarks>
     /// This is the multi-card version of the mistake the first test in this file exists for. The entries that
     /// act on the vault's selection and the entries that act on the set are in one markup, so the thing that
-    /// must never happen is both being offered at once: a Delete… asking about the card under the pointer
-    /// while six sit ticked behind the menu is the wrong machine deleted, arrived at from the other
-    /// direction. A right click outside the set is what drops it, so the two are never both meaningful.
+    /// must never happen is both being offered at once. A right click outside the set is what drops it, so
+    /// the two are never both meaningful.
     /// </remarks>
     [Fact]
     public async Task TheMenuIsAboutTheSetWhileOneIsUpAndAboutTheCardOtherwise()
     {
-        await OnTheGridAsync((screen, window) =>
+        await OnTheBoardAsync((screen, window) =>
         {
             var ticked = Row(vault, "prod-db");
             var other = Row(vault, "stage-web");
 
-            Click(CardFor(screen, ticked), window, RawInputModifiers.Control);
+            var tickedCard = CardFor(screen, ticked);
 
-            RightClick(CardFor(screen, ticked), window);
+            Click(tickedCard, window, RawInputModifiers.Control);
 
-            var menu = screen.HostGrid.ContextMenu.ShouldNotBeNull();
+            RightClick(tickedCard, window);
+
+            var menu = SectionMenuFor(tickedCard).ShouldNotBeNull();
 
             menu.IsOpen.ShouldBeTrue();
             vault.ChosenHostCount.ShouldBe(1, "a right click inside the set leaves it alone");
@@ -748,22 +405,23 @@ public sealed class HostGridTests : IAsyncLifetime
 
             menu.Close();
 
-            RightClick(CardFor(screen, other), window);
+            var otherCard = CardFor(screen, other);
+            RightClick(otherCard, window);
 
             vault.IsChoosingHosts.ShouldBeFalse("a right click on a card outside the set drops it");
             vault.SelectedHost.ShouldBeSameAs(other, "and aims the ordinary menu, as it always has");
 
-            menu.Items.OfType<MenuItem>()
+            SectionMenuFor(otherCard).ShouldNotBeNull().Items.OfType<MenuItem>()
                 .Where(item => item.IsVisible)
                 .ShouldContain(item => ReferenceEquals(item.Command, vault.DeleteHostCommand));
         });
     }
 
     /// <remarks>
-    /// Ctrl+A is every card <em>on the screen</em> and not every host in the keychain, which is the
-    /// difference that matters the moment there is something in the find box: a shortcut that quietly ticked
-    /// the machines it is not showing would be the worst possible input to Delete. Esc is the way back out,
-    /// and the grid is where both are handled — Ctrl+A in the find box above has to go on selecting text.
+    /// Ctrl+A is every card <em>on the board</em> and not every host in the keychain, which is the difference
+    /// that matters the moment there is something in the find box: a shortcut that quietly ticked the
+    /// machines it is not showing would be the worst possible input to Delete. Esc is the way back out, and
+    /// <c>Board</c> is where both are handled — Ctrl+A in the find box above has to go on selecting text.
     /// </remarks>
     [Fact]
     public async Task CtrlAChoosesEveryCardOnTheScreenAndEscapeDropsThem()
@@ -772,14 +430,14 @@ public sealed class HostGridTests : IAsyncLifetime
 
         vault.HostFilter = "prod";
 
-        await OnTheGridAsync((screen, window) =>
+        await OnTheBoardAsync((screen, window) =>
         {
             vault.VisibleHosts.Count.ShouldBe(1, "the filter is what makes this test about the screen");
 
-            screen.HostGrid.Focus();
+            screen.Board.Focus();
             Dispatcher.UIThread.RunJobs();
 
-            screen.HostGrid.IsFocused.ShouldBeTrue("the keys are the grid's");
+            screen.Board.IsFocused.ShouldBeTrue("the keys are the board's");
 
             window.KeyPressQwerty(PhysicalKey.A, RawInputModifiers.Control);
 
@@ -791,64 +449,11 @@ public sealed class HostGridTests : IAsyncLifetime
         });
     }
 
-    /// <remarks>
-    /// The drag carries a list because a drag that starts on a ticked card carries every ticked card, and the
-    /// group cards have to answer for the whole of it. Refused only when there is nothing in it left to file:
-    /// a set with one host from somewhere else in it is a real move, and offering the "no" cursor for it
-    /// would be a drop the user can see the point of and cannot make.
-    /// </remarks>
-    [Fact]
-    public async Task AGroupCardTakesAWholeSetOfDraggedHosts()
-    {
-        await OnTheGridAsync((screen, _) =>
-        {
-            IReadOnlyList<HostRowViewModel> set = [Row(vault, "prod-db"), Row(vault, "stage-web")];
-
-            var carried = new DataTransfer();
-            carried.Add(DataTransferItem.Create(HostFormat, set));
-
-            var onto = screen.GroupGrid
-                .GetVisualDescendants()
-                .OfType<ListBoxItem>()
-                .Single(item => item.DataContext is HostGroupRowViewModel);
-
-            var over = Over(onto, carried);
-
-            over.DragEffects.ShouldBe(DragDropEffects.Move, "both of them can be filed there");
-        });
-    }
-
     // ---- Helpers ----
 
-    /// <summary>The same in-process format the screen's own drag carries.</summary>
-    /// <remarks>
-    /// Declared again here rather than made visible, because what the two have in common is the contract —
-    /// the name and the type — and a test holding the screen's own field would go on passing if the screen
-    /// started carrying something else under it.
-    /// </remarks>
-    private static readonly DataFormat<IReadOnlyList<HostRowViewModel>> HostFormat =
-        DataFormat.CreateInProcessFormat<IReadOnlyList<HostRowViewModel>>("dodossh-host-rows");
-
-    /// <summary>Holds a dragged host over one control and returns what the screen said about it.</summary>
-    /// <remarks>
-    /// The nearest a headless test gets to the gesture. No platform drag can be synthesised — there is no
-    /// native window to start one — but <c>DragOver</c> is an ordinary routed event, and it is where every
-    /// decision this screen makes about a drop is taken: whether the thing under the pointer would accept
-    /// the host, and whether it is marked while it is being held there. The drop itself only repeats that
-    /// question and runs the command. See docs/manual-checks.md 7.6 for what is left over.
-    /// </remarks>
-    private static DragEventArgs Over(Interactive target, DataTransfer carried)
+    private static void RightClick(Visual card, Visual window)
     {
-        var over = new DragEventArgs(DragDrop.DragOverEvent, carried, target, default, KeyModifiers.None);
-
-        target.RaiseEvent(over);
-
-        return over;
-    }
-
-    private static void RightClick(Visual row, Visual window)
-    {
-        var at = Centre(row, window);
+        var at = Centre(card, window);
 
         ((Window)window).MouseDown(at, MouseButton.Right);
         ((Window)window).MouseUp(at, MouseButton.Right);
@@ -874,7 +479,7 @@ public sealed class HostGridTests : IAsyncLifetime
         control.TranslatePoint(default, window)
         ?? throw new InvalidOperationException("the control is not in this window's tree");
 
-    private Task OnTheGridAsync(Action<HostsScreen, Window> body) =>
+    private Task OnTheBoardAsync(Action<HostsScreen, Window> body) =>
         LayoutHarness.OnTheUiThreadAsync(
             () =>
             {
@@ -894,53 +499,27 @@ public sealed class HostGridTests : IAsyncLifetime
             },
             Token);
 
-    private static ListBoxItem GroupCard(HostsScreen screen) =>
-        screen.GroupGrid
-            .GetVisualDescendants()
-            .OfType<ListBoxItem>()
-            .Single(item => item.DataContext is HostGroupRowViewModel);
-
-    /// <remarks>Any row: a host card or a group card, which are both items of a list on this screen.</remarks>
-    private static ListBoxItem CardFor(Visual screen, object row) =>
+    /// <summary>The card for a host, out of whichever section's own list is drawing it.</summary>
+    private static ListBoxItem CardFor(Visual screen, HostRowViewModel row) =>
         screen.GetVisualDescendants()
             .OfType<ListBoxItem>()
             .First(item => ReferenceEquals(item.DataContext, row));
 
+    /// <summary>The <c>ContextMenu</c> of the section list a card belongs to.</summary>
+    /// <remarks>
+    /// Every section draws its own <c>ListBox</c> — see the remarks on <c>HostSectionViewModel</c> — so
+    /// there is no longer one menu for the whole board; this is what "the menu" now means for a given card.
+    /// </remarks>
+    private static ContextMenu? SectionMenuFor(ListBoxItem card) =>
+        card.FindAncestorOfType<ListBox>()?.ContextMenu;
+
     private static HostRowViewModel Row(VaultViewModel vault, string label) =>
         vault.Hosts.First(row => string.Equals(row.Label, label, StringComparison.Ordinal));
 
-    /// <remarks>
-    /// Out of the cards on screen rather than out of every group, because that is what the card's own data
-    /// context is — <c>Groups</c> holds the same row objects, but only one level of them is drawn.
-    /// </remarks>
-    private static HostGroupRowViewModel GroupRow(VaultViewModel vault, string label) =>
-        vault.VisibleGroups.First(row => string.Equals(row.Label, label, StringComparison.Ordinal));
-
     private static Point Centre(Visual control, Visual window) =>
         control.TranslatePoint(new Point(control.Bounds.Width / 2, control.Bounds.Height / 2), window)
         ?? throw new InvalidOperationException("the control is not in this window's tree");
 
-    private async Task AddGroupAsync(string label)
-    {
-        vault.GroupEditorLabel = label;
-
-        await vault.SaveGroupCommand.ExecuteAsync(null);
-    }
-
-    /// <summary>Files one group under another the way a user can: through the group's own editor.</summary>
-    private async Task FileGroupUnderAsync(string group, string parent)
-    {
-        vault.SelectedGroup = vault.Groups.Single(
-            row => string.Equals(row.Label, group, StringComparison.Ordinal));
-
-        vault.EditGroupCommand.Execute(null);
-
-        vault.GroupEditorSelectedParent = vault.GroupEditorParentChoices.Single(
-            choice => string.Equals(choice.Label, parent, StringComparison.Ordinal));
-
-        await vault.SaveGroupCommand.ExecuteAsync(null);
-    }
-
     /// <summary>One more machine, the way somebody adds one: through the editor.</summary>
     private async Task AddHostAsync(string label)
     {
@@ -953,7 +532,11 @@ public sealed class HostGridTests : IAsyncLifetime
         await vault.LoadAsync(Token);
     }
 
-    /// <remarks>Two hosts and a group, so there is a heading in the list and a selection to move off.</remarks>
+    /// <remarks>
+    /// Two hosts and a group, so there is a heading in the board and a selection to move off. Neither host
+    /// is filed under the group — it stays in the seed only because several of the suites in this project
+    /// still ask for one to exist, empty though it is here.
+    /// </remarks>
     private async Task SeedAsync()
     {
         foreach (var label in new[] { "prod-db", "stage-web" })
diff --git a/tests/DodoSSH.Client.App.Layout.Tests/HostSectionsTests.cs b/tests/DodoSSH.Client.App.Layout.Tests/HostSectionsTests.cs
new file mode 100644
index 0000000..30fde56
--- /dev/null
+++ b/tests/DodoSSH.Client.App.Layout.Tests/HostSectionsTests.cs
@@ -0,0 +1,331 @@
+using DodoSSH.Client.Session;
+using DodoSSH.Client.Session.Tests;
+using DodoSSH.Client.Shell.ViewModels;
+using DodoSSH.Client.Ssh;
+using DodoSSH.Client.Storage;
+using DodoSSH.Client.Terminal;
+using DodoSSH.Crypto;
+using NSubstitute;
+
+namespace DodoSSH.Client.App.Layout.Tests;
+
+/// <summary>
+/// <see cref="VaultViewModel.HostSections"/>: the desktop board's own flattening, one section per group.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Split out of <see cref="HostGridTests"/> rather than folded into it, because none of what is here needs a
+/// realized <c>HostsScreen</c> — it is <see cref="VaultViewModel"/> alone, the same surface
+/// <c>VaultViewModel.RebuildHostSections</c>, <c>FlattenIntoSections</c> and the monogram properties on
+/// <see cref="HostRowViewModel"/> already carry doc comments for. This is where those comments are held to
+/// account.
+/// </para>
+/// <para>
+/// A real <see cref="VaultViewModel"/> over a real unlocked vault, for the reason every other suite in this
+/// project uses one: compiled bindings resolve against the declared type, and a stand-in would still have to
+/// be it.
+/// </para>
+/// </remarks>
+public sealed class HostSectionsTests : IAsyncLifetime
+{
+    private const string Passphrase = "a sufficiently long passphrase";
+    private const string ServerUrl = "https://dodossh.example";
+
+    /// <remarks>Far below the shipped profile: nothing here attacks a wrap.</remarks>
+    private static readonly Argon2Profile CheapProfile =
+        Argon2Profile.FromStoredParameters(memoryKibibytes: 8 * 1024, passes: 1, parallelism: 1);
+
+    private readonly FakeAccountServer server = new();
+    private readonly StubKeyBinding keyBinding = new();
+    private readonly VaultKnownHostStore knownHosts = new();
+
+    private ClientCacheFactory caches = null!;
+    private TerminalWorkspace workspace = null!;
+    private VaultSession session = null!;
+    private VaultViewModel vault = null!;
+
+    private static CancellationToken Token => TestContext.Current.CancellationToken;
+
+    /// <inheritdoc />
+    public async ValueTask InitializeAsync()
+    {
+        caches = ClientCacheFactory.ForMemory($"host-sections-{Guid.CreateVersion7():N}");
+        await caches.MigrateAsync(Token);
+
+        await new AccountProvisioner(server, keyBinding, caches, TimeProvider.System, CheapProfile)
+            .EnrollAsync(ServerUrl, Passphrase, "laptop", "Personal", Token);
+
+        var outcome = await new SessionOpener(caches, TimeProvider.System).UnlockAsync(Passphrase, Token);
+        outcome.IsUnlocked.ShouldBeTrue(outcome.Message);
+        session = outcome.Session!;
+
+        workspace = new TerminalWorkspace(
+            new InMemoryTerminalAssetProvider(new Dictionary<string, TerminalAsset>(StringComparer.Ordinal)),
+            Substitute.For<ISshConnectionFactory>(),
+            TimeProvider.System);
+
+        await knownHosts.OpenAsync(session, Token);
+
+        vault = new VaultViewModel(session, workspace, knownHosts, static () => null);
+    }
+
+    /// <inheritdoc />
+    public async ValueTask DisposeAsync()
+    {
+        knownHosts.Close();
+        await workspace.DisposeAsync();
+        await vault.DisposeAsync();
+        caches.Dispose();
+    }
+
+    /// <remarks>
+    /// The invariant <c>HostsScreen.axaml</c> depends on for a groupless keychain to look exactly as it did
+    /// before groups existed: one section, and its <c>Header</c> is null rather than a heading with nothing
+    /// worth saying. See <c>HostSectionViewModel.HasHeader</c> and the XAML's own <c>IsVisible</c> on it.
+    /// </remarks>
+    [Fact]
+    public async Task AGrouplessKeychainDrawsOneHeaderlessSection()
+    {
+        await AddHostAsync("prod-db");
+        await AddHostAsync("stage-web");
+
+        vault.HostSections.ShouldHaveSingleItem();
+        vault.HostSections[0].HasHeader.ShouldBeFalse();
+        vault.HostSections[0].Hosts.Select(row => row.Label)
+            .ShouldBe(["prod-db", "stage-web"], ignoreOrder: true);
+    }
+
+    /// <summary>
+    /// Every group is a section, in label order, "No group" first — the flattening the phone's
+    /// <c>SidebarRows</c> has always drawn, adopted by the desktop board in v5.
+    /// </summary>
+    /// <remarks>
+    /// The three groups are made out of label order on purpose — "zeta" before "alpha" before "mid" — so a
+    /// pass that happened to preserve creation order rather than sorting would still be caught.
+    /// </remarks>
+    [Fact]
+    public async Task SectionsAreInLabelOrderWithNoGroupFirst()
+    {
+        await AddGroupAsync("zeta");
+        await AddGroupAsync("alpha");
+        await AddGroupAsync("mid");
+
+        await AddHostAsync("loose");
+        await AddHostInGroupAsync("z-host", "zeta");
+        await AddHostInGroupAsync("a-host", "alpha");
+        await AddHostInGroupAsync("m-host", "mid");
+
+        vault.HostSections.Select(section => section.Header?.Label ?? "No group")
+            .ShouldBe(["No group", "alpha", "mid", "zeta"]);
+
+        vault.HostSections.Single(section => string.Equals(section.Header?.Label, "alpha", StringComparison.Ordinal))
+            .Hosts.Select(row => row.Label).ShouldBe(["a-host"]);
+    }
+
+    /// <summary>
+    /// An empty group still gets a heading; a filter that empties a group's contents does not remove it, but
+    /// the ungrouped heading disappears entirely once nothing is left under it.
+    /// </summary>
+    [Fact]
+    public async Task AnEmptyNamedGroupKeepsItsHeadingAndAnEmptyUngroupedHeadingDropsAway()
+    {
+        await AddGroupAsync("empty-shelf");
+        await AddHostInGroupAsync("only-host", "empty-shelf");
+
+        vault.HostSections.Select(section => section.Header?.Label)
+            .ShouldNotContain("No group", "nothing is ungrouped, so that heading is not drawn at all");
+
+        vault.HostSections.Single(section => string.Equals(section.Header?.Label, "empty-shelf", StringComparison.Ordinal))
+            .Hosts.Select(row => row.Label).ShouldBe(["only-host"]);
+    }
+
+    /// <remarks>
+    /// Collapsing a section keeps its heading — the count on it is still real — and empties its own card
+    /// list; expanding it again restores the cards. Both go through <c>ToggleGroupCommand</c>, the same
+    /// command the heading's chevron button is bound to.
+    /// </remarks>
+    [Fact]
+    public async Task TogglingASectionEmptiesItsCardsWithoutDroppingItsHeading()
+    {
+        await AddGroupAsync("production");
+        await AddHostInGroupAsync("prod-db", "production");
+        await AddHostInGroupAsync("prod-web", "production");
+
+        var header = vault.HostSections.Single(section => string.Equals(section.Header?.Label, "production", StringComparison.Ordinal)).Header!;
+
+        header.IsExpanded.ShouldBeTrue("nothing has folded it yet");
+
+        vault.ToggleGroupCommand.Execute(header);
+
+        var collapsed = vault.HostSections.Single(section => string.Equals(section.Header?.Label, "production", StringComparison.Ordinal));
+        collapsed.Header!.IsExpanded.ShouldBeFalse();
+        collapsed.Header.Count.ShouldBe(2, "the heading still says how many are under it");
+        collapsed.Hosts.ShouldBeEmpty("but the card list under it is folded away");
+
+        vault.ToggleGroupCommand.Execute(collapsed.Header);
+
+        vault.HostSections.Single(section => string.Equals(section.Header?.Label, "production", StringComparison.Ordinal))
+            .Hosts.Select(row => row.Label).ShouldBe(["prod-db", "prod-web"], ignoreOrder: true);
+    }
+
+    /// <remarks>
+    /// Collapse all folds every section at once and Expand all — the same command, its label swapped by
+    /// <c>CollapseAllLabel</c> — brings every one of them back. See the remark on that property for why it
+    /// reads "collapse" until every section already is one.
+    /// </remarks>
+    [Fact]
+    public async Task CollapseAllFoldsEverySectionAndExpandAllRestoresThem()
+    {
+        await AddGroupAsync("alpha");
+        await AddGroupAsync("beta");
+        await AddHostInGroupAsync("a-host", "alpha");
+        await AddHostInGroupAsync("b-host", "beta");
+        await AddHostAsync("loose");
+
+        vault.CollapseAllLabel.ShouldBe("Collapse all", "something is still open, so this is the fold action");
+
+        vault.ToggleAllGroupsCommand.Execute(null);
+
+        vault.HostSections.SelectMany(section => section.Hosts).ShouldBeEmpty("every section folded at once");
+        vault.CollapseAllLabel.ShouldBe("Expand all");
+
+        vault.ToggleAllGroupsCommand.Execute(null);
+
+        vault.HostSections.SelectMany(section => section.Hosts).Select(row => row.Label)
+            .ShouldBe(["loose", "a-host", "b-host"], ignoreOrder: true);
+        vault.CollapseAllLabel.ShouldBe("Collapse all");
+    }
+
+    /// <summary>
+    /// Group ▾, Tag ▾ and the find box all narrow the same board at once, and a host has to clear every one
+    /// of them that is active — the toolbar's two flyouts are an AND with each other and with the box, even
+    /// though a single flyout's own ticks are an OR among themselves.
+    /// </summary>
+    [Fact]
+    public async Task GroupFilterTagFilterAndFindComposeAsAnIntersection()
+    {
+        await AddGroupAsync("alpha");
+        await AddGroupAsync("beta");
+
+        await AddHostInGroupWithTagAsync("a-prod", "alpha", "prod");
+        await AddHostInGroupWithTagAsync("a-dev", "alpha", "dev");
+        await AddHostInGroupWithTagAsync("b-prod", "beta", "prod");
+
+        var alphaChoice = vault.GroupFilterChoices.Single(choice => choice.Label == "alpha");
+        vault.ToggleGroupFilterCommand.Execute(alphaChoice);
+
+        vault.HostBoardOrder.Select(row => row.Label)
+            .ShouldBe(["a-prod", "a-dev"], ignoreOrder: true, "narrowed to alpha, both its hosts");
+
+        var prodChoice = vault.TagFilterChoices.Single(choice => choice.Label == "prod");
+        vault.ToggleTagFilterCommand.Execute(prodChoice);
+
+        vault.HostBoardOrder.Select(row => row.Label)
+            .ShouldBe(["a-prod"], "alpha AND prod, not either alone — b-prod fails the group half");
+
+        vault.HostFilter = "a-dev";
+
+        vault.HostBoardOrder.ShouldBeEmpty(
+            "the find box adds a third condition none of alpha's prod-tagged hosts can pass");
+
+        vault.HostFilter = string.Empty;
+        vault.ResetTagFilterCommand.Execute(null);
+        vault.ResetGroupFilterCommand.Execute(null);
+
+        vault.HostBoardOrder.Select(row => row.Label)
+            .ShouldBe(["a-prod", "a-dev", "b-prod"], ignoreOrder: true, "every filter cleared");
+    }
+
+    /// <summary>
+    /// The same label always draws the same two letters and the same hue — across a rebuild, which replaces
+    /// every row object outright, and that is exactly the case worth holding: nothing on the row itself
+    /// survives a reload, so the answer has to come from the label alone.
+    /// </summary>
+    /// <remarks>
+    /// FNV-1a rather than <see cref="string.GetHashCode()"/> is the reason this can be asserted at all — see
+    /// <c>HostRowViewModel.MonogramHue</c>. A hash randomised per process would still pass a same-instance
+    /// comparison but never a same-label-after-reload one, which is the case that matters: a card must not
+    /// repaint itself a different colour because the application happened to restart.
+    /// </remarks>
+    [Fact]
+    public async Task TheSameLabelDrawsTheSameMonogramAcrossAReload()
+    {
+        await AddHostAsync("prod-db-01");
+
+        var before = Host("prod-db-01");
+        var monogram = before.Monogram;
+        var hue = before.MonogramHue;
+
+        monogram.ShouldBe("pd", "the first letters of the first two hyphen-separated words, lowercased");
+
+        await vault.LoadAsync(Token);
+
+        var after = Host("prod-db-01");
+        after.ShouldNotBeSameAs(before, "the reload replaces every row — this is the case worth holding");
+        after.Monogram.ShouldBe(monogram);
+        after.MonogramHue.ShouldBe(hue);
+    }
+
+    /// <remarks>
+    /// The one-word rule is a different branch of <c>HostRowViewModel.Monogram</c> than the two-word one
+    /// above, and worth its own case: it is the first two characters of the label rather than the first
+    /// letter of two words, which for a one-word host name are not the same computation by coincidence.
+    /// </remarks>
+    [Fact]
+    public async Task AOneWordLabelDrawsItsFirstTwoCharacters()
+    {
+        await AddHostAsync("Bastion");
+
+        Host("Bastion").Monogram.ShouldBe("ba");
+    }
+
+    // ---- Helpers ----
+
+    private HostRowViewModel Host(string label) =>
+        vault.Hosts.First(row => string.Equals(row.Label, label, StringComparison.Ordinal));
+
+    private async Task AddGroupAsync(string label)
+    {
+        vault.GroupEditorLabel = label;
+        await vault.SaveGroupCommand.ExecuteAsync(Token);
+        await vault.LoadAsync(Token);
+    }
+
+    private async Task AddHostAsync(string label)
+    {
+        vault.NewHostCommand.Execute(null);
+        vault.EditorLabel = label;
+        vault.EditorHostname = $"{label}.internal";
+        vault.EditorUsername = "deploy";
+
+        await vault.SaveHostCommand.ExecuteAsync(Token);
+        await vault.LoadAsync(Token);
+    }
+
+    private async Task AddHostInGroupAsync(string label, string groupLabel)
+    {
+        vault.NewHostCommand.Execute(null);
+        vault.EditorLabel = label;
+        vault.EditorHostname = $"{label}.internal";
+        vault.EditorUsername = "deploy";
+        vault.EditorSelectedGroup = vault.EditorGroupChoices.Single(
+            choice => string.Equals(choice.Label, groupLabel, StringComparison.Ordinal));
+
+        await vault.SaveHostCommand.ExecuteAsync(Token);
+        await vault.LoadAsync(Token);
+    }
+
+    private async Task AddHostInGroupWithTagAsync(string label, string groupLabel, string tag)
+    {
+        await AddHostInGroupAsync(label, groupLabel);
+
+        vault.SelectedHost = Host(label);
+        vault.EditSelectedHostCommand.Execute(null);
+
+        vault.EditorNewTag = tag;
+        await vault.AddEditorTagCommand.ExecuteAsync(Token);
+
+        await vault.SaveHostCommand.ExecuteAsync(Token);
+        await vault.LoadAsync(Token);
+    }
+}
diff --git a/tests/DodoSSH.Client.App.Layout.Tests/ScreenLayoutTests.cs b/tests/DodoSSH.Client.App.Layout.Tests/ScreenLayoutTests.cs
index c47c286..b21017a 100644
--- a/tests/DodoSSH.Client.App.Layout.Tests/ScreenLayoutTests.cs
+++ b/tests/DodoSSH.Client.App.Layout.Tests/ScreenLayoutTests.cs
@@ -287,7 +287,7 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
 
         await OnTheHostsScreenAsync((screen, window) =>
         {
-            var card = screen.HostGrid.GetVisualDescendants()
+            var card = screen.GetVisualDescendants()
                 .OfType<ListBoxItem>()
                 .First(item => item.DataContext is HostRowViewModel);
 
@@ -332,22 +332,22 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
     {
         await OnTheHostsScreenAsync((screen, _) =>
         {
-            screen.KeyboardTarget.ShouldBeSameAs(screen.HostGrid);
-            screen.KeyboardTarget.Focus().ShouldBeTrue("the grid has cards in it");
+            screen.KeyboardTarget.ShouldBeSameAs(screen.Board);
+            screen.KeyboardTarget.Focus().ShouldBeTrue("the board has cards on it");
         });
 
         vault.HostFilter = "nothing matches this";
-        vault.HasVisibleHosts.ShouldBeFalse();
+        vault.HasHostBoardEntries.ShouldBeFalse();
 
         await OnTheHostsScreenAsync((screen, _) =>
         {
             screen.KeyboardTarget.ShouldBeSameAs(screen.HostFilter);
-            screen.KeyboardTarget.Focus().ShouldBeTrue("the grid is empty, so the find box takes it");
+            screen.KeyboardTarget.Focus().ShouldBeTrue("the board is empty, so the find box takes it");
         });
     }
 
     /// <remarks>
-    /// The editor open with the grid still on screen beside it, which is the state a user is most likely to
+    /// The editor open with the board still on screen beside it, which is the state a user is most likely to
     /// leave this screen in — so it is the state the keyboard answer most has to hold in.
     /// </remarks>
     [Fact]
@@ -357,56 +357,61 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
 
         await OnTheHostsScreenAsync((screen, _) =>
         {
-            screen.HostGrid.IsEffectivelyVisible.ShouldBeTrue();
+            screen.Board.IsEffectivelyVisible.ShouldBeTrue();
             screen.KeyboardTarget.Focus().ShouldBeTrue();
         });
     }
 
     /// <summary>
-    /// The grid is cards and nothing else, whatever the vault has been filed into.
+    /// v5: each section's own card list holds cards and nothing else — the heading is a sibling, not a row.
     /// </summary>
     /// <remarks>
     /// <para>
-    /// It used to hold the group headings too — a full-width fold-away bar between the cards for each group
-    /// — and in a wrap of cards that read as a dropdown somebody had left open. They are the phone's now.
-    /// This asserts the grid's contents rather than only measuring them, because a heading that came back
-    /// would lay out perfectly cleanly: the harness asks whether a control is inside the window, and a bar
-    /// that spans the width is as inside it as a card is.
+    /// This used to hold for one flat grid: no group headings were mixed into the host rows, because the
+    /// group cards above it were where a group's name was drawn. The board replaces that grid with one
+    /// section per group — see <c>VaultViewModel.HostSections</c> — and the invariant moves down a level
+    /// with it: it is each section's own <c>ListBox</c> (<c>Classes="sectioncards"</c>) that must hold only
+    /// <see cref="HostRowViewModel"/>s, because <c>HostsScreen.axaml.cs</c> finds every card by walking every
+    /// list wearing that class and would misfire on a heading it found mixed in.
     /// </para>
     /// <para>
-    /// Measured with every host filed and that group open, which is the shape that used to produce the most
-    /// headings. Open, because the grid holds one level of the tree — a host inside a group is drawn inside
-    /// that group and nowhere else — so measuring at the outermost level would be measuring an empty grid.
-    /// See <c>VaultViewModel.Matches</c>.
+    /// Measured with every host filed under one group, which is the shape that puts the most rows behind one
+    /// heading.
     /// </para>
     /// </remarks>
     [Fact]
-    public async Task TheHostsGridHoldsCardsAndNoGroupHeadings()
+    public async Task EachSectionsCardListHoldsCardsAndNothingElse()
     {
         await SeedGroupsAsync(3);
 
+        // Filed through the host editor, same as SeedGroupsAsync itself does — the drag this used to exercise
+        // left with the group cards in v5; see VaultViewModel.EditGroup's own remarks.
         foreach (var host in vault.Hosts.ToArray())
         {
-            await vault.MoveHostToGroupCommand.ExecuteAsync(
-                new HostGroupMove(host, vault.Groups[0].EntityId));
-        }
+            vault.SelectedHost = host;
+            vault.EditSelectedHostCommand.Execute(null);
 
-        vault.OpenGroupCommand.Execute(vault.Groups[0]);
+            vault.EditorSelectedGroup = vault.EditorGroupChoices
+                .First(choice => choice.EntityId == vault.Groups[0].EntityId);
+
+            await vault.SaveHostCommand.ExecuteAsync(null);
+        }
 
         await OnTheHostsScreenAsync((screen, _) =>
         {
-            var rows = screen.HostGrid
-                .GetVisualDescendants()
-                .OfType<ListBoxItem>()
+            var rows = screen.GetVisualDescendants()
+                .OfType<ListBox>()
+                .Where(list => list.Classes.Contains("sectioncards"))
+                .SelectMany(list => list.GetVisualDescendants().OfType<ListBoxItem>())
                 .Select(item => item.DataContext)
                 .ToList();
 
-            rows.ShouldNotBeEmpty("the seed has to put hosts in the grid");
+            rows.ShouldNotBeEmpty("the seed has to put hosts in one of the sections");
             rows.ShouldAllBe(row => row is HostRowViewModel);
         });
 
         await MeasureHostsAsync(
-            faults => faults.ShouldBeEmpty("with every host filed and the group holding them open"));
+            faults => faults.ShouldBeEmpty("with every host filed under one group and four sections drawn"));
     }
 
     /// <remarks>
@@ -447,15 +452,14 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
 
         await OnTheHostsScreenAsync((screen, window) =>
         {
-            var cards = screen.HostGrid
-                .GetVisualDescendants()
+            var cards = screen.GetVisualDescendants()
                 .OfType<ListBoxItem>()
                 .Where(item => item.DataContext is HostRowViewModel)
                 .Select(item => item.TranslatePoint(default, window)
                     ?? throw new InvalidOperationException("a card is not in this window's tree"))
                 .ToList();
 
-            cards.Count.ShouldBeGreaterThan(1, "the seed has to put more than one host in the grid");
+            cards.Count.ShouldBeGreaterThan(1, "the seed has to put more than one host on the board");
 
             cards.GroupBy(point => Math.Round(point.Y))
                 .Max(row => row.Count())
@@ -589,8 +593,9 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
     {
         await SeedGroupsAsync(3);
 
-        vault.SelectedGroup = vault.Groups[0];
-        vault.DeleteGroupCommand.Execute(null);
+        // Passed directly, the way DeleteGroupFromHeading resolves and hands in a row now that there is no
+        // group-card selection to fall back on.
+        vault.DeleteGroupCommand.Execute(vault.Groups[0]);
 
         vault.IsConfirmingGroupDeletion.ShouldBeTrue("the question has to be up for this to measure it");
         vault.PendingDeletion.ShouldNotBeNull().HasChoice
@@ -617,8 +622,6 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
     {
         await SeedGroupsAsync(3);
 
-        vault.SelectedGroup = vault.Groups[0];
-
         vault.MoveGroupVaultChoices.Add(
             new VaultChoiceViewModel(Guid.CreateVersion7(), "Platform Engineering secrets", false));