Give the phone the second design, and both heads the palette it arrives with

The Android v2 design is what this head draws now: four destinations in a bottom bar — Hosts,
Terminal, Keychain, More — with snippets, SFTP, S3, logs and preferences one tap deeper behind the
last. The first design's four had nothing behind them, which is what made a hub worth building.

The palette moved from green-black to blue-black, and it moved in the shared project because that is
where it lives and the desktop v2 specifies the same seventeen tokens. One colour changed meaning
rather than value, and it is the only semantic change in the file. Green used to *be* the accent, so
Ellipse.dot.live filled with Accent and "the thing to press" and "a shell is open on this host" were
the same colour by construction. v2 makes the accent blue and keeps a green for status alone, which
finally separates them: Live is that green and nothing merely interactive may use it. The accent is
also two colours now — Accent fills, AccentText writes — because a row of chips in the fill colour is
a row of things that all look like the primary action.

A palette is not one file, which is the part worth knowing before the next one. Nine hex literals
lived outside it: the nav bar's own label colours, the accessory keys and their Ctrl-latched state,
two scrims, the window background Android paints before Avalonia has a frame, and the launcher
vector. The two C# sites now resolve from the dictionary by name rather than restating it. The
renderer's page cannot — it is served to a WebView over a loopback socket — so terminal.css and
terminal.js keep hand-copied values and say so at both sites.

ShellScreen gained More and Buckets, appended rather than slotted in. SFTP and S3 are one screen over
one TransfersViewModel differing only in which picker they offer, and the kind is set by the button
that navigates rather than on arrival — doing it in OnScreenChanged made every arrival at Transfers
force the picker back to hosts, including the desktop's own rail arriving at a screen with a bucket
already open. It refuses to change kind while a session is live, because there is one session behind
both destinations and switching under it would title a screen S3 while it listed an SFTP host.

What the design draws and this does not, on the usual grounds. The FORWARDING screen: nothing here
forwards anything, so every toggle would be a control with no effect — it is a paragraph on the hub
naming the absence, for the reason the desktop keeps TEAMS in its rail. The terminal's `23 ms · fwd
5432`. An ED25519 badge and a SHA256 line on keychain cards, which need an algorithm field and a
fingerprint the item type does not have. An `agent` chip, for an agent that does not exist. Snippet
run history and exit codes. The Logs FOLLOW pill, which claims a live tail over records that are
written once at close and read when the screen opens, and the severity filter, which has nothing to
count — that chip row is spent on the real choice, which of the two logs. S3 bucket totals and
lifecycle. And the + on HOSTS, which would open a host editor this head has not got.

SFTP is browse, open and delete. Both transfer commands work, and what they work against is the local
pane: QueueDownloads writes to Path.Combine(LocalPath, name), and LocalPath starts at
SpecialFolder.UserProfile, which on Android is the application's own private directory. A download
would have reported success and left the file where the person who asked for it cannot open it, which
is worse than not offering it — a refusal is visible and a file in /data/user/0/ is not. The queue is
not drawn either, since nothing here can put anything in it. Both return with the document picker.
The foreground service still counts zero transfers, and the reason moved rather than went away.

Four defects worth naming, because three of them are the kind that compile. A Button as a ListBox
ItemTemplate swallows the pointer press before the list sees it, so the files listing selected
nothing and every command reading the selection did nothing — the row is a Border now and the
phone-only single-tap-to-open is a Tapped handler, which also keeps a desktop single click from
walking into directories. Avalonia type selectors are exact, so TextBlock.fingerprint never matched
SelectableTextBlock and every fingerprint on this head rendered proportional and unwrapped: that was
breaking the never-truncated rule on the host-key sheet already. The new two-level hierarchy had no
handler for the system back gesture, so back left the application from a log screen. And the tab's
close cross had shrunk to a 30x32 target flush against the select target, which is the one control
here that ends a shell with no confirmation and no undo.

Fingerprint unlock is raised on arriving at the lock screen rather than waiting for its button, which
is still there. Only at launch: a lock the user asked for is not answered with an immediate request
to unlock, which makes LOCK look inert and trains the reflex of authenticating at a prompt nobody
asked for. And once, because a declined gesture leaves the passphrase box exactly where it was and a
prompt that came back after being dismissed would be a modal you cannot get out of to type into it.

Two fixes fall on the desktop. Its file listing coloured directories with Info and executables with
Accent, which was blue against green and is now two steps of one blue; an executable is Live now.
And a bucket's folders were drawn with a 0001-01-01 timestamp, because a prefix has no modification
time — blank now, for the reason a directory's size is blank.

Verified by the whole suite: 1309 tests over nineteen projects, none failing, including the layout
suite that stands up real Avalonia and parses every desktop screen. Both heads build. Not verified on
a device — nothing in this head ever has been; see docs/android-port.md.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AZE3u99BNt6LzgTC5jhbz2

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

@@ -102,6 +102,34 @@ internal enum ShellScreen
     /// <summary>What has been connected to, and what has been changed.</summary>
     /// <inheritdoc cref="KnownHosts" path="/remarks" />
     Logs = 8,
+
+    /// <summary>
+    /// The phone's hub for everything the bottom bar has no room for.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Drawn by the Android head alone. The desktop has a nav rail with room for every destination, so it has
+    /// nothing to put behind a hub and never sets this; the v2 phone design has four slots and nine places to
+    /// go, so five of them live one tap deeper. It is a member of the shared enum rather than a phone-local
+    /// bool because it is a value of <see cref="Screen"/> like any other — the back arrow on each of those
+    /// five screens comes here, and a second notion of "where am I" is how the two would disagree.
+    /// </para>
+    /// <inheritdoc cref="KnownHosts" path="/remarks" />
+    /// </remarks>
+    More = 9,
+
+    /// <summary>
+    /// Objects in an S3-compatible bucket.
+    /// </summary>
+    /// <remarks>
+    /// The same screen as <see cref="Transfers"/> over the same <see cref="TransfersViewModel"/>, and a
+    /// separate destination anyway. What differs is only which picker is offered, so the two do not each
+    /// need a screen — but they do each need a name, because the v2 design puts SFTP and S3 side by side in
+    /// the hub, and a single "files" entry that silently remembered which kind you last opened would be a
+    /// destination whose meaning depended on history. Entering either sets
+    /// <see cref="TransfersViewModel.Remote"/>; see <see cref="OnScreenChanged"/>.
+    /// </remarks>
+    Buckets = 10,
 }
 
 /// <summary>
@@ -701,6 +729,12 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
     /// <inheritdoc cref="IsHostsScreen" />
     internal bool IsLogsScreen => Screen is ShellScreen.Logs;
 
+    /// <inheritdoc cref="IsHostsScreen" />
+    internal bool IsMoreScreen => Screen is ShellScreen.More;
+
+    /// <inheritdoc cref="IsHostsScreen" />
+    internal bool IsBucketsScreen => Screen is ShellScreen.Buckets;
+
     /// <summary>
     /// Whether the nav rail should light its Hosts entry.
     /// </summary>
@@ -734,6 +768,28 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
     /// <inheritdoc cref="IsHostsShowing" />
     internal bool IsLogsShowing => IsShowingPages && IsLogsScreen;
 
+    /// <inheritdoc cref="IsHostsShowing" />
+    internal bool IsMoreShowing => IsShowingPages && IsMoreScreen;
+
+    /// <inheritdoc cref="IsHostsShowing" />
+    internal bool IsBucketsShowing => IsShowingPages && IsBucketsScreen;
+
+    /// <summary>
+    /// Whether the phone's MORE tab should light.
+    /// </summary>
+    /// <remarks>
+    /// The hub and everything behind it, because a bottom bar that went dark the moment you opened one of
+    /// its destinations would be a bar that only ever lights three of its four entries. This is the one
+    /// place where "which tab" and "which screen" are deliberately not the same question — the other three
+    /// tabs are each exactly one screen, and this one is six.
+    ///
+    /// Preferences is in the list because the phone reaches it through the hub. The desktop reaches it from
+    /// the rail and never asks this.
+    /// </remarks>
+    internal bool IsMoreSurface =>
+        IsShowingPages && Screen is ShellScreen.More or ShellScreen.Snippets or ShellScreen.Logs
+            or ShellScreen.Transfers or ShellScreen.Buckets or ShellScreen.Preferences;
+
     /// <summary>
     /// Whether the terminal's WebView may be on screen at this instant.
     /// </summary>
@@ -2435,6 +2491,43 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
         {
             _ = teams.LoadAsync(CancellationToken.None);
         }
+
+    }
+
+    /// <summary>
+    /// Goes to the file screen with one of the two kinds of remote offered.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The phone splits SFTP and S3 into two destinations over this one view model; the desktop has a
+    /// single FILES screen with the toggle on it. So the kind is set here, by the thing that navigates,
+    /// rather than in <see cref="OnScreenChanged"/> — which would have made every arrival at
+    /// <see cref="ShellScreen.Transfers"/> force the picker back to hosts, including the desktop's own nav
+    /// rail arriving at a screen with a bucket already open.
+    /// </para>
+    /// <para>
+    /// <b>It will not change the kind while something is open.</b> There is one session behind both
+    /// destinations, so switching the picker under a live one would leave a screen titled S3 listing an
+    /// SFTP host's files. Refusing and saying so is the honest half of sharing a view model between two
+    /// destinations; the screen keeps showing what is actually open.
+    /// </para>
+    /// </remarks>
+    [RelayCommand]
+    private void ShowFiles(RemoteKind kind)
+    {
+        if (Transfers.IsConnected && Transfers.Remote != kind)
+        {
+            Transfers.Status = kind is RemoteKind.Bucket
+                ? "An SFTP session is open. Close it before opening a bucket."
+                : "A bucket is open. Close it before connecting to a host.";
+        }
+        else
+        {
+            Transfers.Remote = kind;
+        }
+
+        Screen = kind is RemoteKind.Bucket ? ShellScreen.Buckets : ShellScreen.Transfers;
+        Surface = ShellSurface.Page;
     }
 
     /// <inheritdoc cref="OnScreenChanged" />
@@ -2456,6 +2549,8 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
         OnPropertyChanged(nameof(IsImportScreen));
         OnPropertyChanged(nameof(IsSnippetsScreen));
         OnPropertyChanged(nameof(IsLogsScreen));
+        OnPropertyChanged(nameof(IsMoreScreen));
+        OnPropertyChanged(nameof(IsBucketsScreen));
 
         OnPropertyChanged(nameof(IsShowingPages));
         OnPropertyChanged(nameof(IsHostsShowing));
@@ -2466,6 +2561,9 @@ internal sealed partial class MainWindowViewModel : ObservableObject, IAsyncDisp
         OnPropertyChanged(nameof(IsKnownHostsShowing));
         OnPropertyChanged(nameof(IsSnippetsShowing));
         OnPropertyChanged(nameof(IsLogsShowing));
+        OnPropertyChanged(nameof(IsMoreShowing));
+        OnPropertyChanged(nameof(IsBucketsShowing));
+        OnPropertyChanged(nameof(IsMoreSurface));
 
         RaiseTerminalState();
     }