release(server): server-v1.6.4

fix(server): route concurrent desktop clients explicitly
Merge pull request #333 from Codename-11/dev
2026-08-12 18:38:32 -04:00 · 2026-08-12 18:38:02 -04:00 · 2026-08-11 22:00:43 -04:00 · 2026-08-11 21:46:45 -04:00 · 2026-08-11 21:37:54 -04:00 · 2026-08-11 21:35:40 -04:00
345 changed files with 28491 additions and 3488 deletions
@@ -63,7 +63,7 @@ jobs:
          java-version: 17

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6.2.0
+        uses: gradle/actions/setup-gradle@v6.3.0
        with:
          cache-read-only: ${{ github.ref != 'refs/heads/main' && github.ref != 'refs/heads/dev' }}

@@ -95,7 +95,7 @@ jobs:
          java-version: 17

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6.2.0
+        uses: gradle/actions/setup-gradle@v6.3.0
        with:
          cache-read-only: ${{ github.ref != 'refs/heads/main' && github.ref != 'refs/heads/dev' }}

@@ -139,7 +139,7 @@ jobs:
          java-version: 17

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6.2.0
+        uses: gradle/actions/setup-gradle@v6.3.0
        with:
          cache-read-only: ${{ github.ref != 'refs/heads/main' && github.ref != 'refs/heads/dev' }}

@@ -203,7 +203,7 @@ jobs:
          java-version: 17

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6.2.0
+        uses: gradle/actions/setup-gradle@v6.3.0
        with:
          cache-read-only: ${{ github.ref != 'refs/heads/main' && github.ref != 'refs/heads/dev' }}

@@ -100,13 +100,15 @@ jobs:
        with:
          node-version: '22'
          cache: npm
-          cache-dependency-path: desktop/package-lock.json
+          cache-dependency-path: |
+            desktop/package-lock.json
+            desktop/tray/package-lock.json

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Install deps
-        run: npm ci
+        run: npm ci && npm --prefix tray ci

      - name: Check tray formatting
        run: npm run tray:fmt
@@ -76,7 +76,7 @@ jobs:
          java-version: 17

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6.2.0
+        uses: gradle/actions/setup-gradle@v6.3.0
        with:
          cache-read-only: false

@@ -74,7 +74,7 @@ jobs:
          java-version: 17

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6.2.0
+        uses: gradle/actions/setup-gradle@v6.3.0
        with:
          cache-read-only: false

@@ -125,7 +125,7 @@ jobs:
          java-version: 17

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6.2.0
+        uses: gradle/actions/setup-gradle@v6.3.0
        with:
          cache-read-only: false

@@ -163,7 +163,7 @@ jobs:
          java-version: 17

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6.2.0
+        uses: gradle/actions/setup-gradle@v6.3.0
        with:
          cache-read-only: false

@@ -168,7 +168,9 @@ jobs:
        with:
          node-version: '22'
          cache: npm
-          cache-dependency-path: desktop/package-lock.json
+          cache-dependency-path: |
+            desktop/package-lock.json
+            desktop/tray/package-lock.json

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
@@ -179,7 +181,7 @@ jobs:
        uses: dtolnay/rust-toolchain@stable

      - name: Install deps
-        run: npm ci
+        run: npm ci && npm --prefix tray ci

      - name: Type-check
        run: npm run type-check
@@ -213,12 +215,153 @@ jobs:
          $proc = Start-Process -FilePath tray/target/release/hermes-relay-tray.exe -WindowStyle Hidden -PassThru
          Start-Sleep -Seconds 5
          if ($proc.HasExited) { throw "tray app exited early with code $($proc.ExitCode)" }
-          $proc.Refresh()
-          if ($proc.MainWindowHandle -ne 0) { throw 'menu-only systray created an application window' }
          $traySize = (Get-Item tray/target/release/hermes-relay-tray.exe).Length
-          if ($traySize -gt 5242880) { throw "tray executable exceeds 5 MiB: $traySize bytes" }
+          if ($traySize -le 0) { throw 'tray executable is empty' }
          Stop-Process -Id $proc.Id -Force
-          Write-Host "menu-only tray launch smoke OK pid=$($proc.Id) bytes=$traySize"
+          Write-Host "management tray launch smoke OK pid=$($proc.Id) bytes=$traySize"
+
+      - name: Smoke-test packaged installer lifecycle
+        shell: pwsh
+        env:
+          EXPECTED_DESKTOP_VERSION: ${{ needs.validate-release.outputs.version }}
+        run: |
+          $ErrorActionPreference = 'Stop'
+
+          function Normalize-UserPath([string]$Value) {
+            return (@($Value -split ';' | Where-Object { $_ }) -join ';')
+          }
+
+          function Get-RawUserPath {
+            $environmentKey = [Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment')
+            if ($null -eq $environmentKey) { return '' }
+            try {
+              return [string]$environmentKey.GetValue(
+                'Path',
+                '',
+                [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames
+              )
+            } finally {
+              $environmentKey.Dispose()
+            }
+          }
+
+          $setup = (Resolve-Path 'dist/tray/hermes-relay-windows-x64-setup.exe').Path
+          $smokeRoot = Join-Path $env:RUNNER_TEMP 'hermes-installer-lifecycle-smoke'
+          $smokeProfile = Join-Path $smokeRoot 'profile'
+          $installDir = Join-Path $smokeRoot 'installed files'
+          $sessionDir = Join-Path $smokeProfile '.hermes'
+          $sessionSentinel = Join-Path $sessionDir 'remote-sessions.json'
+          $uninstaller = Join-Path $installDir 'uninstall-hermes-relay.exe'
+          $uninstallKey = 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\HermesRelay'
+          $productKey = 'HKCU:\Software\HermesRelay'
+          $startupKey = 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Run'
+          $startMenuDir = Join-Path $env:APPDATA 'Microsoft\Windows\Start Menu\Programs\Hermes-Relay CLI'
+          $oldUserProfile = $env:USERPROFILE
+          $oldHomeEnv = $env:HOME
+          $environmentKey = [Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment', $true)
+          $hadUserPath = $environmentKey.GetValueNames() -contains 'Path'
+          $originalUserPath = Get-RawUserPath
+          $originalUserPathKind = if ($hadUserPath) { $environmentKey.GetValueKind('Path') } else { $null }
+          $userPathBefore = 'C:\Windows\System32'
+          $environmentKey.Dispose()
+          $startupBefore = (Get-ItemProperty -Path $startupKey -Name HermesRelayTray -ErrorAction SilentlyContinue).HermesRelayTray
+
+          if (Test-Path $uninstallKey) { throw 'installer smoke requires a clean HermesRelay uninstall registry key' }
+          if (Test-Path $productKey) { throw 'installer smoke requires a clean HermesRelay product registry key' }
+          if (Test-Path $smokeRoot) { Remove-Item -LiteralPath $smokeRoot -Recurse -Force }
+          New-Item -ItemType Directory -Force -Path $sessionDir | Out-Null
+          Set-Content -LiteralPath $sessionSentinel -Value '{"sentinel":"preserve-me"}' -Encoding UTF8
+
+          $env:USERPROFILE = $smokeProfile
+          $env:HOME = $smokeProfile
+          try {
+            $environmentKey = [Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment', $true)
+            $environmentKey.SetValue('Path', $userPathBefore, [Microsoft.Win32.RegistryValueKind]::String)
+            $environmentKey.Dispose()
+
+            $installProcess = Start-Process -FilePath $setup -ArgumentList @('/S', "/D=$installDir") -Wait -PassThru
+            if ($installProcess.ExitCode -ne 0) { throw "installer exited with code $($installProcess.ExitCode)" }
+
+            $expectedFiles = @(
+              'hermes-relay.exe',
+              'hermes-relay-tray.exe',
+              'hermes-relay-ui.cmd',
+              'hermes-relay-path.ps1',
+              'uninstall-hermes-relay.exe'
+            )
+            foreach ($name in $expectedFiles) {
+              $path = Join-Path $installDir $name
+              if (-not (Test-Path -LiteralPath $path -PathType Leaf)) {
+                throw "packaged installer did not create $path"
+              }
+            }
+
+            $cli = Join-Path $installDir 'hermes-relay.exe'
+            $versionOutput = (& $cli --version | Out-String).Trim()
+            if ($LASTEXITCODE -ne 0) { throw "installed CLI --version exited with code $LASTEXITCODE" }
+            if ($versionOutput -ne "hermes-relay $env:EXPECTED_DESKTOP_VERSION") {
+              throw "installed CLI version mismatch: expected $env:EXPECTED_DESKTOP_VERSION, got '$versionOutput'"
+            }
+            $helpOutput = (& $cli --help | Out-String)
+            if ($LASTEXITCODE -ne 0 -or $helpOutput -notmatch 'Usage:') {
+              throw 'installed CLI --help smoke failed'
+            }
+            if (-not (Test-Path -LiteralPath $sessionSentinel -PathType Leaf)) {
+              throw 'installer removed profile session data'
+            }
+
+            $uninstallProcess = Start-Process -FilePath $uninstaller -ArgumentList '/S' -Wait -PassThru
+            if ($uninstallProcess.ExitCode -ne 0) { throw "uninstaller exited with code $($uninstallProcess.ExitCode)" }
+
+            $deadline = [DateTime]::UtcNow.AddSeconds(20)
+            while ((Test-Path -LiteralPath $uninstaller) -and [DateTime]::UtcNow -lt $deadline) {
+              Start-Sleep -Milliseconds 250
+            }
+            foreach ($name in $expectedFiles) {
+              $path = Join-Path $installDir $name
+              if (Test-Path -LiteralPath $path) { throw "uninstaller left owned artifact $path" }
+            }
+            if (Test-Path $uninstallKey) { throw 'uninstaller left the Installed Apps registry key' }
+            if (Test-Path $productKey) { throw 'uninstaller left the HermesRelay product registry key' }
+            if (Test-Path -LiteralPath $startMenuDir) { throw "uninstaller left Start-menu artifacts at $startMenuDir" }
+            if (-not (Test-Path -LiteralPath $sessionSentinel -PathType Leaf)) {
+              throw 'uninstaller removed preserved profile session data'
+            }
+            if ((Get-Content -LiteralPath $sessionSentinel -Raw) -notmatch 'preserve-me') {
+              throw 'installer lifecycle modified preserved profile session data'
+            }
+
+            # Compare the raw registry value so expandable entries such as
+            # %USERPROFILE% are not resolved against the isolated smoke profile.
+            $userPathAfter = Normalize-UserPath (Get-RawUserPath)
+            if ($userPathAfter -ne $userPathBefore) {
+              throw "uninstaller did not restore user PATH (before='$userPathBefore', after='$userPathAfter')"
+            }
+            $startupAfter = (Get-ItemProperty -Path $startupKey -Name HermesRelayTray -ErrorAction SilentlyContinue).HermesRelayTray
+            if ($startupAfter -ne $startupBefore) {
+              throw "installer lifecycle changed the pre-existing tray startup preference"
+            }
+
+            Write-Host "packaged installer lifecycle smoke OK version=$versionOutput install=$installDir"
+          } finally {
+            Get-Process -Name 'hermes-relay-tray' -ErrorAction SilentlyContinue |
+              Stop-Process -Force -ErrorAction SilentlyContinue
+            if (Test-Path -LiteralPath $uninstaller) {
+              Start-Process -FilePath $uninstaller -ArgumentList '/S' -Wait | Out-Null
+            }
+            $env:USERPROFILE = $oldUserProfile
+            $env:HOME = $oldHomeEnv
+            $environmentKey = [Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment', $true)
+            if ($hadUserPath) {
+              $environmentKey.SetValue('Path', $originalUserPath, $originalUserPathKind)
+            } else {
+              $environmentKey.DeleteValue('Path', $false)
+            }
+            $environmentKey.Dispose()
+            if (Test-Path -LiteralPath $smokeRoot) {
+              Remove-Item -LiteralPath $smokeRoot -Recurse -Force -ErrorAction SilentlyContinue
+            }
+          }

      - name: Upload Windows tray release asset
        uses: actions/upload-artifact@v4
@@ -8,9 +8,126 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this

 ### Fixed

- **Issue area labels require maintainer review.** The unreliable keyword-based auto-labeling workflow no longer assigns ownership from ambiguous issue text.
+- **Android keeps profile management and retained automation truthful.** Custom Endpoint list and mutation routes now follow the selected Hermes profile, while completed one-shot cron jobs show their retained outcome and expose only valid Runs/Delete actions.
+- **Android and Relay recover more generated media reliably.** Android accepts upstream-valid wrapped, punctuated, adjacent, spaced, and Windows `MEDIA:` markers without consuming fenced examples, and Relay translates Docker-visible workspace, home, cache, and configured-mount paths before applying its existing credential, sandbox, and size checks.
+
+## [1.6.4] - 2026-08-12
+
+### Added
+
+- **Desktop tools support explicit host targeting.** Every client-routed desktop tool accepts a stable device ID or unambiguous computer name, and `/desktop/health` enumerates connected targets and their advertised tools.
+- **USB operations retain both routing scopes.** Raw USB and ADB tools use `device` to select the desktop PC, while ADB operations continue to use `serial` to select hardware attached to that PC.
+
+### Fixed
+
+- **Multiple desktop clients remain connected simultaneously.** The Relay no longer replaces the previous desktop when another heartbeat arrives; concurrent requests are bound to their selected WebSockets, responses from another PC are ignored, and an untargeted call fails closed when several desktops are online.
+- **Pairing another desktop preserves existing credentials.** Legacy placeholder device identifiers are treated as absent instead of shared ownership, preventing an unrelated PC from revoking the first desktop's session.
+
+## [1.6.3] - 2026-08-11
+
+### Fixed
+
+- **Relay diagnostics distinguish a prior clean stop from a crash.** Doctor and `/relay/info` expose only bounded clean, unclean, or unknown gateway-exit state with an optional suspected out-of-memory hint, without returning raw log evidence.
+- **Relay reconnects spread out after shared gateway restarts.** Ordinary exponential reconnect delays use full jitter while explicit reconnects and server-directed retry timing retain their exact behavior.
+
+## [0.4.0-alpha.7] - 2026-08-11
+
+### Fixed
+
+- **Installer lifecycle validation uses an isolated Windows PATH fixture.** Release smoke tests now verify add/remove cleanup against a fixed registry value and restore the runner's original value afterward, independently of the temporary profile used for session-preservation checks.
+
+## [0.4.0-alpha.6] - 2026-08-11
+
+### Fixed
+
+- **Installer cleanup validation compares the unexpanded Windows PATH.** Release smoke tests now read the raw user registry value, ensuring `%USERPROFILE%` entries are verified without temporary-profile expansion changing their apparent value.
+
+## [0.4.0-alpha.5] - 2026-08-11
+
+### Fixed
+
+- **Installer cleanup validation handles expandable Windows PATH entries.** Release smoke tests restore the original profile environment before comparing user PATH, avoiding false failures when unchanged `%USERPROFILE%` entries are expanded inside an isolated test profile.
+
+## [0.4.0-alpha.4] - 2026-08-11
+
+### Fixed
+
+- **Windows release validation waits for installer processes.** The packaged install/uninstall lifecycle smoke now captures GUI-subsystem process exit codes reliably before validating installed files, preserved sessions, registry state, and cleanup.
+
+## [0.4.0-alpha.3] - 2026-08-11
+
+### Added
+
+- **Windows tray provides focused remote-access management.** The compact host-aware popup covers connection state, per-host Ask/Trusted/Full Access, pending grant dialogs, authorized-client revocation, activity, daemon controls, and settings without adding chat, terminal, plugin, voice, or session surfaces.
+- **Desktop access policy is isolated per Hermes host.** `hermes-relay hosts` lists and selects local pairings and stores fail-closed access modes independently for each canonical relay URL.
+- **Windows CLI installations can add or open the management UI directly.** `hermes-relay ui install|open|status` and the installed UI shim provide a supported lifecycle for optional UI setup, discovery, and activation.
+
+### Changed
+
+- **Daemon connectivity no longer requires a tool grant.** Ask mode can keep an authenticated daemon connected with zero desktop tools attached; Trusted enables command/file tools with task-scoped screen/input grants, while Full Access removes those task prompts only for the selected host.
+- **Windows bundle updates preserve the desktop lifecycle.** The CLI and tray coordinate one verified installer launch, restore the daemon and UI after setup, and permit same-version UI add or repair without silently downgrading a newer CLI.
+
+### Fixed
+
+- **Background daemon start reports real readiness.** Detached startup now waits for the spawned process to authenticate and connect, and returns actionable log evidence for configuration, authentication, early-exit, and timeout failures.
+- **Local and release tray builds embed the packaged UI.** Development installs use Tauri's production protocol instead of attempting to load a missing localhost development server, and release CI exercises a silent install/uninstall lifecycle.
 - **Windows-trusted certificates work in the desktop CLI.** The packaged Windows binary and newer Node runtimes add the Windows certificate store without dropping bundled or operator-supplied roots, while TLS verification and Relay certificate pinning remain enforced.

+## [1.6.2] - 2026-08-11
+
+### Fixed
+
+- **Paired sessions use recognizable device identities.** Relay sessions preserve a client-provided hostname as the primary name, retain model and platform details, and enrich valid reconnects without requiring users to pair again.
+- **Long-lived session expiry is readable.** The Dashboard presents paired-session lifetime in days or weeks with the exact local deadline available in the detail view instead of accumulating hundreds of hours.
+
+## [Android 1.8.1] - 2026-08-09
+
+### Fixed
+
+- **Android preserves complete long-session transcripts.** API-server and profile-scoped Dashboard history reads now use explicit bounded pagination, retain compatibility with older unpaginated responses, and keep edit, retry, sharing, and recovery anchors stable beyond Hermes' latest-500 default window.
+- **Android follows authoritative Gateway turn contracts.** Submit rejections retain the server's message without silently falling through to SSE, event envelopes reconcile consistently, and edit-and-regenerate requests send the required truncation confirmation.
+
+## [Android 1.8.0] - 2026-08-09
+
+### Added
+
+- **Android chat keeps work in context and makes live turns easier to read.** Draft text, edits, quotes, and attachments stay with their connection, profile, and session; conversation search and prompt-turn navigation jump by stable message identity; message actions reveal smoothly on tap; quoted replies use linked previews without placing markup in the composer; assistant replies retain their compact high-contrast bubbles; and pending attachments support preview, removal, and accessible reordering.
+- **Android reasoning and tool activity use a quieter transcript.** Live thinking opens as an inline disclosure and settles to a collapsed Thought row, while consecutive routine reads, searches, commands, browser actions, and device actions share one live activity ticker or concise completed summary. Approvals, failures, generated media, file changes, output risks, and delegated work keep their own visible lifecycle surfaces even when ordinary tool progress is hidden.
+- **Android Profile Shelf makes agent switching immediate without mixing conversations.** The Chat header expands a compact, accessible shelf with ordered profile avatars, a subtle Server-default home badge on the resolved identity, last-session restoration, display hiding, lock controls, and one full switcher shared with Agent Passport.
+- **Android accepts shared text as a new Chat draft.** Hermes Relay now appears in the system sharesheet for text, opens the active profile in a fresh conversation, and fills the composer for review without sending automatically.
+
+### Changed
+
+- **Android appearance controls are more expressive and easier to preview.** Theme presets, accent and shape customization, imported Sphere skins, and custom pet creation share one live-preview workflow while preserving separate agent, background, and companion identities.
+
+### Fixed
+
+- **Android restores complete Gateway activity and makes settled replies speakable.** Successful Gateway turns reconcile structured persisted tool calls even when an upstream server omits live tool lifecycle events, and a configured voice can read a completed assistant reply from its message actions without requiring Voice Mode. While that narration is active, the same message actions expose Stop without cancelling an unrelated chat turn.
+- **Android chat matches standard keyboard, scrolling, and photo behavior.** Sentence capitalization is enabled, physical Enter can send or insert a newline according to a device-level setting, Ctrl/Command+Enter always submits, directional keys stay with the text caret, expanded thinking and tool content retains bottom-follow until the user scrolls away, and portrait attachments honor their EXIF orientation in previews and message viewers.
+- **Android distinguishes live-turn corrections from queued follow-ups.** The composer names its current action with visible text and accessible state, successful gateway redirects show a correction lifecycle marker, and attachment-bearing follow-ups always enter the session-owned queue because the upstream redirect operation is text-only.
+- **Android visibly explains quiet startup work without an empty chat bubble.** The full-size thinking animation now sits directly in the conversation lane with a stable reviewable status until the first answer text arrives, while recovery keeps its explicit reconnecting state.
+- **Android keeps pets and screen chrome inside safe interaction bounds.** Floating companions avoid agent identity rows and controls during scrolling, remain touchable for their menu, and settings headers respect edge-to-edge system insets.
+
+## [Android 1.7.1] - 2026-08-08
+
+### Fixed
+
+- **Android chat follows a growing live reply.** Bottom-owned conversations now observe each replacement of the streaming message list, keeping newly added lines visible while preserving the reader's position after a manual scroll away.
+- **Hosted Hermes onboarding completes through the official Dashboard sign-in path.** Android recognizes hosted account addresses, uses the system-browser native PKCE flow, and resumes the verified Dashboard session after its loopback callback.
+- **Live Android tool cards remain expandable while a run is active.** Streaming Gateway updates preserve stable card identity and merge tool arguments and result previews into the existing row, so details can be opened before the session finishes.
+- **Completed Android replies format Markdown immediately.** Live assistant text keeps its stable plain renderer only while incomplete, then the same owned row transitions to rich code blocks, lists, emphasis, and links without leaving or reopening the session.
+- **Android approval cards require an explicit labeled decision.** Reading or scrolling a guarded command, navigating away, backgrounding, recomposition, later turn activity, and card dismissal cannot submit or locally resolve it; pending requests remain bound to their owning profile and session until an explicit response or authoritative upstream expiry.
+- **Android Agent Passport controls are readable and easy to dismiss.** Safety and speed choices use full-width accessible targets with plain-language selected-state explanations, while a persistent close action and boundary-aware downward swipe make the sheet reliably dismissible without stealing nested content scrolling.
+- **Android queued messages stay with their originating chat.** Follow-ups now retain their exact connection, profile, session, run, route, attachments, and voice context across concurrent Gateway session switches instead of following whichever session is visible when a run finishes.
+- **Android model pickers reject duplicate catalog identities before rendering.** Repeated provider/model rows from cached or refreshed inventories are merged at the provider boundary, while identical model IDs under different providers remain distinct choices with provider-aware reasoning capabilities.
+- **Android session pins and archives survive app restarts.** The session drawer now reads and updates the owning Hermes profile's durable session metadata, rolls failed changes back, and makes unpinned stars clearly distinct in light theme.
+
+## [1.6.1] - 2026-08-08
+
+### Fixed
+
+- **The Dashboard plugin hands hosted Hermes connections to Android reliably.** Mobile setup exposes the canonical Dashboard address and keeps dialog focus handling contained, so system-browser authentication can return to the correct connection without disrupting the Dashboard.
+
 ## [Android 1.7.0] - 2026-08-06

 ### Added
@@ -1,35 +1,38 @@
-# Hermes-Relay-CLI v__VERSION__
+# Hermes-Relay CLI v__VERSION__

-**Release Date:** 2026-07-13
+**Release Date:** 2026-08-11

-This alpha makes the desktop direction explicit: Hermes-Relay is a real CLI/TUI with an optional Windows right-click systray—not a second desktop application. The old Tauri/WebView dashboard and its embedded windows are gone. The installed CLI remains the single source of behavior for pairing, TUI, daemon management, grants, audit, diagnostics, chat, voice, and tools.
+This alpha replaces the right-click-only Windows tray with the compact **Hermes-Relay CLI UI** popup while keeping Hermes-Relay's desktop boundary narrow. Chat, the remote TUI, plugins, voice, and agent sessions remain CLI or upstream desktop concerns.

-**Experimental phase.** Assets are unsigned, so Windows SmartScreen and macOS Gatekeeper may warn on first launch. Standalone CLI binaries ship for Windows x64, Linux x64, and macOS x64/arm64; the optional native systray is Windows-only.
+**Experimental phase.** Assets remain unsigned, so Windows SmartScreen and macOS Gatekeeper may warn on first launch. Standalone CLI binaries ship for Windows x64, Linux x64, and macOS x64/arm64; the management tray is Windows-only.

 ## What's changed

 ### Added

- **Persistent desktop-use control.** `hermes-relay computer-use status|enable|disable|cancel` stores one local preference, reports daemon privilege and active/pending grants, and can end an active task-scoped grant without relying on a GUI.
- **Headless grant review.** `hermes-relay grants` lists pending local computer-use requests and supports interactive review plus explicit `approve`, `reject`, and JSON forms for scripts.
- **Typed Relay chat option.** `chat --relay-chat` sends `chat.send` over WSS and renders typed `stream.event` v1 assistant, tool, artifact, memory, skill, and error lifecycles while preserving the existing gateway path as the default.
- **Release-parity verification.** One version contract now keeps the npm package, compiled CLI, Rust tray, lockfile, and installer metadata aligned. The Windows verification target covers TypeScript, compiled-binary smoke tests, Rust formatting/lint/check/tests, and installer packaging.
+- **Compact Windows management tray.** The popup provides connection status, host selection, per-host access, pending approval dialogs, recent activity, daemon controls, startup settings, and authorized-client revocation.
+- **Host-aware desktop access.** `hermes-relay hosts` lists and selects paired Hermes instances and stores independent Ask, Trusted, or Full Access policy for each canonical relay URL.
+- **In-window grant decisions.** New computer-use requests bring the tray forward and show the requesting host, scope, reason, and duration with explicit Approve and Reject actions.
+- **Supported UI lifecycle from the CLI.** `hermes-relay ui install|open|status` lets a CLI-only Windows installation add, reveal, or inspect the optional management UI without rerunning setup by hand.

 ### Changed

- **Menu-only Windows systray.** The optional tray is a small native Rust process with no application window, WebView, overlay, embedded terminal, chat view, voice view, or settings dashboard. Interactive actions open the installed CLI in a normal terminal.
- **State- and privilege-aware daemon control.** The menu reports PID-backed daemon state and User/Administrator privilege, disables invalid lifecycle actions, and requests UAC only when **Start/Restart daemon as Administrator…** is explicitly chosen. The tray itself remains unprivileged.
- **Visible desktop-use safety.** The tray shows enablement, active grant mode and expiry, warns when an Administrator control grant is active, raises a native alert for pending approvals, opens CLI grant review, and provides immediate cancellation and emergency stop.
- **Per-user Windows installation.** The default PowerShell installer downloads the checksum-verified NSIS package, installs the CLI and optional tray under `~/.hermes/bin`, adds Start-menu shortcuts and user PATH, and can start the tray at sign-in. CLI-only installation remains available with `HERMES_RELAY_INSTALL_SURFACE=cli`.
+- **Daemon startup is connectivity-first.** Ask mode can keep an authenticated daemon connected with zero desktop tools attached, so starting the daemon does not itself grant authority.
+- **Full Access is explicit and host-scoped.** Trusted hosts may use command and file tools while screen/input remains task-granted. Full Access also removes task prompts for screen, input, and file patches for that host, while authentication, audit, revocation, emergency stop, and UAC boundaries remain enforced.
+- **Host changes apply immediately.** Selecting a different host or changing its access mode restarts an already-running daemon and the UI verifies that the daemon URL matches the selected host before showing it as connected.
+- **PowerShell remains first-class.** Agents should prefer the dedicated `desktop_powershell` RPC for native Windows work; `desktop_terminal` remains cmd-compatible for existing callers.
+- **CLI and UI updates share one verified installer.** Bundle updates coordinate shutdown and restart, allow same-version UI repair, and refuse accidental downgrade unless explicitly forced.

 ### Fixed

- **Installed-binary diagnostics.** `hermes-relay doctor` reports the physical Bun-compiled executable instead of a virtual embedded-module path, so PATH and install-directory checks describe the binary that actually launched.
- **Release guardrails.** CLI tag automation rejects version drift, tags not contained in `main`, oversized tray binaries, or a tray process that creates an application window.
+- **Detached daemon start reports real readiness.** `daemon start` waits for the spawned PID to authenticate and connect, and reports configuration, authentication, early-exit, and timeout diagnostics instead of returning a false success.
+- **Normal tray operation no longer requires opening a CLI for grants.** Pending requests are resolved directly in the focused management dialog.
+- **Release checks match the management tray.** CI builds the React assets, validates Tauri metadata, and smoke-tests the packaged tray without obsolete menu-only size or window assertions.
+- **Installed tray builds no longer depend on a localhost development server.** Local and packaged builds embed their UI assets, eliminating the `127.0.0.1 refused to connect` failure.

 ## Install

-**Windows CLI + optional systray (PowerShell):**
+**Windows CLI + management tray (PowerShell):**

 ```powershell
 irm https://raw.githubusercontent.com/Codename-11/hermes-relay/main/desktop/scripts/install.ps1 | iex
@@ -53,11 +56,11 @@ Pin this release with `HERMES_RELAY_VERSION=__TAG__`.

 ```text
 hermes-relay --version
-hermes-relay pair --remote ws://<host>:8767 --grant-tools
+hermes-relay hosts list --json
 hermes-relay daemon start
-hermes-relay daemon status
+hermes-relay daemon status --json
 ```

-On Windows, open **Hermes Relay Systray** from the Start menu and right-click its notification-area icon. No separate desktop window is installed.
+On Windows, click the Hermes-Relay CLI UI notification-area icon to open the management popup directly above it.

-See the [CLI and systray guide](https://hermes-relay.dev/docs/desktop/) for installation, commands, desktop-use safety, and troubleshooting.
+See the [CLI and tray guide](https://hermes-relay.dev/docs/desktop/) for installation, access modes, grants, and troubleshooting.
@@ -1,5 +1,206 @@
 # Hermes-Relay — Dev Log

+## 2026-08-09 — Gateway activity recovery and chat speech
+
+Successful Android Gateway turns now reconcile against their profile-owned,
+structured session history. This recovers persisted tool calls when an upstream
+Gateway completes a turn without emitting live tool lifecycle events; assistant
+prose is never inspected for inferred activity, and the recovered calls continue
+through the existing Off, Compact, and Detailed display policy.
+
+The Speak message action now follows configured voice readiness and idle output
+state instead of active Voice Mode or presentation style. A settled assistant
+reply can therefore be read aloud directly from chat, while live or provider
+playback still prevents overlapping output. One-shot message narration owns its
+completion state outside Voice Mode and replaces Speak with Stop while active;
+stopping drains only that narration pipeline and does not cancel a chat turn
+started while the response was playing.
+
+## 2026-08-09 — Quiet reasoning and grouped tool activity
+
+Android Chat now treats reasoning and routine tools as transcript scaffolding.
+Visible live reasoning opens automatically without a tinted card, then collapses
+to a quiet Thought disclosure when it settles unless the reader has explicitly
+chosen its state. Empty reasoning remains absent and the existing first-token
+status continues to own the waiting state.
+
+Top-level routine calls retain their source order but render as consecutive
+activity runs. A live run keeps one summary and one latest-activity ticker in a
+stable footprint; a settled run becomes one collapsed summary that can disclose
+the original identity-preserving tool rows. File edits, approval/question tools,
+generated media, failures, output-risk findings, and delegated work split runs
+and retain independent surfaces. Off hides only ordinary activity runs, Compact
+uses compact disclosed rows, and Detailed preserves the full per-tool detail
+surface on demand. Expansion still yields bottom-follow ownership, and each run
+registers its measured bounds as Chat pet terrain.
+
+## 2026-08-09 — Android chat experience and attachment polish
+
+The Android composer now declares sentence capitalization and a Send IME
+action. A device-level setting chooses whether unmodified physical Enter sends
+or inserts a newline; Shift+Enter remains a newline and Ctrl/Command+Enter
+always submits. Every submit route converges on the existing live-turn owner,
+so the current gateway state still decides whether content steers the active
+turn or queues behind it. Directional focus traversal is cancelled while the
+editor owns focus so hardware arrow keys continue to move the caret and
+selection.
+
+Conversation bottom-follow now remains owned when thinking or tool details
+expand. Only an actual drag ending above the bottom yields that ownership, and
+a chat first measured while the IME is already visible now captures the same
+resize-follow state as a keyboard opened after composition.
+
+Bitmap-backed attachment surfaces now apply EXIF rotation and reflection before
+display. Attachment reads and Base64 conversion also leave the UI thread, so
+selecting a larger photo no longer performs the full ingestion path inside the
+activity-result callback.
+
+Composer drafts now belong to the stable connection, profile, and session
+identity. Text, edit context, and pending attachments restore when returning to
+a chat without persisting attachment bytes. Pending attachments expose bounded,
+orientation-aware previews plus explicit remove and reorder controls.
+
+Conversation overflow now opens transcript search with previous/next matches
+and a prompt-turn rail, both keyed to the same stable UI identity as the message
+list. Assistant prose retains the compact bubble and subtle edge treatment that
+keeps it legible above the animated chat background. Tapping a message reveals
+the existing copy, quote, speak, and edit actions with reduced-motion-aware
+expansion and accessible targets.
+
+Quotes are composer-owned structured references instead of raw blockquote text.
+The composer and sent message render a linked, highlighted author preview; the
+transport remains ordinary Markdown so unmodified Desktop and TUI clients show
+a readable quoted reply. Thinking and top-level tools continue to use their
+independent compact thought bubbles and configured compact or full tool cards,
+without an aggregate completion card. The composer also names Correction and
+Queue states with visible labels. Gateway redirects remain text-only:
+follow-ups with attachments are forced through the existing destination-owned
+queue so files cannot be left behind by a correction request.
+
+## 2026-08-08 — Standalone Android thinking status
+
+Blank streaming assistant rows now present the full-size working animation
+directly in the conversation lane above the visible `Still working…` label,
+without painting an empty assistant bubble around the status. The first answer
+token replaces that standalone state with the normal response bubble, while
+recovery retains the distinct `Reconnecting to your answer…` wording. The
+status owns one stable TalkBack description and suppresses animated child
+nodes, avoiding repeated announcements without claiming measurable progress.
+
+## 2026-08-08 — Android text-share draft handoff
+
+The shared Android manifest now advertises a `text/*` `ACTION_SEND` target for
+both app flavors. `MainActivity` accepts only non-blank single-item text shares
+and places them in a process-local, identity-fenced handoff that survives cold
+Compose initialization. Once the configured chat context settles, the app root
+navigates to Chat and delegates draft creation and composer prefill to
+`ChatViewModel`.
+
+The ViewModel reuses the existing new-chat lifecycle, preserving Gateway
+background-turn reconciliation and the active connection/profile/transport
+namespace. Composer prefills use a one-consumer conflated channel so an intent
+received before Chat composition is delivered once. Shared text is never
+routed through message sending; the user must review and submit it explicitly.
+
+## 2026-08-08 — Android Profile Shelf and profile-context identity
+
+Chat profile selection now lives in a collapsible shelf directly below the top
+app bar. The header toggles the shelf, the active capsule opens Agent Passport,
+inactive 48 dp avatars switch context, and a pinned overflow opens the same full
+switcher used by Passport. Saved ordering and hidden state drive both surfaces;
+the selected hidden profile remains disclosed, while a one-identity shelf stays
+out of the layout. Long-press actions expose inspection, Passport, profile lock,
+and hiding without adding activity or presence claims.
+
+The shelf uses the chat surface instead of a second elevated toolbar. A neutral
+active capsule, 36 dp avatar artwork inside 48 dp targets, compact spacing, and
+a contained overflow affordance keep the row visually subordinate to Chat. When
+Server default resolves to a concrete profile, that profile's avatar remains
+the identity and a small home badge discloses its default routing role.
+Local avatar lookup remains keyed to the Server-default presentation identity,
+so an image customized while that row is selected appears consistently in both
+the Chat header and shelf rather than being re-keyed to whichever explicit
+profile is currently active.
+
+The Server-default sentinel is now distinct from a profile literally named
+`default`. Profile selection restores the last compatible connection/profile/
+transport session, otherwise leaves a fresh draft. Gateway turns detach and
+reconcile in their original session, live SSE turns keep switching disabled,
+and every profile transition clears session-scoped model, provider, personality,
+reasoning, approval, Fast, and YOLO state before the destination session seeds
+its own values. Server sticky-default state is never written.
+
+## 2026-08-08 — Streaming reply tail follow
+
+Android's conversation-bottom follower now reads the current immutable message
+list from Compose state inside its long-lived layout observer. Each streamed
+replacement can therefore advance the viewport as the active bubble gains
+lines, while dragging or scrolling away still releases bottom ownership.
+
+## 2026-08-08 — Settled live replies transition to Markdown
+
+Android now releases the live plain-text renderer immediately after an
+assistant row settles. The transition retains the row's stable UI identity,
+commits the final live frame before replacing its selectable text topology,
+and anchors the same bottom-owned row during the Markdown remeasure. Readers
+who scrolled away retain their viewport, while completed code fences, lists,
+emphasis, links, and interrupted partial replies no longer require session
+navigation before rich rendering appears.
+
+## 2026-08-08 — Explicit-consent ownership for Android approvals
+
+Android no longer treats unrelated Gateway activity or a terminal display event
+as proof that an approval was resolved. Approval cards remain pending through
+scrolling, recomposition, navigation, and background restoration, and retain
+their exact connection, profile, and session ownership. Only a labeled action
+that successfully reaches `approval.respond`, an authoritative upstream expiry,
+or an explicit interrupt can retire the local request; the interrupt path stays
+visibly denied because upstream force-denies it.
+
+## 2026-08-08 — Agent Passport control and dismissal accessibility
+
+The Android Agent Passport keeps its title and explicit close action outside
+the nested content scroller. Material bottom-sheet gestures are enabled again,
+so a downward gesture scrolls long content toward its top boundary before the
+sheet receives the gesture and dismisses; backdrop and Back dismissal retain
+the same callback.
+
+Safety and speed choices now sit below their labels instead of competing for a
+narrow horizontal column. Every segment provides at least a 48 dp target,
+allows two-line labels, exposes radio-selection semantics, and states the
+meaning of the current approval, chat override, or processing-tier choice in
+plain language. The layout remains scrollable on compact heights and at larger
+font scales without moving the close action off-screen.
+
+## 2026-08-08 — Session-owned Android send queues
+
+Android follow-up queues now capture the composing connection/profile context,
+stored session, configured transport, originating run, attachments, and voice
+context as one immutable destination. Queue presentation is filtered to the
+visible session, while completion eligibility is tied to the exact run and live
+Gateway generation that owned the queue. A completion from another session or
+an older live generation cannot dispatch through the current composer route.
+
+In-flight checkpoints retain bounded queued text across process restoration.
+Attachment bytes are not copied into Preferences DataStore; an attachment queue
+that cannot be restored is rejected with a visible review-and-resend notice.
+Connection replacement and session deletion cancel their owned queues, while
+switching among concurrent Gateway sessions preserves each session's queue.
+
+## 2026-08-07 — Provider-owned model inventory identity
+
+Android now normalizes Gateway and API model inventories before publishing
+them to picker consumers. Repeated provider rows merge by canonical provider
+slug, repeated exact model IDs collapse within that provider, and capability
+metadata follows the same provider/model identity. Models intentionally offered
+by different providers remain distinct choices, even when their display labels
+and model IDs match.
+
+The searchable picker groups and keys rows by provider slug plus exact model ID
+instead of provider display text. Cached loads, dynamic refreshes, API aliases,
+and Manage inventory use the same idempotent identity rule, preventing duplicate
+catalog data from reaching keyed Compose lists without hiding valid routes.
+
 ## 2026-08-05 — Restored chat bottom ownership and effort fallback clarity

 Opening an existing Android session now retains exact bottom ownership through
@@ -1,22 +1,23 @@
 # Hermes-Relay-Server v__VERSION__

-**Release Date:** August 6, 2026
+**Release Date:** August 12, 2026

-This patch adds an optional Relay capability overlay so clients can present the reasoning effort levels supported by an exact provider and model without changing upstream model selection or chat behavior.
+This patch adds safe simultaneous routing for multiple connected desktop PCs and makes host selection explicit across command, file, screen, USB, and ADB operations.

 Standard chat, session history, and Vanilla Hermes voice remain upstream-owned and do not require this plugin.

 ## What's changed

+### Fixed
+
+- **No more latest-client-wins routing.** Connecting a second desktop no longer evicts the first. Requests are bound to the selected desktop WebSocket, and a response from another PC cannot satisfy them.
+- **Ambiguous calls fail closed.** With more than one desktop online, client-routed tools require a stable device ID or unambiguous computer name instead of silently choosing the latest heartbeat.
+- **Pairing preserves existing PCs.** Placeholder legacy device identifiers no longer collide and revoke another desktop's session.
+
 ### Added

- **Profile-aware reasoning capability resolution.** `POST /relay/model-capabilities` accepts exact provider/model pairs and returns ordered effort choices with explicit exactness and source metadata.
- **Bounded live discovery for local and authenticated providers.** Relay can query OpenAI Codex, GitHub Copilot, LM Studio, and Ollama Cloud capability surfaces with short timeouts, concurrency limits, isolated caches, and an explicit refresh option.
- **Capability advertisement.** `/relay/info` now advertises `model_reasoning_capabilities_v1` so clients can detect the optional overlay before using it.
-
-### Security
-
- **Provider credentials remain host-local.** Remote requests require a paired session with the chat grant, and responses never serialize provider credentials.
+- **Target discovery.** `desktop_health` lists every connected desktop with its stable ID, name, and advertised tools.
+- **Two-level USB targeting.** USB and ADB tools use `device` for the host PC; ADB operations retain `serial` for the attached Android device.

 ## Install / update

@@ -31,6 +32,7 @@ Standard chat, session history, and Vanilla Hermes voice remain upstream-owned a
 ## Verify

    hermes relay doctor
+    # Agent/tool callers can use desktop_health to list desktop targets.
    python scripts/check-plugin-version-sync.py --expect __VERSION__

 ---
@@ -138,7 +138,7 @@ Full server setup, TLS, and systemd details: [docs/relay-server.md](docs/relay-s

 <table>
  <tr>
-    <td align="center" width="25%"><img src="assets/screenshots/01_startup.png" alt="Cold start" width="100%"><br><sub><b>Cold start</b></sub></td>
+    <td align="center" width="25%"><img src="assets/screenshots/01_voice_conversation.png" alt="Voice controls in chat" width="100%"><br><sub><b>Voice in chat</b></sub></td>
    <td align="center" width="25%"><img src="assets/screenshots/02_chat.png" alt="Streaming chat" width="100%"><br><sub><b>Streaming chat</b></sub></td>
    <td align="center" width="25%"><img src="assets/screenshots/03_voice.png" alt="Hands-free voice" width="100%"><br><sub><b>Hands-free voice</b></sub></td>
    <td align="center" width="25%"><img src="assets/screenshots/04_sessions.png" alt="Session history" width="100%"><br><sub><b>Session history</b></sub></td>
@@ -186,7 +186,7 @@ tracked independently so community corrections remain easy to contribute.

 ## Hands on any machine — the Hermes-Relay CLI&nbsp;<sub>(alpha)</sub>

-> **Alpha.** Self-contained CLI binaries ship for Windows x64, Linux x64, and macOS x64/arm64 — no Node required. Windows also has an optional native, menu-only systray. Assets are unsigned during the experimental phase, so SmartScreen / Gatekeeper warnings are expected.
+> **Alpha.** Self-contained CLI binaries ship for Windows x64, Linux x64, and macOS x64/arm64 — no Node required. Windows also has an optional compact management tray. Assets are unsigned during the experimental phase, so SmartScreen / Gatekeeper warnings are expected.

 The agent's brain stays on the host; the CLI lets it call tools **on your machine** over the same WSS relay — `read_file`, `write_file`, `terminal`, `search_files`, `screenshot`, `clipboard`, `open_in_editor`, and more — behind a one-time consent gate, interactive diff approval for patches, and a `--no-tools` kill-switch.

@@ -202,7 +202,7 @@ hermes-relay update                            # self-update via GitHub Releases

 It pairs against the **same relay and credential store** as the Android app — pair once from either, both work. Tagged on the `desktop-v*` [release track](https://github.com/Codename-11/hermes-relay/releases?q=desktop), with historical releases still visible under `cli-v*`.

-On Windows, the default installer adds the optional right-click-only systray: no dashboard or app window, just TUI launch, User/Administrator-aware daemon controls, pairing, local grant review, audit, diagnostics, logs, desktop-use status/cancellation, sign-in startup, and emergency stop.
+On Windows, the default installer adds the optional compact **Hermes-Relay CLI UI** tray popup for host selection and pairing, connection and daemon state, per-host Ask/Trusted/Full Access, local grant dialogs, authorized-client revocation, activity, settings, and emergency stop. It is a management surface only—chat, TUI, plugins, voice, and agent sessions remain CLI/upstream concerns.

 - **Docs:** [CLI guide](https://hermes-relay.dev/docs/desktop/) · [`desktop/README.md`](desktop/README.md)
 - **AI-agent setup recipe:** `/hermes-relay-desktop-setup`
@@ -119,9 +119,9 @@ artifacts.
 ### CLI / tray versioning

 `desktop/package.json` is the Desktop/CLI release track's source of truth. Its version
-must match the generated CLI and native Windows systray metadata. The systray is
-a menu-only controller for the installed CLI; it has no application window,
-WebView, embedded terminal, or separate desktop product surface. The public
+must match the generated CLI and Windows tray metadata. The tray is a compact
+management popup over the installed CLI and shared state; it has no chat,
+embedded terminal, plugins, voice, or separate desktop product surface. The public
 release remains one `Hermes-Relay-Desktop` track containing CLI binaries plus the
 optional Windows installer.

@@ -132,6 +132,9 @@ optional Windows installer.
 | `desktop/src/version.ts` | compiled CLI runtime version |
 | `desktop/tray/Cargo.toml` | native systray package version |
 | `desktop/tray/Cargo.lock` | locked systray package version |
+| `desktop/tray/tauri.conf.json` | tray application and bundle version |
+| `desktop/tray/package.json` | tray UI package version |
+| `desktop/tray/package-lock.json` | locked tray UI package version |

 Prepare a new CLI version on `dev` without creating a tag or npm-generated
 commit:
@@ -1,10 +1,10 @@
-# Hermes-Relay-Android v1.7.0
+# Hermes-Relay-Android v1.8.1

-**Release Date:** August 6, 2026
+**Release Date:** August 9, 2026

 ## Download

-> Installing on your phone? Download `hermes-relay-1.7.0-sideload-release.apk` and tap it for the full feature set, or install the conservative build from [Google Play](https://play.google.com/store/apps/details?id=com.axiomlabs.hermesrelay).
+> Installing on your phone? Download `hermes-relay-1.8.1-sideload-release.apk` and tap it for the full feature set, or install the conservative build from [Google Play](https://play.google.com/store/apps/details?id=com.axiomlabs.hermesrelay).

 The `.aab` file is a Play Console upload bundle and cannot be installed by tapping it on a phone.

@@ -12,39 +12,23 @@ Verify the download against `SHA256SUMS.txt`. See the [sideload guide](https://h

 ## Summary

-This patch makes model reasoning controls provider-aware, keeps active and
-restored conversations stable, and adds private, actionable support information.
-
-## Added
-
- Reasoning effort choices now follow the selected provider and model when an
-  exact list is available. Standard choices remain available as an advisory
-  fallback on unmodified Hermes or without the optional Relay capability overlay.
- The session drawer can search sessions and shows which conversations are
-  working or waiting for input.
- Diagnostics now provides a locally redacted support report that can be
-  reviewed before copy, share, or opening GitHub. Nothing uploads automatically.
+This patch keeps long Hermes conversations complete and aligns Android's
+Gateway behavior with current upstream turn contracts.

 ## Fixed

- Restored and completed conversations remain at the exact bottom through late
-  message, composer, keyboard, and status-row layout changes without overriding
-  someone who intentionally scrolls up.
- Chat recovery keeps one stable rendered row through checkpoint restore,
-  streaming callbacks, server reconciliation, and replay, preventing recurring
-  duplicate-row crashes in Chat and Voice.
- Focus Voice controls receive taps again while the modal background continues
-  to block interaction with the chat behind it.
- Connection diagnostics identify the attempted route and operation, redact host
-  details, and give targeted guidance for DNS, timeout, TLS, authentication,
-  rate-limit, missing-route, and server failures.
- The session drawer dismisses the composer keyboard when opening, preserves the
-  newest row during refresh, and keeps floating pets on measured safe terrain.
+- Complete transcript reads page explicitly across both API-server and
+  profile-scoped Dashboard routes, so sessions beyond Hermes' latest-500
+  default retain stable history, sharing, retry, edit, and recovery anchors.
+- Gateway submit rejections preserve the authoritative server message without
+  silently falling through to SSE.
+- Gateway event envelopes reconcile consistently, and edit-and-regenerate
+  requests send the required truncation confirmation.

 ## Install / Verify

- App version: **1.7.0** (versionCode **39**).
- Standard Chat, model selection, and Vanilla Hermes voice continue to work
+- App version: **1.8.1** (versionCode **42**).
+- Standard Chat, sessions, Manage, and Vanilla Hermes voice continue to work
  against unmodified upstream Hermes.
- Relay capability discovery is optional and fail-soft; unavailable or older
-  Relay installations retain the standard reasoning choices.
+- The optional Relay plugin is not required for standard Android chat or hosted
+  Dashboard authentication.
@@ -6,6 +6,29 @@ For shipped work, see `DEVLOG.md`. For architectural decisions, see `docs/decisi

 ---

+## Structured desktop hardware capabilities
+
+Desktop command, PowerShell, process, and job tools currently execute with the
+desktop daemon's OS-user authority. Add typed hardware operations for reliable
+schemas, audit detail, and task-scoped approval, but do not present hardware
+toggles as isolation while an enabled general shell can reach the same device.
+
+- Define per-host capabilities for commands, files, processes, clipboard,
+  screen, input, connected devices, microphone, and camera. Disabled must win,
+  hardware-sensitive capabilities must default off, and unavailable backends
+  must appear unavailable rather than as inert toggles.
+- Add a **Structured only** access profile that withholds shell/process escape
+  hatches so individual capability toggles become enforceable boundaries.
+- Implement connected-device support first with typed, serial-bound ADB
+  operations (`list`, `shell`, `push`, `pull`, `install`, and bounded logcat)
+  instead of a generic device-exec wrapper.
+- Add microphone and camera only with backend readiness detection, bounded local
+  grants, active-use indicators, audit events, and immediate cancellation.
+- Reconcile legacy `desktop_screenshot` with the task-granted computer screenshot
+  path so screen capture follows one policy.
+
+---
+
 ## Android Plugin Studio protocol follow-ups

 The first live declarative Plugin lane is host-local: Relay tools create bounded
@@ -1274,7 +1297,7 @@ Follow-ups:
  profile/skill-aware empty-state chips and the ~40-flow recomposition hotspot at
  the top of `ChatScreen`.
 - **Pet hot-load + in-app add/remove (shipped 2026-06-20).** Pets now live-refresh: an `avatarsRefreshTick` keys the avatar `produceState` in `RelayApp`, and Appearance re-scans `pets/` on open and after in-app import/delete — no app restart. Appearance gained "Add a pet" (SAF `.zip` import via `PetImporter`, zip-slip/zip-bomb guarded + validated through `toAvatar`) and an "Installed pets" list with per-pet remove (`PetLoader.deletePet`, confirm dialog, Sphere fallback). Remaining:
-  - **Sphere-skin parity.** Skins are still process-scoped + `adb push` only — the live tick and the importer cover pets, not skins. Extend the tick to `loadUserSkins` and add a `.json` skin import if hot-loading/adding skins in-app is wanted.
+  - **Sphere-skin parity (shipped 2026-08-09).** Appearance now imports a bounded, validated declarative `.json` skin through the system picker, hot-refreshes the shared sphere registry, and selects the imported skin without an app restart.
  - `**adb push` into `Android/data` hangs on Samsung scoped storage.** Confirmed: pushing a pet pack to `/sdcard/Android/data/<pkg>/files/pets/` stalls (no bytes written) although `adb shell ls` of the dir works. In-app `.zip` import is the supported path; `/sdcard/Download` pushes fine. Consider softening `docs/pet-spec.md` + user-docs to lead with in-app import over adb.
  - **On-device import/delete smoke.** Import `/sdcard/Download/lucy.zip` via Add a pet → confirm Lucy appears, selects, and animates all states; then remove it and confirm the avatar falls back to the Sphere.
 - **Pet behavior model — richer state association (spec'd 2026-06-19, `docs/pet-spec.md` "Agent states &amp; pet behavior").** Shipped: the honesty clamp (declared reactivity ∩ `PET_RENDERER_CAPABILITIES`), the friendly `writing` alias, the `**working`/tool-use overlay** (pet-local sub-state from `toolCallBurst`; opt-in `working` clip drives both the swap and the Tools badge), the **one-shot reaction layer** (`greet`/`wake` on appear, `done`/`celebrate` on turn-finish — opt-in, play-once-then-revert, transition-derived; `ONE_SHOT_MAX_MS` backstop), and `**intensity` modulation** (opt-in `reactive.intensity` → live playback speedup ≤1.6× via `rememberUpdatedState`; un-clamps the Activity badge). Voice · Tools · Activity reactivity is now complete. Remaining:
@@ -320,6 +320,7 @@ dependencies {
    // Coil 3 — async image loading for generated images in chat
    implementation(libs.coil.compose)
    implementation(libs.coil.network.okhttp)
+    implementation(libs.exifinterface)

    // QR Code scanning (ML Kit + CameraX)
    implementation(libs.mlkit.barcode)
@@ -369,8 +370,8 @@ dependencies {
    // [POC] Roborazzi host-side screenshot rendering (src/test, Robolectric).
    // Renders real composables on the JVM at an exact canvas — no device, no
    // status bar, no clipping. See StoreScreenshotTest.
-    testImplementation("io.github.takahirom.roborazzi:roborazzi:1.70.0")
-    testImplementation("io.github.takahirom.roborazzi:roborazzi-compose:1.70.0")
+    testImplementation("io.github.takahirom.roborazzi:roborazzi:1.71.0")
+    testImplementation("io.github.takahirom.roborazzi:roborazzi-compose:1.71.0")
    testImplementation(libs.compose.ui.test.junit4)
    testImplementation(libs.compose.ui.test.manifest)
    testImplementation("androidx.test.ext:junit:1.3.0")
@@ -121,12 +121,15 @@ class OnboardingFlowTest {
    }

    @Test
-    fun connectPage_showsNearbyFirst() {
+    fun connectPage_recommendsGeneralSetupQr() {
        setOnboardingContent()
        navigateToPage(4)

        composeTestRule
-            .onNodeWithText("Enter address instead")
+            .onNodeWithText("Scan Hermes setup QR")
+            .assertIsDisplayed()
+        composeTestRule
+            .onNodeWithText("Recommended")
            .assertIsDisplayed()
    }

@@ -135,7 +138,7 @@ class OnboardingFlowTest {
        setOnboardingContent()
        navigateToPage(4)

-        composeTestRule.onNodeWithText("Enter address instead").performClick()
+        composeTestRule.onNodeWithText("Server or VPS").performClick()
        composeTestRule.waitForIdle()

        composeTestRule
@@ -148,7 +151,7 @@ class OnboardingFlowTest {
        setOnboardingContent()
        navigateToPage(4)

-        composeTestRule.onNodeWithText("Enter address instead").performClick()
+        composeTestRule.onNodeWithText("Server or VPS").performClick()
        composeTestRule.waitForIdle()

        composeTestRule
@@ -156,12 +159,28 @@ class OnboardingFlowTest {
            .assertIsDisplayed()
    }

+    @Test
+    fun cloudSetup_requestsTheHostedDashboardAddress() {
+        setOnboardingContent()
+        navigateToPage(4)
+
+        composeTestRule.onNodeWithText("Nous-hosted Hermes").performClick()
+        composeTestRule.waitForIdle()
+
+        composeTestRule
+            .onNodeWithText("Connect to Nous-hosted Hermes")
+            .assertIsDisplayed()
+        composeTestRule
+            .onNodeWithText("Use the complete HTTPS address shown for your hosted agent.")
+            .assertIsDisplayed()
+    }
+
    @Test
    fun connectPage_keepsPairingOptional() {
        setOnboardingContent()
        navigateToPage(4)

-        composeTestRule.onNodeWithText("Other connection methods").performClick()
+        composeTestRule.onNodeWithText("Advanced").performClick()
        composeTestRule.waitForIdle()

        composeTestRule
@@ -1 +1 @@
-Smarter reasoning controls now match the selected provider and model, with standard choices when exact levels are unavailable. The session drawer shows working and needs-input chats. Restored and completed conversations stay bottom-pinned without overriding scrollback. Redacted local support information and clearer connection diagnostics make problems easier to resolve. Focus Voice controls and recovered chat rows are more reliable.
+Long sessions now retain complete history beyond Hermes' latest-500 default, keeping edit, retry, sharing, and recovery anchors stable. Gateway submit rejections preserve the server's message without unintended SSE fallback, while event envelopes and edit-and-regenerate requests follow current upstream contracts.
@@ -48,6 +48,25 @@
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
+            <!-- User-mediated text handoff. The app opens a fresh Chat draft
+                 and fills the composer; it never sends from an external intent. -->
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/*" />
+            </intent-filter>
+            <!-- The loopback native-PKCE result page uses this fixed, tokenless
+                 link only to bring the installed flavor back to the foreground.
+                 MainActivity intentionally does not interpret the URI as an auth
+                 callback or navigation command. -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data
+                    android:scheme="${applicationId}"
+                    android:host="return" />
+            </intent-filter>
            <!-- Some Android OEM assistant pickers enumerate ACTION_ASSIST
                 activities in addition to VoiceInteractionService providers. -->
            <intent-filter>
@@ -1,5 +1,89 @@
 {
 "versions": [
+  {
+   "version": "1.8.1",
+   "title": "Complete, reliable transcripts",
+   "date": "2026-08-09",
+   "sections": [
+    {
+     "header": "Keep long sessions complete",
+     "bullets": [
+      "Android pages explicitly through complete API-server and profile-scoped Dashboard history instead of silently stopping at Hermes' latest-500 default.",
+      "Sharing, retry, edit, and recovery retain stable transcript anchors while bounded safety limits keep unusually large reads controlled."
+     ]
+    },
+    {
+     "header": "Follow Gateway truth",
+     "bullets": [
+      "Authoritative submit rejections preserve the server's message without an unintended SSE fallback.",
+      "Gateway event envelopes and edit-and-regenerate truncation confirmation now follow current upstream contracts."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.8.0",
+   "title": "Conversations with more context",
+   "date": "2026-08-09",
+   "sections": [
+    {
+     "header": "Keep the whole turn together",
+     "bullets": [
+      "Quote, edit, search, and attach or reorder files without losing the active connection, profile, or session.",
+      "Share text from another Android app into a fresh Chat draft for review before sending."
+     ]
+    },
+    {
+     "header": "See the work without the clutter",
+     "bullets": [
+      "Live thinking settles into a compact Thought disclosure, while routine tool activity groups into concise runs.",
+      "Approvals, failures, generated media, file changes, risks, and delegated work remain clearly distinct."
+     ]
+    },
+    {
+     "header": "Switch agents, not identities",
+     "bullets": [
+      "The Profile Shelf switches agents from Chat while restoring each profile's last session.",
+      "Agent Passport model and reasoning controls remain scoped to the active session instead of rewriting server defaults."
+     ]
+    },
+    {
+     "header": "Make it yours",
+     "bullets": [
+      "Preview theme accents and shapes, Sphere skins, and pets in one Appearance workflow.",
+      "Message speech controls, pet touch targets, scrolling terrain, image rotation, and edge-to-edge settings layout are more reliable."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.7.1",
+   "title": "Safer, steadier conversations",
+   "date": "2026-08-08",
+   "sections": [
+    {
+     "header": "Chat stays with you",
+     "bullets": [
+      "Growing streamed replies stay visible while you are at the bottom, and intentional scrollback remains undisturbed.",
+      "Completed replies render Markdown immediately while live tool details remain expandable."
+     ]
+    },
+    {
+     "header": "Sessions keep their ownership",
+     "bullets": [
+      "Queued follow-ups retain their originating connection, profile, session, route, attachments, and voice context.",
+      "Session pins and archives persist across restarts, and duplicate model rows are reconciled before rendering."
+     ]
+    },
+    {
+     "header": "Safer controls and setup",
+     "bullets": [
+      "Approval cards require an explicit labeled decision, and Agent Passport safety controls are easier to read and dismiss.",
+      "Hosted Hermes setup completes through the official Dashboard system-browser sign-in flow."
+     ]
+    }
+   ]
+  },
  {
   "version": "1.7.0",
   "title": "Smarter controls, steadier sessions",
@@ -1,7 +1,6 @@
-v1.7.0 - Smarter controls, steadier sessions
+v1.8.1 - Complete, reliable transcripts

-* Match reasoning levels to the selected provider and model, with a standard fallback.
-* See working and needs-input activity in the searchable session drawer.
-* Keep restored and completed chats bottom-pinned without overriding scrollback.
-* Review redacted local support information and actionable connection guidance.
-* Restore Focus Voice controls and stabilize recovered chat rows.
+* Keep complete history in long sessions beyond Hermes' latest-500 default.
+* Preserve stable edit, retry, sharing, and recovery anchors while paging history.
+* Show authoritative Gateway rejection messages without an unintended fallback.
+* Reconcile Gateway events and edit-and-regenerate requests with current upstream contracts.
@@ -25,6 +25,8 @@ import com.hermesandroid.relay.notifications.TurnCompleteNotifier
 import com.hermesandroid.relay.notifications.InteractionRequestNotifier
 import com.hermesandroid.relay.ui.RelayApp
 import com.hermesandroid.relay.util.NavRouteRequest
+import com.hermesandroid.relay.util.SharedTextRequest
+import com.hermesandroid.relay.util.extractSharedText
 import com.hermesandroid.relay.viewmodel.ConnectionViewModel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.flow.collect
@@ -127,6 +129,7 @@ class MainActivity : AppCompatActivity() {
        // in RelayApp's NavRouteRequest collector — we just pump the request
        // into the SharedFlow here.
        consumeNavRouteIntent(intent)
+        consumeSharedTextIntent(intent)
        val consumedAssistantActivation =
            com.hermesandroid.relay.assistant.AssistantSessionProtocol.consumeActivation(
                this,
@@ -153,6 +156,7 @@ class MainActivity : AppCompatActivity() {
        // instead of onCreate. RelayApp's collector handles both cases.
        setIntent(intent)
        consumeNavRouteIntent(intent)
+        consumeSharedTextIntent(intent)
        com.hermesandroid.relay.assistant.AssistantSessionProtocol.consumeActivation(this, intent)
        // === END PHASE3-safety-rails-followup ===
    }
@@ -163,6 +167,15 @@ class MainActivity : AppCompatActivity() {
        NavRouteRequest.tryRequest(route)
    }

+    private fun consumeSharedTextIntent(intent: Intent?) {
+        val sharedText = extractSharedText(
+            action = intent?.action,
+            mimeType = intent?.type,
+            text = intent?.getCharSequenceExtra(Intent.EXTRA_TEXT),
+        ) ?: return
+        SharedTextRequest.tryRequest(sharedText)
+    }
+
    private fun configureAssistantWindow(intent: Intent?) {
        if (
            intent?.getBooleanExtra(
@@ -1,6 +1,7 @@
 package com.hermesandroid.relay.auth

 import android.content.Context
+import android.provider.Settings
 import android.util.Log
 import com.hermesandroid.relay.data.Connection
 import com.hermesandroid.relay.data.EndpointCandidate
@@ -631,7 +632,7 @@ class AuthManager(
        val now = System.currentTimeMillis() / 1000L
        val defaults = PairedSession(
            token = token,
-            deviceName = android.os.Build.MODEL,
+            deviceName = relayDeviceName(),
            expiresAt = null,
            grants = emptyMap(),
            transportHint = null,
@@ -651,7 +652,7 @@ class AuthManager(
            val transportHint = obj["transport_hint"]?.jsonPrimitive?.contentOrNull
            val firstSeen = obj["first_seen"]?.jsonPrimitive?.longOrNull ?: now
            val deviceName = obj["device_name"]?.jsonPrimitive?.contentOrNull
-                ?: android.os.Build.MODEL
+                ?: relayDeviceName()

            PairedSession(
                token = token,
@@ -750,6 +751,26 @@ class AuthManager(
        })
    }

+    private fun JsonObjectBuilder.putRelayDeviceIdentity() {
+        val model = android.os.Build.MODEL.orEmpty().ifBlank { "Android device" }
+        val deviceName = relayDeviceName()
+        put("device_name", deviceName)
+        put("device_hostname", deviceName)
+        put("device_model", model)
+        put("device_platform", "Android ${android.os.Build.VERSION.RELEASE}")
+        put("client_surface", "android")
+        put("device_form_factor", "phone")
+    }
+
+    private fun relayDeviceName(): String {
+        val configured = runCatching {
+            Settings.Global.getString(context.contentResolver, "device_name")
+        }.getOrNull()?.trim().orEmpty()
+        return configured.ifBlank {
+            android.os.Build.MODEL.orEmpty().ifBlank { "Android device" }
+        }
+    }
+
    /**
     * Send auth envelope when connection is established.
     *
@@ -784,7 +805,7 @@ class AuthManager(
                            put("refresh_token", refreshToken)
                        }
                        put("device_id", deviceId)
-                        put("device_name", android.os.Build.MODEL)
+                        putRelayDeviceIdentity()
                        putRelayClientSupports()
                    }
                }
@@ -800,7 +821,7 @@ class AuthManager(
                    buildJsonObject {
                        put("pairing_code", codeToSend)
                        put("device_id", deviceId)
-                        put("device_name", android.os.Build.MODEL)
+                        putRelayDeviceIdentity()
                        putRelayClientSupports()
                        pendingTtlSeconds?.let { put("ttl_seconds", it) }
                        pendingGrants?.let { grants ->
@@ -1066,7 +1087,7 @@ class AuthManager(

                    val paired = PairedSession(
                        token = token,
-                        deviceName = android.os.Build.MODEL,
+                        deviceName = relayDeviceName(),
                        expiresAt = expiresAt,
                        grants = grantsMap,
                        transportHint = transportHint,
@@ -74,6 +74,14 @@ data class PairedDeviceInfo(
    val deviceName: String = "",
    @SerialName("device_id")
    val deviceId: String = "",
+    @SerialName("device_model")
+    val deviceModel: String = "",
+    @SerialName("device_platform")
+    val devicePlatform: String = "",
+    @SerialName("client_surface")
+    val clientSurface: String = "",
+    @SerialName("device_form_factor")
+    val deviceFormFactor: String = "",
    @SerialName("created_at")
    val createdAt: Double? = null,
    @SerialName("last_seen")
@@ -3,10 +3,10 @@ package com.hermesandroid.relay.data
 /**
 * Shared profile/personality display and request identity helpers.
 *
- * A null profile name is the app's explicit "Server default" state. The
- * relay also advertises the root Hermes config as a synthetic profile named
- * "default"; for request/session identity that row is an alias of server
- * default so it does not split chat, voice, or session scope.
+ * A null profile name is the app's explicit "Server default" state. It is
+ * intentionally distinct from a real profile whose name is literally
+ * `default`: the former follows the server's sticky default, while the latter
+ * explicitly addresses the root profile.
 */
 object AgentDisplay {
    const val SERVER_DEFAULT_PROFILE_KEY: String = "__server_default__"
@@ -16,17 +16,16 @@ object AgentDisplay {
        "hermes agent",
    )

-    // Only an EXPLICIT pick drives request/session identity. The advertised
-    // "default" profile is an alias for server default, so falling back to it
-    // here would split chat, voice, or session scope.
+    // Only an explicit pick drives request identity. Server default is the null
+    // selection; a named `default` profile is an ordinary explicit pick.
    @Suppress("UNUSED_PARAMETER")
    fun effectiveProfile(
        selectedProfile: Profile?,
        profiles: List<Profile>,
    ): Profile? = selectedProfile

-    // Display can use the synthetic default profile's metadata without making
-    // it a request/session override. Verbose SOUL summaries are filtered by
+    // Display can use the root default profile's metadata without making it a
+    // request/session override. Verbose SOUL summaries are filtered by
    // profileDisplayName below, so this is safe for headers/cards.
    fun effectiveDisplayProfile(
        selectedProfile: Profile?,
@@ -39,7 +38,7 @@ object AgentDisplay {
            ?.let { activeName ->
                profiles.firstOrNull { it.name.equals(activeName, ignoreCase = true) }
            }
-            ?: profiles.firstOrNull { isServerDefaultAlias(it.name) }
+            ?: profiles.firstOrNull { it.name.equals("default", ignoreCase = true) }
    }

    // The NAME goes in the name slot. Non-default profiles use their profile
@@ -48,7 +47,7 @@ object AgentDisplay {
    // verbose SOUL summary.
    fun profileDisplayName(profile: Profile?): String? {
        if (profile == null) return null
-        if (isServerDefaultAlias(profile.name)) {
+        if (profile.name.equals("default", ignoreCase = true)) {
            return defaultProfileDisplayName(profile)
        }
        return when {
@@ -135,22 +134,18 @@ object AgentDisplay {
            ?.takeIf { it.isNotEmpty() }
            ?.takeUnless { it.lowercase() in GENERIC_MODEL_ALIASES }

-    fun isServerDefaultAlias(profileName: String?): Boolean =
-        profileName?.trim()?.equals("default", ignoreCase = true) == true
-
-    fun normalizeSelection(profile: Profile?): Profile? =
-        if (isServerDefaultAlias(profile?.name)) null else profile
+    fun normalizeSelection(profile: Profile?): Profile? = profile

    fun profileRequestName(profileName: String?): String? =
        profileName
            ?.trim()
-            ?.takeIf { it.isNotEmpty() && !isServerDefaultAlias(it) }
+            ?.takeIf { it.isNotEmpty() && it != SERVER_DEFAULT_PROFILE_KEY }

    /**
     * The profile name that owns chat sessions for the current UI selection.
     *
-     * [selectedProfileName] is null (or the synthetic `default` alias) for the
-     * "Server default" row. That UI sentinel must remain distinct from the
+     * [selectedProfileName] is null for the "Server default" row. That UI
+     * sentinel must remain distinct from the
     * server's sticky active profile: a dashboard launched under the root home
     * may still report `active=victor`, in which case upstream Gateway and
     * dashboard session calls must explicitly target `victor`. The resolved
@@ -0,0 +1,147 @@
+package com.hermesandroid.relay.data
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+
+/**
+ * Immutable owner of one composer draft.
+ *
+ * Callers must supply stable ids rather than display labels. [sessionId] may be
+ * a server id or a stable client-generated id for a not-yet-created session.
+ * [draftId] separates the primary composer from any future named draft slot.
+ */
+data class ChatComposerDraftKey(
+    val connectionId: String,
+    val profileId: String,
+    val sessionId: String,
+    val draftId: String = PRIMARY_DRAFT_ID,
+) {
+    init {
+        require(connectionId.isNotBlank()) { "connectionId must not be blank" }
+        require(profileId.isNotBlank()) { "profileId must not be blank" }
+        require(sessionId.isNotBlank()) { "sessionId must not be blank" }
+        require(draftId.isNotBlank()) { "draftId must not be blank" }
+    }
+
+    companion object {
+        const val PRIMARY_DRAFT_ID = "primary"
+        const val DEFAULT_PROFILE_ID = "default"
+    }
+}
+
+/** Message references associated with composer content. */
+data class ChatComposerDraftContext(
+    val quotedMessageId: String? = null,
+    val editingMessageId: String? = null,
+) {
+    internal fun normalized(): ChatComposerDraftContext = copy(
+        quotedMessageId = quotedMessageId?.takeIf(String::isNotBlank),
+        editingMessageId = editingMessageId?.takeIf(String::isNotBlank),
+    )
+}
+
+/**
+ * Complete restorable state for one composer.
+ *
+ * Selection offsets use the same start-inclusive/end-exclusive convention as
+ * Compose text fields. The store clamps them whenever the text changes so a
+ * restored selection can never address outside the restored string.
+ */
+data class ChatComposerDraft(
+    val text: String = "",
+    val selectionStart: Int = text.length,
+    val selectionEnd: Int = selectionStart,
+    val context: ChatComposerDraftContext = ChatComposerDraftContext(),
+    val attachments: List<Attachment> = emptyList(),
+) {
+    val isEmpty: Boolean
+        get() = text.isEmpty() &&
+            context.quotedMessageId == null &&
+            context.editingMessageId == null &&
+            attachments.isEmpty()
+
+    internal fun normalized(): ChatComposerDraft {
+        val normalizedStart = selectionStart.coerceIn(0, text.length)
+        val normalizedEnd = selectionEnd.coerceIn(0, text.length)
+        return copy(
+            selectionStart = minOf(normalizedStart, normalizedEnd),
+            selectionEnd = maxOf(normalizedStart, normalizedEnd),
+            context = context.normalized(),
+            attachments = attachments.toList(),
+        )
+    }
+}
+
+/**
+ * Session-owned composer state.
+ *
+ * This store is deliberately memory-only: outbound [Attachment.content] can
+ * contain large Base64 payloads and must not enter Preferences DataStore. Keep
+ * one instance in the chat owner (normally its ViewModel) so drafts survive
+ * navigation and Activity recreation. Process death starts with empty drafts;
+ * a future durable implementation should persist URI grants, not attachment
+ * bytes.
+ */
+interface ChatComposerDraftStore {
+    fun observe(key: ChatComposerDraftKey): Flow<ChatComposerDraft>
+    fun snapshot(key: ChatComposerDraftKey): ChatComposerDraft
+    fun save(key: ChatComposerDraftKey, draft: ChatComposerDraft)
+    fun update(
+        key: ChatComposerDraftKey,
+        transform: (ChatComposerDraft) -> ChatComposerDraft,
+    )
+    fun remove(key: ChatComposerDraftKey)
+    fun removeSession(connectionId: String, profileId: String, sessionId: String)
+    fun clear()
+}
+
+class InMemoryChatComposerDraftStore : ChatComposerDraftStore {
+    private val drafts = MutableStateFlow<Map<ChatComposerDraftKey, ChatComposerDraft>>(emptyMap())
+
+    override fun observe(key: ChatComposerDraftKey): Flow<ChatComposerDraft> =
+        drafts
+            .map { it[key] ?: ChatComposerDraft() }
+            .distinctUntilChanged()
+
+    override fun snapshot(key: ChatComposerDraftKey): ChatComposerDraft =
+        drafts.value[key] ?: ChatComposerDraft()
+
+    @Synchronized
+    override fun save(key: ChatComposerDraftKey, draft: ChatComposerDraft) {
+        val normalized = draft.normalized()
+        drafts.value = if (normalized.isEmpty) {
+            drafts.value - key
+        } else {
+            drafts.value + (key to normalized)
+        }
+    }
+
+    @Synchronized
+    override fun update(
+        key: ChatComposerDraftKey,
+        transform: (ChatComposerDraft) -> ChatComposerDraft,
+    ) {
+        save(key, transform(snapshot(key)))
+    }
+
+    @Synchronized
+    override fun remove(key: ChatComposerDraftKey) {
+        drafts.value = drafts.value - key
+    }
+
+    @Synchronized
+    override fun removeSession(connectionId: String, profileId: String, sessionId: String) {
+        drafts.value = drafts.value.filterKeys { key ->
+            key.connectionId != connectionId ||
+                key.profileId != profileId ||
+                key.sessionId != sessionId
+        }
+    }
+
+    @Synchronized
+    override fun clear() {
+        drafts.value = emptyMap()
+    }
+}
@@ -0,0 +1,48 @@
+package com.hermesandroid.relay.data
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+
+/** Phone-local behavior for a physical keyboard's unmodified Enter key. */
+enum class PhysicalKeyboardEnterBehavior(val storedValue: String) {
+    SendMessage("send_message"),
+    InsertNewline("insert_newline"),
+    ;
+
+    companion object {
+        fun fromStoredValue(value: String?): PhysicalKeyboardEnterBehavior =
+            entries.firstOrNull { it.storedValue == value } ?: SendMessage
+    }
+}
+
+/** Device-level chat input preferences shared by every Hermes profile. */
+class ChatInputPreferencesRepository(
+    private val dataStore: DataStore<Preferences>,
+) {
+    constructor(context: Context) : this(context.relayDataStore)
+
+    companion object {
+        internal val KEY_PHYSICAL_KEYBOARD_ENTER =
+            stringPreferencesKey("physical_keyboard_enter_behavior")
+    }
+
+    val physicalKeyboardEnterBehavior: Flow<PhysicalKeyboardEnterBehavior> = dataStore.data
+        .map { preferences ->
+            PhysicalKeyboardEnterBehavior.fromStoredValue(
+                preferences[KEY_PHYSICAL_KEYBOARD_ENTER],
+            )
+        }
+        .distinctUntilChanged()
+
+    suspend fun setPhysicalKeyboardEnterBehavior(behavior: PhysicalKeyboardEnterBehavior) {
+        dataStore.edit { preferences ->
+            preferences[KEY_PHYSICAL_KEYBOARD_ENTER] = behavior.storedValue
+        }
+    }
+}
@@ -112,12 +112,11 @@ data class ChatMessage(
     */
    val clientOnly: Boolean = false,
    /**
-     * Delivery state for a message the user sends into an agent **Thread** over
-     * the relay proactive channel ([com.hermesandroid.relay.viewmodel.ChatViewModel]
-     * routes `source=phone` sessions here instead of the normal chat send).
-     * `SENDING` until the relay acks (`proactive.reply.ack`) → `DELIVERED`;
-     * `FAILED` on a send error. Null for ordinary chat messages — those render
-     * no status affix.
+     * Delivery state for a user-authored message. Agent **Thread** replies use
+     * `SENDING` until the relay acks (`proactive.reply.ack`) → `DELIVERED`,
+     * with `FAILED` on a send error. Ordinary chat may additionally use
+     * `QUEUED` and `STEERED` to make active-turn routing visible. Null keeps the
+     * legacy behavior of rendering no status affix.
     */
    val deliveryStatus: MessageDeliveryStatus? = null,
    /**
@@ -367,12 +366,20 @@ data class ToolCall(
     * header can render without a separate lane registry.
     */
    val taskLabel: String? = null,
+    /** Live upstream child id used by subagent.steer while this lane runs. */
+    val subagentId: String? = null,
    /** Deterministic non-low output risk reported by upstream for this call. */
    val outputRisk: String? = null,
    /** Human-readable deterministic findings; rendered as untrusted metadata. */
    val outputRiskFindings: List<String> = emptyList(),
    /** Upstream removed sensitive spans before emitting the findings. */
    val outputRiskRedacted: Boolean = false,
+    /**
+     * Stable UI identity retained when a generating placeholder adopts its
+     * gateway tool ID. This keeps per-card interaction state attached to the
+     * logical call across streaming reconciliation and list updates.
+     */
+    val uiKey: String = id ?: "$name:$startedAt",
 )

 enum class MessageRole {
@@ -382,15 +389,17 @@ enum class MessageRole {
 }

 /**
- * Delivery state of a user reply sent into an agent Thread over the relay
- * proactive channel. Only set on Thread replies; ordinary chat messages leave
- * it null and show no status affix.
+ * Delivery state of a user-authored message. Thread replies use the relay ack
+ * lifecycle; ordinary chat can additionally expose queue and steer outcomes.
+ * Null preserves the legacy behavior of rendering no status affix.
 *
 * - [SENDING]   handed to the relay; awaiting the per-reply ack.
+ * - [QUEUED]    held client-side until the active turn completes.
+ * - [STEERED]   accepted as a correction to the active turn.
 * - [DELIVERED] the relay acked (`proactive.reply.ack`) — buffered for the agent.
 * - [FAILED]    the send errored (e.g. relay disconnected).
 */
-enum class MessageDeliveryStatus { SENDING, DELIVERED, FAILED }
+enum class MessageDeliveryStatus { SENDING, QUEUED, STEERED, DELIVERED, FAILED }

 data class ChatSession(
    val sessionId: String,
@@ -409,6 +418,9 @@ data class ChatSession(
    val source: String? = null,
    /** Server reports a persisted session runtime/model binding. */
    val hasModelConfig: Boolean = false,
+    /** Durable upstream session metadata, scoped by the owning connection/profile DB. */
+    val pinned: Boolean = false,
+    val archived: Boolean = false,
 ) {
    val activityTimestamp: Long
        get() = firstPositive(lastActivityAt, updatedAt, startedAt)
@@ -0,0 +1,66 @@
+package com.hermesandroid.relay.data
+
+import java.nio.charset.StandardCharsets
+import java.util.Base64
+
+/** Structured identity and preview for a quoted chat message. */
+data class ChatQuoteReference(
+    val messageId: String,
+    val authorLabel: String,
+    val excerpt: String,
+)
+
+/** Parsed transport envelope: Android renders [reference] separately from [body]. */
+data class ChatQuoteEnvelope(
+    val reference: ChatQuoteReference,
+    val body: String,
+)
+
+/**
+ * Serialize a structured quote as ordinary Markdown for unmodified Hermes clients.
+ * Android parses the same envelope back into a quote chip, while Desktop/TUI see
+ * a readable linked attribution instead of an Android-only marker.
+ */
+fun buildChatQuotedPrompt(body: String, reference: ChatQuoteReference?): String {
+    if (reference == null) return body
+    val encodedId = Base64.getUrlEncoder().withoutPadding().encodeToString(
+        reference.messageId.toByteArray(StandardCharsets.UTF_8),
+    )
+    val author = reference.authorLabel.normalizedQuoteText(MAX_AUTHOR_CHARS)
+    val excerpt = reference.excerpt.normalizedQuoteText(MAX_EXCERPT_CHARS)
+    if (encodedId.isBlank() || author.isBlank() || excerpt.isBlank()) return body
+    return "> **Replying to [@$author](hermes-message://$encodedId):** $excerpt\n\n$body"
+}
+
+/** Parse only the exact bounded envelope emitted by [buildChatQuotedPrompt]. */
+fun parseChatQuotedPrompt(content: String): ChatQuoteEnvelope? {
+    val match = QUOTE_ENVELOPE.matchEntire(content) ?: return null
+    val author = match.groupValues[1]
+    val encodedId = match.groupValues[2]
+    val excerpt = match.groupValues[3]
+    val body = match.groupValues[4]
+    val messageId = runCatching {
+        String(Base64.getUrlDecoder().decode(encodedId), StandardCharsets.UTF_8)
+    }.getOrNull()?.takeIf { it.isNotBlank() && it.length <= MAX_MESSAGE_ID_CHARS } ?: return null
+    return ChatQuoteEnvelope(
+        reference = ChatQuoteReference(messageId, author, excerpt),
+        body = body,
+    )
+}
+
+private fun String.normalizedQuoteText(maxChars: Int): String =
+    replace(Regex("[\\p{Cc}\\s]+"), " ")
+        .replace("\\", "")
+        .replace("]", "")
+        .trim()
+        .take(maxChars)
+
+private val QUOTE_ENVELOPE = Regex(
+    pattern = "^> \\*\\*Replying to \\[@([^]\\r\\n]{1,$MAX_AUTHOR_CHARS})]" +
+        "\\(hermes-message://([A-Za-z0-9_-]{1,512})\\):\\*\\* " +
+        "([^\\r\\n]{1,$MAX_EXCERPT_CHARS})\\n\\n([\\s\\S]*)$",
+)
+
+private const val MAX_AUTHOR_CHARS = 40
+private const val MAX_EXCERPT_CHARS = 240
+private const val MAX_MESSAGE_ID_CHARS = 512
@@ -32,6 +32,7 @@ data class ChatTurnCheckpoint(
    val priorUserMessageCount: Int,
    val baselineAssistantCount: Int,
    val pendingAsk: ChatTurnAskCheckpoint? = null,
+    val queuedMessages: List<ChatQueuedMessageCheckpoint> = emptyList(),
    val startedAt: Long,
    val updatedAt: Long,
 ) {
@@ -41,6 +42,17 @@ data class ChatTurnCheckpoint(
    }
 }

+@Serializable
+data class ChatQueuedMessageCheckpoint(
+    val id: String,
+    val text: String,
+    val transport: String,
+    val ownerRunId: String,
+    val interfaceContextPrompt: String? = null,
+    /** Attachment bytes are intentionally not copied into Preferences DataStore. */
+    val hadAttachments: Boolean = false,
+)
+
@Serializable
 data class ChatTurnUserCheckpoint(
    val id: String,
@@ -134,7 +134,7 @@ data class Connection(
         * than to crash).
         */
        fun extractDefaultLabel(apiServerUrl: String): String =
-            extractHost(apiServerUrl) ?: apiServerUrl
+            extractHost(apiServerUrl)?.let(::defaultLabelFromHost) ?: apiServerUrl

        /** Preserve explicit labels while upgrading an auto-generated IP label to a discovered host name. */
        fun chooseDiscoveredLabel(
@@ -160,7 +160,25 @@ data class Connection(
            val primary = dashboardUrl?.trim()?.takeIf { it.isNotBlank() }
                ?: apiServerUrl.trim().takeIf { it.isNotBlank() }
                ?: relayUrl.trim()
-            return extractHost(primary) ?: primary
+            return extractHost(primary)?.let(::defaultLabelFromHost) ?: primary
+        }
+
+        /**
+         * Nous-hosted agent gateways use the stable
+         * `<slug>.agents.nousresearch.com` origin contract. The public Hermes
+         * status response deliberately carries no tenant/agent display name,
+         * so a URL-only connection uses that exact single-label slug as its
+         * least-surprising default. Portal's human-readable agent name is only
+         * available through its separately authenticated discovery API.
+         *
+         * Match the complete suffix and exactly one leading DNS label. This
+         * avoids shortening lookalike or operator-controlled hostnames.
+         */
+        private fun defaultLabelFromHost(host: String): String {
+            val suffix = ".agents.nousresearch.com"
+            if (!host.endsWith(suffix, ignoreCase = true)) return host
+            val slug = host.dropLast(suffix.length)
+            return slug.takeIf { it.isNotBlank() && '.' !in it } ?: host
        }

        private fun extractHost(url: String): String? = try {
@@ -26,7 +26,6 @@ object ProfilePresentationPolicy {
    fun availableKeys(profiles: List<Profile>): List<String> = buildList {
        add(AgentDisplay.SERVER_DEFAULT_PROFILE_KEY)
        profiles.asSequence()
-            .filterNot { AgentDisplay.isServerDefaultAlias(it.name) }
            .map(Profile::name)
            .distinct()
            .forEach(::add)
@@ -49,6 +48,12 @@ object ProfilePresentationPolicy {
    ): List<String> = orderedKeys(profiles, presentation).filter { key ->
        key == selectedKey || key !in presentation.hidden
    }
+
+    fun shouldShowShelf(
+        profiles: List<Profile>,
+        presentation: ProfilePresentation,
+        selectedKey: String,
+    ): Boolean = visibleKeys(profiles, presentation, selectedKey).size > 1
 }

 class ProfilePresentationStore(
@@ -19,6 +19,7 @@ import com.hermesandroid.relay.diagnostics.NetworkDiagnosticGuidance
 import com.hermesandroid.relay.network.relay.models.Envelope
 import com.hermesandroid.relay.network.shared.EndpointResolver
 import com.hermesandroid.relay.network.shared.EndpointSurface
+import com.hermesandroid.relay.network.shared.fullJitterDelayMs
 import com.hermesandroid.relay.network.shutdownOffMainThread
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -139,6 +140,8 @@ class ConnectionManager(
     * non-null — the manager falls back to the single-URL path.
     */
    private val deviceIdProvider: (suspend () -> String?)? = null,
+    /** Random source for ordinary reconnect full-jitter; exact backoffs never use it. */
+    private val reconnectJitterUnit: () -> Double = { kotlin.random.Random.nextDouble() },
 ) {
    private val supervisorJob = SupervisorJob()
    private val scope = CoroutineScope(supervisorJob + Dispatchers.IO)
@@ -1213,8 +1216,9 @@ class ConnectionManager(
                SLOW_POLL_BACKOFF_MS
            }
            else -> {
-                val ms = (BASE_BACKOFF_MS * (1L shl minOf(reconnectAttempt - 1, 4)))
+                val capMs = (BASE_BACKOFF_MS * (1L shl minOf(reconnectAttempt - 1, 4)))
                    .coerceAtMost(MAX_BACKOFF_MS)
+                val ms = fullJitterDelayMs(capMs, reconnectJitterUnit())
                DiagnosticsLog.record(
                    category = DiagnosticCategory.Relay,
                    severity = DiagnosticSeverity.Info,
@@ -61,7 +61,7 @@ object HermesLanDiscovery {
            .callTimeout(PROBE_TIMEOUT_MS * 2, TimeUnit.MILLISECONDS)
            .build()

-        coroutineScope {
+        val results = coroutineScope {
            val semaphore = Semaphore(MAX_CONCURRENT_PROBES)
            hosts.map { host ->
                async {
@@ -79,6 +79,8 @@ object HermesLanDiscovery {
                        .thenBy { it.host },
                )
        }
+        Log.d(TAG, "scan complete hosts=${hosts.size} matches=${results.size}")
+        results
    }

    private fun probeHost(
@@ -133,8 +135,7 @@ object HermesLanDiscovery {
                val body = response.body.string().take(2_048)
                expectedBody(body, contentType)
            }
-        } catch (e: Exception) {
-            Log.d(TAG, "probe failed url=$url type=${e.javaClass.simpleName}")
+        } catch (_: Exception) {
            false
        }
    }
@@ -0,0 +1,13 @@
+package com.hermesandroid.relay.network.shared
+
+import kotlin.random.Random
+
+/** Full-jitter retry delay in the inclusive range 0..[capMs]. */
+internal fun fullJitterDelayMs(
+    capMs: Long,
+    unit: Double = Random.nextDouble(),
+): Long {
+    if (capMs <= 0L) return 0L
+    val boundedUnit = unit.coerceIn(0.0, Math.nextDown(1.0))
+    return (boundedUnit * (capMs + 1.0)).toLong().coerceAtMost(capMs)
+}
@@ -90,12 +90,9 @@ class ChatHandler {
        // Fallback form (no relay): `MEDIA:/absolute/path` — relay wasn't
        //   reachable when the tool fired, so we render an "unavailable"
        //   placeholder instead of attempting a fetch.
-        private val mediaRelayRegex = Regex("""MEDIA:hermes-relay://([A-Za-z0-9_-]+)""")
-        // `/.+?` (not `/\S+`) so absolute paths containing spaces — e.g.
-        // `MEDIA:/mnt/media/Coralee Adshade/undressher.jpg` — still match. The
-        // trailing `\s*$` trims any trailing whitespace; non-greedy keeps the
-        // capture to the path. OkHttp re-encodes the space for /media/by-path.
-        private val mediaBarePathRegex = Regex("""^\s*MEDIA:(/.+?)\s*$""")
+        private val mediaRelayPayloadRegex = Regex("""^hermes-relay://([A-Za-z0-9_-]+)$""")
+        private val mediaMarkerPrefixRegex = Regex("MEDIA:")
+        private val windowsAbsoluteMediaPathRegex = Regex("""^[A-Za-z]:[\\/].+""")
        // Rich card marker — single line, full JSON object payload.
        //
        // Agents emit:
@@ -188,6 +185,7 @@ class ChatHandler {
     * post-stream finalize reconciliation pass.
     */
    private var mediaLineBuffer = StringBuilder()
+    private var mediaFenceDelimiter: String? = null
    private val dispatchedMediaMarkers = mutableSetOf<String>()

    /**
@@ -1176,12 +1174,14 @@ class ChatHandler {
        // Drop any pending line buffers / dedupe state so a fresh session
        // doesn't inherit leftovers from the previous one.
        mediaLineBuffer.clear()
+        mediaFenceDelimiter = null
        dispatchedMediaMarkers.clear()
        annotationLineBuffer.clear()
        activeAnnotationTools.clear()
        cardLineBuffer.clear()
        dispatchedCardMarkers.clear()
        subagentLabels.clear()
+        subagentIds.clear()
    }

    /**
@@ -1771,7 +1771,7 @@ class ChatHandler {
        for (line in text.lines()) {
            val t = line.trim()
            if (t.isEmpty()) continue
-            if (mediaRelayRegex.containsMatchIn(t) || mediaBarePathRegex.containsMatchIn(t)) continue
+            if (parseMediaMarkerLine(t).isNotEmpty()) continue
            if (PersistedImageReferenceParser.parse(t).paths.isNotEmpty()) continue
            if (cardMarkerRegex.containsMatchIn(t)) continue
            if (sb.isNotEmpty()) sb.append('\n')
@@ -1788,6 +1788,51 @@ class ChatHandler {
        data class BarePath(val path: String) : MediaMarkerHit
    }

+    /**
+     * Parse one marker-only line using upstream-compatible wrappers and
+     * boundaries. Prose and malformed examples remain ordinary text; a whole
+     * inline-code or emphasis wrapper is accepted, as are adjacent markers,
+     * sentence-final punctuation, POSIX paths, and Windows absolute paths.
+     */
+    private fun parseMediaMarkerLine(line: String): List<MediaMarkerHit> {
+        val trimmed = line.trim()
+        if (trimmed.isEmpty() || trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+            return emptyList()
+        }
+        val starts = mediaMarkerPrefixRegex.findAll(trimmed).map { it.range.first }.toList()
+        if (starts.isEmpty()) return emptyList()
+        val prefix = trimmed.substring(0, starts.first())
+        if (prefix.any { !it.isWhitespace() && it !in "`*_~" }) return emptyList()
+
+        val hits = ArrayList<MediaMarkerHit>(starts.size)
+        for ((index, start) in starts.withIndex()) {
+            val payloadStart = start + "MEDIA:".length
+            val payloadEnd = starts.getOrNull(index + 1) ?: trimmed.length
+            val payload = trimmed.substring(payloadStart, payloadEnd)
+                .trim()
+                .trimEnd { it in "`*_~.,;:)}]" }
+                .trim()
+            if (payload.isEmpty()) return emptyList()
+            val relay = mediaRelayPayloadRegex.matchEntire(payload)
+            when {
+                relay != null -> hits += MediaMarkerHit.RelayToken(relay.groupValues[1])
+                payload.startsWith("/") || windowsAbsoluteMediaPathRegex.matches(payload) ->
+                    hits += MediaMarkerHit.BarePath(payload)
+                else -> return emptyList()
+            }
+        }
+        return hits
+    }
+
+    private fun fenceDelimiter(line: String): String? {
+        val trimmed = line.trimStart()
+        return when {
+            trimmed.startsWith("```") -> "```"
+            trimmed.startsWith("~~~") -> "~~~"
+            else -> null
+        }
+    }
+
    /**
     * Scan loaded (non-streaming) message content line-by-line for media
     * markers, append hits to [out], and return the content with matched
@@ -1800,24 +1845,20 @@ class ChatHandler {
        out: MutableList<Pair<String, MediaMarkerHit>>,
    ): String {
        var cleaned = content
+        var openFence: String? = null
        for (rawLine in content.lines()) {
            val trimmed = rawLine.trim()
            if (trimmed.isEmpty()) continue
-
-            val relayMatch = mediaRelayRegex.find(trimmed)
-            if (relayMatch != null) {
-                out.add(messageId to MediaMarkerHit.RelayToken(relayMatch.groupValues[1]))
-                cleaned = cleaned
-                    .replace("\n$rawLine\n", "\n")
-                    .replace("\n$rawLine", "")
-                    .replace("$rawLine\n", "")
-                    .replace(rawLine, "")
+            val delimiter = fenceDelimiter(rawLine)
+            if (delimiter != null) {
+                openFence = if (openFence == delimiter) null else if (openFence == null) delimiter else openFence
                continue
            }
+            if (openFence != null) continue

-            val bareMatch = mediaBarePathRegex.find(trimmed)
-            if (bareMatch != null) {
-                out.add(messageId to MediaMarkerHit.BarePath(bareMatch.groupValues[1]))
+            val hits = parseMediaMarkerLine(trimmed)
+            if (hits.isNotEmpty()) {
+                hits.forEach { out.add(messageId to it) }
                cleaned = cleaned
                    .replace("\n$rawLine\n", "\n")
                    .replace("\n$rawLine", "")
@@ -1909,6 +1950,37 @@ class ChatHandler {
        }
    }

+    /**
+     * Returns true when structured session history contains tool lifecycle
+     * state that the live transcript did not receive. This is a read-only
+     * preflight for Gateway completion reconciliation: healthy live turns keep
+     * their current StateFlow list and UI identity, while omitted upstream
+     * tool events opt into [loadMessageHistory]. Assistant prose is never
+     * inspected or interpreted here.
+     */
+    fun hasMissingPersistedToolActivity(items: List<MessageItem>): Boolean {
+        val toolResults = items.filter { it.role == "tool" }
+            .associateBy { it.toolCallId }
+        val persistedCalls = coalesceRenderedHistoryItems(items)
+            .asSequence()
+            .filter { it.role == "assistant" }
+            .flatMap { parseToolCallsFromHistory(it.toolCalls, toolResults).asSequence() }
+            .toList()
+        if (persistedCalls.isEmpty()) return false
+
+        val localCalls = _messages.value.flatMap { it.toolCalls }
+        return persistedCalls.any { persisted ->
+            val local = persisted.id?.let { id -> localCalls.firstOrNull { it.id == id } }
+                ?: localCalls.firstOrNull {
+                    it.id == null && it.name == persisted.name && it.args == persisted.args
+                }
+            local == null ||
+                (persisted.isComplete && !local.isComplete) ||
+                (persisted.result != null && persisted.result != local.result) ||
+                (persisted.success != null && persisted.success != local.success)
+        }
+    }
+
    // --- Session management ---

    fun setSessionId(sessionId: String?) {
@@ -1962,6 +2034,8 @@ class ChatHandler {
                // rows (default source). (ADR 12 — Threads surface, slice 1.)
                source = item.source,
                hasModelConfig = item.hasModelConfig,
+                pinned = item.pinned,
+                archived = item.archived,
            )
        }.sortedByDescending { it.activityTimestamp }
        // Preserve the active session's optimistic row when the server list
@@ -2008,6 +2082,26 @@ class ChatHandler {
        }
    }

+    /** Apply an optimistic pin/archive mutation; a failed server write restores the copy. */
+    fun setSessionFlagsLocal(
+        sessionId: String,
+        pinned: Boolean? = null,
+        archived: Boolean? = null,
+    ) {
+        _sessions.update { sessions ->
+            sessions.map { session ->
+                if (session.sessionId == sessionId) {
+                    session.copy(
+                        pinned = pinned ?: session.pinned,
+                        archived = archived ?: session.archived,
+                    )
+                } else {
+                    session
+                }
+            }
+        }
+    }
+
    /**
     * Add a newly created session to the list.
     */
@@ -2212,6 +2306,18 @@ class ChatHandler {
            val trimmed = line.trim()
            if (trimmed.isEmpty()) continue

+            fenceDelimiter(line)?.let { delimiter ->
+                mediaFenceDelimiter = if (mediaFenceDelimiter == delimiter) {
+                    null
+                } else if (mediaFenceDelimiter == null) {
+                    delimiter
+                } else {
+                    mediaFenceDelimiter
+                }
+                continue
+            }
+            if (mediaFenceDelimiter != null) continue
+
            if (tryDispatchMediaMarker(messageId, trimmed)) {
                stripLineFromContent(messageId, trimmed)
            }
@@ -2341,29 +2447,26 @@ class ChatHandler {
     * Returns true when a marker was matched so the caller can strip the line.
     */
    private fun tryDispatchMediaMarker(messageId: String, line: String): Boolean {
-        val relayMatch = mediaRelayRegex.find(line)
-        if (relayMatch != null) {
-            val token = relayMatch.groupValues[1]
-            val dedupeKey = "$messageId:relay:$token"
-            if (dispatchedMediaMarkers.add(dedupeKey)) {
-                Log.d(TAG, "Media marker (relay): token=$token")
-                onMediaAttachmentRequested(messageId, token)
+        val hits = parseMediaMarkerLine(line)
+        for (hit in hits) {
+            when (hit) {
+                is MediaMarkerHit.RelayToken -> {
+                    val dedupeKey = "$messageId:relay:${hit.token}"
+                    if (dispatchedMediaMarkers.add(dedupeKey)) {
+                        Log.d(TAG, "Media marker (relay): token=${hit.token}")
+                        onMediaAttachmentRequested(messageId, hit.token)
+                    }
+                }
+                is MediaMarkerHit.BarePath -> {
+                    val dedupeKey = "$messageId:bare:${hit.path}"
+                    if (dispatchedMediaMarkers.add(dedupeKey)) {
+                        Log.d(TAG, "Media marker (bare-path): ${hit.path}")
+                        onMediaBarePathRequested(messageId, hit.path)
+                    }
+                }
            }
-            return true
        }
-
-        val bareMatch = mediaBarePathRegex.find(line)
-        if (bareMatch != null) {
-            val path = bareMatch.groupValues[1]
-            val dedupeKey = "$messageId:bare:$path"
-            if (dispatchedMediaMarkers.add(dedupeKey)) {
-                Log.d(TAG, "Media marker (bare-path, unavailable): $path")
-                onMediaBarePathRequested(messageId, path)
-            }
-            return true
-        }
-
-        return false
+        return hits.isNotEmpty()
    }

    /**
@@ -2502,10 +2605,11 @@ class ChatHandler {
        if (mediaLineBuffer.isNotEmpty()) {
            val remaining = mediaLineBuffer.toString().trim()
            mediaLineBuffer.clear()
-            if (remaining.isNotEmpty() && tryDispatchMediaMarker(messageId, remaining)) {
+            if (mediaFenceDelimiter == null && remaining.isNotEmpty() && tryDispatchMediaMarker(messageId, remaining)) {
                stripLineFromContent(messageId, remaining)
            }
        }
+        mediaFenceDelimiter = null

        // Post-stream reconciliation: re-scan the final content for markers
        // that raced with stripLineFromContent during streaming.
@@ -2514,12 +2618,16 @@ class ChatHandler {
                if (!msg.matchesIdentity(messageId) || msg.role != MessageRole.ASSISTANT) return@map msg
                var cleaned = msg.content
                var changed = false
+                var openFence: String? = null
                for (rawLine in msg.content.lines()) {
                    val trimmed = rawLine.trim()
                    if (trimmed.isEmpty()) continue
-                    if (mediaRelayRegex.containsMatchIn(trimmed) ||
-                        mediaBarePathRegex.containsMatchIn(trimmed)
-                    ) {
+                    val delimiter = fenceDelimiter(rawLine)
+                    if (delimiter != null) {
+                        openFence = if (openFence == delimiter) null else if (openFence == null) delimiter else openFence
+                        continue
+                    }
+                    if (openFence == null && parseMediaMarkerLine(trimmed).isNotEmpty()) {
                        tryDispatchMediaMarker(messageId, trimmed)
                        cleaned = cleaned
                            .replace("\n$rawLine\n", "\n")
@@ -2726,6 +2834,7 @@ class ChatHandler {
        messageId: String,
        toolCallId: String,
        toolName: String,
+        argsPreview: String? = null,
        runId: String? = null,
        provenance: String? = null,
    ) {
@@ -2753,6 +2862,7 @@ class ChatHandler {
                        calls[genIdx] = calls[genIdx].copy(
                            id = toolCallId,
                            name = toolName,
+                            args = argsPreview ?: calls[genIdx].args,
                            isGenerating = false,
                            // Execution starts now — preparing time isn't runtime.
                            startedAt = System.currentTimeMillis(),
@@ -2765,7 +2875,7 @@ class ChatHandler {
                            toolCalls = msg.toolCalls + ToolCall(
                                id = toolCallId,
                                name = toolName,
-                                args = null,
+                                args = argsPreview,
                                result = null,
                                success = null,
                                isComplete = false,
@@ -2786,7 +2896,7 @@ class ChatHandler {
                        ToolCall(
                            id = toolCallId,
                            name = toolName,
-                            args = null,
+                            args = argsPreview,
                            result = null,
                            success = null,
                            isComplete = false,
@@ -2848,6 +2958,7 @@ class ChatHandler {
     * [onStreamComplete] / [clearMessages].
     */
    private val subagentLabels = mutableMapOf<Int, String>()
+    private val subagentIds = mutableMapOf<Int, String>()

    /**
     * Apply one gateway `subagent.*` lifecycle event to the streaming
@@ -2863,6 +2974,9 @@ class ChatHandler {
        when (event.phase) {
            GatewaySubagentEvent.Phase.START -> {
                if (label != null) subagentLabels[event.taskIndex] = label
+                event.subagentId?.takeIf(String::isNotBlank)?.let {
+                    subagentIds[event.taskIndex] = it
+                }
            }

            GatewaySubagentEvent.Phase.TOOL -> {
@@ -2877,6 +2991,8 @@ class ChatHandler {
                    isComplete = false,
                    taskIndex = event.taskIndex,
                    taskLabel = laneLabel,
+                    subagentId = event.subagentId?.takeIf(String::isNotBlank)
+                        ?: subagentIds[event.taskIndex],
                )
                _messages.update { messages ->
                    val target = messages.findLast {
@@ -2916,6 +3032,7 @@ class ChatHandler {
                // "interrupted" lanes never finished — not a success either.
                val failed = event.status == "failed" || event.status == "interrupted"
                val laneLabel = subagentLabels.remove(event.taskIndex) ?: label
+                val subagentId = subagentIds.remove(event.taskIndex) ?: event.subagentId
                val summaryId = "subagent-${event.taskIndex}-${syntheticToolSeq++}"
                _messages.update { messages ->
                    messages.map { msg ->
@@ -2948,6 +3065,7 @@ class ChatHandler {
                                completedAt = System.currentTimeMillis(),
                                taskIndex = event.taskIndex,
                                taskLabel = laneLabel,
+                                subagentId = subagentId,
                            )
                        }
                        msg.copy(toolCalls = withSummary)
@@ -3205,6 +3323,7 @@ class ChatHandler {
            }
        }
        subagentLabels.clear()
+        subagentIds.clear()
    }

    fun onStreamError(message: String) {
@@ -3234,6 +3353,7 @@ class ChatHandler {
            }
        }
        subagentLabels.clear()
+        subagentIds.clear()
    }

    fun onThinkingDelta(messageId: String, delta: String) {
@@ -500,6 +500,7 @@ class DashboardApiClient(
        name: String,
        cloneFromDefault: Boolean = true,
        description: String? = null,
+        mcpServers: List<String> = emptyList(),
    ): Result<JsonObject> =
        postJsonObject(
            path = "/api/profiles",
@@ -507,9 +508,16 @@ class DashboardApiClient(
                put("name", name)
                put("clone_from_default", cloneFromDefault)
                if (!description.isNullOrBlank()) put("description", description)
+                if (mcpServers.isNotEmpty()) {
+                    put("mcp_servers", JsonArray(mcpServers.map(::JsonPrimitive)))
+                }
            },
        )

+    /** Create a host-owned Hermes backup, distinct from Android settings export. */
+    suspend fun createServerBackup(): Result<JsonObject> =
+        postJsonObject("/api/ops/backup")
+
    suspend fun setProfileDescription(name: String, description: String): Result<JsonObject> =
        putJsonObject(
            path = "/api/profiles/${pathSegment(name)}/description",
@@ -605,15 +613,16 @@ class DashboardApiClient(
        )
    }

-    suspend fun getCustomEndpoints(): Result<DashboardCustomEndpoints> =
-        getJsonObject("/api/providers/custom-endpoints")
+    suspend fun getCustomEndpoints(profile: String? = null): Result<DashboardCustomEndpoints> =
+        getJsonObject("/api/providers/custom-endpoints${profileQuery(profile)}")
            .mapCatching(::parseCustomEndpoints)

    suspend fun saveCustomEndpoint(
        draft: DashboardCustomEndpointDraft,
+        profile: String? = null,
    ): Result<DashboardCustomEndpoints> =
        postJsonObject(
-            "/api/providers/custom-endpoints",
+            "/api/providers/custom-endpoints${profileQuery(profile)}",
            customEndpointPayload(draft),
        ).mapCatching(::parseCustomEndpoints)

@@ -634,13 +643,19 @@ class DashboardApiClient(

    suspend fun activateCustomEndpoint(
        id: String,
+        profile: String? = null,
    ): Result<JsonObject> =
-        postJsonObject("/api/providers/custom-endpoints/${pathSegment(id)}/activate")
+        postJsonObject(
+            "/api/providers/custom-endpoints/${pathSegment(id)}/activate${profileQuery(profile)}",
+        )

    suspend fun deleteCustomEndpoint(
        id: String,
+        profile: String? = null,
    ): Result<DashboardCustomEndpoints> =
-        deleteJsonObject("/api/providers/custom-endpoints/${pathSegment(id)}")
+        deleteJsonObject(
+            "/api/providers/custom-endpoints/${pathSegment(id)}${profileQuery(profile)}",
+        )
            .mapCatching(::parseCustomEndpoints)

    suspend fun installMcpCatalogEntry(
@@ -752,6 +767,27 @@ class DashboardApiClient(
            Result.success(sessions.values.take(limit.coerceIn(1, SESSION_LIST_WINDOW_LIMIT)))
        }

+    /**
+     * Read the bounded, authoritative session window across every profile.
+     * Every usable row must retain its owning profile; rows without one are
+     * skipped rather than risking a cross-profile transcript or mutation.
+     */
+    suspend fun listAllProfileSessions(
+        limit: Int = SESSION_LIST_WINDOW_LIMIT,
+    ): Result<List<SessionItem>> = withContext(Dispatchers.IO) {
+        val boundedLimit = limit.coerceIn(1, SESSION_LIST_WINDOW_LIMIT)
+        getJson(
+            "/api/profiles/sessions?limit=$boundedLimit&offset=0&order=recent" +
+                "&min_messages=1&archived=include&profile=all",
+        ).mapCatching { root ->
+            val parsed = json.decodeFromJsonElement(SessionListResponse.serializer(), root)
+            (parsed.sessions ?: parsed.items ?: parsed.data ?: emptyList())
+                .filter { it.id.isNotBlank() && !it.profile.isNullOrBlank() }
+                .distinctBy { "${it.profile}:${it.id}" }
+                .take(boundedLimit)
+        }
+    }
+
    /**
     * A session's message history, scoped to its owning profile via the dashboard
     * `GET /api/sessions/{id}/messages?profile=`. Required twin of [listSessions]:
@@ -763,12 +799,24 @@ class DashboardApiClient(
    suspend fun getSessionMessages(
        sessionId: String,
        profile: String? = null,
+        mode: SessionMessageLoadMode = SessionMessageLoadMode.COMPLETE,
    ): Result<List<MessageItem>> = withContext(Dispatchers.IO) {
        val name = profile?.trim().orEmpty()
-        val query = if (name.isNotBlank()) "?profile=${pathSegment(name)}" else ""
-        getJson("/api/sessions/${pathSegment(sessionId)}/messages$query").mapCatching { root ->
-            val parsed = json.decodeFromJsonElement(MessageListResponse.serializer(), root)
-            parsed.messages ?: parsed.data ?: parsed.items ?: emptyList()
+        loadSessionMessages(mode) { page ->
+            val query = buildList {
+                add("limit=${page.limit}")
+                add("offset=${page.offset}")
+                add("order=${page.order}")
+                if (name.isNotBlank()) add("profile=${pathSegment(name)}")
+            }.joinToString(prefix = "?", separator = "&")
+            getJson("/api/sessions/${pathSegment(sessionId)}/messages$query").mapCatching { root ->
+                val parsed = json.decodeFromJsonElement(MessageListResponse.serializer(), root)
+                SessionMessagePage(
+                    messages = parsed.messages ?: parsed.data ?: parsed.items ?: emptyList(),
+                    pagination = parsed.pagination,
+                    payloadChars = root.toString().length,
+                )
+            }
        }
    }

@@ -832,6 +880,20 @@ class DashboardApiClient(
            },
        )

+    /** Persist the upstream keep flag that backs official-client session pins. */
+    suspend fun setSessionPinned(
+        sessionId: String,
+        pinned: Boolean,
+        profile: String? = null,
+    ): Result<JsonObject> =
+        patchJsonObject(
+            "/api/sessions/${pathSegment(sessionId)}${profileQuery(profile)}",
+            buildJsonObject {
+                put("pinned", pinned)
+                profile?.trim()?.takeIf { it.isNotBlank() }?.let { put("profile", it) }
+            },
+        )
+
    /**
     * Dry-run a server-backed bulk session cleanup via the dashboard
     * `POST /api/sessions/prune` (`dry_run: true`). Returns what WOULD be
@@ -18,10 +18,12 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withTimeout
+import com.hermesandroid.relay.network.shared.fullJitterDelayMs
 import kotlinx.coroutines.withTimeoutOrNull
 import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonNull
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.booleanOrNull
@@ -86,6 +88,8 @@ class GatewayChatClient(
    private val promptSubmitTimeoutMs: Long = PROMPT_SUBMIT_REQUEST_TIMEOUT_MS,
    /** Test seam — idle-progress watchdog base. Production keeps [TURN_TIMEOUT_MS]. */
    private val turnIdleTimeoutMs: Long = TURN_TIMEOUT_MS,
+    /** Random source for ordinary reconnect full-jitter. */
+    private val reconnectJitterUnit: () -> Double = { kotlin.random.Random.nextDouble() },
 ) {
    /** Existing upstream rich-chat vocabulary; do not invent a Relay-only source. */
    private val sessionSource = "webui"
@@ -562,7 +566,11 @@ class GatewayChatClient(
                    buildJsonObject {
                        put("session_id", liveSessionId ?: error("no live session"))
                        put("text", text)
-                        truncateBeforeUserOrdinal?.let { put("truncate_before_user_ordinal", it) }
+                        truncateBeforeUserOrdinal?.let { ordinal ->
+                            put("truncate_before_user_ordinal", ordinal)
+                            put("confirm_truncate", true)
+                            if (ordinal == 0) put("confirm_empty_truncate", true)
+                        }
                        if (queuedFollowUp) put("queued", true)
                    },
                    // Long-running RPC, not a generic 15s ack — see the
@@ -588,7 +596,7 @@ class GatewayChatClient(
                    if (activeTurn === turn) activeTurn = null
                    turn.disarmWatchdog()
                    val submitError = submitted.exceptionOrNull()
-                    if ((submitError as? GatewayRpcException)?.code == ACTIVE_SESSION_CAP_REJECTION) {
+                    if (submitError.isAuthoritativePromptSubmitRejection()) {
                        // Authoritative policy rejection: the gateway received
                        // the prompt and deliberately refused to create the
                        // first turn. Falling back to SSE would bypass the cap
@@ -597,7 +605,7 @@ class GatewayChatClient(
                        // through the normal failed-turn callback instead.
                        turn.tracer.done("submit-rejected")
                        turn.callbacks.onError(
-                            submitError.message ?: "Hermes rejected the new session",
+                            submitError?.message ?: "Hermes rejected the new session",
                        )
                        return@launch
                    }
@@ -1122,41 +1130,59 @@ class GatewayChatClient(
        )

    /** Answer a [GatewayAsk.Kind.CLARIFY] ask. */
-    suspend fun respondClarify(requestId: String, answer: String): Result<GatewayAskResponse> =
-        rpc(
+    suspend fun respondClarify(requestId: String, answer: String): Result<GatewayAskResponse> {
+        val respondingTurn = activeTurn
+        return rpc(
            "clarify.respond",
            buildJsonObject {
                put("request_id", requestId)
                put("answer", answer)
            },
-        ).map { it.gatewayAskResponse() }
+        ).map {
+            it.gatewayAskResponse().also {
+                respondingTurn?.acknowledgeInteraction(GatewayAskExpiry(GatewayAsk.Kind.CLARIFY, requestId))
+            }
+        }
+    }

    /**
     * Answer a [GatewayAsk.Kind.SUDO] ask. The password must NEVER be logged
     * or persisted — it exists only inside this outbound frame.
     */
-    suspend fun respondSudo(requestId: String, password: String): Result<GatewayAskResponse> =
-        rpc(
+    suspend fun respondSudo(requestId: String, password: String): Result<GatewayAskResponse> {
+        val respondingTurn = activeTurn
+        return rpc(
            "sudo.respond",
            buildJsonObject {
                put("request_id", requestId)
                put("password", password)
            },
-        ).map { it.gatewayAskResponse() }
+        ).map {
+            it.gatewayAskResponse().also {
+                respondingTurn?.acknowledgeInteraction(GatewayAskExpiry(GatewayAsk.Kind.SUDO, requestId))
+            }
+        }
+    }

    /**
     * Answer a [GatewayAsk.Kind.SECRET] ask. Empty [value] = skip (upstream
     * returns `skipped: true` to the tool). The value must NEVER be logged
     * or persisted — it exists only inside this outbound frame.
     */
-    suspend fun respondSecret(requestId: String, value: String): Result<GatewayAskResponse> =
-        rpc(
+    suspend fun respondSecret(requestId: String, value: String): Result<GatewayAskResponse> {
+        val respondingTurn = activeTurn
+        return rpc(
            "secret.respond",
            buildJsonObject {
                put("request_id", requestId)
                put("value", value)
            },
-        ).map { it.gatewayAskResponse() }
+        ).map {
+            it.gatewayAskResponse().also {
+                respondingTurn?.acknowledgeInteraction(GatewayAskExpiry(GatewayAsk.Kind.SECRET, requestId))
+            }
+        }
+    }

    /**
     * Answer a [GatewayAsk.Kind.APPROVAL] ask — correlated by the live
@@ -1164,6 +1190,7 @@ class GatewayChatClient(
     * resolves every pending approval on the session at once.
     */
    suspend fun respondApproval(choice: String, all: Boolean = false): Result<GatewayAskResponse> {
+        val respondingTurn = activeTurn
        val sid = liveSessionId
            ?: return Result.failure(GatewayRpcException("no live session"))
        return rpc(
@@ -1173,7 +1200,11 @@ class GatewayChatClient(
                put("choice", choice)
                put("all", all)
            },
-        ).map { it.gatewayAskResponse() }
+        ).map {
+            it.gatewayAskResponse().also {
+                respondingTurn?.acknowledgeInteraction(GatewayAskExpiry(GatewayAsk.Kind.APPROVAL, null))
+            }
+        }
    }

    /**
@@ -1426,10 +1457,12 @@ class GatewayChatClient(
            if (refresh) put("refresh", true)
        }
        return rpc("model.options", params).map { result ->
-            val providers = (result["providers"] as? JsonArray).orEmpty().mapNotNull { el ->
-                val obj = el as? JsonObject ?: return@mapNotNull null
-                parseGatewayModelProvider(obj)
-            }
+            val providers = normalizeGatewayModelProviders(
+                (result["providers"] as? JsonArray).orEmpty().mapNotNull { el ->
+                    val obj = el as? JsonObject ?: return@mapNotNull null
+                    parseGatewayModelProvider(obj)
+                },
+            )
            GatewayModelOptions(
                providers = providers,
                currentModel = result.stringField("model") ?: "",
@@ -1457,6 +1490,43 @@ class GatewayChatClient(
            },
        )

+    /**
+     * React to the newest message for a role without guessing a transcript row
+     * id. This follows the upstream gateway contract, which resolves the row
+     * atomically inside the active session. A null emoji removes the reaction.
+     */
+    suspend fun reactToNewest(role: String, emoji: String?): Result<JsonObject> {
+        require(role == "user" || role == "assistant") { "unsupported reaction role" }
+        val sid = liveSessionId
+            ?: return Result.failure(GatewayRpcException("no live session"))
+        return rpc(
+            "message.react",
+            buildJsonObject {
+                put("session_id", sid)
+                put("newest_role", role)
+                if (emoji == null) put("emoji", JsonNull) else put("emoji", emoji)
+                put("author", "user")
+            },
+        )
+    }
+
+    /** Redirect one running child agent without interrupting the parent turn. */
+    suspend fun steerSubagent(subagentId: String, text: String): Result<JsonObject> {
+        val sessionId = liveSessionId
+            ?: return Result.failure(IllegalStateException("No live gateway session"))
+        if (subagentId.isBlank() || text.isBlank()) {
+            return Result.failure(IllegalArgumentException("Subagent and instruction are required"))
+        }
+        return rpc(
+            "subagent.steer",
+            buildJsonObject {
+                put("session_id", sessionId)
+                put("subagent_id", subagentId)
+                put("text", text.trim())
+            },
+        )
+    }
+
    /** Fetch the session/global reasoning effort and display mode. */
    suspend fun getReasoningSettings(): Result<GatewayReasoningSettings> {
        if (webSocket == null || readySignal?.isCompleted != true) {
@@ -2065,6 +2135,42 @@ class GatewayChatClient(
            return
        }

+        // Upstream emits session.reclaimed process-wide, so it is identified
+        // by payload rather than params.session_id. Retire only an exact live
+        // runtime we own; preserve the durable id so the next send resumes it.
+        if (type == "session.reclaimed") {
+            val reclaimedLiveId = payload?.stringField("session_id")
+            val reclaimedStoredId = payload?.stringField("stored_session_id")
+            val reason = payload?.stringField("reason")
+            val supportedReason = reason in setOf("idle_timeout", "lru_evict", "ws_orphan_reap")
+            if (!reclaimedLiveId.isNullOrBlank() && supportedReason) {
+                val background = backgroundTurns.remove(reclaimedLiveId)
+                if (background != null) {
+                    callbackDispatcher {
+                        unmatchedTurnCompleteListener?.invoke(
+                            GatewayBackgroundTurnCompletion(
+                                storedSessionId = reclaimedStoredId?.takeIf(String::isNotBlank)
+                                    ?: background.storedSessionId,
+                                liveSessionId = reclaimedLiveId,
+                                profile = background.profile,
+                                expectedAssistantText = null,
+                            ),
+                        )
+                    }
+                }
+                if (reclaimedLiveId == liveSessionId) {
+                    liveSessionId = null
+                    reclaimedStoredId?.takeIf(String::isNotBlank)?.let { storedSessionId = it }
+                    val turn = activeTurn
+                    if (turn != null && !turn.ended) {
+                        activeTurn = null
+                        turn.failFromTransport("Gateway reclaimed the inactive session")
+                    }
+                }
+            }
+            return
+        }
+
        // read_terminal is a renderer query, not a user decision. Android has
        // no xterm pane on the Gateway chat surface, so mirror upstream
        // desktop's no-live-pane behavior and answer with empty text instead
@@ -2141,13 +2247,14 @@ class GatewayChatClient(
                pendingAsk.kind == expiry.kind &&
                (pendingAsk.kind == GatewayAsk.Kind.APPROVAL ||
                    pendingAsk.requestId == expiry.requestId)
-            val turnResumed = pendingAsk != null &&
-                GatewayEventMapper.isInteractionResumeEvent(type)
-            if (explicitlyExpired || turnResumed) {
+            // Ordinary turn activity is not a decision acknowledgement. It can
+            // be replayed or buffered. Only an authoritative expiry retires a
+            // detached ask; an explicit response is retired by its foreground VM.
+            if (explicitlyExpired) {
                backgroundTurn.pendingAsk = null
                callbackDispatcher {
                    backgroundInteractionListener?.invoke(
-                        GatewayBackgroundInteractionEvent.Resolved(
+                        GatewayBackgroundInteractionEvent.Expired(
                            storedSessionId = backgroundTurn.storedSessionId,
                            profile = backgroundTurn.profile,
                            ask = pendingAsk,
@@ -2163,6 +2270,7 @@ class GatewayChatClient(
                    unmatchedTurnCompleteListener?.invoke(
                        GatewayBackgroundTurnCompletion(
                            storedSessionId = backgroundTurn.storedSessionId,
+                            liveSessionId = eventSessionId,
                            profile = backgroundTurn.profile,
                            expectedAssistantText = expectedText,
                        ),
@@ -2237,6 +2345,7 @@ class GatewayChatClient(
                    unmatchedTurnCompleteListener?.invoke(
                        GatewayBackgroundTurnCompletion(
                            storedSessionId = storedId,
+                            liveSessionId = eventSessionId,
                            profile = liveSessionProfile,
                            expectedAssistantText = expectedText,
                        ),
@@ -2380,7 +2489,7 @@ class GatewayChatClient(
                Log.i(TAG, "Gateway socket rejoined for ${backgroundTurns.size} detached turn(s)")
                return
            }
-            delay(backoffMs)
+            delay(fullJitterDelayMs(backoffMs, reconnectJitterUnit()))
            backoffMs = (backoffMs * 2).coerceAtMost(5_000L)
        }
    }
@@ -2473,7 +2582,7 @@ class GatewayChatClient(
                )
                return
            }
-            delay(backoffMs)
+            delay(fullJitterDelayMs(backoffMs, reconnectJitterUnit()))
            backoffMs = (backoffMs * 2).coerceAtMost(5_000L)
        }
        if (activeTurn === turn) activeTurn = null
@@ -2645,6 +2754,9 @@ class GatewayChatClient(
        fun restoreInteraction(ask: GatewayAsk) {
            mapper.restoreInteraction(ask)
        }
+        fun acknowledgeInteraction(expiry: GatewayAskExpiry) {
+            mapper.acknowledgeInteraction(expiry)
+        }
        private val deferredEventLock = Any()
        private val deferredEvents = mutableListOf<Pair<String, JsonObject?>>()
        private var eventsDeferred = deferEvents
@@ -2974,7 +3086,9 @@ class GatewayChatClient(
            callbackDispatcher { callbacks.onInterimReconciled(text) }
        },
        onThinkingDelta = { v -> callbackDispatcher { callbacks.onThinkingDelta(v) } },
-        onToolCallStart = { a, b -> callbackDispatcher { callbacks.onToolCallStart(a, b) } },
+        onToolCallStart = { id, name, args ->
+            callbackDispatcher { callbacks.onToolCallStart(id, name, args) }
+        },
        onToolCallDone = { a, b -> callbackDispatcher { callbacks.onToolCallDone(a, b) } },
        onToolCallFailed = { a, b -> callbackDispatcher { callbacks.onToolCallFailed(a, b) } },
        onToolOutputRisk = { v -> callbackDispatcher { callbacks.onToolOutputRisk(v) } },
@@ -2988,7 +3102,6 @@ class GatewayChatClient(
        onMoaReference = { v -> callbackDispatcher { callbacks.onMoaReference(v) } },
        onInteractionRequest = { v -> callbackDispatcher { callbacks.onInteractionRequest(v) } },
        onInteractionExpired = { v -> callbackDispatcher { callbacks.onInteractionExpired(v) } },
-        onInteractionResolved = { v -> callbackDispatcher { callbacks.onInteractionResolved(v) } },
        // MUST be wrapped like every other member: GatewayTurnCallbacks gives
        // onStatusUpdate a default no-op, so omitting it here silently swallows
        // EVERY gateway status line — the ❌ terminal-error lifecycle update
@@ -3052,7 +3165,13 @@ internal class GatewayConnectAttemptException(message: String) : Exception(messa
 internal class GatewayRpcException(message: String, val code: Int? = null) : Exception(message)

 private const val JSONRPC_METHOD_NOT_FOUND = -32601
-private const val ACTIVE_SESSION_CAP_REJECTION = 4090
+private val AUTHORITATIVE_PROMPT_SUBMIT_REJECTIONS = setOf(
+    4028, // first-turn truncate requires explicit empty-history confirmation
+    4029, // every destructive truncate requires explicit confirmation
+    4090, // active-session capacity policy
+    5070, // initial session persistence failed: storage full
+    5071, // other authoritative initial session persistence failure
+)
 private const val MAX_RECOVERED_CORRECTIONS = 32
 private const val MAX_RECOVERED_CORRECTION_CHARS = 32_768
 private const val PET_THUMB_DATA_PREFIX = "data:image/png;base64,"
@@ -3108,6 +3227,9 @@ private fun Throwable?.isMethodNotFound(): Boolean {
        msg.contains("unknown method", ignoreCase = true)
 }

+private fun Throwable?.isAuthoritativePromptSubmitRejection(): Boolean =
+    (this as? GatewayRpcException)?.code in AUTHORITATIVE_PROMPT_SUBMIT_REJECTIONS
+
 private fun Throwable?.isApprovalModeUnsupported(): Boolean {
    val rpcError = this as? GatewayRpcException ?: return false
    val message = rpcError.message.orEmpty()
@@ -40,6 +40,15 @@ class GatewayEventMapper(
        if (!duplicate) callbacks.onInteractionRequest(ask)
    }

+    /** Retire only the ask whose explicit respond RPC reached server truth. */
+    internal fun acknowledgeInteraction(expiry: GatewayAskExpiry) {
+        val pending = pendingInteraction ?: return
+        if (pending.matches(expiry)) {
+            pendingInteraction = null
+            drainDeferredTerminalEvent()
+        }
+    }
+
    private var sawMessageStart = false
    private var previousEventType: String? = null
    private var sawTextDelta = false
@@ -50,6 +59,7 @@ class GatewayEventMapper(
    private var compactionStatusActive = false
    private var moaStatusActive = false
    private var pendingInteraction: GatewayAsk? = null
+    private var deferredTerminalEvent: Pair<String, JsonObject?>? = null

    /**
     * `tool.complete` events match their `tool.start` by `tool_id`; when a
@@ -81,17 +91,17 @@ class GatewayEventMapper(
            }
            callbacks.onInteractionExpired(expiry)
            previousEventType = type
+            if (pendingInteraction == null) drainDeferredTerminalEvent()
            return
        }
-        if (type in INTERACTION_RESUME_EVENTS) {
-            pendingInteraction?.let { ask ->
-                pendingInteraction = null
-                callbacks.onInteractionResolved(
-                    GatewayAskExpiry(kind = ask.kind, requestId = ask.requestId),
-                )
-            }
+        if (pendingInteraction != null && type in TERMINAL_EVENTS) {
+            // A buffered/late terminal frame is not consent. Upstream blocks
+            // the turn on an interaction, so hold the first terminal until an
+            // explicit response acknowledgement or authoritative expiry.
+            if (deferredTerminalEvent == null) deferredTerminalEvent = type to payload
+            previousEventType = type
+            return
        }
-
        when (type) {
            "reasoning.delta" -> {
                val text = payload.string("text")
@@ -197,7 +207,14 @@ class GatewayEventMapper(
                    }
                    else -> syntheticToolId(name)
                }
-                callbacks.onToolCallStart(toolId, name)
+                val argsPreview = payload?.get("args")
+                    ?.takeUnless { it is JsonPrimitive && it.contentOrNull.isNullOrBlank() }
+                    ?.toString()
+                    ?.takeIf { it.isNotBlank() && it != "null" }
+                    ?: payload.string("args_text")
+                    ?.takeIf { it.isNotBlank() }
+                    ?: payload.string("context")?.takeIf { it.isNotBlank() }
+                callbacks.onToolCallStart(toolId, name, argsPreview)
            }

            "tool.complete" -> {
@@ -210,7 +227,10 @@ class GatewayEventMapper(
                if (!error.isNullOrEmpty()) {
                    callbacks.onToolCallFailed(toolId, error)
                } else {
-                    callbacks.onToolCallDone(toolId, payload.string("summary"))
+                    val resultPreview = payload.string("result_text")
+                        ?.takeIf { it.isNotBlank() }
+                        ?: payload.string("summary")?.takeIf { it.isNotBlank() }
+                    callbacks.onToolCallDone(toolId, resultPreview)
                }
            }

@@ -278,6 +298,7 @@ class GatewayEventMapper(
                        // text; thinking/progress carry text only.
                        preview = payload.string("tool_preview") ?: payload.string("text"),
                        durationSeconds = payload.double("duration_seconds"),
+                        subagentId = payload.string("subagent_id"),
                    ),
                )
            }
@@ -371,6 +392,12 @@ class GatewayEventMapper(
        previousEventType = type
    }

+    private fun drainDeferredTerminalEvent() {
+        val deferred = deferredTerminalEvent ?: return
+        deferredTerminalEvent = null
+        onEvent(deferred.first, deferred.second)
+    }
+
    private fun syntheticToolId(name: String): String {
        val id = "gateway-tool-$name-${syntheticToolCounter++}"
        openSyntheticIdsByName.getOrPut(name) { ArrayDeque() }.addLast(id)
@@ -410,20 +437,7 @@ class GatewayEventMapper(
        private const val MAX_MOA_LABEL_CHARS = 120
        private const val MAX_MOA_REFERENCE_CHARS = 16_000
        private val OUTPUT_RISK_LEVELS = setOf("low", "medium", "high", "critical")
-        private val INTERACTION_RESUME_EVENTS = setOf(
-            "reasoning.delta",
-            "thinking.delta",
-            "reasoning.available",
-            "message.delta",
-            "message.interim",
-            "message.start",
-            "tool.generating",
-            "tool.start",
-            "tool.complete",
-            "message.complete",
-            "error",
-        )
-
+        private val TERMINAL_EVENTS = setOf("message.complete", "error")
        internal fun isFailedMoaReference(text: String): Boolean {
            val normalized = text.trimStart().lowercase()
            return normalized.startsWith("[failed:") || normalized.startsWith("[skipped:")
@@ -497,8 +511,6 @@ class GatewayEventMapper(
            else -> null
        }

-        fun isInteractionResumeEvent(type: String): Boolean = type in INTERACTION_RESUME_EVENTS
-
        /**
         * Hermes 2026-07-15 emits these operational wait lines through the
         * legacy `thinking.delta` display callback. Match the deliberately
@@ -173,6 +173,7 @@ data class GatewaySessionRecovery(
 /** A detached sibling turn reached its terminal event on the shared Gateway socket. */
 data class GatewayBackgroundTurnCompletion(
    val storedSessionId: String,
+    val liveSessionId: String,
    val profile: String?,
    val expectedAssistantText: String?,
 )
@@ -189,7 +190,8 @@ sealed interface GatewayBackgroundInteractionEvent {
        override val ask: GatewayAsk,
    ) : GatewayBackgroundInteractionEvent

-    data class Resolved(
+    /** An authoritative upstream `*.expire` event ended this request. */
+    data class Expired(
        override val storedSessionId: String,
        override val profile: String?,
        override val ask: GatewayAsk,
@@ -268,6 +270,7 @@ data class GatewaySubagentEvent(
    val toolName: String? = null,
    val preview: String? = null,
    val durationSeconds: Double? = null,
+    val subagentId: String? = null,
 ) {
    enum class Phase { START, THINKING, TOOL, PROGRESS, COMPLETE }
 }
@@ -364,11 +367,14 @@ internal fun parseGatewayModelProvider(obj: JsonObject): GatewayModelProvider? {
        val row = raw as? JsonObject ?: return@mapNotNull null
        val effortsElement = row["reasoning_efforts"]
        val efforts = if (effortsElement is JsonArray) {
-            effortsElement.mapNotNull { (it as? JsonPrimitive)?.contentOrNull }
+            effortsElement
+                .mapNotNull { (it as? JsonPrimitive)?.contentOrNull?.trim()?.takeIf(String::isNotEmpty) }
+                .distinct()
        } else {
            null
        }
-        model to GatewayModelCapabilities(
+        val modelId = model.trim().takeIf { it.isNotEmpty() } ?: return@mapNotNull null
+        modelId to GatewayModelCapabilities(
            reasoning = (row["reasoning"] as? JsonPrimitive)?.booleanOrNull,
            reasoningEfforts = efforts,
            reasoningEffortsExact =
@@ -379,18 +385,92 @@ internal fun parseGatewayModelProvider(obj: JsonObject): GatewayModelProvider? {
        name = (obj["name"] as? JsonPrimitive)?.contentOrNull ?: slug,
        slug = slug,
        models = (obj["models"] as? JsonArray).orEmpty()
-            .mapNotNull { (it as? JsonPrimitive)?.contentOrNull },
+            .mapNotNull { (it as? JsonPrimitive)?.contentOrNull?.trim()?.takeIf(String::isNotEmpty) }
+            .distinct(),
        isCurrent = (obj["is_current"] as? JsonPrimitive)?.booleanOrNull ?: false,
        warning = (obj["warning"] as? JsonPrimitive)?.contentOrNull,
        authenticated = (obj["authenticated"] as? JsonPrimitive)?.booleanOrNull ?: true,
        unavailableModels = (obj["unavailable_models"] as? JsonArray).orEmpty()
-            .mapNotNull { (it as? JsonPrimitive)?.contentOrNull },
+            .mapNotNull { (it as? JsonPrimitive)?.contentOrNull?.trim()?.takeIf(String::isNotEmpty) }
+            .distinct(),
        freeTier = (obj["free_tier"] as? JsonPrimitive)?.booleanOrNull ?: false,
        totalModels = (obj["total_models"] as? JsonPrimitive)?.contentOrNull?.toIntOrNull() ?: 0,
        capabilities = capabilities,
    )
 }

+/**
+ * Publish one coherent row per provider identity.
+ *
+ * Dynamic catalogs and compatibility payloads can repeat a provider row or a
+ * model inside that row. Provider slugs are case-insensitive upstream, while
+ * model ids remain exact request values. Merge only equal provider slugs so a
+ * model intentionally offered by two different providers stays selectable.
+ */
+internal fun normalizeGatewayModelProviders(
+    providers: List<GatewayModelProvider>,
+): List<GatewayModelProvider> {
+    val normalized = linkedMapOf<String, GatewayModelProvider>()
+    providers.forEach { raw ->
+        val slug = raw.slug.trim()
+        if (slug.isEmpty()) return@forEach
+        val models = raw.models.map(String::trim).filter(String::isNotEmpty).distinct()
+        val unavailable = raw.unavailableModels
+            .map(String::trim)
+            .filter(String::isNotEmpty)
+            .distinct()
+        val capabilities = raw.capabilities.mapNotNull { (model, capability) ->
+            model.trim().takeIf(String::isNotEmpty)?.let { it to capability }
+        }.toMap()
+        val row = raw.copy(
+            name = raw.name.trim().ifEmpty { slug },
+            slug = slug,
+            models = models,
+            unavailableModels = unavailable,
+            totalModels = maxOf(raw.totalModels, models.size),
+            capabilities = capabilities,
+        )
+        val identity = slug.lowercase()
+        val existing = normalized[identity]
+        normalized[identity] = if (existing == null) {
+            row
+        } else {
+            val mergedModels = (existing.models + row.models).distinct()
+            existing.copy(
+                models = mergedModels,
+                isCurrent = existing.isCurrent || row.isCurrent,
+                warning = existing.warning ?: row.warning,
+                authenticated = existing.authenticated || row.authenticated,
+                unavailableModels = (existing.unavailableModels + row.unavailableModels).distinct(),
+                freeTier = existing.freeTier || row.freeTier,
+                totalModels = maxOf(existing.totalModels, row.totalModels, mergedModels.size),
+                capabilities = mergeGatewayModelCapabilities(existing.capabilities, row.capabilities),
+            )
+        }
+    }
+    return normalized.values.toList()
+}
+
+private fun mergeGatewayModelCapabilities(
+    existing: Map<String, GatewayModelCapabilities>,
+    incoming: Map<String, GatewayModelCapabilities>,
+): Map<String, GatewayModelCapabilities> {
+    val merged = existing.toMutableMap()
+    incoming.forEach { (model, next) ->
+        val current = merged[model]
+        merged[model] = if (current == null) {
+            next
+        } else {
+            GatewayModelCapabilities(
+                reasoning = next.reasoning ?: current.reasoning,
+                reasoningEfforts = next.reasoningEfforts ?: current.reasoningEfforts,
+                reasoningEffortsExact = next.reasoningEffortsExact ?: current.reasoningEffortsExact,
+            )
+        }
+    }
+    return merged
+}
+
 data class GatewayMoaReference(
    val index: Int?,
    val count: Int?,
@@ -424,6 +504,21 @@ internal fun isCurrentModelOptionsResponse(
 ): Boolean =
    requestGeneration == currentGeneration && requestProfileKey == currentProfileKey

+/**
+ * Selects the identity a model-options response may publish into chat UI state.
+ * Catalog-only requests populate picker choices without changing session identity.
+ */
+internal fun modelOptionsIdentityToPublish(
+    catalogOnly: Boolean,
+    hasLiveSession: Boolean,
+    sessionIdentity: GatewayModelIdentity?,
+    options: GatewayModelOptions,
+): GatewayModelIdentity? = when {
+    catalogOnly -> null
+    hasLiveSession && sessionIdentity != null -> sessionIdentity
+    else -> GatewayModelIdentity(options.currentModel, options.currentProvider)
+}
+
 /**
 * The explicit in-chat overrides to bind onto a gateway `session.create` as the
 * new session's PER-SESSION overrides. Matches the upstream desktop client,
@@ -488,7 +583,7 @@ class GatewayTurnCallbacks(
     */
    val onInterimReconciled: (text: String) -> Unit = { _ -> },
    val onThinkingDelta: (String) -> Unit,
-    val onToolCallStart: (toolCallId: String, toolName: String) -> Unit,
+    val onToolCallStart: (toolCallId: String, toolName: String, argsPreview: String?) -> Unit,
    val onToolCallDone: (toolCallId: String, resultPreview: String?) -> Unit,
    val onToolCallFailed: (toolCallId: String, errorMsg: String?) -> Unit,
    /** Attach deterministic output-risk metadata to the matching tool card. */
@@ -521,8 +616,6 @@ class GatewayTurnCallbacks(
    val onInteractionRequest: (GatewayAsk) -> Unit,
    /** Server declared a pending interaction expired; clear only the matching card. */
    val onInteractionExpired: (GatewayAskExpiry) -> Unit,
-    /** The turn resumed after a pending interaction was resolved elsewhere. */
-    val onInteractionResolved: (GatewayAskExpiry) -> Unit = { _ -> },
    /**
     * Gateway `status.update` lifecycle line — model fallback, retries, and
     * errors (often emoji-prefixed: 🔄 fallback, ⏳ retry, ❌ error). Default
@@ -19,6 +19,7 @@ import com.hermesandroid.relay.network.upstream.models.SkillListResponse
 import com.hermesandroid.relay.network.upstream.models.UsageInfo
 import com.hermesandroid.relay.util.TurnLatencyTracer
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.Serializable
@@ -27,6 +28,7 @@ import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.buildJsonObject
 import kotlinx.serialization.json.contentOrNull
 import kotlinx.serialization.json.decodeFromJsonElement
 import kotlinx.serialization.json.put
@@ -213,10 +215,12 @@ internal fun parseApiProviderModelOptionsBody(
    val root = runCatching { json.parseToJsonElement(body) as? JsonObject }.getOrNull()
        ?: return null
    val rows = root["providers"] as? JsonArray ?: return null
-    val providers = rows.mapNotNull { element ->
-        val obj = element as? JsonObject ?: return@mapNotNull null
-        parseGatewayModelProvider(obj)
-    }
+    val providers = normalizeGatewayModelProviders(
+        rows.mapNotNull { element ->
+            val obj = element as? JsonObject ?: return@mapNotNull null
+            parseGatewayModelProvider(obj)
+        },
+    )
    return ApiProviderModelOptions(
        providers = providers,
        currentModel = (root["model"] as? JsonPrimitive)?.contentOrNull.orEmpty(),
@@ -323,7 +327,7 @@ internal fun parseModelOptionsBody(json: Json, body: String): List<ApiModelOptio
            root = (obj["root"] as? JsonPrimitive)?.contentOrNull,
            parent = (obj["parent"] as? JsonPrimitive)?.contentOrNull,
        )
-    }
+    }.distinctBy { it.id }
 }

 private const val STREAM_ERROR_BODY_LIMIT = 16L * 1024L
@@ -682,19 +686,62 @@ class HermesApiClient(
        }
    }

-    suspend fun getMessages(sessionId: String): List<MessageItem> = withContext(Dispatchers.IO) {
+    suspend fun setSessionPinned(sessionId: String, pinned: Boolean): Boolean =
+        patchSessionFlag(sessionId, "pinned", pinned)
+
+    suspend fun setSessionArchived(sessionId: String, archived: Boolean): Boolean =
+        patchSessionFlag(sessionId, "archived", archived)
+
+    private suspend fun patchSessionFlag(
+        sessionId: String,
+        field: String,
+        value: Boolean,
+    ): Boolean = withContext(Dispatchers.IO) {
        try {
-            val request = authRequest("$baseUrl/api/sessions/$sessionId/messages")
-                .get()
+            val reqBody = buildJsonObject { put(field, value) }.toString()
+            val request = authRequest("$baseUrl/api/sessions/$sessionId")
+                .patch(reqBody.toRequestBody(JSON_MEDIA))
                .build()
            client.newCall(request).execute().use { response ->
-                if (!response.isSuccessful) return@withContext emptyList()
-                val body = response.body?.string() ?: return@withContext emptyList()
-                val parsed = json.decodeFromString<MessageListResponse>(body)
-                parsed.data ?: parsed.items ?: parsed.messages ?: emptyList()
+                if (!response.isSuccessful) {
+                    Log.w(TAG, "Set session $field failed: HTTP ${response.code}")
+                }
+                response.isSuccessful
            }
        } catch (e: Exception) {
-            Log.w(TAG, "Failed to get messages: ${e.message}")
+            Log.w(TAG, "Failed to set session $field: ${e.message}")
+            false
+        }
+    }
+
+    suspend fun getMessages(
+        sessionId: String,
+        mode: SessionMessageLoadMode = SessionMessageLoadMode.COMPLETE,
+    ): List<MessageItem> = withContext(Dispatchers.IO) {
+        loadSessionMessages(mode) { page ->
+            runCatching {
+                val url = "$baseUrl/api/sessions/$sessionId/messages".toHttpUrlOrNull()
+                    ?.newBuilder()
+                    ?.addQueryParameter("limit", page.limit.toString())
+                    ?.addQueryParameter("offset", page.offset.toString())
+                    ?.addQueryParameter("order", page.order)
+                    ?.build()
+                    ?: error("invalid session messages URL")
+                val request = authRequest(url.toString()).get().build()
+                client.newCall(request).execute().use { response ->
+                    if (!response.isSuccessful) error("HTTP ${response.code}")
+                    val body = response.body?.string() ?: error("empty response body")
+                    val parsed = json.decodeFromString<MessageListResponse>(body)
+                    SessionMessagePage(
+                        messages = parsed.data ?: parsed.items ?: parsed.messages ?: emptyList(),
+                        pagination = parsed.pagination,
+                        payloadChars = body.length,
+                    )
+                }
+            }
+        }.getOrElse { error ->
+            if (error is CancellationException) throw error
+            Log.w(TAG, "Failed to get messages: ${error.message}")
            emptyList()
        }
    }
@@ -4,17 +4,28 @@ import android.content.Context
 import com.hermesandroid.relay.auth.SessionTokenStore
 import com.hermesandroid.relay.auth.SecureStoreCache
 import com.hermesandroid.relay.auth.buildRawTokenStore
+import java.io.EOFException
 import java.io.IOException
+import java.io.InterruptedIOException
+import java.net.ConnectException
+import java.net.InetAddress
+import java.net.NoRouteToHostException
+import java.net.SocketException
+import java.net.UnknownHostException
 import java.security.MessageDigest
 import java.security.SecureRandom
+import java.util.Collections
+import java.util.IdentityHashMap
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
+import javax.net.ssl.SSLException
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import okhttp3.Authenticator
+import okhttp3.Dns
 import okhttp3.Interceptor
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
@@ -28,6 +39,7 @@ import okio.ByteString.Companion.toByteString
 private const val NATIVE_PKCE_FLOW = "native_pkce"
 private const val CALLBACK_PATH = "/callback"
 private const val TOKEN_KEY = "dashboard_native_tokens_json"
+private const val NATIVE_AUTH_DNS_RETRY_BACKOFF_MILLIS = 75L
 private val JSON_MEDIA = "application/json; charset=utf-8".toMediaType()

@Serializable
@@ -91,6 +103,8 @@ class NativeDashboardAuthClient(
    baseUrl: String,
    private val tokenStore: NativeDashboardTokenStore,
    private val client: OkHttpClient = OkHttpClient.Builder()
+        .dns(RetryingNativeAuthDns())
+        .retryOnConnectionFailure(false)
        .connectTimeout(10, TimeUnit.SECONDS)
        .readTimeout(15, TimeUnit.SECONDS)
        .writeTimeout(15, TimeUnit.SECONDS)
@@ -271,12 +285,19 @@ class NativeDashboardAuthClient(
                }
                throw NativeDashboardAuthHttpException(response.code)
            }
-            val body = response.body?.string().orEmpty()
+            val body = response.body.string()
            runCatching { json.decodeFromString<NativeDashboardTokens>(body) }
-                .getOrElse { throw IOException("Dashboard token response was malformed", it) }
+                .getOrElse {
+                    throw NativeDashboardTokenShapeException(
+                        "Dashboard token response was malformed",
+                        it,
+                    )
+                }
                .also {
                    if (it.accessToken.isBlank()) {
-                        throw IOException("Dashboard token response did not include an access token")
+                        throw NativeDashboardTokenShapeException(
+                            "Dashboard token response did not include an access token",
+                        )
                    }
                }
        }
@@ -285,7 +306,7 @@ class NativeDashboardAuthClient(
                NativeTokenRefreshCoordinator.currentGeneration(tokenStore.coordinationKey) !=
                expectedGeneration
            ) {
-                throw IOException("Dashboard sign-in is no longer active")
+                throw NativeDashboardInactiveAuthorizationException()
            }
            tokenStore.save(tokens)
        }
@@ -312,6 +333,42 @@ class NativeDashboardAuthClient(
    }
 }

+/**
+ * Retries only the name lookup that precedes a native-auth request. The HTTP
+ * call itself remains single-shot, so a one-time authorization code is never
+ * replayed after the server may have consumed it.
+ */
+internal class RetryingNativeAuthDns(
+    private val delegate: Dns = Dns.SYSTEM,
+    private val backoffMillis: Long = NATIVE_AUTH_DNS_RETRY_BACKOFF_MILLIS,
+    private val sleeper: (Long) -> Unit = { Thread.sleep(it) },
+) : Dns {
+    override fun lookup(hostname: String): List<InetAddress> {
+        val firstFailure = try {
+            return delegate.lookup(hostname)
+        } catch (error: UnknownHostException) {
+            error
+        }
+
+        if (backoffMillis > 0L) {
+            try {
+                sleeper(backoffMillis)
+            } catch (interrupted: InterruptedException) {
+                Thread.currentThread().interrupt()
+                firstFailure.addSuppressed(interrupted)
+                throw firstFailure
+            }
+        }
+
+        return try {
+            delegate.lookup(hostname)
+        } catch (secondFailure: UnknownHostException) {
+            secondFailure.addSuppressed(firstFailure)
+            throw secondFailure
+        }
+    }
+}
+
 internal class NativeDashboardCallbackException(
    message: String,
    val retryable: Boolean = true,
@@ -430,10 +487,56 @@ class DashboardBearerAuth(
    }
 }

-private class NativeDashboardAuthHttpException(
+internal class NativeDashboardAuthHttpException(
    val statusCode: Int,
 ) : IOException("Dashboard native authentication failed (HTTP $statusCode)")

+internal class NativeDashboardTokenShapeException(
+    message: String,
+    cause: Throwable? = null,
+) : IOException(message, cause)
+
+internal class NativeDashboardInactiveAuthorizationException :
+    IOException("Dashboard sign-in is no longer active")
+
+internal fun nativeDashboardSignInFailureStage(error: Throwable): String {
+    error.firstCauseOfType<NativeDashboardCallbackException>()?.let { return "callback_error" }
+    error.firstCauseOfType<NativeDashboardAuthHttpException>()?.let {
+        return "token_http_${it.statusCode}"
+    }
+    if (error.firstCauseOfType<NativeDashboardTokenShapeException>() != null) return "token_shape"
+    if (error.firstCauseOfType<NativeDashboardInactiveAuthorizationException>() != null) {
+        return "inactive_generation"
+    }
+    if (error.firstCauseOfType<InterruptedIOException>() != null) return "token_transport_timeout"
+    if (error.firstCauseOfType<UnknownHostException>() != null) return "token_transport_dns"
+    if (error.firstCauseOfType<ConnectException>() != null ||
+        error.firstCauseOfType<NoRouteToHostException>() != null
+    ) {
+        return "token_transport_connect"
+    }
+    if (error.firstCauseOfType<SSLException>() != null) return "token_transport_tls"
+    if (error.firstCauseOfType<SocketException>() != null ||
+        error.firstCauseOfType<EOFException>() != null
+    ) {
+        return "token_transport_socket"
+    }
+    return if (error.firstCauseOfType<IOException>() != null) "token_transport" else "token_store"
+}
+
+internal fun nativeDashboardSignInFailureDiagnostic(error: Throwable): String =
+    "dashboard_native_pkce_failed stage=${nativeDashboardSignInFailureStage(error)}"
+
+private inline fun <reified T : Throwable> Throwable.firstCauseOfType(): T? {
+    val seen = Collections.newSetFromMap(IdentityHashMap<Throwable, Boolean>())
+    var current: Throwable? = this
+    while (current != null && seen.add(current)) {
+        if (current is T) return current
+        current = current.cause
+    }
+    return null
+}
+
 private object NativeTokenRefreshCoordinator {
    private val locks = ConcurrentHashMap<String, Any>()
    private val generations = ConcurrentHashMap<String, Long>()
@@ -1,5 +1,6 @@
 package com.hermesandroid.relay.network.upstream

+import com.hermesandroid.relay.BuildConfig
 import java.io.IOException
 import java.io.InputStream
 import java.net.InetAddress
@@ -7,6 +8,7 @@ import java.net.InetSocketAddress
 import java.net.ServerSocket
 import java.net.Socket
 import java.net.SocketTimeoutException
+import java.security.MessageDigest
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.TimeoutCancellationException
 import kotlinx.coroutines.currentCoroutineContext
@@ -14,12 +16,44 @@ import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
+import okio.ByteString.Companion.toByteString

 private const val CALLBACK_PATH = "/callback"
 private const val MAX_REQUEST_LINE_BYTES = 8 * 1024
 private const val MAX_HEADER_BYTES = 16 * 1024
 private const val ACCEPT_POLL_MILLIS = 500
 internal const val DEFAULT_NATIVE_SIGN_IN_TIMEOUT_MILLIS = 2 * 60 * 1000L
+internal val NATIVE_SIGN_IN_RETURN_URI = "${BuildConfig.APPLICATION_ID}://return"
+
+private enum class CallbackPage(
+    val modifier: String,
+    val eyebrow: String,
+    val title: String,
+    val message: String,
+    val guidance: String,
+) {
+    Success(
+        modifier = "success",
+        eyebrow = "Secure sign-in",
+        title = "Sign-in complete",
+        message = "Your secure session is ready in Hermes Relay.",
+        guidance = "Return to Hermes Relay to continue.",
+    ),
+    Failure(
+        modifier = "failure",
+        eyebrow = "Secure sign-in",
+        title = "Sign-in needs another try",
+        message = "No session details were saved from this attempt.",
+        guidance = "Return to Hermes Relay and start sign-in again.",
+    ),
+    Rejected(
+        modifier = "rejected",
+        eyebrow = "Protected callback",
+        title = "Callback not accepted",
+        message = "Hermes Relay ignored this request to protect your sign-in.",
+        guidance = "Return to the app and continue the sign-in already in progress.",
+    ),
+}

 internal enum class DashboardRedirectAuthMode {
    NativePkce,
@@ -119,7 +153,7 @@ class NativeDashboardSignInCoordinator(
                    writeResponse(
                        socket,
                        status = "403 Forbidden",
-                        body = "This sign-in callback was not accepted.",
+                        page = CallbackPage.Rejected,
                    )
                    return@use null
                }
@@ -132,7 +166,7 @@ class NativeDashboardSignInCoordinator(
                    writeResponse(
                        socket,
                        status = "400 Bad Request",
-                        body = "This sign-in callback was not accepted.",
+                        page = CallbackPage.Rejected,
                    )
                    return@use null
                }
@@ -145,7 +179,7 @@ class NativeDashboardSignInCoordinator(
                        writeResponse(
                            socket,
                            status = "200 OK",
-                            body = "Sign-in complete. You can return to Hermes Relay.",
+                            page = CallbackPage.Success,
                        )
                    }
                } catch (error: NativeDashboardCallbackException) {
@@ -153,21 +187,21 @@ class NativeDashboardSignInCoordinator(
                        writeResponse(
                            socket,
                            status = "400 Bad Request",
-                            body = "This sign-in callback was not accepted.",
+                            page = CallbackPage.Rejected,
                        )
                        return@use null
                    }
                    writeResponse(
                        socket,
                        status = "400 Bad Request",
-                        body = "Sign-in could not be completed. Return to Hermes Relay and try again.",
+                        page = CallbackPage.Failure,
                    )
                    throw error
                } catch (error: Exception) {
                    writeResponse(
                        socket,
                        status = "400 Bad Request",
-                        body = "Sign-in could not be completed. Return to Hermes Relay and try again.",
+                        page = CallbackPage.Failure,
                    )
                    throw error
                }
@@ -237,17 +271,20 @@ class NativeDashboardSignInCoordinator(
        throw IOException("Native sign-in callback line was too large")
    }

-    private fun writeResponse(socket: Socket, status: String, body: String) {
-        val html = """
-            <!doctype html>
-            <html><head><meta name="viewport" content="width=device-width,initial-scale=1"></head>
-            <body><p>${escapeHtml(body)}</p></body></html>
-        """.trimIndent().toByteArray(Charsets.UTF_8)
+    private fun writeResponse(socket: Socket, status: String, page: CallbackPage) {
+        val html = callbackPageHtml(page).toByteArray(Charsets.UTF_8)
        val headers = buildString {
            append("HTTP/1.1 ").append(status).append("\r\n")
            append("Content-Type: text/html; charset=utf-8\r\n")
            append("Content-Length: ").append(html.size).append("\r\n")
            append("Cache-Control: no-store\r\n")
+            append("Pragma: no-cache\r\n")
+            append("Expires: 0\r\n")
+            append("Content-Security-Policy: ").append(CALLBACK_CSP).append("\r\n")
+            append("Referrer-Policy: no-referrer\r\n")
+            append("X-Content-Type-Options: nosniff\r\n")
+            append("X-Frame-Options: DENY\r\n")
+            append("Permissions-Policy: camera=(), geolocation=(), microphone=(), payment=(), usb=()\r\n")
            append("Connection: close\r\n\r\n")
        }.toByteArray(Charsets.US_ASCII)
        runCatching {
@@ -259,8 +296,63 @@ class NativeDashboardSignInCoordinator(
        }
    }

-    private fun escapeHtml(value: String): String =
-        value.replace("&", "&amp;")
-            .replace("<", "&lt;")
-            .replace(">", "&gt;")
+    private fun callbackPageHtml(page: CallbackPage): String = """
+        <!doctype html>
+        <html lang="en">
+        <head>
+          <meta charset="utf-8">
+          <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
+          <meta name="color-scheme" content="dark">
+          <title>${page.title} · Hermes Relay</title>
+          <style>$CALLBACK_STYLE</style>
+        </head>
+        <body>
+          <main class="shell">
+            <section class="card ${page.modifier}" aria-labelledby="page-title" aria-describedby="page-message page-guidance">
+              <div class="status-rail" aria-hidden="true"></div>
+              <p class="brand">Hermes Relay</p>
+              <p class="eyebrow">${page.eyebrow}</p>
+              <h1 id="page-title" tabindex="-1">${page.title}</h1>
+              <p id="page-message" class="message">${page.message}</p>
+              <p id="page-guidance" class="guidance">${page.guidance}</p>
+              <a class="return-link" href="$NATIVE_SIGN_IN_RETURN_URI">Return to Hermes Relay</a>
+            </section>
+          </main>
+        </body>
+        </html>
+    """.trimIndent()
+
+    private companion object {
+        private val CALLBACK_STYLE = """
+            :root{color-scheme:dark;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;background:#08090d;color:#f7f4ff}
+            *{box-sizing:border-box}
+            body{margin:0;min-height:100vh;min-height:100svh;background:#08090d}
+            .shell{min-height:100vh;min-height:100svh;display:grid;place-items:center;padding:max(24px,env(safe-area-inset-top)) max(20px,env(safe-area-inset-right)) max(24px,env(safe-area-inset-bottom)) max(20px,env(safe-area-inset-left))}
+            .card{position:relative;width:min(100%,460px);overflow:hidden;border:1px solid #2d2938;border-radius:18px;background:#111219;padding:32px 28px 28px;box-shadow:0 18px 48px rgba(0,0,0,.34);animation:card-in 220ms ease-out both}
+            .status-rail{position:absolute;inset:0 auto 0 0;width:4px;background:#9b6bf0}
+            .success .status-rail{background:#55d98b}.failure .status-rail{background:#ff7188}
+            .brand{margin:0 0 28px;color:#bba4f5;font-size:.78rem;font-weight:750;letter-spacing:.12em;text-transform:uppercase}
+            .eyebrow{margin:0 0 8px;color:#cac4d8;font-size:.9rem;font-weight:650}
+            h1{margin:0;color:#fff;font-size:clamp(1.8rem,8vw,2.45rem);font-weight:720;letter-spacing:-.035em;line-height:1.08;outline:none}
+            h1:focus-visible{outline:2px solid #9b6bf0;outline-offset:6px;border-radius:3px}
+            .message{margin:18px 0 0;color:#eeeaf7;font-size:1.04rem;line-height:1.6}
+            .guidance{margin:12px 0 0;color:#bdb7c9;font-size:.95rem;line-height:1.55}
+            .return-link{display:block;width:100%;margin-top:26px;border:1px solid #8c5ef0;border-radius:12px;background:#6b35e8;color:#fff;padding:13px 18px;font:inherit;font-weight:700;text-align:center;text-decoration:none;cursor:pointer}
+            .return-link:hover{border-color:#c4a8ff}.return-link:focus-visible{outline:3px solid #c4a8ff;outline-offset:3px}.return-link:active{background:#5d28d3}
+            @keyframes card-in{from{opacity:0;transform:translateY(8px)}to{opacity:1;transform:none}}
+            @media (prefers-reduced-motion:reduce){*,*::before,*::after{animation:none!important;scroll-behavior:auto!important;transition:none!important}}
+            @media (max-width:380px){.card{padding:28px 22px 24px;border-radius:16px}}
+        """.trimIndent()
+
+        private fun cspHash(value: String): String = MessageDigest.getInstance("SHA-256")
+            .digest(value.toByteArray(Charsets.UTF_8))
+            .toByteString()
+            .base64()
+
+        private val CALLBACK_CSP = buildString {
+            append("default-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'; ")
+            append("img-src 'none'; connect-src 'none'; object-src 'none'; script-src 'none'; ")
+            append("style-src 'sha256-").append(cspHash(CALLBACK_STYLE)).append("'")
+        }
+    }
 }
@@ -0,0 +1,78 @@
+package com.hermesandroid.relay.network.upstream
+
+import com.hermesandroid.relay.network.upstream.models.MessageItem
+import com.hermesandroid.relay.network.upstream.models.MessagePagination
+import kotlinx.coroutines.CancellationException
+
+/** Explicit transcript read intent for Hermes' bounded messages endpoint. */
+enum class SessionMessageLoadMode {
+    /** One bounded newest-first window, returned in chronological order. */
+    LATEST,
+
+    /** Every page, oldest first, subject to Android memory safety bounds. */
+    COMPLETE,
+}
+
+internal const val SESSION_MESSAGE_PAGE_SIZE = 500
+private const val MAX_COMPLETE_TRANSCRIPT_MESSAGES = 50_000
+private const val MAX_COMPLETE_TRANSCRIPT_PAYLOAD_CHARS = 32_000_000
+
+internal data class SessionMessagePageRequest(
+    val limit: Int = SESSION_MESSAGE_PAGE_SIZE,
+    val offset: Int = 0,
+    val order: String,
+)
+
+internal data class SessionMessagePage(
+    val messages: List<MessageItem>,
+    val pagination: MessagePagination?,
+    val payloadChars: Int,
+)
+
+internal class SessionTranscriptTooLargeException(message: String) : IllegalStateException(message)
+
+/** Shared API-server/dashboard pagination contract. Legacy unpaginated envelopes remain valid. */
+internal suspend fun loadSessionMessages(
+    mode: SessionMessageLoadMode,
+    fetchPage: suspend (SessionMessagePageRequest) -> Result<SessionMessagePage>,
+): Result<List<MessageItem>> {
+    return try {
+        val order = if (mode == SessionMessageLoadMode.LATEST) "latest" else "oldest"
+        val collected = ArrayList<MessageItem>()
+        var offset = 0
+        var payloadChars = 0L
+
+        while (true) {
+            val request = SessionMessagePageRequest(offset = offset, order = order)
+            val page = fetchPage(request).getOrThrow()
+            payloadChars += page.payloadChars
+            if (payloadChars > MAX_COMPLETE_TRANSCRIPT_PAYLOAD_CHARS) {
+                throw SessionTranscriptTooLargeException(
+                    "Session transcript exceeds Android's 32 MB safe-load limit",
+                )
+            }
+            if (collected.size + page.messages.size > MAX_COMPLETE_TRANSCRIPT_MESSAGES) {
+                throw SessionTranscriptTooLargeException(
+                    "Session transcript exceeds Android's 50,000-message safe-load limit",
+                )
+            }
+            collected += page.messages
+
+            if (mode == SessionMessageLoadMode.LATEST) break
+            // Older Hermes returned one unpaginated complete envelope. Never issue
+            // a speculative second request against that contract.
+            val pagination = page.pagination ?: break
+            val returned = pagination.returned ?: page.messages.size
+            if (page.messages.isEmpty() || returned < request.limit || page.messages.size < request.limit) break
+
+            val nextOffset = offset + page.messages.size
+            if (nextOffset <= offset) break
+            offset = nextOffset
+        }
+        Result.success(collected)
+    } catch (error: CancellationException) {
+        throw error
+    } catch (error: Throwable) {
+        Result.failure(error)
+    }
+}
@@ -142,6 +142,8 @@ data class SessionItem(
    val preview: String? = null,
    val model: String? = null,
    val source: String? = null,
+    /** Owning profile on the cross-profile `/api/profiles/sessions` endpoint. */
+    val profile: String? = null,
    @SerialName("started_at")
    @Serializable(with = FlexibleTimestampSerializer::class)
    val startedAt: Double? = null,
@@ -165,6 +167,9 @@ data class SessionItem(
    @SerialName("input_tokens") val inputTokens: Int? = null,
    @SerialName("output_tokens") val outputTokens: Int? = null,
    @SerialName("has_model_config") val hasModelConfig: Boolean = false,
+    /** Durable flags returned by current Dashboard and API-server session resources. */
+    val pinned: Boolean = false,
+    val archived: Boolean = false,
 ) {
    val resolvedLastActivity: Double?
        get() = lastActive ?: lastActivity ?: lastActivityAt ?: updatedAt
@@ -241,7 +246,16 @@ data class MessageListResponse(
    val items: List<MessageItem>? = null,
    val messages: List<MessageItem>? = null, // alternate key
    val data: List<MessageItem>? = null, // upstream /api/sessions/{id}/messages list envelope
-    val total: Int? = null
+    val total: Int? = null,
+    val pagination: MessagePagination? = null,
+)
+
+@Serializable
+data class MessagePagination(
+    val limit: Int? = null,
+    val offset: Int? = null,
+    val order: String? = null,
+    val returned: Int? = null,
 )

@Serializable
@@ -176,10 +176,12 @@ internal class HermesRuntimeBinder(
        chat.setDisplayProfileProvider { connection.effectiveDisplayProfile.value }
        chat.setDisplayAliasProvider { connection.profileDisplayAlias.value }
        chat.setProfileSessionLister { connection.listProfileScopedSessions() }
-        chat.setProfileMessageLoader(connection::loadProfileScopedMessages)
+        chat.setProfileMessageLoaderWithMode(connection::loadProfileScopedMessages)
        chat.setDashboardConfigLoader { connection.loadActiveDashboardConfig() }
        chat.profileSessionDeleter = connection::deleteProfileScopedSession
        chat.profileSessionRenamer = connection::renameProfileScopedSession
+        chat.profileSessionPinner = connection::setProfileScopedSessionPinned
+        chat.profileSessionArchiver = connection::setProfileScopedSessionArchived
        chat.onSessionChanged = connection::saveLastSessionId
        chat.setDemoModeWiring(
            isDemo = { connection.isDemoMode.value },
@@ -59,6 +59,7 @@ import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalWindowInfo
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.unit.dp
@@ -96,13 +97,16 @@ import com.hermesandroid.relay.ui.components.avatar.LocalPetPlaybackSpeed
 import com.hermesandroid.relay.ui.components.avatar.LocalPetStabilize
 import com.hermesandroid.relay.ui.components.avatar.PetLoader
 import com.hermesandroid.relay.ui.components.avatar.SphereAvatar
+import com.hermesandroid.relay.ui.components.avatar.resolveBackgroundAvatar
 import com.hermesandroid.relay.ui.components.FloatingPetCompanion
 import com.hermesandroid.relay.ui.components.shouldCompactFloatingPet
 import com.hermesandroid.relay.ui.components.pet.LocalPetCompanionCoordinator
 import com.hermesandroid.relay.ui.components.pet.LocalPetSafeAreaRegistry
 import com.hermesandroid.relay.ui.components.pet.PetCompanionCoordinator
+import com.hermesandroid.relay.ui.components.pet.PetInteractionLayer
 import com.hermesandroid.relay.ui.components.pet.PetSafeAreaRegistry
 import com.hermesandroid.relay.ui.components.pet.petPerchSurface
+import com.hermesandroid.relay.ui.components.pet.platformModalOwnsPetLayer
 import com.hermesandroid.relay.ui.components.ConnectionSwitcherSheet
 import com.hermesandroid.relay.ui.components.ChatTransportStatusBadge
 import com.hermesandroid.relay.ui.components.ChatTransportTier
@@ -135,6 +139,7 @@ import com.hermesandroid.relay.ui.onboarding.OnboardingScreen
 import com.hermesandroid.relay.ui.screens.AboutScreen
 import com.hermesandroid.relay.ui.screens.AnalyticsScreen
 import com.hermesandroid.relay.ui.screens.AppearanceSettingsScreen
+import com.hermesandroid.relay.ui.screens.CustomPetGuideScreen
 import com.hermesandroid.relay.ui.screens.PetdexBrowseScreen
 import com.hermesandroid.relay.ui.screens.BridgeCoreScreen
 import com.hermesandroid.relay.ui.screens.DiagnosticsScreen
@@ -272,6 +277,20 @@ internal fun shouldShowConnectionFooter(
    presentationMode: VoicePresentationMode,
 ): Boolean = !voiceMode || presentationMode == VoicePresentationMode.Conversation

+/**
+ * Full-screen setup owns the whole window. Keeping connection-dependent app
+ * chrome composed behind it makes that chrome rebuild while Add connection
+ * swaps to its placeholder, visibly resizing the entering setup surface.
+ */
+internal fun shouldSuppressGlobalChrome(
+    onboardingCompleted: Boolean,
+    isDemoMode: Boolean,
+    currentRoute: String?,
+): Boolean =
+    (!onboardingCompleted && !isDemoMode) ||
+        currentRoute == Screen.Onboarding.route ||
+        currentRoute == Screen.Pair.route
+
 internal const val APP_STATUS_PET_WALK_REGION = "app-status-footer"

 /**
@@ -451,6 +470,7 @@ sealed class Screen(
    data object MediaSettings : Screen("settings/media", "Media", Icons.Filled.Settings)
    data object AppearanceSettings : Screen("settings/appearance", "Appearance", Icons.Filled.Settings)
    data object PetdexBrowse : Screen("settings/appearance/petdex", "Petdex", Icons.Filled.Settings)
+    data object CustomPetGuide : Screen("settings/appearance/custom-pet", "Create a pet", Icons.Filled.Settings)
    data object Analytics : Screen("settings/analytics", "Analytics", Icons.Filled.Settings)
    data object Diagnostics : Screen("settings/diagnostics", "Diagnostics", Icons.Filled.Settings)
    data object DeveloperSettings : Screen("settings/developer", "Developer", Icons.Filled.Settings)
@@ -684,16 +704,20 @@ fun RelayApp() {
    val appThemeId by connectionViewModel.appTheme.collectAsState()
    val fontScale by connectionViewModel.fontScale.collectAsState()
    val appFontId by connectionViewModel.appFont.collectAsState()
+    val appearanceAccent by connectionViewModel.appearanceAccent.collectAsState()
+    val appearanceShape by connectionViewModel.appearanceShape.collectAsState()

    // Resolve the active sphere skin (built-in / adaptive / user-loaded) and
    // publish it + the full available set so every MorphingSphere picks it up
    // via LocalSphereSkin without per-call-site threading. Adaptive skins read
    // the brand lazily inside MorphingSphere, so this can sit outside the theme.
    val sphereSkinId by connectionViewModel.sphereSkin.collectAsState()
+    val appearanceAssetsRefreshTick by connectionViewModel.avatarsRefreshTick.collectAsState()
    val sphereContext = androidx.compose.ui.platform.LocalContext.current
    val availableSphereSkins by produceState(
        initialValue = SphereRegistry.builtIns,
        key1 = sphereContext,
+        key2 = appearanceAssetsRefreshTick,
    ) {
        value = SphereRegistry.builtIns +
            withContext(Dispatchers.IO) { SphereSkinLoader.loadUserSkins(sphereContext) }
@@ -706,14 +730,14 @@ fun RelayApp() {
        )
    }

-    // Ambient visualization and pet companionship are independent. Existing
-    // LocalAgentAvatar call sites keep rendering the sphere; a selected pet is
-    // published separately for the floating companion surface.
+    // Central/background visualization and pet companionship are independent.
+    // LocalAgentAvatar owns the central surfaces; LocalFloatingPet owns roaming.
    val floatingPetId by connectionViewModel.floatingPet.collectAsState()
+    val backgroundAvatarId by connectionViewModel.backgroundAvatar.collectAsState()
    // Re-scans the pets/ dir whenever the tick bumps (in-app import/delete, or the
    // Appearance screen opening), so newly added/removed pets appear everywhere
    // without an app restart.
-    val avatarsRefreshTick by connectionViewModel.avatarsRefreshTick.collectAsState()
+    val avatarsRefreshTick = appearanceAssetsRefreshTick
    val availablePets by produceState(
        initialValue = emptyList<AgentAvatar>(),
        key1 = sphereContext,
@@ -724,6 +748,10 @@ fun RelayApp() {
    val activeFloatingPet = remember(floatingPetId, availablePets) {
        availablePets.firstOrNull { it.id == floatingPetId }
    }
+    var floatingPetMenuExpanded by remember(activeFloatingPet?.id) { mutableStateOf(false) }
+    val activeBackgroundAvatar = remember(backgroundAvatarId, availablePets) {
+        resolveBackgroundAvatar(backgroundAvatarId, availablePets)
+    }
    val petSpeed by connectionViewModel.petSpeed.collectAsState()
    val petStabilize by connectionViewModel.petStabilize.collectAsState()
    val petRoamingEnabled by connectionViewModel.petRoamingEnabled.collectAsState()
@@ -804,7 +832,7 @@ fun RelayApp() {
    CompositionLocalProvider(
        LocalSphereSkin provides activeSphereSkin,
        LocalAvailableSphereSkins provides availableSphereSkins,
-        LocalAgentAvatar provides SphereAvatar,
+        LocalAgentAvatar provides activeBackgroundAvatar,
        // Compatibility list for the existing Appearance picker during the
        // transition; new companion UI consumes LocalAvailablePets.
        LocalAvailableAvatars provides listOf(SphereAvatar) + availablePets,
@@ -817,11 +845,23 @@ fun RelayApp() {
        LocalPetSafeAreaRegistry provides petSafeAreaRegistry,
        LocalAgentIconPath provides agentIconPath,
    ) {
+        // Dialogs and modal sheets use their own focused window. Treat that
+        // focus handoff as an app-wide interaction layer so a dock-only pet on
+        // any route cannot remain visible beneath modal chrome.
+        PetInteractionLayer(
+            owner = "platform-modal-window",
+            active = platformModalOwnsPetLayer(
+                windowFocused = LocalWindowInfo.current.isWindowFocused,
+                petMenuExpanded = floatingPetMenuExpanded,
+            ),
+        )
    HermesRelayTheme(
        appThemeId = appThemeId,
        themePreference = themePreference,
        fontScale = fontScale,
        appFontId = appFontId,
+        accentHex = appearanceAccent,
+        shapeId = appearanceShape,
    ) {
        // Surface a crash report from a previous session, if any. Renders a
        // platform Dialog (own window) so tree position is z-order-agnostic;
@@ -907,8 +947,11 @@ fun RelayApp() {

        val navBackStackEntry by navController.currentBackStackEntryAsState()
        val currentRoute = navBackStackEntry?.destination?.route
-        val isOnboarding = currentRoute == Screen.Onboarding.route
-        val suppressGlobalChrome = (!onboardingCompleted && !isDemoMode) || isOnboarding
+        val suppressGlobalChrome = shouldSuppressGlobalChrome(
+            onboardingCompleted = onboardingCompleted,
+            isDemoMode = isDemoMode,
+            currentRoute = currentRoute,
+        )

        // Safety net: landing on a real connect surface (onboarding or the
        // Connect/Pair wizard) while demo is still active — via the banner's
@@ -1034,6 +1077,22 @@ fun RelayApp() {
        val gatewayCurrentModel by chatViewModel.gatewayCurrentModel.collectAsState()
        val appReady by connectionViewModel.isReady.collectAsState()
        val initialChatSettled by chatViewModel.initialChatSettled.collectAsState()
+        // Android sharesheet handoff: wait until the configured chat context is
+        // settled, then ask ChatViewModel to own the new draft and composer
+        // prefill. Navigation is presentation-only; no composable writes chat
+        // stores or sends the shared text.
+        LaunchedEffect(navController, onboardingCompleted, initialChatSettled) {
+            if (!onboardingCompleted || !initialChatSettled) return@LaunchedEffect
+            com.hermesandroid.relay.util.SharedTextRequest.pending.collect { request ->
+                request ?: return@collect
+                if (chatViewModel.openSharedTextDraft(request.text)) {
+                    navController.navigate(Screen.Chat.route(openAgentSheet = false)) {
+                        launchSingleTop = true
+                    }
+                    com.hermesandroid.relay.util.SharedTextRequest.consume(request.id)
+                }
+            }
+        }
        // The SAME readiness signal ChatScreen renders its "Connect Standard
        // Hermes" CTA from (chat client exists + reachable verdict). The gate
        // must release on this — releasing on the resolver's earlier
@@ -1640,9 +1699,9 @@ fun RelayApp() {
                ) { backStackEntry ->
                    // Responsive bubble width based on screen width. The "Blend"
                    // chat look favors wider bubbles: on compact phones the cap is
-                    // raised so long turns fill most of the row (binding on the
-                    // available width minus the assistant avatar gutter) instead
-                    // of wrapping early in a narrow column.
+                    // raised so long turns fill most of the row instead of
+                    // wrapping early in a narrow column. Assistant identity
+                    // stays in the group header and does not reduce this cap.
                    val configuration = LocalConfiguration.current
                    val screenWidthDp = configuration.screenWidthDp.dp
                    val maxBubbleWidth = when {
@@ -2458,6 +2517,7 @@ fun RelayApp() {
                        connectionViewModel = connectionViewModel,
                        onBack = { navController.popBackStack() },
                        onBrowsePetdex = { navController.navigate(Screen.PetdexBrowse.route) },
+                        onCreatePet = { navController.navigate(Screen.CustomPetGuide.route) },
                    )
                }
                composable(Screen.PetdexBrowse.route) {
@@ -2466,6 +2526,20 @@ fun RelayApp() {
                        onBack = { navController.popBackStack() },
                    )
                }
+                composable(Screen.CustomPetGuide.route) {
+                    CustomPetGuideScreen(
+                        connectionViewModel = connectionViewModel,
+                        onBack = { navController.popBackStack() },
+                        onStartNewChat = { prompt ->
+                            chatViewModel.createNewChat()
+                            chatViewModel.stageComposerDraft(prompt)
+                            navController.navigate(Screen.Chat.route(openAgentSheet = false)) {
+                                popUpTo(Screen.Chat.route) { inclusive = false }
+                                launchSingleTop = true
+                            }
+                        },
+                    )
+                }
                composable(Screen.Analytics.route) {
                    AnalyticsScreen(
                        connectionViewModel = connectionViewModel,
@@ -2653,6 +2727,7 @@ fun RelayApp() {
                onOpenAppearance = {
                    navController.navigate(Screen.AppearanceSettings.route) { launchSingleTop = true }
                },
+                onMenuExpandedChanged = { floatingPetMenuExpanded = it },
                onExitTerrainDebug = {
                    petTerrainOverlayScope.launch {
                        FeatureFlags.setPetTerrainOverlayEnabled(sphereContext, false)
@@ -1,15 +1,20 @@
 package com.hermesandroid.relay.ui.components

+import androidx.compose.foundation.Image
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
+import com.hermesandroid.relay.R
 import java.io.File

 /**
@@ -28,6 +33,15 @@ fun AgentAvatarFace(name: String, letterStyle: TextStyle, modifier: Modifier = M
            contentScale = ContentScale.Crop,
            modifier = modifier.fillMaxSize(),
        )
+    } else if (name.equals("Hermes", ignoreCase = true)) {
+        Image(
+            painter = painterResource(R.drawable.splash_icon),
+            contentDescription = null,
+            contentScale = ContentScale.Fit,
+            modifier = modifier
+                .fillMaxSize()
+                .padding(2.dp),
+        )
    } else {
        Box(modifier = modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
            Text(
@@ -332,7 +332,7 @@ private fun decodeGalleryBitmap(bytes: ByteArray): android.graphics.Bitmap? {
        sample *= 2
    }
    val options = BitmapFactory.Options().apply { inSampleSize = sample }
-    return BitmapFactory.decodeByteArray(bytes, 0, bytes.size, options)
+    return decodeOrientedBitmap(bytes, options)
 }

 private const val GALLERY_COLUMNS = 2
@@ -4,7 +4,6 @@ package com.hermesandroid.relay.ui.components

 import android.content.Context
 import android.graphics.Bitmap
-import android.graphics.BitmapFactory
 import android.graphics.pdf.PdfRenderer
 import android.media.audiofx.Visualizer
 import android.net.Uri
@@ -697,7 +696,7 @@ private fun ImageBody(
                val decoded = withContext(Dispatchers.IO) {
                    runCatching {
                        val bytes = attachmentBytes(context, attachment)
-                        bytes?.let { BitmapFactory.decodeByteArray(it, 0, it.size)?.asImageBitmap() }
+                        bytes?.let { decodeOrientedBitmap(it)?.asImageBitmap() }
                    }.getOrNull()
                }
                if (decoded != null) bitmap = decoded else failed = true
@@ -304,10 +304,8 @@ private fun DataUrlChatImage(image: ChatInlineImage, maxWidth: Dp) {
            BitmapFactory.decodeByteArray(decoded.bytes, 0, decoded.bytes.size, bounds)
            val sample = inlineImageSampleSize(bounds.outWidth, bounds.outHeight)
                ?: return@withInlineImageDecodeLock DataUrlImagePhase.Rejected
-            val bitmap = BitmapFactory.decodeByteArray(
+            val bitmap = decodeOrientedBitmap(
                decoded.bytes,
-                0,
-                decoded.bytes.size,
                BitmapFactory.Options().apply {
                    inSampleSize = sample
                    inPreferredConfig = android.graphics.Bitmap.Config.ARGB_8888
@@ -482,7 +480,7 @@ private fun RelayServerImage(
                is ServerImageResult.Success -> {
                    val bytes = result.bytes
                    val bmp = runCatching {
-                        BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+                        decodeOrientedBitmap(bytes)
                    }.getOrNull()?.asImageBitmap()
                    if (bmp != null) {
                        putInlineImage(image.src, bmp, result.sensitive)
@@ -29,6 +29,8 @@ import androidx.compose.foundation.layout.widthIn
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.Send
 import androidx.compose.material.icons.filled.Add
@@ -58,8 +60,18 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.input.key.onPreviewKeyEvent
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import com.hermesandroid.relay.R
@@ -84,6 +96,7 @@ enum class ChatInputTrailing { SEND, VOICE, STOP, STEER, QUEUE }

 private val ChatComposerShape = RoundedCornerShape(18.dp)
 private val ChatInputChipShape = RoundedCornerShape(12.dp)
+internal const val CHAT_INPUT_FIELD_TEST_TAG = "chat-input-field"

 data class ChatInputPickerOption(
    val label: String,
@@ -174,7 +187,14 @@ fun ChatInputBar(
    modifier: Modifier = Modifier,
    surfaceModifier: Modifier = Modifier,
    enabled: Boolean = true,
+    physicalEnterSends: Boolean = true,
 ) {
+    val canSubmit = enabled && trailing in setOf(
+        ChatInputTrailing.SEND,
+        ChatInputTrailing.STEER,
+        ChatInputTrailing.QUEUE,
+    )
+
    // Keep the last caption around so the AnimatedVisibility exit doesn't
    // flash an empty line while collapsing.
    var lastCaption by remember { mutableStateOf<String?>(null) }
@@ -203,18 +223,57 @@ fun ChatInputBar(
    }

    Column(modifier = modifier.fillMaxWidth()) {
-        // Caption row — correct/queue hinting, single line, no buttons.
+        // Correction and queueing are materially different actions. Keep the
+        // explanation, but lead with a visible state pill so the distinction
+        // does not depend on the trailing icon or accent color alone.
        AnimatedVisibility(visible = caption != null) {
-            Text(
-                text = caption ?: lastCaption.orEmpty(),
-                style = relayMetadataStyle(),
-                color = if (trailing == ChatInputTrailing.STEER) {
-                    MaterialTheme.colorScheme.tertiary.copy(alpha = 0.9f)
-                } else {
-                    MaterialTheme.colorScheme.onSurfaceVariant
-                },
-                modifier = Modifier.padding(horizontal = 20.dp, vertical = 2.dp),
-            )
+            val detail = caption ?: lastCaption.orEmpty()
+            val actionLabel = when (trailing) {
+                ChatInputTrailing.STEER -> stringResource(R.string.chat_input_steer_response)
+                ChatInputTrailing.QUEUE -> stringResource(R.string.chat_input_queue_message)
+                else -> null
+            }
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 20.dp, vertical = 2.dp)
+                    .semantics {
+                        liveRegion = LiveRegionMode.Polite
+                        contentDescription = listOfNotNull(actionLabel, detail)
+                            .joinToString(separator = ". ")
+                    },
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                if (actionLabel != null) {
+                    Text(
+                        text = actionLabel,
+                        style = MaterialTheme.typography.labelSmall,
+                        color = if (trailing == ChatInputTrailing.STEER) {
+                            MaterialTheme.colorScheme.onTertiaryContainer
+                        } else {
+                            MaterialTheme.colorScheme.onSecondaryContainer
+                        },
+                        modifier = Modifier
+                            .clip(RoundedCornerShape(999.dp))
+                            .background(
+                                if (trailing == ChatInputTrailing.STEER) {
+                                    MaterialTheme.colorScheme.tertiaryContainer
+                                } else {
+                                    MaterialTheme.colorScheme.secondaryContainer
+                                },
+                            )
+                            .padding(horizontal = 8.dp, vertical = 3.dp),
+                    )
+                }
+                Text(
+                    text = detail,
+                    style = relayMetadataStyle(),
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                )
+            }
        }

        // Voice hint pill — floats above the trailing button.
@@ -290,9 +349,44 @@ fun ChatInputBar(
                        modifier = Modifier
                            .fillMaxWidth()
                            .heightIn(min = 34.dp)
-                            .padding(horizontal = 8.dp, vertical = 4.dp),
+                            .padding(horizontal = 8.dp, vertical = 4.dp)
+                            // Keep directional keys inside the editor. Compose's
+                            // BasicTextField owns normal caret/selection movement;
+                            // cancelling focus traversal prevents a boundary arrow
+                            // from jumping to a neighboring composer control.
+                            .focusProperties {
+                                left = FocusRequester.Cancel
+                                right = FocusRequester.Cancel
+                                up = FocusRequester.Cancel
+                                down = FocusRequester.Cancel
+                            }
+                            .onPreviewKeyEvent { event ->
+                                val native = event.nativeKeyEvent
+                                val isEnter = native.keyCode == android.view.KeyEvent.KEYCODE_ENTER ||
+                                    native.keyCode == android.view.KeyEvent.KEYCODE_NUMPAD_ENTER
+                                val isSubmitShortcut = native.isCtrlPressed || native.isMetaPressed
+                                if (native.action != android.view.KeyEvent.ACTION_DOWN || !isEnter) {
+                                    false
+                                } else if (isSubmitShortcut || (physicalEnterSends && !native.isShiftPressed)) {
+                                    if (canSubmit) onSend()
+                                    true
+                                } else {
+                                    // Shift+Enter always inserts a newline. When
+                                    // Enter is configured for newlines, the plain
+                                    // key also stays owned by BasicTextField.
+                                    false
+                                }
+                            }
+                            .testTag(CHAT_INPUT_FIELD_TEST_TAG),
                        maxLines = 5,
                        enabled = enabled,
+                        keyboardOptions = KeyboardOptions(
+                            capitalization = KeyboardCapitalization.Sentences,
+                            imeAction = ImeAction.Send,
+                        ),
+                        keyboardActions = KeyboardActions(
+                            onSend = { if (canSubmit) onSend() },
+                        ),
                        textStyle = MaterialTheme.typography.bodyLarge.copy(
                            color = MaterialTheme.colorScheme.onSurface,
                        ),
@@ -314,7 +408,7 @@ fun ChatInputBar(
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
-                        .heightIn(min = 40.dp),
+                        .heightIn(min = 48.dp),
                    verticalAlignment = Alignment.CenterVertically,
                    horizontalArrangement = Arrangement.spacedBy(4.dp),
                ) {
@@ -324,7 +418,7 @@ fun ChatInputBar(
                    Box {
                        Box(
                            modifier = Modifier
-                                .size(38.dp)
+                                .size(48.dp)
                                .clip(CircleShape)
                                .combinedClickable(
                                    onClick = { attachMenuExpanded = true },
@@ -0,0 +1,122 @@
+package com.hermesandroid.relay.ui.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ColorScheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.R
+import com.hermesandroid.relay.data.ChatQuoteReference
+
+internal data class ChatQuoteReferenceColors(
+    val background: Color,
+    val author: Color,
+    val excerpt: Color,
+    val accent: Color,
+)
+
+internal fun chatQuoteReferenceColors(colorScheme: ColorScheme) = ChatQuoteReferenceColors(
+    background = colorScheme.surfaceContainerHigh,
+    author = colorScheme.onSurface,
+    excerpt = colorScheme.onSurfaceVariant,
+    accent = colorScheme.primary,
+)
+
+/** Attachment-like quote reference used in both the composer and sent bubbles. */
+@Composable
+fun ChatQuoteReferenceChip(
+    reference: ChatQuoteReference,
+    modifier: Modifier = Modifier,
+    onOpenOriginal: (() -> Unit)? = null,
+    onRemove: (() -> Unit)? = null,
+) {
+    val openDescription = stringResource(R.string.chat_quote_open, reference.authorLabel)
+    val colors = chatQuoteReferenceColors(MaterialTheme.colorScheme)
+    Surface(
+        modifier = modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(8.dp),
+        color = colors.background,
+    ) {
+        Row(
+            modifier = Modifier
+                .then(
+                    onOpenOriginal?.let { open ->
+                        Modifier.clickable(
+                            role = Role.Button,
+                            onClickLabel = openDescription,
+                            onClick = open,
+                        )
+                    } ?: Modifier,
+                )
+                .semantics { contentDescription = "$openDescription. ${reference.excerpt}" }
+                .padding(start = 7.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Box(
+                modifier = Modifier
+                    .width(3.dp)
+                    .height(32.dp)
+                    .clip(RoundedCornerShape(99.dp))
+                    .background(colors.accent),
+            )
+            Column(
+                modifier = Modifier
+                    .weight(1f)
+                    .padding(horizontal = 8.dp, vertical = 5.dp),
+            ) {
+                Text(
+                    text = "@${reference.authorLabel}",
+                    style = MaterialTheme.typography.labelMedium,
+                    fontWeight = FontWeight.Medium,
+                    color = colors.author,
+                )
+                Text(
+                    text = reference.excerpt,
+                    style = MaterialTheme.typography.labelSmall,
+                    color = colors.excerpt,
+                    maxLines = 2,
+                    overflow = TextOverflow.Ellipsis,
+                )
+            }
+            if (onRemove != null) {
+                IconButton(
+                    onClick = onRemove,
+                    modifier = Modifier.size(48.dp),
+                ) {
+                    Icon(
+                        imageVector = Icons.Filled.Close,
+                        contentDescription = stringResource(R.string.chat_quote_remove),
+                        tint = colors.excerpt,
+                        modifier = Modifier.size(18.dp),
+                    )
+                }
+            }
+        }
+    }
+}
@@ -64,6 +64,10 @@ data class SlashCommand(
     * instead of plain text.
     */
    val source: String? = null,
+    /** Bounded server-recorded skill usage; zero for non-skill commands. */
+    val usageRank: Int = 0,
+    /** Sanitized server skill origin such as local or bundled. */
+    val origin: String? = null,
 ) {
    companion object {
        const val SOURCE_SERVER = "server"
@@ -5,9 +5,11 @@ import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.ScrollState
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.Row
@@ -15,6 +17,7 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -32,6 +35,7 @@ import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
 import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.Bolt
 import androidx.compose.material.icons.filled.ChatBubble
+import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.ContentCopy
 import androidx.compose.material.icons.filled.Edit
 import androidx.compose.material.icons.filled.Language
@@ -83,6 +87,7 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.ClipEntry
 import androidx.compose.ui.platform.LocalClipboard
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
@@ -679,7 +684,6 @@ fun RelayInfoSheet(
 // the Profile section footer spells out the override.

 private enum class AgentPassportPicker {
-    Profile,
    Personality,
    Model,
    Reasoning,
@@ -694,7 +698,6 @@ fun AgentInfoSheet(
    onNavigateToConnections: () -> Unit,
    onNavigateToProfileInspector: (String) -> Unit = {},
 ) {
-    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
    val agentProfiles by connectionViewModel.agentProfiles.collectAsState()
    val selectedProfile by connectionViewModel.selectedProfile.collectAsState()
    val resolvedProfile by connectionViewModel.effectiveDisplayProfile.collectAsState()
@@ -758,6 +761,7 @@ fun AgentInfoSheet(

    var selectedTab by remember { mutableStateOf(0) }
    var activePicker by remember { mutableStateOf<AgentPassportPicker?>(null) }
+    var showProfileSwitcher by remember { mutableStateOf(false) }
    var showIdentityEditor by remember { mutableStateOf(false) }
    var showProfileManager by remember { mutableStateOf(false) }

@@ -767,6 +771,20 @@ fun AgentInfoSheet(
    val currentSession = remember(sessions, currentSessionId) {
        sessions.firstOrNull { it.sessionId == currentSessionId }
    }
+    val sessionModelState = resolveSessionModelUiState(
+        hasSession = currentSessionId != null,
+        pendingModel = selectedModel,
+        pendingProvider = selectedProvider,
+        gatewayModel = gatewayModel,
+        gatewayProvider = gatewayProvider,
+        persistedSessionModel = currentSession?.model,
+        profileDefaultModel = resolvedProfile?.model,
+        serverDefaultModel = serverModel,
+    )
+    val sessionPickerProvider = sessionModelState.pickerProvider
+        ?: sessionModelState.pickerModel?.let { model ->
+            modelProviders.singleOrNull { model in it.models }?.slug
+        }
    val agentName = AgentDisplay.agentName(
        profile = resolvedProfile,
        selectedPersonality = selectedPersonality,
@@ -778,25 +796,22 @@ fun AgentInfoSheet(
        AgentDisplay.profileDisplayName(it) ?: it.name
    } ?: stringResource(R.string.conn_info_server_default)
    val serverDefaultLabel = stringResource(R.string.conn_info_server_default)
-    val modelLabel = AgentDisplay.displayModelName(selectedModel ?: gatewayModel)
-        ?: AgentDisplay.displayModelName(resolvedProfile?.model)
-        ?: AgentDisplay.displayModelName(serverModel)
+    val modelLabel = AgentDisplay.displayModelName(sessionModelState.model)
        ?: serverDefaultLabel
    val serverDefaultModelLabel = AgentDisplay.displayModelName(serverModel)
        ?: AgentDisplay.displayModelName(resolvedProfile?.model)
    val providerLabel = modelProviders
-        .firstOrNull { it.slug.equals(gatewayProvider, ignoreCase = true) }
+        .firstOrNull { it.slug.equals(sessionModelState.provider, ignoreCase = true) }
        ?.name
        ?.takeIf { it.isNotBlank() }
-        ?: gatewayProvider.takeIf { it.isNotBlank() }
-    val sessionModelLabel = AgentDisplay.displayModelName(currentSession?.model)
-        ?: modelLabel
-    val sessionProviderLabel = currentSession?.model
+        ?: sessionModelState.provider
+    val sessionModelLabel = modelLabel
+    val sessionProviderLabel = sessionModelState.model
        ?.takeIf { it.isNotBlank() }
        ?.let { sessionModel ->
            modelProviders.firstOrNull { sessionModel in it.models }?.name
        }
-        ?: providerLabel.takeIf { currentSession?.model.isNullOrBlank() }
+        ?: providerLabel
    val connected = chatReady
    val resolvedPresence = resolvedProfile?.let {
        ProfilePresenceResolver.resolve(it, connected)
@@ -846,6 +861,9 @@ fun AgentInfoSheet(
        apiModelOptions,
        agentProfiles,
        selectedModel,
+        selectedProvider,
+        sessionModelState,
+        sessionPickerProvider,
        modelLabel,
        unavailableModelLabel,
        modelNeedsSetupLabel,
@@ -866,7 +884,7 @@ fun AgentInfoSheet(
                    label = serverDefaultLabel,
                    value = null,
                    secondary = serverDefaultModelLabel,
-                    selected = selectedModel == null,
+                    selected = sessionModelState.inheritsProfileDefault,
                ),
            )
            modelProviders
@@ -886,7 +904,8 @@ fun AgentInfoSheet(
                                        provider.warning ?: modelNeedsSetupLabel
                                    else -> null
                                },
-                                selected = selectedModel == model,
+                                selected = sessionModelState.pickerModel == model &&
+                                    sessionPickerProvider.equals(provider.slug, ignoreCase = true),
                                enabled = !unavailable,
                            ),
                        )
@@ -902,7 +921,7 @@ fun AgentInfoSheet(
                            value = model.id,
                            group = "Routes",
                            secondary = model.routeDetail,
-                            selected = selectedModel == model.id,
+                            selected = sessionModelState.pickerModel == model.id,
                        ),
                    )
                }
@@ -910,10 +929,10 @@ fun AgentInfoSheet(
    }

    LaunchedEffect(Unit) {
-        chatViewModel.refreshModelOptions()
+        chatViewModel.refreshModelOptions(catalogOnly = true)
        chatViewModel.refreshApprovalMode()
        chatViewModel.refreshPersonalities()
-        chatViewModel.refreshModels()
+        chatViewModel.refreshModels(catalogOnly = true)
        connectionViewModel.refreshDashboardProfiles()
    }

@@ -926,28 +945,10 @@ fun AgentInfoSheet(
        showIdentityEditor = false
    }

-    ModalBottomSheet(
-        onDismissRequest = onDismiss,
-        sheetState = sheetState,
-        sheetGesturesEnabled = false,
-        dragHandle = null,
+    AgentPassportSheetHost(
+        scrollState = passportScrollState,
+        onDismiss = onDismiss,
    ) {
-        Column(
-            modifier = Modifier
-                .fillMaxHeight(0.94f)
-                .verticalScroll(
-                    state = passportScrollState,
-                    overscrollEffect = null,
-                )
-                .padding(horizontal = 20.dp, vertical = 4.dp)
-                .navigationBarsPadding(),
-            verticalArrangement = Arrangement.spacedBy(10.dp),
-        ) {
-            Text(
-                text = stringResource(R.string.conn_info_agent_passport),
-                style = MaterialTheme.typography.titleMedium,
-                fontWeight = FontWeight.SemiBold,
-            )
            AgentPassportHeader(
                agentName = agentName,
                profileLabel = profileLabel,
@@ -957,10 +958,7 @@ fun AgentInfoSheet(
                presence = resolvedPresence,
                hasSoul = resolvedProfile?.hasSoul == true,
                skillCount = resolvedProfile?.skillCount ?: 0,
-                transportLabel = transportFriendlyName(sessionTransport.type),
-                sessionLabel = currentSessionId?.take(8) ?: "—",
-                contextLabel = contextLabel,
-                onProfileClick = { activePicker = AgentPassportPicker.Profile },
+                onProfileClick = { showProfileSwitcher = true },
            )

            if (showIdentityEditor) {
@@ -994,7 +992,7 @@ fun AgentInfoSheet(
                ) {
                    Column {
                        Text(
-                            text = stringResource(R.string.conn_info_active_configuration),
+                            text = stringResource(R.string.conn_info_session_title),
                            modifier = Modifier.padding(
                                start = 18.dp,
                                top = 17.dp,
@@ -1004,25 +1002,13 @@ fun AgentInfoSheet(
                            style = MaterialTheme.typography.titleMedium,
                            fontWeight = FontWeight.SemiBold,
                        )
-                        PassportConfigRow(
-                            icon = Icons.Filled.Person,
-                            title = stringResource(R.string.conn_info_personality_title),
-                            value = AgentDisplay.personalityLabel(
-                                selectedPersonality,
-                                defaultPersonality,
-                            ),
-                            expanded = false,
-                            enabled = !isStreaming,
-                            onClick = { activePicker = AgentPassportPicker.Personality },
-                        )
-                        PassportDivider()
                        PassportConfigRow(
                            icon = Icons.Filled.ViewInAr,
                            title = stringResource(R.string.conn_info_model_title),
-                            value = selectedModel ?: if (modelLabel == serverDefaultLabel) {
-                                serverDefaultLabel
-                            } else {
+                            value = if (sessionModelState.inheritsProfileDefault) {
                                stringResource(R.string.conn_info_server_default_model, modelLabel)
+                            } else {
+                                modelLabel
                            },
                            expanded = false,
                            enabled = !isStreaming,
@@ -1046,6 +1032,44 @@ fun AgentInfoSheet(
                    }
                }

+                // Upstream personality changes persist to the active profile
+                // while also applying to the live session. Keep that control
+                // visibly separate from the session-only model/effort card so
+                // it cannot be mistaken for an ephemeral override.
+                Surface(
+                    shape = RoundedCornerShape(22.dp),
+                    color = MaterialTheme.colorScheme.surfaceContainer,
+                    border = androidx.compose.foundation.BorderStroke(
+                        1.dp,
+                        MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.55f),
+                    ),
+                ) {
+                    Column {
+                        Text(
+                            text = stringResource(R.string.conn_info_profile),
+                            modifier = Modifier.padding(
+                                start = 18.dp,
+                                top = 17.dp,
+                                end = 18.dp,
+                                bottom = 4.dp,
+                            ),
+                            style = MaterialTheme.typography.titleMedium,
+                            fontWeight = FontWeight.SemiBold,
+                        )
+                        PassportConfigRow(
+                            icon = Icons.Filled.Person,
+                            title = stringResource(R.string.conn_info_personality_title),
+                            value = AgentDisplay.personalityLabel(
+                                selectedPersonality,
+                                defaultPersonality,
+                            ),
+                            expanded = false,
+                            enabled = !isStreaming,
+                            onClick = { activePicker = AgentPassportPicker.Personality },
+                        )
+                    }
+                }
+
                AgentPassportSafetyCard(
                    approvalMode = approvalMode,
                    approvalCapability = approvalCapability,
@@ -1164,53 +1188,9 @@ fun AgentInfoSheet(
                )
                }
            }
-        }
    }

    when (activePicker) {
-        AgentPassportPicker.Profile -> {
-            val selectedProfileKey = AgentDisplay.profileSessionKey(selectedProfile?.name)
-            val visibleProfileKeys = ProfilePresentationPolicy.visibleKeys(
-                profiles = agentProfiles,
-                presentation = profilePresentation,
-                selectedKey = selectedProfileKey,
-            )
-            val options = visibleProfileKeys.mapNotNull { profileKey ->
-                if (profileKey == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY) {
-                    ChatInputPickerOption(
-                        label = serverDefaultLabel,
-                        value = null,
-                        secondary = AgentDisplay.profileDisplayName(resolvedProfile),
-                        selected = selectedProfile == null,
-                        enabled = !isProfileLocked && profileSwitchEnabled,
-                    )
-                } else {
-                    agentProfiles.firstOrNull { it.name == profileKey }?.let { profile ->
-                        ChatInputPickerOption(
-                            label = AgentDisplay.profileDisplayName(profile)
-                                ?: profile.name.replaceFirstChar { it.uppercase() },
-                            value = profile.name,
-                            secondary = profile.model.takeIf { it.isNotBlank() },
-                            selected = selectedProfile?.name == profile.name,
-                            enabled = !isProfileLocked && profileSwitchEnabled,
-                        )
-                    }
-                }
-            }
-            OptionPickerSheet(
-                title = stringResource(R.string.conn_info_profile),
-                options = options,
-                onSelect = { option ->
-                    val profile = option.value?.let { name ->
-                        agentProfiles.firstOrNull { it.name == name }
-                    }
-                    connectionViewModel.selectProfile(profile)
-                    chatViewModel.activateGatewayProfile(profile)
-                    activePicker = null
-                },
-                onDismiss = { activePicker = null },
-            )
-        }
        AgentPassportPicker.Personality -> OptionPickerSheet(
            title = stringResource(R.string.conn_info_personality_title),
            options = buildList {
@@ -1241,7 +1221,9 @@ fun AgentInfoSheet(
        AgentPassportPicker.Model -> ModelPickerSheet(
            options = passportModelOptions,
            refreshing = modelOptionsRefreshing,
-            onRefresh = { chatViewModel.refreshModelOptions(refresh = true) },
+            onRefresh = {
+                chatViewModel.refreshModelOptions(refresh = true, catalogOnly = true)
+            },
            onSelect = { option ->
                activePicker = null
                if (option.provider == null && apiModelOptions.any { it.id == option.value }) {
@@ -1287,6 +1269,31 @@ fun AgentInfoSheet(
        null -> Unit
    }

+    if (showProfileSwitcher) {
+        ProfileSwitcherSheet(
+            connectionViewModel = connectionViewModel,
+            profiles = agentProfiles,
+            selectedProfile = selectedProfile,
+            resolvedProfile = resolvedProfile,
+            presentation = profilePresentation,
+            isProfileLocked = isProfileLocked,
+            switchEnabled = profileSwitchEnabled,
+            onSelect = { profile ->
+                if (AgentDisplay.profileSessionKey(profile?.name) !=
+                    AgentDisplay.profileSessionKey(selectedProfile?.name)
+                ) {
+                    connectionViewModel.selectProfile(profile)
+                    chatViewModel.activateGatewayProfile(profile)
+                }
+            },
+            onManageDisplay = {
+                showProfileSwitcher = false
+                showProfileManager = true
+            },
+            onDismiss = { showProfileSwitcher = false },
+        )
+    }
+
    if (showProfileManager) {
        ProfileDisplayManagerDialog(
            profiles = agentProfiles,
@@ -1300,6 +1307,75 @@ fun AgentInfoSheet(
    }
 }

+internal const val AGENT_PASSPORT_SHEET_TAG = "agentPassportSheet"
+internal const val AGENT_PASSPORT_SCROLL_TAG = "agentPassportScroll"
+internal const val AGENT_PASSPORT_CLOSE_TAG = "agentPassportClose"
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+internal fun AgentPassportSheetHost(
+    scrollState: ScrollState,
+    onDismiss: () -> Unit,
+    content: @Composable ColumnScope.() -> Unit,
+) {
+    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
+
+    ModalBottomSheet(
+        onDismissRequest = onDismiss,
+        sheetState = sheetState,
+        // A full-height sheet and its long verticalScroll child otherwise
+        // compete for the same drag at the content boundaries. On some devices
+        // that repeatedly settles/re-expands the sheet and produces a visible
+        // vibration at the bottom. Close and system Back remain explicit.
+        sheetGesturesEnabled = false,
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxHeight(0.94f)
+                .testTag(AGENT_PASSPORT_SHEET_TAG),
+        ) {
+            // Keep the close action visible while compact or large-font content
+            // scrolls independently below it.
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .heightIn(min = 56.dp)
+                    .padding(start = 20.dp, end = 8.dp),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Text(
+                    text = stringResource(R.string.conn_info_agent_passport),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold,
+                )
+                IconButton(
+                    onClick = onDismiss,
+                    modifier = Modifier.testTag(AGENT_PASSPORT_CLOSE_TAG),
+                ) {
+                    Icon(
+                        imageVector = Icons.Filled.Close,
+                        contentDescription = stringResource(R.string.common_close),
+                    )
+                }
+            }
+            Column(
+                modifier = Modifier
+                    .weight(1f)
+                    .verticalScroll(
+                        state = scrollState,
+                        overscrollEffect = null,
+                    )
+                    .testTag(AGENT_PASSPORT_SCROLL_TAG)
+                    .padding(horizontal = 20.dp, vertical = 4.dp)
+                    .navigationBarsPadding(),
+                verticalArrangement = Arrangement.spacedBy(10.dp),
+                content = content,
+            )
+        }
+    }
+}
+
@Composable
 private fun AgentPassportIdentityEditor(
    connectionViewModel: ConnectionViewModel,
@@ -1385,9 +1461,6 @@ private fun AgentPassportHeader(
    presence: ProfilePresence?,
    hasSoul: Boolean,
    skillCount: Int,
-    transportLabel: String,
-    sessionLabel: String,
-    contextLabel: String,
    onProfileClick: () -> Unit,
 ) {
    val brand = LocalBrand.current
@@ -1405,18 +1478,9 @@ private fun AgentPassportHeader(
        }
    }
    val identityMetadata = listOfNotNull(
-        providerLabel,
        stringResource(R.string.conn_info_soul).takeIf { hasSoul },
        stringResource(R.string.conn_info_skills_count, skillCount).takeIf { skillCount > 0 },
    ).joinToString(" · ")
-    val connectionValue = listOf(
-        transportLabel,
-        if (connected) {
-            stringResource(R.string.conn_info_connected)
-        } else {
-            stringResource(R.string.conn_info_disconnected)
-        },
-    ).joinToString(" · ")
    Surface(
        shape = RoundedCornerShape(24.dp),
        color = MaterialTheme.colorScheme.surfaceContainer,
@@ -1509,7 +1573,7 @@ private fun AgentPassportHeader(
            ) {
                Column(modifier = Modifier.padding(horizontal = 14.dp, vertical = 10.dp)) {
                    Text(
-                        text = stringResource(R.string.conn_info_active_profile).uppercase(),
+                        text = stringResource(R.string.profile_shelf_switch_agent).uppercase(),
                        style = MaterialTheme.typography.labelSmall,
                        color = MaterialTheme.colorScheme.primary,
                    )
@@ -1551,40 +1615,17 @@ private fun AgentPassportHeader(
                }
            }
            HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f))
-            Row(modifier = Modifier.fillMaxWidth()) {
-                PassportTechnicalField(
-                    label = stringResource(R.string.conn_info_model_title),
-                    value = modelLabel,
-                    modifier = Modifier.weight(1f),
-                )
-                PassportTechnicalDivider(height = 44.dp)
-                PassportTechnicalField(
-                    label = stringResource(R.string.conn_info_connection),
-                    value = connectionValue,
-                    valueColor = if (connected) brand.green else MaterialTheme.colorScheme.error,
-                    modifier = Modifier.weight(1f),
-                )
-            }
-            HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f))
-            Row(modifier = Modifier.fillMaxWidth()) {
-                PassportTechnicalField(
-                    label = stringResource(R.string.conn_info_session_title),
-                    value = sessionLabel,
-                    modifier = Modifier.weight(1f),
-                )
-                PassportTechnicalDivider(height = 42.dp)
-                PassportTechnicalField(
-                    label = stringResource(R.string.conn_info_context),
-                    value = contextLabel,
-                    modifier = Modifier.weight(1f),
-                )
-                PassportTechnicalDivider(height = 42.dp)
-                PassportTechnicalField(
-                    label = stringResource(R.string.conn_info_transport),
-                    value = transportLabel,
-                    modifier = Modifier.weight(1f),
-                )
-            }
+            PassportTechnicalField(
+                label = stringResource(R.string.voice_test_label_provider),
+                value = providerLabel ?: "—",
+                modifier = Modifier.fillMaxWidth(),
+            )
+            PassportTechnicalField(
+                label = stringResource(R.string.conn_info_model_title),
+                value = modelLabel,
+                modifier = Modifier.fillMaxWidth(),
+                maxLines = 2,
+            )
        }
    }
 }
@@ -1595,6 +1636,7 @@ private fun PassportTechnicalField(
    value: String,
    modifier: Modifier = Modifier,
    valueColor: Color = MaterialTheme.colorScheme.onSurface,
+    maxLines: Int = 1,
 ) {
    Column(
        modifier = modifier.padding(horizontal = 8.dp),
@@ -1610,22 +1652,12 @@ private fun PassportTechnicalField(
            text = value,
            style = MaterialTheme.typography.labelLarge,
            color = valueColor,
-            maxLines = 1,
+            maxLines = maxLines,
            overflow = TextOverflow.Ellipsis,
        )
    }
 }

-@Composable
-private fun PassportTechnicalDivider(height: Dp) {
-    Box(
-        modifier = Modifier
-            .height(height)
-            .widthIn(min = 1.dp, max = 1.dp)
-            .background(MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f)),
-    )
-}
-
@Composable
 private fun AgentPassportTabs(
    selected: Int,
@@ -1751,8 +1783,17 @@ private fun PassportDivider() {
    )
 }

+internal const val PASSPORT_APPROVAL_CONTROL_TAG = "passportApproval"
+internal const val PASSPORT_CHAT_OVERRIDE_CONTROL_TAG = "passportChatOverride"
+internal const val PASSPORT_FAST_CONTROL_TAG = "passportFast"
+
+internal data class PassportSegmentOption(
+    val label: String,
+    val description: String,
+)
+
@Composable
-private fun AgentPassportSafetyCard(
+internal fun AgentPassportSafetyCard(
    approvalMode: GatewayApprovalMode?,
    approvalCapability: GatewayApprovalModeCapability,
    approvalWritable: Boolean,
@@ -1766,9 +1807,18 @@ private fun AgentPassportSafetyCard(
    onFast: (Boolean) -> Unit,
 ) {
    val approvalModes = listOf(
-        GatewayApprovalMode.Manual to stringResource(R.string.conn_info_approval_mode_manual),
-        GatewayApprovalMode.Smart to stringResource(R.string.conn_info_approval_mode_smart),
-        GatewayApprovalMode.Off to stringResource(R.string.conn_info_approval_mode_off),
+        GatewayApprovalMode.Manual to PassportSegmentOption(
+            label = stringResource(R.string.conn_info_approval_mode_manual),
+            description = stringResource(R.string.conn_info_approval_mode_manual_desc),
+        ),
+        GatewayApprovalMode.Smart to PassportSegmentOption(
+            label = stringResource(R.string.conn_info_approval_mode_smart),
+            description = stringResource(R.string.conn_info_approval_mode_smart_desc),
+        ),
+        GatewayApprovalMode.Off to PassportSegmentOption(
+            label = stringResource(R.string.conn_info_approval_mode_off),
+            description = stringResource(R.string.conn_info_approval_mode_off_desc),
+        ),
    )
    Surface(
        shape = RoundedCornerShape(22.dp),
@@ -1811,11 +1861,12 @@ private fun AgentPassportSafetyCard(
                    }
                    GatewayApprovalModeCapability.Supported -> {
                        PassportSegmentedControl(
-                            labels = approvalModes.map { it.second },
+                            options = approvalModes.map { it.second },
                            selected = approvalModes.indexOfFirst { it.first == approvalMode }
                                .takeIf { it >= 0 },
                            enabled = controlsAvailable && gatewayReady &&
                                approvalWritable && !isStreaming,
+                            testTagPrefix = PASSPORT_APPROVAL_CONTROL_TAG,
                            onSelected = { index -> onApprovalMode(approvalModes[index].first) },
                        )
                    }
@@ -1833,15 +1884,26 @@ private fun AgentPassportSafetyCard(
                },
            ) {
                PassportSegmentedControl(
-                    labels = listOf(
-                        stringResource(R.string.conn_info_inherited),
-                        stringResource(R.string.conn_info_bypassed),
+                    options = listOf(
+                        PassportSegmentOption(
+                            label = stringResource(R.string.conn_info_inherited),
+                            description = if (approvalMode == GatewayApprovalMode.Off) {
+                                stringResource(R.string.conn_info_profile_already_bypasses)
+                            } else {
+                                stringResource(R.string.conn_info_chat_override_inherited_desc)
+                            },
+                        ),
+                        PassportSegmentOption(
+                            label = stringResource(R.string.conn_info_bypassed),
+                            description = stringResource(R.string.conn_info_yolo_mode_desc_ephemeral),
+                        ),
                    ),
                    selected = if (
                        approvalMode != GatewayApprovalMode.Off && yoloEnabled == true
                    ) 1 else 0,
                    enabled = controlsAvailable && gatewayReady && !isStreaming &&
                        approvalMode != GatewayApprovalMode.Off,
+                    testTagPrefix = PASSPORT_CHAT_OVERRIDE_CONTROL_TAG,
                    onSelected = { onYolo(it == 1) },
                )
            }
@@ -1853,12 +1915,19 @@ private fun AgentPassportSafetyCard(
                description = stringResource(R.string.conn_info_fast_mode_desc),
            ) {
                PassportSegmentedControl(
-                    labels = listOf(
-                        stringResource(R.string.conn_info_fast),
-                        stringResource(R.string.appearance_font_normal),
+                    options = listOf(
+                        PassportSegmentOption(
+                            label = stringResource(R.string.conn_info_fast),
+                            description = stringResource(R.string.conn_info_fast_mode_desc),
+                        ),
+                        PassportSegmentOption(
+                            label = stringResource(R.string.appearance_font_normal),
+                            description = stringResource(R.string.conn_info_normal_tier_desc),
+                        ),
                    ),
                    selected = if (fastEnabled == true) 0 else 1,
                    enabled = controlsAvailable && gatewayReady && !isStreaming,
+                    testTagPrefix = PASSPORT_FAST_CONTROL_TAG,
                    onSelected = { onFast(it == 0) },
                )
            }
@@ -1873,91 +1942,119 @@ private fun PassportSafetyRow(
    description: String,
    control: @Composable () -> Unit,
 ) {
-    Row(
+    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 7.dp),
-        verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.spacedBy(10.dp),
+        verticalArrangement = Arrangement.spacedBy(10.dp),
    ) {
-        Surface(
-            modifier = Modifier.size(38.dp),
-            shape = CircleShape,
-            color = MaterialTheme.colorScheme.surfaceContainerHighest,
-            contentColor = MaterialTheme.colorScheme.primary,
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(10.dp),
        ) {
-            Box(contentAlignment = Alignment.Center) {
-                Icon(icon, contentDescription = null, modifier = Modifier.size(20.dp))
+            Surface(
+                modifier = Modifier.size(40.dp),
+                shape = CircleShape,
+                color = MaterialTheme.colorScheme.surfaceContainerHighest,
+                contentColor = MaterialTheme.colorScheme.primary,
+            ) {
+                Box(contentAlignment = Alignment.Center) {
+                    Icon(icon, contentDescription = null, modifier = Modifier.size(20.dp))
+                }
+            }
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.bodyLarge,
+                    fontWeight = FontWeight.Medium,
+                )
+                Text(
+                    text = description,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
            }
        }
-        Column(modifier = Modifier.weight(1.25f)) {
-            Text(
-                text = title,
-                style = MaterialTheme.typography.bodyMedium,
-                fontWeight = FontWeight.Medium,
-            )
-            Text(
-                text = description,
-                style = MaterialTheme.typography.labelSmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                maxLines = 3,
-                overflow = TextOverflow.Ellipsis,
-            )
-        }
-        Box(modifier = Modifier.weight(1f)) {
-            control()
-        }
+        control()
    }
 }

@Composable
-private fun PassportSegmentedControl(
-    labels: List<String>,
+internal fun PassportSegmentedControl(
+    options: List<PassportSegmentOption>,
    selected: Int?,
    enabled: Boolean,
+    testTagPrefix: String,
    onSelected: (Int) -> Unit,
 ) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .selectableGroup()
-            .clip(RoundedCornerShape(14.dp))
-            .background(MaterialTheme.colorScheme.surfaceContainerHighest)
-            .padding(3.dp)
-            .alpha(if (enabled) 1f else 0.52f),
-    ) {
-        labels.forEachIndexed { index, label ->
-            Surface(
-                modifier = Modifier
-                    .weight(1f)
-                    .selectable(
-                        selected = selected == index,
-                        enabled = enabled,
-                        role = Role.RadioButton,
-                        onClick = { onSelected(index) },
-                    ),
-                shape = RoundedCornerShape(11.dp),
-                color = if (selected == index) {
-                    MaterialTheme.colorScheme.primary
-                } else {
-                    Color.Transparent
-                },
-                contentColor = if (selected == index) {
-                    MaterialTheme.colorScheme.onPrimary
-                } else {
-                    MaterialTheme.colorScheme.onSurfaceVariant
-                },
-            ) {
-                Text(
-                    text = label,
-                    modifier = Modifier.padding(horizontal = 4.dp, vertical = 8.dp),
-                    textAlign = androidx.compose.ui.text.style.TextAlign.Center,
-                    style = MaterialTheme.typography.labelMedium,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
-                )
+    Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .selectableGroup()
+                .clip(RoundedCornerShape(14.dp))
+                .background(MaterialTheme.colorScheme.surfaceContainerHighest)
+                .padding(3.dp),
+        ) {
+            options.forEachIndexed { index, option ->
+                Surface(
+                    modifier = Modifier
+                        .weight(1f)
+                        .heightIn(min = 48.dp)
+                        .testTag("$testTagPrefix-$index")
+                        .selectable(
+                            selected = selected == index,
+                            enabled = enabled,
+                            role = Role.RadioButton,
+                            onClick = { onSelected(index) },
+                        )
+                        .semantics {
+                            contentDescription = "${option.label}. ${option.description}"
+                        },
+                    shape = RoundedCornerShape(11.dp),
+                    color = when {
+                        selected != index -> Color.Transparent
+                        enabled -> MaterialTheme.colorScheme.primary
+                        else -> MaterialTheme.colorScheme.primaryContainer
+                    },
+                    contentColor = when {
+                        selected == index && enabled -> MaterialTheme.colorScheme.onPrimary
+                        selected == index -> MaterialTheme.colorScheme.onPrimaryContainer
+                        enabled -> MaterialTheme.colorScheme.onSurfaceVariant
+                        else -> MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.7f)
+                    },
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .heightIn(min = 48.dp)
+                            .padding(horizontal = 6.dp, vertical = 6.dp),
+                        contentAlignment = Alignment.Center,
+                    ) {
+                        Text(
+                            text = option.label,
+                            textAlign = androidx.compose.ui.text.style.TextAlign.Center,
+                            style = MaterialTheme.typography.bodyMedium,
+                            fontWeight = if (selected == index) {
+                                FontWeight.SemiBold
+                            } else {
+                                FontWeight.Medium
+                            },
+                            maxLines = 2,
+                        )
+                    }
+                }
            }
        }
+        selected?.let(options::getOrNull)?.let { option ->
+            Text(
+                text = option.description,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(horizontal = 4.dp),
+            )
+        }
    }
 }

@@ -2169,7 +2266,7 @@ private fun LegacyAgentInfoSheet(

    // Pull the gateway's curated provider/model list (model.options) when the
    // sheet opens — the real switchable models, grouped by provider.
-    LaunchedEffect(Unit) { chatViewModel.refreshModelOptions() }
+    LaunchedEffect(Unit) { chatViewModel.refreshModelOptions(catalogOnly = true) }
    LaunchedEffect(Unit) { chatViewModel.refreshApprovalMode() }
    // Re-pull server-supplied personalities (list + default + active) on open so
    // a server-side change shows without an app reload.
@@ -2177,7 +2274,7 @@ private fun LegacyAgentInfoSheet(
    // Re-pull the SSE-fallback model list + skill catalog on open so server-side
    // changes surface without an app reload (gateway model groups are covered by
    // refreshModelOptions above; skills feed the command palette).
-    LaunchedEffect(Unit) { chatViewModel.refreshModels() }
+    LaunchedEffect(Unit) { chatViewModel.refreshModels(catalogOnly = true) }
    LaunchedEffect(Unit) { chatViewModel.refreshSkills() }
    // Pull the host's agent profiles from the dashboard so they appear in the
    // Profile picker even on a dashboard-only (non-relay) connection.
@@ -2382,7 +2479,7 @@ private fun LegacyAgentInfoSheet(
                // "default" so "Server default" vs "default" would be
                // otherwise indistinguishable.
                val serverDefaultProfile = agentProfiles
-                    .firstOrNull { AgentDisplay.isServerDefaultAlias(it.name) }
+                    .firstOrNull { it.name.equals("default", ignoreCase = true) }
                val selectedKey = AgentDisplay.profileSessionKey(selectedProfile?.name)
                val visibleProfileKeys = ProfilePresentationPolicy
                    .visibleKeys(agentProfiles, profilePresentation, selectedKey)
@@ -2405,8 +2502,7 @@ private fun LegacyAgentInfoSheet(
                    val lockedDisplayName = when {
                        lockedProfileName == null ->
                            stringResource(R.string.conn_info_server_default)
-                        AgentDisplay.isServerDefaultAlias(lockedProfileName) ||
-                            lockedProfileName == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY ->
+                        lockedProfileName == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY ->
                            stringResource(R.string.conn_info_server_default)
                        else ->
                            agentProfiles
@@ -3494,7 +3590,7 @@ private fun LegacyAgentInfoSheet(
 // --- AgentInfoSheet helpers ----------------------------------------------

@Composable
-private fun ProfileDisplayManagerDialog(
+internal fun ProfileDisplayManagerDialog(
    profiles: List<Profile>,
    presentation: ProfilePresentation,
    selectedProfileName: String?,
@@ -10,7 +10,9 @@ import android.widget.Toast
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.animateContentSize
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
+import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.animation.togetherWith
@@ -38,12 +40,15 @@ import androidx.compose.material.icons.automirrored.outlined.MenuBook
 import androidx.compose.material.icons.filled.ArrowDropDown
 import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.ChevronRight
+import androidx.compose.material.icons.filled.Cloud
 import androidx.compose.material.icons.filled.ContentCopy
+import androidx.compose.material.icons.filled.Dns
 import androidx.compose.material.icons.filled.ErrorOutline
 import androidx.compose.material.icons.filled.Keyboard
 import androidx.compose.material.icons.filled.PhonelinkLock
 import androidx.compose.material.icons.filled.QrCodeScanner
 import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Wifi
 import androidx.compose.material.icons.filled.Visibility
 import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material3.AlertDialog
@@ -76,7 +81,6 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalClipboard
 import androidx.compose.ui.platform.LocalContext
@@ -201,6 +205,8 @@ fun ConnectionWizard(
    val currentRelayUrl by connectionViewModel.relayUrl.collectAsState()
    val currentDashboardUrl by connectionViewModel.effectiveDashboardUrl.collectAsState()
    val activeConnection by connectionViewModel.activeConnection.collectAsState()
+    val accessibleMotion = rememberAccessibleMotionState()
+    val animateWizardTransitions = shouldAnimateWizardTransitions(accessibleMotion)

    var step by remember { mutableStateOf(WizardStep.Nearby) }
    var chosenMethod by remember { mutableStateOf(PairMethod.Standard) }
@@ -222,7 +228,7 @@ fun ConnectionWizard(
        mutableStateOf<ConnectionViewModel.DashboardSetupResult?>(null)
    }
    var dashboardSuggestedHostname by remember { mutableStateOf<String?>(null) }
-    var connectionGuideExpanded by rememberSaveable { mutableStateOf(showSkip) }
+    var dashboardEntryIntent by rememberSaveable { mutableStateOf(DashboardEntryIntent.Server) }
    var pendingDashboardDraft by remember { mutableStateOf<DashboardConnectionDraft?>(null) }
    val relayScopedFlow = autoStart == "relay"
    val pairingHome = if (relayScopedFlow) WizardStep.RelayChoice else WizardStep.Method
@@ -527,18 +533,27 @@ fun ConnectionWizard(
        }
    }

-    Column(
-        modifier = modifier
-            .fillMaxWidth()
-            .verticalScroll(rememberScrollState())
-            .padding(horizontal = 20.dp, vertical = 16.dp),
-        verticalArrangement = Arrangement.spacedBy(16.dp),
-    ) {
-        WizardStepIndicator(currentStep = step.indicatorIndex, method = chosenMethod)
+    if (!showQrScanner) {
+        Column(
+            modifier = modifier
+                .fillMaxWidth()
+                .verticalScroll(rememberScrollState())
+                .padding(horizontal = 20.dp, vertical = 16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+        if (step != WizardStep.Nearby) {
+            WizardStepIndicator(currentStep = step.indicatorIndex, method = chosenMethod)
+        }

        AnimatedContent(
            targetState = step,
-            transitionSpec = { fadeIn() togetherWith fadeOut() },
+            transitionSpec = {
+                if (animateWizardTransitions) {
+                    fadeIn(tween(200)) togetherWith fadeOut(tween(180))
+                } else {
+                    EnterTransition.None togetherWith ExitTransition.None
+                }
+            },
            label = "wizard-step",
        ) { current ->
            when (current) {
@@ -553,7 +568,14 @@ fun ConnectionWizard(
                            inspectDashboard(dashboardUrl, candidate.hostname)
                        }
                    },
-                    onManual = {
+                    onCloud = {
+                        dashboardEntryIntent = DashboardEntryIntent.Cloud
+                        dashboardProbeError = null
+                        dashboardAddress = ""
+                        step = WizardStep.DashboardManual
+                    },
+                    onManualServer = {
+                        dashboardEntryIntent = DashboardEntryIntent.Server
                        dashboardProbeError = null
                        step = WizardStep.DashboardManual
                    },
@@ -569,11 +591,10 @@ fun ConnectionWizard(
                    onOtherWays = { step = WizardStep.Method },
                    onSkip = if (showSkip) onCancel else null,
                    onTryDemo = onTryDemo,
-                    guideExpanded = connectionGuideExpanded,
-                    onGuideExpandedChange = { connectionGuideExpanded = it },
                )

                WizardStep.DashboardManual -> DashboardManualStep(
+                    intent = dashboardEntryIntent,
                    address = dashboardAddress,
                    onAddressChange = {
                        dashboardAddress = it
@@ -582,7 +603,7 @@ fun ConnectionWizard(
                    busy = dashboardProbeBusy,
                    error = dashboardProbeError,
                    onBack = { step = WizardStep.Nearby },
-                    onSubmit = { inspectDashboard(dashboardAddress, null) },
+                    onSubmit = { resolvedAddress -> inspectDashboard(resolvedAddress, null) },
                )

                WizardStep.DashboardFound -> dashboardProbeResult?.let { result ->
@@ -728,47 +749,65 @@ fun ConnectionWizard(
                                // role — otherwise Retry would drop the user's
                                // "Prefer" choice on every failure.
                                pendingPayload = reorderedPayload
-                                // Pre-pair duplicate check — stops the flow
-                                // on the Confirm screen if the scanned
-                                // serverUrl already matches an existing
-                                // connection. User can then re-pair that
-                                // existing entry in place (see the
-                                // DuplicateConnectionDialog at the bottom
-                                // of this composable) or cancel out. If no
-                                // duplicate, proceed to Verify as before.
-                                val existing = if (relayScopedFlow) {
-                                    null
-                                } else {
-                                    findDuplicateFor(
-                                        reorderedPayload.serverUrl,
-                                        reorderedPayload.relay?.url.orEmpty(),
-                                        reorderedPayload.dashboardUrl,
-                                    )
-                                }
-                                if (existing != null) {
-                                    duplicatePrompt = existing
-                                } else if (reorderedPayload.relay == null) {
-                                    launchStandardConnect(
-                                        reorderedPayload.serverUrl,
-                                        reorderedPayload.key,
-                                        "",
-                                        reorderedPayload.dashboardUrl.orEmpty(),
-                                        reorderedPayload.endpoints,
-                                    )
-                                } else {
-                                    wizardScope.launch {
-                                        connectionViewModel.ensureActiveConnectionForSetup(
-                                            apiServerUrl = reorderedPayload.serverUrl,
-                                            relayUrl = reorderedPayload.relay.url,
-                                            routeCandidates = reorderedPayload.endpoints,
+                                val dispatch = setupQrDispatch(reorderedPayload)
+                                when (dispatch) {
+                                    SetupQrDispatch.Dashboard -> {
+                                        // Dashboard-only setup belongs to the same
+                                        // upstream probe/auth owner as manual and LAN
+                                        // Dashboard setup. DashboardFound performs the
+                                        // existing duplicate check before persistence,
+                                        // and applyDashboardConnect launches native
+                                        // sign-in when the advertised status requires it.
+                                        // Move to the manual Dashboard surface before
+                                        // probing so a contract failure is visible and
+                                        // retryable instead of being hidden by Confirm.
+                                        dashboardEntryIntent = DashboardEntryIntent.Server
+                                        dashboardAddress = reorderedPayload.dashboardUrl.orEmpty()
+                                        step = WizardStep.DashboardManual
+                                        inspectDashboard(
+                                            reorderedPayload.dashboardUrl.orEmpty(),
+                                            null,
                                        )
-                                        connectionViewModel.applyPairingPayload(
-                                            reorderedPayload,
-                                            ttlSeconds,
-                                            preserveStandardConfig = relayScopedFlow,
-                                        )
-                                        step = WizardStep.Verify
-                                        verifyAttempt += 1
+                                    }
+                                    SetupQrDispatch.StandardApi,
+                                    SetupQrDispatch.Relay -> {
+                                        // API and Relay payloads retain their existing
+                                        // duplicate/persistence behavior unchanged.
+                                        val existing = if (relayScopedFlow) {
+                                            null
+                                        } else {
+                                            findDuplicateFor(
+                                                reorderedPayload.serverUrl,
+                                                reorderedPayload.relay?.url.orEmpty(),
+                                                reorderedPayload.dashboardUrl,
+                                            )
+                                        }
+                                        if (existing != null) {
+                                            duplicatePrompt = existing
+                                        } else if (dispatch == SetupQrDispatch.StandardApi) {
+                                            launchStandardConnect(
+                                                reorderedPayload.serverUrl,
+                                                reorderedPayload.key,
+                                                "",
+                                                reorderedPayload.dashboardUrl.orEmpty(),
+                                                reorderedPayload.endpoints,
+                                            )
+                                        } else {
+                                            wizardScope.launch {
+                                                connectionViewModel.ensureActiveConnectionForSetup(
+                                                    apiServerUrl = reorderedPayload.serverUrl,
+                                                    relayUrl = reorderedPayload.relay?.url.orEmpty(),
+                                                    routeCandidates = reorderedPayload.endpoints,
+                                                )
+                                                connectionViewModel.applyPairingPayload(
+                                                    reorderedPayload,
+                                                    ttlSeconds,
+                                                    preserveStandardConfig = relayScopedFlow,
+                                                )
+                                                step = WizardStep.Verify
+                                                verifyAttempt += 1
+                                            }
+                                        }
                                    }
                                }
                            },
@@ -839,6 +878,7 @@ fun ConnectionWizard(
            }
        }
    }
+    }

    if (showQrScanner) {
        QrPairingScanner(
@@ -1096,6 +1136,44 @@ private enum class WizardStep {

 private enum class PairMethod { Standard, Scan, EnterCode, ShowCode }

+private enum class DashboardEntryIntent { Cloud, Server }
+
+internal enum class SetupQrDispatch { Dashboard, StandardApi, Relay }
+
+/** Keep setup QR routing aligned with the surface that owns its credentials. */
+internal fun setupQrDispatch(payload: HermesPairingPayload): SetupQrDispatch = when {
+    payload.relay != null -> SetupQrDispatch.Relay
+    !payload.hasApiServer && !payload.dashboardUrl.isNullOrBlank() -> SetupQrDispatch.Dashboard
+    else -> SetupQrDispatch.StandardApi
+}
+
+/** Wizard motion follows the shared OS-animation and touch-exploration policy. */
+internal fun shouldAnimateWizardTransitions(state: AccessibleMotionState): Boolean =
+    state.osAnimations && !state.touchExploration
+
+private const val NOUS_CLOUD_HOST_SUFFIX = ".agents.nousresearch.com"
+private val NOUS_CLOUD_SLUG = Regex("^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$")
+
+internal fun resolveNousCloudDashboardAddress(value: String): String {
+    val trimmed = value.trim()
+    if (trimmed.contains("://")) return trimmed
+    val slug = trimmed.removeSuffix(NOUS_CLOUD_HOST_SUFFIX)
+    return if (NOUS_CLOUD_SLUG.matches(slug)) {
+        "https://$slug$NOUS_CLOUD_HOST_SUFFIX"
+    } else {
+        trimmed
+    }
+}
+
+internal fun isValidNousCloudSlug(value: String): Boolean =
+    NOUS_CLOUD_SLUG.matches(value.trim())
+
+internal fun isValidNousCloudAddressInput(value: String): Boolean {
+    val trimmed = value.trim()
+    if (trimmed.contains("://")) return false
+    return isValidNousCloudSlug(trimmed.removeSuffix(NOUS_CLOUD_HOST_SUFFIX))
+}
+
 private data class StandardConnectionDraft(
    val apiUrl: String,
    val apiKey: String,
@@ -1201,19 +1279,50 @@ private fun NearbyHermesStep(
    message: String?,
    onSearchAgain: () -> Unit,
    onSelect: (HermesLanDiscoveryResult) -> Unit,
-    onManual: () -> Unit,
+    onCloud: () -> Unit,
+    onManualServer: () -> Unit,
    onPairRelayQr: () -> Unit,
    onPairRelayCode: () -> Unit,
    onOtherWays: () -> Unit,
    onSkip: (() -> Unit)?,
    onTryDemo: (() -> Unit)?,
-    guideExpanded: Boolean,
-    onGuideExpandedChange: (Boolean) -> Unit,
+) {
+    NewNearbyHermesStep(
+        busy = busy,
+        setupReady = setupReady,
+        results = results,
+        message = message,
+        onSearchAgain = onSearchAgain,
+        onSelect = onSelect,
+        onCloud = onCloud,
+        onManualServer = onManualServer,
+        onScanQr = onPairRelayQr,
+        onAdvanced = onOtherWays,
+        onSkip = onSkip,
+        onTryDemo = onTryDemo,
+    )
+}
+
+
+@Composable
+private fun NewNearbyHermesStep(
+    busy: Boolean,
+    setupReady: Boolean,
+    results: List<HermesLanDiscoveryResult>,
+    message: String?,
+    onSearchAgain: () -> Unit,
+    onSelect: (HermesLanDiscoveryResult) -> Unit,
+    onCloud: () -> Unit,
+    onManualServer: () -> Unit,
+    onScanQr: () -> Unit,
+    onAdvanced: () -> Unit,
+    onSkip: (() -> Unit)?,
+    onTryDemo: (() -> Unit)?,
 ) {
    val context = LocalContext.current
    Column(
        modifier = Modifier.fillMaxWidth(),
-        verticalArrangement = Arrangement.spacedBy(14.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
    ) {
        Text(
            text = stringResource(R.string.cw_connect_to_hermes),
@@ -1221,183 +1330,140 @@ private fun NearbyHermesStep(
            modifier = Modifier.semantics { heading() },
        )
        Text(
-            text = stringResource(R.string.cw_nearby_description),
+            text = stringResource(R.string.cw_connection_chooser_description),
            style = MaterialTheme.typography.bodyMedium,
            color = MaterialTheme.colorScheme.onSurfaceVariant,
        )

-        Surface(
-            color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.72f),
-            shape = RoundedCornerShape(16.dp),
+        Card(
            modifier = Modifier
                .fillMaxWidth()
-                .animateContentSize(),
+                .clickable(enabled = setupReady, role = Role.Button, onClick = onScanQr),
+            colors = CardDefaults.cardColors(
+                containerColor = MaterialTheme.colorScheme.primaryContainer,
+            ),
+            shape = RoundedCornerShape(18.dp),
        ) {
-            Column(
-                modifier = Modifier.fillMaxWidth(),
+            Row(
+                modifier = Modifier.padding(horizontal = 18.dp, vertical = 20.dp),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(16.dp),
            ) {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .clickable(
-                            role = Role.Button,
-                            onClick = { onGuideExpandedChange(!guideExpanded) },
-                        )
-                        .padding(horizontal = 16.dp, vertical = 14.dp),
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.spacedBy(12.dp),
+                Icon(
+                    imageVector = Icons.Filled.QrCodeScanner,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onPrimaryContainer,
+                    modifier = Modifier.size(34.dp),
+                )
+                Column(
+                    modifier = Modifier.weight(1f),
+                    verticalArrangement = Arrangement.spacedBy(3.dp),
                ) {
                    Text(
-                        text = stringResource(R.string.cw_before_connecting),
+                        text = stringResource(R.string.cw_scan_setup_qr_title),
                        style = MaterialTheme.typography.titleMedium,
                        fontWeight = FontWeight.SemiBold,
-                        modifier = Modifier.weight(1f),
+                        color = MaterialTheme.colorScheme.onPrimaryContainer,
                    )
-                    Icon(
-                        imageVector = Icons.Filled.ChevronRight,
-                        contentDescription = null,
-                        modifier = Modifier
-                            .size(22.dp)
-                            .rotate(if (guideExpanded) 90f else 0f),
+                    Text(
+                        text = stringResource(R.string.cw_recommended),
+                        style = MaterialTheme.typography.labelMedium,
+                        color = MaterialTheme.colorScheme.onPrimaryContainer,
+                    )
+                    Text(
+                        text = stringResource(R.string.cw_scan_setup_qr_subtitle),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.82f),
                    )
                }
-                if (guideExpanded) {
-                    Column(
-                        modifier = Modifier.padding(start = 16.dp, end = 16.dp, bottom = 12.dp),
-                        verticalArrangement = Arrangement.spacedBy(14.dp),
-                    ) {
-                        ConnectionGuideStep(
-                            number = "1",
-                            title = stringResource(R.string.cw_connect_step_server_title),
-                            body = stringResource(R.string.cw_connect_step_server_body),
-                        )
-                        ConnectionGuideStep(
-                            number = "2",
-                            title = stringResource(R.string.cw_connect_step_network_title),
-                            body = stringResource(R.string.cw_connect_step_network_body),
-                        )
-                        ConnectionGuideStep(
-                            number = "3",
-                            title = stringResource(R.string.cw_connect_step_phone_title),
-                            body = stringResource(R.string.cw_connect_step_phone_body),
-                        )
-                        TextButton(
-                            onClick = { openExternalUrl(context, SetupGuideUrl) },
-                            modifier = Modifier.align(Alignment.End),
-                        ) {
-                            Icon(
-                                imageVector = Icons.AutoMirrored.Outlined.MenuBook,
-                                contentDescription = null,
-                                modifier = Modifier.size(16.dp),
-                            )
-                            Spacer(Modifier.size(6.dp))
-                            Text(stringResource(R.string.cw_setup_guide))
-                        }
-                    }
-                }
+                Icon(
+                    imageVector = Icons.Filled.ChevronRight,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onPrimaryContainer,
+                )
            }
        }

-        if (busy) {
-            Surface(
-                color = MaterialTheme.colorScheme.surfaceVariant,
-                shape = RoundedCornerShape(12.dp),
-                modifier = Modifier.fillMaxWidth(),
-            ) {
-                Row(
-                    modifier = Modifier.padding(16.dp),
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.spacedBy(12.dp),
-                ) {
-                    CircularProgressIndicator(modifier = Modifier.size(22.dp), strokeWidth = 2.dp)
-                    Column {
-                        Text(
-                            stringResource(
-                                if (setupReady) R.string.cw_nearby_searching
-                                else R.string.cw_preparing_connection,
-                            ),
-                            style = MaterialTheme.typography.titleSmall,
-                        )
-                        Text(
-                            stringResource(
-                                if (setupReady) R.string.cw_nearby_searching_hint
-                                else R.string.cw_preparing_connection_hint,
-                            ),
-                            style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant,
-                        )
-                    }
-                }
-            }
-        }
-
-        if (results.isNotEmpty()) {
-            Text(
-                text = stringResource(R.string.cw_nearby_heading),
-                style = MaterialTheme.typography.titleMedium,
-                modifier = Modifier.semantics { heading() },
-            )
-            results.forEach { candidate ->
-                NearbyHermesResult(candidate = candidate, onClick = { onSelect(candidate) })
-            }
-        }
-
-        message?.let {
-            Text(
-                text = it,
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                modifier = Modifier.semantics { liveRegion = LiveRegionMode.Polite },
-            )
-            Text(
-                text = stringResource(R.string.cw_nearby_empty_hint),
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-        }
-
-        if (!busy) {
-            OutlinedButton(
-                onClick = onSearchAgain,
-                modifier = Modifier.fillMaxWidth().heightIn(min = 48.dp),
-            ) {
-                Icon(Icons.Filled.Refresh, contentDescription = null, modifier = Modifier.size(18.dp))
-                Spacer(Modifier.size(8.dp))
-                Text(stringResource(R.string.cw_nearby_search_again))
-            }
-        }
-        Button(
-            onClick = onManual,
-            enabled = setupReady,
-            modifier = Modifier.fillMaxWidth().heightIn(min = 48.dp),
-        ) {
-            Text(stringResource(R.string.cw_nearby_enter_address))
-        }
-
-        HorizontalDivider(modifier = Modifier.padding(vertical = 2.dp))
        Text(
-            text = stringResource(R.string.cw_relay_entry_title),
+            text = stringResource(R.string.cw_other_ways_to_connect),
            style = MaterialTheme.typography.titleMedium,
            fontWeight = FontWeight.SemiBold,
+            modifier = Modifier.semantics { heading() },
        )
+        Surface(
+            color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.58f),
+            shape = RoundedCornerShape(16.dp),
+            modifier = Modifier.fillMaxWidth(),
+        ) {
+            Column(modifier = Modifier.fillMaxWidth()) {
+                ConnectionChooserRow(
+                    icon = Icons.Filled.Cloud,
+                    title = stringResource(R.string.cw_cloud_title),
+                    subtitle = stringResource(R.string.cw_cloud_subtitle),
+                    onClick = onCloud,
+                    enabled = setupReady,
+                )
+                HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
+                ConnectionChooserRow(
+                    icon = Icons.Filled.Dns,
+                    title = stringResource(R.string.cw_server_vps_title),
+                    subtitle = stringResource(R.string.cw_server_vps_subtitle),
+                    onClick = onManualServer,
+                    enabled = setupReady,
+                )
+                if (results.isNotEmpty()) {
+                    results.forEach { candidate ->
+                        HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
+                        ConnectionChooserRow(
+                            icon = Icons.Filled.Wifi,
+                            title = stringResource(R.string.cw_nearby_heading),
+                            subtitle = candidate.dashboardUrl.orEmpty(),
+                            onClick = { onSelect(candidate) },
+                            enabled = setupReady,
+                            status = stringResource(R.string.cw_ready),
+                        )
+                    }
+                } else {
+                    HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
+                    ConnectionChooserRow(
+                        icon = Icons.Filled.Wifi,
+                        title = stringResource(R.string.cw_nearby_heading),
+                        subtitle = when {
+                            busy -> stringResource(R.string.cw_nearby_searching)
+                            !message.isNullOrBlank() -> message
+                            else -> stringResource(R.string.cw_nearby_empty_hint)
+                        },
+                        onClick = onSearchAgain,
+                        enabled = setupReady && !busy,
+                        showProgress = busy,
+                    )
+                }
+            }
+        }
+
        Text(
-            text = stringResource(R.string.cw_relay_entry_desc),
+            text = stringResource(R.string.cw_relay_optional_note),
            style = MaterialTheme.typography.bodySmall,
            color = MaterialTheme.colorScheme.onSurfaceVariant,
        )
-        MethodTile(
-            icon = Icons.Filled.QrCodeScanner,
-            title = stringResource(R.string.cw_relay_pair_qr),
-            subtitle = stringResource(R.string.cw_relay_pair_qr_desc),
-            onClick = onPairRelayQr,
-            enabled = setupReady,
-        )
-        TextButton(onClick = onPairRelayCode, enabled = setupReady, modifier = Modifier.fillMaxWidth()) {
-            Text(stringResource(R.string.cw_relay_enter_code))
-        }

-        TextButton(onClick = onOtherWays, enabled = setupReady, modifier = Modifier.fillMaxWidth()) {
-            Text(stringResource(R.string.cw_other_connection_methods))
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.Center,
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            TextButton(onClick = { openExternalUrl(context, SetupGuideUrl) }) {
+                Icon(
+                    imageVector = Icons.AutoMirrored.Outlined.MenuBook,
+                    contentDescription = null,
+                    modifier = Modifier.size(16.dp),
+                )
+                Spacer(Modifier.size(6.dp))
+                Text(stringResource(R.string.cw_setup_guide))
+            }
+            TextButton(onClick = onAdvanced, enabled = setupReady) {
+                Text(stringResource(R.string.cw_advanced))
+            }
        }
        if (onTryDemo != null) {
            TextButton(onClick = onTryDemo, modifier = Modifier.fillMaxWidth()) {
@@ -1413,33 +1479,55 @@ private fun NearbyHermesStep(
 }

@Composable
-private fun ConnectionGuideStep(
-    number: String,
+private fun ConnectionChooserRow(
+    icon: androidx.compose.ui.graphics.vector.ImageVector,
    title: String,
-    body: String,
+    subtitle: String,
+    onClick: () -> Unit,
+    enabled: Boolean,
+    status: String? = null,
+    showProgress: Boolean = false,
 ) {
    Row(
-        verticalAlignment = Alignment.Top,
-        horizontalArrangement = Arrangement.spacedBy(12.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(enabled = enabled, role = Role.Button, onClick = onClick)
+            .padding(horizontal = 16.dp, vertical = 14.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(14.dp),
    ) {
        Surface(
-            color = MaterialTheme.colorScheme.primaryContainer,
-            contentColor = MaterialTheme.colorScheme.onPrimaryContainer,
-            shape = CircleShape,
-            modifier = Modifier.size(28.dp),
+            color = MaterialTheme.colorScheme.surface,
+            shape = RoundedCornerShape(12.dp),
        ) {
-            Box(contentAlignment = Alignment.Center) {
-                Text(number, style = MaterialTheme.typography.labelLarge, fontWeight = FontWeight.Bold)
-            }
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.padding(10.dp).size(24.dp),
+            )
        }
-        Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
+        Column(modifier = Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
            Text(title, style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold)
            Text(
-                body,
+                subtitle,
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                maxLines = 2,
            )
        }
+        status?.let {
+            Text(
+                it,
+                style = MaterialTheme.typography.labelMedium,
+                color = MaterialTheme.colorScheme.primary,
+            )
+        }
+        if (showProgress) {
+            CircularProgressIndicator(modifier = Modifier.size(20.dp), strokeWidth = 2.dp)
+        } else {
+            Icon(Icons.Filled.ChevronRight, contentDescription = null)
+        }
    }
 }

@@ -1488,42 +1576,103 @@ private fun NearbyHermesResult(

@Composable
 private fun DashboardManualStep(
+    intent: DashboardEntryIntent,
    address: String,
    onAddressChange: (String) -> Unit,
    busy: Boolean,
    error: String?,
    onBack: () -> Unit,
-    onSubmit: () -> Unit,
+    onSubmit: (String) -> Unit,
 ) {
    val context = LocalContext.current
-    val fieldError = optionalHttpUrlError(address, context)
+    var useCustomAddress by rememberSaveable(intent) { mutableStateOf(false) }
+    val cloudSlugMode = intent == DashboardEntryIntent.Cloud && !useCustomAddress
+    val fieldError = if (cloudSlugMode) {
+        when {
+            address.isBlank() -> null
+            !isValidNousCloudAddressInput(address) -> context.getString(R.string.cw_cloud_slug_error)
+            else -> null
+        }
+    } else {
+        optionalHttpUrlError(address, context)
+    }
+    val resolvedAddress = if (cloudSlugMode) resolveNousCloudDashboardAddress(address) else address.trim()
    Column(modifier = Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(14.dp)) {
        Text(
-            text = stringResource(R.string.cw_manual_hermes_title),
+            text = stringResource(
+                if (intent == DashboardEntryIntent.Cloud) R.string.cw_cloud_entry_title
+                else R.string.cw_manual_hermes_title,
+            ),
            style = MaterialTheme.typography.headlineSmall,
            modifier = Modifier.semantics { heading() },
        )
        Text(
-            text = stringResource(R.string.cw_manual_hermes_description),
+            text = stringResource(
+                if (intent == DashboardEntryIntent.Cloud) R.string.cw_cloud_entry_description
+                else R.string.cw_manual_hermes_description,
+            ),
            style = MaterialTheme.typography.bodyMedium,
            color = MaterialTheme.colorScheme.onSurfaceVariant,
        )
        OutlinedTextField(
            value = address,
-            onValueChange = onAddressChange,
-            label = { Text(stringResource(R.string.cw_hermes_address)) },
-            placeholder = { Text(stringResource(R.string.cw_hermes_address_placeholder)) },
+            onValueChange = { updated ->
+                if (cloudSlugMode && (updated.contains("://") || updated.contains('/'))) {
+                    useCustomAddress = true
+                }
+                onAddressChange(updated)
+            },
+            label = {
+                Text(
+                    stringResource(
+                        if (cloudSlugMode) R.string.cw_cloud_agent_name
+                        else R.string.cw_hermes_address,
+                    )
+                )
+            },
+            placeholder = {
+                Text(
+                    stringResource(
+                        if (cloudSlugMode) R.string.cw_cloud_slug_placeholder
+                        else if (intent == DashboardEntryIntent.Cloud) R.string.cw_cloud_address_placeholder
+                        else R.string.cw_hermes_address_placeholder,
+                    )
+                )
+            },
            supportingText = {
-                Text(fieldError ?: stringResource(R.string.cw_hermes_address_hint))
+                Text(
+                    fieldError ?: stringResource(
+                        if (cloudSlugMode) R.string.cw_cloud_slug_hint
+                        else if (intent == DashboardEntryIntent.Cloud) R.string.cw_cloud_address_hint
+                        else R.string.cw_hermes_address_hint,
+                    )
+                )
            },
            isError = fieldError != null || error != null,
            singleLine = true,
            keyboardOptions = KeyboardOptions(imeAction = ImeAction.Go, autoCorrectEnabled = false),
            keyboardActions = KeyboardActions(onGo = {
-                if (address.isNotBlank() && fieldError == null && !busy) onSubmit()
+                if (address.isNotBlank() && fieldError == null && !busy) onSubmit(resolvedAddress)
            }),
            modifier = Modifier.fillMaxWidth(),
        )
+        if (intent == DashboardEntryIntent.Cloud) {
+            TextButton(
+                onClick = {
+                    useCustomAddress = !useCustomAddress
+                    onAddressChange("")
+                },
+                enabled = !busy,
+                modifier = Modifier.align(Alignment.End),
+            ) {
+                Text(
+                    stringResource(
+                        if (useCustomAddress) R.string.cw_cloud_use_nous_address
+                        else R.string.cw_cloud_use_custom_address,
+                    )
+                )
+            }
+        }
        error?.let {
            Text(it, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.error)
        }
@@ -1532,7 +1681,7 @@ private fun DashboardManualStep(
                Text(stringResource(R.string.cw_back))
            }
            Button(
-                onClick = onSubmit,
+                onClick = { onSubmit(resolvedAddress) },
                enabled = address.isNotBlank() && fieldError == null && !busy,
                modifier = Modifier.weight(1f).heightIn(min = 48.dp),
            ) {
@@ -3093,11 +3242,13 @@ private fun ConfirmStep(
                modifier = Modifier.padding(14.dp),
                verticalArrangement = Arrangement.spacedBy(8.dp),
            ) {
-                LabeledLine(
-                    label = stringResource(R.string.cw_label_api_server),
-                    value = payload.serverUrl,
-                    hint = stringResource(R.string.cw_hint_chat),
-                )
+                if (payload.hasApiServer) {
+                    LabeledLine(
+                        label = stringResource(R.string.cw_label_api_server),
+                        value = payload.serverUrl,
+                        hint = stringResource(R.string.cw_hint_chat),
+                    )
+                }
                if (relayUrl == null) {
                    LabeledLine(
                        label = stringResource(R.string.cw_label_dashboard),
@@ -3108,14 +3259,16 @@ private fun ConfirmStep(
                            ?: stringResource(R.string.cw_value_derived),
                        hint = stringResource(R.string.cw_hint_manage),
                    )
-                    LabeledLine(
-                        label = stringResource(R.string.cw_label_api_key),
-                        value = if (payload.key.isBlank()) {
-                            stringResource(R.string.cw_value_not_included)
-                        } else {
-                            stringResource(R.string.cw_value_included)
-                        },
-                    )
+                    if (payload.hasApiServer) {
+                        LabeledLine(
+                            label = stringResource(R.string.cw_label_api_key),
+                            value = if (payload.key.isBlank()) {
+                                stringResource(R.string.cw_value_not_included)
+                            } else {
+                                stringResource(R.string.cw_value_included)
+                            },
+                        )
+                    }
                }
                if (relayUrl != null) {
                    LabeledLine(
@@ -19,6 +19,7 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
@@ -319,6 +320,31 @@ internal fun shouldDockFloatingPet(
    roamingAllowed: Boolean,
 ): Boolean = !roamingEnabled || !roamingAllowed

+/**
+ * Chat gives a deliberately paused companion one stable home: the live
+ * composer rail. Other routes retain the user's saved free-form edge home, and
+ * active roaming keeps its richer settled-chat habitat hierarchy.
+ */
+internal fun floatingPetHomePoint(
+    route: String?,
+    roamingEnabled: Boolean,
+    roamingAllowed: Boolean,
+    manualHomePoint: PetPoint,
+    roamingHomePoint: PetPoint?,
+    pausedChatDockPoint: PetPoint?,
+): PetPoint = when {
+    route == "chat" && roamingAllowed && !roamingEnabled && pausedChatDockPoint != null -> {
+        pausedChatDockPoint
+    }
+    roamingEnabled && roamingAllowed -> roamingHomePoint ?: manualHomePoint
+    else -> manualHomePoint
+}
+
+internal fun floatingPetAllowsVerticalMoveActions(
+    route: String?,
+    roamingEnabled: Boolean,
+): Boolean = route != "chat" || roamingEnabled
+
 internal fun petRailSupportingPoint(
    rails: Iterable<PetRoamingRail>,
    point: PetPoint,
@@ -465,10 +491,19 @@ fun FloatingPetCompanion(
    onResetPlacement: () -> Unit,
    onHide: () -> Unit,
    onOpenAppearance: () -> Unit,
+    onMenuExpandedChanged: (Boolean) -> Unit = {},
    onExitTerrainDebug: () -> Unit = {},
    modifier: Modifier = Modifier,
 ) {
    var menuExpanded by remember(pet.id) { mutableStateOf(false) }
+    val latestOnMenuExpandedChanged by rememberUpdatedState(onMenuExpandedChanged)
+    fun setMenuExpanded(expanded: Boolean) {
+        menuExpanded = expanded
+        onMenuExpandedChanged(expanded)
+    }
+    DisposableEffect(pet.id) {
+        onDispose { latestOnMenuExpandedChanged(false) }
+    }
    var dragging by remember(pet.id) { mutableStateOf(false) }
    var draggedPoint by remember(pet.id) { mutableStateOf<PetPoint?>(null) }
    var pendingDrop by remember(pet.id) { mutableStateOf<PendingPetDrop?>(null) }
@@ -834,30 +869,47 @@ fun FloatingPetCompanion(
        val requested = placement.sanitized().resolve(safeBounds, petLayoutDirection)
        projectIntoSafeBounds(requested, safeBounds, registeredObstacles) ?: requested
    }
-    val homeRail = remember(roamingRails, manualHomePoint, settledHabitat) {
+    val composerHomeRail = remember(composerRails, manualHomePoint) {
+        val distanceToHome: (PetRoamingRail) -> Float = { rail ->
+            rail.bounds.clamp(manualHomePoint).distanceSquaredTo(manualHomePoint)
+        }
+        composerRails.minByOrNull(distanceToHome)
+    }
+    val homeRail = remember(roamingRails, manualHomePoint, settledHabitat, composerHomeRail) {
        val distanceToHome: (PetRoamingRail) -> Float = { rail ->
            rail.bounds.clamp(manualHomePoint).distanceSquaredTo(manualHomePoint)
        }
        settledHabitat?.rail
-            ?: roamingRails.filter { it.perchKey == CHAT_PET_WALK_REGION }.minByOrNull(distanceToHome)
+            ?: composerHomeRail
            ?: roamingRails.minByOrNull(distanceToHome)
    }
+    fun pointAtPlacementEdge(rail: PetSafeBounds): PetPoint {
+        val xAtEdge = if (
+            (placement.edge == PetLogicalEdge.Start) == (petLayoutDirection == PetLayoutDirection.Ltr)
+        ) rail.left else rail.right
+        return PetPoint(xAtEdge, rail.top)
+    }
    val roamingHomePoint = remember(placement.edge, homeRail, petLayoutDirection) {
-        homeRail?.bounds?.let { rail ->
+        homeRail?.bounds?.let(::pointAtPlacementEdge)
+    }
+    val pausedChatDockPoint = remember(placement.edge, composerHomeRail, petLayoutDirection) {
+        composerHomeRail?.bounds?.let { rail ->
            val xAtEdge = if (
                (placement.edge == PetLogicalEdge.Start) == (petLayoutDirection == PetLayoutDirection.Ltr)
            ) rail.left else rail.right
            PetPoint(xAtEdge, rail.top)
        }
    }
-    // Enabling roaming explicitly docks onto the screen-owned safe rail. A
-    // manual drag or vertical accessibility action pauses roaming first, so the
-    // persisted free-form placement remains visible and authoritative.
-    val homePoint = if (roamingEnabled && roamingAllowed) {
-        roamingHomePoint ?: manualHomePoint
-    } else {
-        manualHomePoint
-    }
+    // Active roaming uses screen-owned terrain. Paused Chat deliberately uses
+    // the composer rail; other routes retain the persisted free-form edge home.
+    val homePoint = floatingPetHomePoint(
+        route = route,
+        roamingEnabled = roamingEnabled,
+        roamingAllowed = roamingAllowed,
+        manualHomePoint = manualHomePoint,
+        roamingHomePoint = roamingHomePoint,
+        pausedChatDockPoint = pausedChatDockPoint,
+    )

    val heldProgress by animateFloatAsState(
        targetValue = if (dragging) 1f else 0f,
@@ -1606,7 +1658,7 @@ fun FloatingPetCompanion(
    // Chat roaming owns a measured composer rail. Publishing before that rail
    // exists lets initialization race route registration and can strand the
    // pet on transient fallback geometry until direct manipulation.
-    val initialTerrainReady = route != "chat" || !roamingEnabled || !roamingAllowed ||
+    val initialTerrainReady = route != "chat" || !roamingAllowed ||
        composerRails.isNotEmpty()
    LaunchedEffect(
        pet.id,
@@ -2350,31 +2402,43 @@ fun FloatingPetCompanion(
                    enabled = floatingPetAcceptsPointerInput(positioned, surfaceScrolling),
                ) {
                    tapReactionNonce += 1
-                    menuExpanded = true
+                    setMenuExpanded(true)
                }
                .semantics(mergeDescendants = true) {
                    role = Role.Button
                    contentDescription = companionDescription
                    stateDescription = stateLabel
-                    customActions = listOf(
-                        CustomAccessibilityAction(moveStartLabel) {
+                    customActions = buildList {
+                        add(CustomAccessibilityAction(moveStartLabel) {
                            onPlacementChanged(placement.copy(edge = PetLogicalEdge.Start)); true
-                        },
-                        CustomAccessibilityAction(moveEndLabel) {
+                        })
+                        add(CustomAccessibilityAction(moveEndLabel) {
                            onPlacementChanged(placement.copy(edge = PetLogicalEdge.End)); true
-                        },
-                        CustomAccessibilityAction(moveUpLabel) {
-                            if (roamingEnabled) onRoamingEnabledChanged(false)
-                            onPlacementChanged(placement.copy(verticalFraction = placement.verticalFraction - 0.15f)); true
-                        },
-                        CustomAccessibilityAction(moveDownLabel) {
-                            if (roamingEnabled) onRoamingEnabledChanged(false)
-                            onPlacementChanged(placement.copy(verticalFraction = placement.verticalFraction + 0.15f)); true
-                        },
-                        CustomAccessibilityAction(resetLabel) { onResetPlacement(); true },
-                        CustomAccessibilityAction(appearanceLabel) { onOpenAppearance(); true },
-                        CustomAccessibilityAction(hideLabel) { onHide(); true },
-                    )
+                        })
+                        // A paused Chat pet has no meaningful vertical free-form
+                        // coordinate: it is deliberately attached to the composer.
+                        // Do not expose TalkBack actions that would appear to do
+                        // nothing; start/end still choose the dock corner.
+                        if (floatingPetAllowsVerticalMoveActions(route, roamingEnabled)) {
+                            add(CustomAccessibilityAction(moveUpLabel) {
+                                if (roamingEnabled) onRoamingEnabledChanged(false)
+                                onPlacementChanged(
+                                    placement.copy(verticalFraction = placement.verticalFraction - 0.15f),
+                                )
+                                true
+                            })
+                            add(CustomAccessibilityAction(moveDownLabel) {
+                                if (roamingEnabled) onRoamingEnabledChanged(false)
+                                onPlacementChanged(
+                                    placement.copy(verticalFraction = placement.verticalFraction + 0.15f),
+                                )
+                                true
+                            })
+                        }
+                        add(CustomAccessibilityAction(resetLabel) { onResetPlacement(); true })
+                        add(CustomAccessibilityAction(appearanceLabel) { onOpenAppearance(); true })
+                        add(CustomAccessibilityAction(hideLabel) { onHide(); true })
+                    }
                },
            contentAlignment = Alignment.Center,
        ) {
@@ -2419,7 +2483,7 @@ fun FloatingPetCompanion(

            DropdownMenu(
                expanded = menuExpanded,
-                onDismissRequest = { menuExpanded = false },
+                onDismissRequest = { setMenuExpanded(false) },
            ) {
                DropdownMenuItem(
                    text = { Text("${pet.label} · $stateLabel", color = MaterialTheme.colorScheme.onSurfaceVariant) },
@@ -2436,28 +2500,28 @@ fun FloatingPetCompanion(
                        )
                    },
                    onClick = {
-                        menuExpanded = false
+                        setMenuExpanded(false)
                        onRoamingEnabledChanged(!roamingEnabled)
                    },
                )
                DropdownMenuItem(
                    text = { Text(resetLabel) },
                    onClick = {
-                        menuExpanded = false
+                        setMenuExpanded(false)
                        onResetPlacement()
                    },
                )
                DropdownMenuItem(
                    text = { Text(appearanceLabel) },
                    onClick = {
-                        menuExpanded = false
+                        setMenuExpanded(false)
                        onOpenAppearance()
                    },
                )
                DropdownMenuItem(
                    text = { Text(hideLabel) },
                    onClick = {
-                        menuExpanded = false
+                        setMenuExpanded(false)
                        onHide()
                    },
                )
@@ -2,7 +2,6 @@ package com.hermesandroid.relay.ui.components

 import android.content.Context
 import android.graphics.Bitmap
-import android.graphics.BitmapFactory
 import android.graphics.pdf.PdfRenderer
 import android.media.MediaMetadataRetriever
 import android.net.Uri
@@ -290,7 +289,7 @@ private fun ImageRender(
                        android.util.Base64.decode(attachment.content, android.util.Base64.DEFAULT)
                    else -> null
                }
-                bytes?.let { BitmapFactory.decodeByteArray(it, 0, it.size)?.asImageBitmap() }
+                bytes?.let { decodeOrientedBitmap(it)?.asImageBitmap() }
            }.getOrNull()
        }
        if (decoded != null) bitmap = decoded else decodeFailed = true
@@ -1,6 +1,11 @@
 package com.hermesandroid.relay.ui.components

+import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.animateContentSize
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
 import androidx.compose.animation.core.LinearOutSlowInEasing
 import androidx.compose.animation.core.RepeatMode
 import androidx.compose.animation.core.animateFloat
@@ -32,15 +37,20 @@ import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.foundation.text.selection.DisableSelection
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.VolumeUp
+import androidx.compose.material.icons.filled.ContentCopy
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material.icons.filled.FormatQuote
+import androidx.compose.material.icons.filled.Stop
 import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.material3.DropdownMenu
 import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
@@ -71,13 +81,16 @@ import com.hermesandroid.relay.data.HermesCardAction
 import com.hermesandroid.relay.data.MediaSettingsRepository
 import com.hermesandroid.relay.data.MessageDeliveryStatus
 import com.hermesandroid.relay.data.MessageRole
+import com.hermesandroid.relay.data.parseChatQuotedPrompt
+import com.hermesandroid.relay.ui.components.pet.petObstacleSurface
 import com.hermesandroid.relay.ui.components.pet.petPerchSurface
 import com.hermesandroid.relay.ui.components.pet.petVisitTargetSurface
 import com.hermesandroid.relay.ui.theme.leftEdgeGlow
-import kotlinx.coroutines.delay
 import java.text.SimpleDateFormat
 import java.util.Date

+internal const val CHAT_PET_IDENTITY_OBSTACLE_PREFIX = "chat-message-identity:"
+
@OptIn(ExperimentalFoundationApi::class)
@Composable
 fun MessageBubble(
@@ -88,23 +101,31 @@ fun MessageBubble(
    isFirstInGroup: Boolean = true,
    isLastInGroup: Boolean = true,
    /**
-     * Keeps a just-completed live tail on its stable Text layout. The owning
-     * list releases this once another row becomes the tail, allowing full
-     * Markdown to render without disturbing the visible bottom anchor.
+     * Keeps the current live tail on its stable Text layout while a final
+     * streaming frame commits. The owning list releases it immediately after
+     * completion so the same row transitions to full Markdown with its bottom
+     * anchor preserved.
     */
    retainStreamingLayout: Boolean = false,
    onCopyMessage: (String) -> Unit = {},
    /**
-     * Quote this message into the input field. Null hides the Quote entry in
-     * the long-press menu, so legacy call sites keep the copy-only behavior.
+     * Select this message as a structured composer quote. Null hides Quote.
     */
-    onQuoteMessage: ((String) -> Unit)? = null,
+    onQuoteMessage: ((ChatMessage) -> Unit)? = null,
+    /** Navigate a rendered quote chip to its original message id. */
+    onNavigateToMessage: ((String) -> Unit)? = null,
+    /** Open an upstream @session:<profile>/<id> reference in app. */
+    onSessionReference: ((SessionReference) -> Unit)? = null,
+    /** React to the newest message for this role; null removes the reaction. */
+    onReact: ((String?) -> Unit)? = null,
    /**
     * Reads a completed assistant response through the active voice renderer.
     * Null hides the entry; the owning screen uses that to limit the action to
     * idle Conversation voice sessions.
     */
    onSpeakMessage: ((String) -> Unit)? = null,
+    /** Stops a message-context narration currently owned by the voice pipeline. */
+    onStopSpeaking: (() -> Unit)? = null,
    /**
     * Invoked when the user taps a FAILED inbound attachment card.
     * `attachmentIndex` is the position in [ChatMessage.attachments] so the
@@ -150,9 +171,11 @@ fun MessageBubble(
    imageGenerationRotationIndex: Int = 0,
    petVisitTargetKey: String? = null,
    petPerchKey: String? = null,
+    animationEnabled: Boolean = true,
 ) {
    val isUser = message.role == MessageRole.USER
    val isSystem = message.role == MessageRole.SYSTEM
+    val sessionReferences = remember(message.content) { parseSessionReferences(message.content) }

    // Phone/voice-origin action bubble marker.
    //
@@ -203,18 +226,19 @@ fun MessageBubble(
    val alignment = if (isUser) Alignment.End else Alignment.Start
    val locale = LocalLocale.current.platformLocale
    val timeFormat = remember(locale) { SimpleDateFormat("h:mm a", locale) }
-    val a11yDescription = "${message.role.name.lowercase()} message: ${message.content.take(100)}"
+    val quoteEnvelope = remember(message.content) { parseChatQuotedPrompt(message.content) }
+    val visibleMessageContent = quoteEnvelope?.body ?: message.content
    val isDarkTheme = LocalBrand.current.isDark

    // Pull generated/inline image links (`![alt](src)`) out of assistant
    // content so they render as real images (remote URLs via Coil) or a
    // graceful inline notice — not the blank element the markdown renderer
    // emits for an image link. User/system bubbles keep their raw content.
-    val (markdownBody, inlineImages) = remember(message.content, isUser, isSystem) {
+    val (markdownBody, inlineImages) = remember(visibleMessageContent, isUser, isSystem) {
        if (isUser || isSystem) {
-            message.content to emptyList()
+            visibleMessageContent to emptyList()
        } else {
-            extractChatInlineImages(message.content)
+            extractChatInlineImages(visibleMessageContent)
        }
    }
    val showImageGeneration = shouldShowImageGenerationPlaceholder(
@@ -222,6 +246,26 @@ fun MessageBubble(
        isStreaming = message.isStreaming,
        hasMediaResult = message.attachments.isNotEmpty() || inlineImages.isNotEmpty(),
    )
+    val streamingStatusLabel = if (
+        !isUser &&
+        !isSystem &&
+        message.isStreaming &&
+        message.content.isBlank() &&
+        !showImageGeneration
+    ) {
+        if (recoveringAnswer) {
+            stringResource(R.string.msg_bubble_reconnecting)
+        } else {
+            stringResource(R.string.msg_bubble_still_working)
+        }
+    } else {
+        null
+    }
+    val a11yDescription = buildString {
+        append(message.role.name.lowercase())
+        append(" message: ")
+        append(streamingStatusLabel ?: visibleMessageContent.take(100))
+    }
    val hasImageGenerationCall = remember(message.toolCalls) {
        message.toolCalls.any {
            it.name.trim().lowercase() == "image_generate"
@@ -250,52 +294,36 @@ fun MessageBubble(
    val blurMode by blurRepo.blurMode.collectAsState(initial = BlurMode.FLAGGED)

    CompositionLocalProvider(LocalMediaBlurMode provides blurMode) {
-    // The active profile image is sender identity, distinct from both the
-    // floating pet companion and the ambient Sphere. Reserve one stable gutter
-    // for an assistant run and render the identity only on its first message.
-    Row(
+    Column(
        modifier = modifier.fillMaxWidth(),
-        verticalAlignment = Alignment.Top,
+        horizontalAlignment = alignment,
    ) {
-    if (!isUser && !isSystem) {
-        Box(
-            modifier = Modifier.width(40.dp),
-            contentAlignment = Alignment.TopCenter,
-        ) {
-            if (shouldShowMessageGroupAvatar(
-                    isUser = isUser,
-                    isSystem = isSystem,
-                    isFirstInGroup = isFirstInGroup,
-                    agentName = message.agentName,
-                )
+        // Keep sender identity in the first-message label rather than a
+        // persistent leading column. Long responses and every follow-up in the
+        // group therefore retain the full bubble-width allowance.
+        if (!isUser && !isSystem && isFirstInGroup && !message.agentName.isNullOrBlank()) {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(6.dp),
+                modifier = Modifier
+                    .padding(bottom = 3.dp, start = 4.dp)
+                    .petObstacleSurface(
+                        key = "$CHAT_PET_IDENTITY_OBSTACLE_PREFIX${message.uiKey}",
+                        routes = setOf("chat"),
+                    ),
            ) {
                Surface(
                    // Decorative: the adjacent visible agent name already owns
                    // the identity announcement, avoiding duplicate TalkBack copy.
-                    modifier = Modifier.size(32.dp),
+                    modifier = Modifier.size(24.dp),
                    shape = CircleShape,
                    color = MaterialTheme.colorScheme.primary,
                ) {
                    AgentAvatarFace(
                        name = message.agentName.orEmpty(),
-                        letterStyle = MaterialTheme.typography.labelMedium,
+                        letterStyle = MaterialTheme.typography.labelSmall,
                    )
                }
-            }
-        }
-    }
-    Column(
-        modifier = Modifier.weight(1f),
-        horizontalAlignment = alignment
-    ) {
-        // Agent name label sits beside the first group identity avatar. Pet
-        // companions never enter this row.
-        if (!isUser && !isSystem && isFirstInGroup && !message.agentName.isNullOrBlank()) {
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.spacedBy(4.dp),
-                modifier = Modifier.padding(bottom = 2.dp, start = 4.dp),
-            ) {
                Text(
                    text = localizeAgentName(message.agentName),
                    style = MaterialTheme.typography.labelSmall,
@@ -330,7 +358,7 @@ fun MessageBubble(
        }

        // Thinking block (above the bubble, only for assistant messages)
-        if (!isUser && showThinking && message.thinkingContent.isNotEmpty()) {
+        if (!isUser && showThinking && message.thinkingContent.isNotBlank()) {
            ThinkingBlock(
                thinkingContent = message.thinkingContent,
                isStreaming = message.isThinkingStreaming,
@@ -379,12 +407,22 @@ fun MessageBubble(
        // carries only thinking and/or tool calls (both rendered OUTSIDE
        // this Surface — the ThinkingBlock above, the tool pills as separate
        // rows) would otherwise paint a bare timestamp-only chip between the
-        // Thought-process block and the tool pill. Keep the bubble while
-        // streaming (StreamingDots is the live "working" indicator) and
-        // whenever there are cards/attachments to render inside it.
+        // Thought-process block and the tool pill. The first-token working state
+        // is rendered directly in the conversation
+        // lane below, without an opaque bubble. Cards and attachments still own
+        // a normal bubble even when response prose has not arrived yet.
+        streamingStatusLabel?.let { streamingStatus ->
+            StandaloneStreamingStatus(
+                status = streamingStatus,
+                accessibilityDescription = a11yDescription,
+                textColor = textColor,
+                modifier = Modifier.padding(start = 12.dp, top = 4.dp, bottom = 6.dp),
+            )
+        }
+
        val showBubble = isUser || isSystem ||
-            message.content.isNotBlank() ||
-            message.isStreaming ||
+            visibleMessageContent.isNotBlank() ||
+            quoteEnvelope != null ||
            showImageGeneration ||
            message.cards.isNotEmpty() ||
            message.attachments.isNotEmpty() ||
@@ -399,19 +437,25 @@ fun MessageBubble(
                    modifier = Modifier
                        .padding(top = 8.dp, bottom = 8.dp, end = 6.dp)
                        .width(3.dp)
-                        .height(if (message.content.isBlank()) 14.dp else 24.dp)
+                        .height(if (visibleMessageContent.isBlank()) 14.dp else 24.dp)
                        .clip(CircleShape)
                        .background(MaterialTheme.colorScheme.tertiary.copy(alpha = 0.85f))
                )
            }
-        // Long-press opens a compact action menu when a quote handler is
-        // wired; with copy as the only action it stays a direct copy so the
-        // one-action case doesn't pay a menu tap.
+        Column(horizontalAlignment = alignment) {
+        // A normal tap reveals the compact action strip. Long-press preserves
+        // the existing overflow menu (or direct-copy shortcut when Copy is the
+        // only available action).
        var showMessageActions by remember { mutableStateOf(false) }
+        var showInlineActions by remember(message.uiKey) { mutableStateOf(false) }
        val haptic = LocalHapticFeedback.current
+        val accessibleMotion = rememberAccessibleMotionState()
+        val animateInlineActions = animationEnabled && accessibleMotion.osAnimations &&
+            !accessibleMotion.touchExploration
        val showEditAction = onEditMessage != null && isUser
        val showSpeakAction = shouldShowSpeakResponseAction(message, onSpeakMessage != null)
-        if (onQuoteMessage != null || showEditAction || showSpeakAction) {
+        val showStopSpeakingAction = shouldShowStopSpeakingAction(message, onStopSpeaking != null)
+        if (onQuoteMessage != null || onReact != null || showEditAction || showSpeakAction || showStopSpeakingAction) {
            DropdownMenu(
                expanded = showMessageActions,
                onDismissRequest = { showMessageActions = false },
@@ -420,7 +464,7 @@ fun MessageBubble(
                    text = { Text(stringResource(R.string.msg_bubble_copy)) },
                    onClick = {
                        showMessageActions = false
-                        onCopyMessage(message.content)
+                        onCopyMessage(visibleMessageContent)
                    },
                )
                if (onQuoteMessage != null) {
@@ -428,7 +472,7 @@ fun MessageBubble(
                        text = { Text(stringResource(R.string.msg_bubble_quote)) },
                        onClick = {
                            showMessageActions = false
-                            onQuoteMessage(message.content)
+                            onQuoteMessage(message.copy(content = visibleMessageContent))
                        },
                    )
                }
@@ -443,7 +487,22 @@ fun MessageBubble(
                        },
                        onClick = {
                            showMessageActions = false
-                            onSpeakMessage?.invoke(message.content)
+                            onSpeakMessage?.invoke(visibleMessageContent)
+                        },
+                    )
+                }
+                if (showStopSpeakingAction) {
+                    DropdownMenuItem(
+                        text = { Text(stringResource(R.string.msg_bubble_stop_speaking)) },
+                        leadingIcon = {
+                            Icon(
+                                imageVector = Icons.Filled.Stop,
+                                contentDescription = null,
+                            )
+                        },
+                        onClick = {
+                            showMessageActions = false
+                            onStopSpeaking?.invoke()
                        },
                    )
                }
@@ -492,16 +551,19 @@ fun MessageBubble(
                    } else Modifier
                )
                .combinedClickable(
-                    onClick = {},
+                    onClick = { showInlineActions = !showInlineActions },
                    onLongClick = {
                        // Buzz the instant the long-press registers — opening the
                        // action menu is the discoverability moment, so it gets the
                        // same tactile confirm every chat app fires.
                        haptic.performHapticFeedback(HapticFeedbackType.LongPress)
-                        if (onQuoteMessage != null || showEditAction || showSpeakAction) {
+                        if (
+                            onQuoteMessage != null || showEditAction || showSpeakAction ||
+                            showStopSpeakingAction
+                        ) {
                            showMessageActions = true
                        } else {
-                            onCopyMessage(message.content)
+                            onCopyMessage(visibleMessageContent)
                        }
                    }
                )
@@ -527,12 +589,23 @@ fun MessageBubble(
                    }
                )
        ) {
-            Column(modifier = Modifier.padding(horizontal = 14.dp, vertical = 9.dp)) {
+            Column(
+                modifier = Modifier.padding(horizontal = 14.dp, vertical = 9.dp),
+            ) {
+                quoteEnvelope?.let { envelope ->
+                    ChatQuoteReferenceChip(
+                        reference = envelope.reference,
+                        onOpenOriginal = onNavigateToMessage?.let { navigate ->
+                            { navigate(envelope.reference.messageId) }
+                        },
+                        modifier = Modifier.padding(bottom = 7.dp),
+                    )
+                }
                val messageTextContent: @Composable () -> Unit = {
                    if (isUser || isSystem) {
                        // Plain text for user and system messages
                        Text(
-                            text = message.content,
+                            text = visibleMessageContent,
                            style = MaterialTheme.typography.bodyMedium.copy(
                                fontSize = 15.sp,
                                lineHeight = 21.sp,
@@ -540,11 +613,10 @@ fun MessageBubble(
                            color = textColor
                        )
                    } else {
-                        // Keep one plain Text node stable while content grows
-                        // and while this completed response remains the visible
-                        // tail. Full Markdown renders once another row becomes
-                        // the tail (or the session is revisited), where its
-                        // remeasure cannot reset the active viewport.
+                        // Keep one plain Text node stable only while content is
+                        // incomplete (plus the final committed live frame).
+                        // Completion releases this flag and selects the full
+                        // Markdown tree on the same stable message row.
                        if (markdownBody.isNotEmpty()) {
                            StreamingMarkdownContent(
                                content = markdownBody,
@@ -559,7 +631,7 @@ fun MessageBubble(
                // a live Text node becomes a Markdown tree, or settled
                // Markdown content changes its node topology, so a handle
                // cannot keep pointing at a removed selectable.
-                if (showSpeakAction) {
+                if (showSpeakAction || showStopSpeakingAction) {
                    DisableSelection { messageTextContent() }
                } else {
                    key(
@@ -573,6 +645,35 @@ fun MessageBubble(
                        SelectionContainer { messageTextContent() }
                    }
                }
+                if (onReact != null) {
+                    listOf("👍", "❤️", "😂").forEach { emoji ->
+                        DropdownMenuItem(
+                            text = { Text("React $emoji") },
+                            onClick = {
+                                showMessageActions = false
+                                onReact(emoji)
+                            },
+                        )
+                    }
+                    DropdownMenuItem(
+                        text = { Text("Remove reaction") },
+                        onClick = {
+                            showMessageActions = false
+                            onReact(null)
+                        },
+                    )
+                }
+
+                if (onSessionReference != null && sessionReferences.isNotEmpty()) {
+                    sessionReferences.forEach { reference ->
+                        TextButton(
+                            onClick = { onSessionReference(reference) },
+                            modifier = Modifier.padding(top = 2.dp),
+                        ) {
+                            Text("Open ${reference.label}")
+                        }
+                    }
+                }

                // Inline generated images (assistant only) — rendered OUTSIDE
                // the SelectionContainer (they're not selectable text). Remote
@@ -687,64 +788,6 @@ fun MessageBubble(
                        }
                }

-                // Streaming indicator — only while awaiting the first token. Once
-                // text starts flowing, the growing reply is itself the progress
-                // signal, so the pulsing dots stop (Messenger/Telegram drop the
-                // typing bubble the moment content appears) instead of throbbing
-                // under the text for the whole turn.
-                if (
-                    message.isStreaming &&
-                    message.content.isBlank() &&
-                    !showImageGeneration
-                ) {
-                    // After a few seconds with no content yet, escalate the bare
-                    // dots to a labeled "Still working…" so a slow first token
-                    // never reads as a hang on the SSE / sessions paths.
-                    val awaitingFirstToken = message.content.isBlank()
-                    var showStillWorking by remember(message.id) { mutableStateOf(false) }
-                    LaunchedEffect(message.id, awaitingFirstToken) {
-                        showStillWorking = false
-                        if (awaitingFirstToken) {
-                            delay(4_000)
-                            showStillWorking = true
-                        }
-                    }
-                    val thinkingIndicator = LocalThinkingIndicator.current
-                    Row(verticalAlignment = Alignment.CenterVertically) {
-                        when (thinkingIndicator.style) {
-                            ThinkingIndicatorStyle.Matrix -> DotMatrixIndicator(
-                                // Auto follows the bubble text color; accents
-                                // come from the brand palette. The grid modulates
-                                // its own alpha (idle dots ≈0.18, lit dots 1.0).
-                                color = thinkingIndicator.color.toColor(autoColor = textColor),
-                                pattern = thinkingIndicator.pattern,
-                                animated = thinkingIndicator.animated,
-                                modifier = Modifier.padding(top = 4.dp),
-                            )
-                            ThinkingIndicatorStyle.Dots -> StreamingDots(
-                                color = textColor.copy(alpha = 0.6f),
-                                modifier = Modifier.padding(top = 4.dp),
-                            )
-                        }
-                        // During dropped-stream answer recovery the label shows
-                        // immediately (the 4s escalation is for a slow first
-                        // token; a recovery is already known to be slow).
-                        if ((showStillWorking || recoveringAnswer) && awaitingFirstToken) {
-                            Spacer(modifier = Modifier.width(8.dp))
-                            Text(
-                                text = if (recoveringAnswer) {
-                                    stringResource(R.string.msg_bubble_reconnecting)
-                                } else {
-                                    stringResource(R.string.msg_bubble_still_working)
-                                },
-                                style = MaterialTheme.typography.labelSmall,
-                                color = textColor.copy(alpha = 0.6f),
-                                modifier = Modifier.padding(top = 4.dp),
-                            )
-                        }
-                    }
-                }
-
                // Timestamp — only on the LAST bubble of a same-author run so a
                // burst of fragments doesn't stack three near-touching time labels.
                // Grouping breaks on a >5min gap (ChatScreen), so every pause still
@@ -771,23 +814,17 @@ fun MessageBubble(
                // message routed over the relay proactive channel). Null on every
                // ordinary chat message, which render nothing here.
                message.deliveryStatus?.takeIf { isUser }?.let { status ->
-                    val label = stringResource(
-                        when (status) {
-                            MessageDeliveryStatus.SENDING -> R.string.msg_bubble_sending
-                            MessageDeliveryStatus.DELIVERED -> R.string.msg_bubble_delivered
-                            MessageDeliveryStatus.FAILED -> R.string.msg_bubble_not_sent
-                        }
-                    )
-                    val alpha = when (status) {
-                        MessageDeliveryStatus.SENDING -> 0.5f
-                        MessageDeliveryStatus.DELIVERED -> 0.5f
-                        MessageDeliveryStatus.FAILED -> 0.7f
-                    }
                    Spacer(modifier = Modifier.height(2.dp))
-                    Text(
-                        text = label,
-                        style = MaterialTheme.typography.labelSmall,
-                        color = textColor.copy(alpha = alpha),
+                    MessageDeliveryIndicator(
+                        status = status,
+                        text = MessageDeliveryIndicatorText(
+                            sending = stringResource(R.string.msg_bubble_sending),
+                            queued = stringResource(R.string.msg_bubble_queued),
+                            steered = stringResource(R.string.msg_bubble_steered),
+                            delivered = stringResource(R.string.msg_bubble_delivered),
+                            failed = stringResource(R.string.msg_bubble_not_sent),
+                            tapToRetry = stringResource(R.string.chat_retry),
+                        ),
                    )
                }

@@ -801,13 +838,127 @@ fun MessageBubble(
                }
            }
        }
+        val inlineActions: @Composable () -> Unit = {
+            MessageInlineActions(
+                showQuote = onQuoteMessage != null,
+                showSpeak = showSpeakAction,
+                showStopSpeaking = showStopSpeakingAction,
+                showEdit = showEditAction,
+                onCopy = {
+                    showInlineActions = false
+                    onCopyMessage(visibleMessageContent)
+                },
+                onQuote = {
+                    showInlineActions = false
+                    onQuoteMessage?.invoke(message.copy(content = visibleMessageContent))
+                },
+                onSpeak = {
+                    showInlineActions = false
+                    onSpeakMessage?.invoke(visibleMessageContent)
+                },
+                onStopSpeaking = {
+                    showInlineActions = false
+                    onStopSpeaking?.invoke()
+                },
+                onEdit = {
+                    showInlineActions = false
+                    onEditMessage?.invoke(message)
+                },
+            )
+        }
+        if (animateInlineActions) {
+            AnimatedVisibility(
+                visible = showInlineActions,
+                enter = fadeIn(tween(120)) + expandVertically(
+                    animationSpec = tween(180, easing = LinearOutSlowInEasing),
+                    expandFrom = Alignment.Top,
+                ),
+                exit = fadeOut(tween(90)) + shrinkVertically(
+                    animationSpec = tween(140),
+                    shrinkTowards = Alignment.Top,
+                ),
+            ) {
+                inlineActions()
+            }
+        } else if (showInlineActions) {
+            inlineActions()
+        }
+        } // end Column (bubble + revealed actions)
        } // end Row (bubble + optional leading accent bar)
        } // end if (showBubble)
    } // end content Column
-    } // end Row (avatar gutter + content)
    } // end CompositionLocalProvider(LocalMediaBlurMode)
 }

+@Composable
+private fun MessageInlineActions(
+    showQuote: Boolean,
+    showSpeak: Boolean,
+    showStopSpeaking: Boolean,
+    showEdit: Boolean,
+    onCopy: () -> Unit,
+    onQuote: () -> Unit,
+    onSpeak: () -> Unit,
+    onStopSpeaking: () -> Unit,
+    onEdit: () -> Unit,
+) {
+    Surface(
+        shape = RoundedCornerShape(12.dp),
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        tonalElevation = 2.dp,
+        modifier = Modifier.padding(top = 2.dp),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier.padding(horizontal = 2.dp),
+        ) {
+            IconButton(onClick = onCopy, modifier = Modifier.size(48.dp)) {
+                Icon(
+                    imageVector = Icons.Filled.ContentCopy,
+                    contentDescription = stringResource(R.string.msg_bubble_copy),
+                    modifier = Modifier.size(18.dp),
+                )
+            }
+            if (showQuote) {
+                IconButton(onClick = onQuote, modifier = Modifier.size(48.dp)) {
+                    Icon(
+                        imageVector = Icons.Filled.FormatQuote,
+                        contentDescription = stringResource(R.string.msg_bubble_quote),
+                        modifier = Modifier.size(18.dp),
+                    )
+                }
+            }
+            if (showSpeak) {
+                IconButton(onClick = onSpeak, modifier = Modifier.size(48.dp)) {
+                    Icon(
+                        imageVector = Icons.AutoMirrored.Filled.VolumeUp,
+                        contentDescription = stringResource(R.string.msg_bubble_speak_response),
+                        modifier = Modifier.size(18.dp),
+                    )
+                }
+            }
+            if (showStopSpeaking) {
+                IconButton(onClick = onStopSpeaking, modifier = Modifier.size(48.dp)) {
+                    Icon(
+                        imageVector = Icons.Filled.Stop,
+                        contentDescription = stringResource(R.string.msg_bubble_stop_speaking),
+                        modifier = Modifier.size(18.dp),
+                    )
+                }
+            }
+            if (showEdit) {
+                IconButton(onClick = onEdit, modifier = Modifier.size(48.dp)) {
+                    Icon(
+                        imageVector = Icons.Filled.Edit,
+                        contentDescription = stringResource(R.string.msg_bubble_edit),
+                        modifier = Modifier.size(18.dp),
+                    )
+                }
+            }
+        }
+    }
+}
+
 internal data class MessageSelectionTopologyKey(
    val renderer: String,
    val markdownBody: String?,
@@ -881,6 +1032,15 @@ internal fun shouldShowSpeakResponseAction(
        !message.isStreaming &&
        message.content.isNotBlank()

+internal fun shouldShowStopSpeakingAction(
+    message: ChatMessage,
+    handlerAvailable: Boolean,
+): Boolean =
+    handlerAvailable &&
+        message.role == MessageRole.ASSISTANT &&
+        !message.isStreaming &&
+        message.content.isNotBlank()
+
 internal fun shouldShowMessageGroupAvatar(
    isUser: Boolean,
    isSystem: Boolean,
@@ -918,6 +1078,42 @@ private fun MessagePathBadge(text: String, leadingIcon: ImageVector? = null) {
    }
 }

+/** First-token progress rendered in the conversation lane, not inside a message bubble. */
+@Composable
+private fun StandaloneStreamingStatus(
+    status: String,
+    accessibilityDescription: String,
+    textColor: Color,
+    modifier: Modifier = Modifier,
+) {
+    val thinkingIndicator = LocalThinkingIndicator.current
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(5.dp),
+        modifier = modifier.clearAndSetSemantics {
+            contentDescription = accessibilityDescription
+        },
+    ) {
+        when (thinkingIndicator.style) {
+            ThinkingIndicatorStyle.Matrix -> DotMatrixIndicator(
+                color = thinkingIndicator.color.toColor(autoColor = textColor),
+                pattern = thinkingIndicator.pattern,
+                animated = thinkingIndicator.animated,
+            )
+            ThinkingIndicatorStyle.Dots -> StreamingDots(
+                color = textColor.copy(alpha = 0.6f),
+            )
+        }
+        Text(
+            text = status,
+            style = MaterialTheme.typography.labelSmall,
+            color = textColor.copy(alpha = 0.68f),
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
+
 /**
 * Three dots that animate opacity in sequence to indicate streaming is in progress.
 */
@@ -0,0 +1,167 @@
+package com.hermesandroid.relay.ui.components
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.Send
+import androidx.compose.material.icons.filled.Bolt
+import androidx.compose.material.icons.filled.CheckCircle
+import androidx.compose.material.icons.filled.ErrorOutline
+import androidx.compose.material.icons.filled.Schedule
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.minimumInteractiveComponentSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.data.MessageDeliveryStatus
+import com.hermesandroid.relay.ui.theme.relayMetadataStyle
+
+/**
+ * Localized copy for [MessageDeliveryIndicator]. Keeping copy at the call site
+ * lets MessageBubble use Android string resources without coupling this small
+ * presentation component to a particular resource catalog.
+ */
+data class MessageDeliveryIndicatorText(
+    val sending: String,
+    val queued: String,
+    val steered: String,
+    val delivered: String,
+    val failed: String,
+    val tapToRetry: String,
+)
+
+/**
+ * Compact, accessible lifecycle feedback for a user-authored chat message.
+ *
+ * Every state has both a distinct icon and a visible text label, so meaning is
+ * never carried by color alone. A failed state becomes a button only when
+ * [onRetry] is supplied; its entire 48dp row is then the retry target.
+ */
+@Composable
+fun MessageDeliveryIndicator(
+    status: MessageDeliveryStatus,
+    text: MessageDeliveryIndicatorText,
+    modifier: Modifier = Modifier,
+    failureMessage: String? = null,
+    onRetry: (() -> Unit)? = null,
+) {
+    val retryAction = onRetry.takeIf { status == MessageDeliveryStatus.FAILED }
+    val retryable = retryAction != null
+    val line = messageDeliveryStatusLine(
+        status = status,
+        text = text,
+        failureMessage = failureMessage,
+        retryable = retryable,
+    )
+    val presentation = messageDeliveryPresentation(status)
+    val tint = when (presentation.colorRole) {
+        DeliveryColorRole.NEUTRAL -> MaterialTheme.colorScheme.onSurfaceVariant
+        DeliveryColorRole.ACCENT -> MaterialTheme.colorScheme.primary
+        DeliveryColorRole.QUEUED -> MaterialTheme.colorScheme.tertiary
+        DeliveryColorRole.ERROR -> MaterialTheme.colorScheme.error
+    }
+
+    Row(
+        modifier = modifier
+            .then(
+                if (retryable) {
+                    Modifier
+                        .minimumInteractiveComponentSize()
+                        .clickable(
+                            role = Role.Button,
+                            onClickLabel = text.tapToRetry,
+                            onClick = retryAction,
+                        )
+                } else {
+                    Modifier
+                },
+            )
+            .semantics(mergeDescendants = true) {
+                contentDescription = line
+                liveRegion = LiveRegionMode.Polite
+            }
+            .padding(horizontal = 2.dp, vertical = 2.dp),
+        horizontalArrangement = Arrangement.spacedBy(4.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Icon(
+            imageVector = presentation.icon,
+            contentDescription = null,
+            tint = tint,
+            modifier = Modifier.size(14.dp),
+        )
+        Text(
+            text = line,
+            style = relayMetadataStyle(),
+            color = tint,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
+
+internal fun messageDeliveryStatusLine(
+    status: MessageDeliveryStatus,
+    text: MessageDeliveryIndicatorText,
+    failureMessage: String? = null,
+    retryable: Boolean = false,
+): String {
+    val label = when (status) {
+        MessageDeliveryStatus.SENDING -> text.sending
+        MessageDeliveryStatus.QUEUED -> text.queued
+        MessageDeliveryStatus.STEERED -> text.steered
+        MessageDeliveryStatus.DELIVERED -> text.delivered
+        MessageDeliveryStatus.FAILED -> text.failed
+    }
+    if (status != MessageDeliveryStatus.FAILED) return label
+
+    return buildList {
+        add(label)
+        failureMessage?.trim()?.takeIf(String::isNotEmpty)?.let(::add)
+        if (retryable) add(text.tapToRetry)
+    }.joinToString(" · ")
+}
+
+private data class DeliveryPresentation(
+    val icon: ImageVector,
+    val colorRole: DeliveryColorRole,
+)
+
+private enum class DeliveryColorRole { NEUTRAL, ACCENT, QUEUED, ERROR }
+
+private fun messageDeliveryPresentation(status: MessageDeliveryStatus): DeliveryPresentation =
+    when (status) {
+        MessageDeliveryStatus.SENDING -> DeliveryPresentation(
+            icon = Icons.AutoMirrored.Filled.Send,
+            colorRole = DeliveryColorRole.NEUTRAL,
+        )
+        MessageDeliveryStatus.QUEUED -> DeliveryPresentation(
+            icon = Icons.Filled.Schedule,
+            colorRole = DeliveryColorRole.QUEUED,
+        )
+        MessageDeliveryStatus.STEERED -> DeliveryPresentation(
+            icon = Icons.Filled.Bolt,
+            colorRole = DeliveryColorRole.ACCENT,
+        )
+        MessageDeliveryStatus.DELIVERED -> DeliveryPresentation(
+            icon = Icons.Filled.CheckCircle,
+            colorRole = DeliveryColorRole.ACCENT,
+        )
+        MessageDeliveryStatus.FAILED -> DeliveryPresentation(
+            icon = Icons.Filled.ErrorOutline,
+            colorRole = DeliveryColorRole.ERROR,
+        )
+    }
@@ -85,7 +85,12 @@ fun ModelPickerSheet(
    // (the caller sorts is_current to the front).
    val otherGroupLabel = stringResource(R.string.model_picker_other)
    val grouped = remember(filtered, otherGroupLabel) {
-        filtered.groupBy { it.group?.takeIf { g -> g.isNotBlank() } ?: otherGroupLabel }
+        filtered.groupBy { option ->
+            ModelPickerGroupIdentity(
+                provider = option.provider?.trim()?.lowercase().orEmpty(),
+                label = option.group?.takeIf { it.isNotBlank() } ?: otherGroupLabel,
+            )
+        }
    }

    ModalBottomSheet(
@@ -180,10 +185,10 @@ fun ModelPickerSheet(
                    }
                }

-                grouped.forEach { (provider, opts) ->
-                    item(key = "header_$provider") {
+                grouped.forEach { (group, opts) ->
+                    item(key = modelPickerHeaderKey(group)) {
                        Text(
-                            text = provider,
+                            text = group.label,
                            style = MaterialTheme.typography.labelMedium,
                            color = MaterialTheme.colorScheme.primary,
                            modifier = Modifier.padding(
@@ -191,7 +196,7 @@ fun ModelPickerSheet(
                            ),
                        )
                    }
-                    items(items = opts, key = { "$provider:${it.value}" }) { opt ->
+                    items(items = opts, key = ::modelPickerOptionKey) { opt ->
                        ModelPickerRow(option = opt, onClick = { onSelect(opt) })
                    }
                }
@@ -217,6 +222,18 @@ fun ModelPickerSheet(
    }
 }

+internal data class ModelPickerGroupIdentity(
+    val provider: String,
+    val label: String,
+)
+
+internal fun modelPickerHeaderKey(group: ModelPickerGroupIdentity): String =
+    "provider:${group.provider}:${group.label}"
+
+/** Exact domain identity; duplicate provider/model rows must be repaired upstream. */
+internal fun modelPickerOptionKey(option: ChatInputPickerOption): String =
+    "model:${option.provider?.trim()?.lowercase().orEmpty()}:${option.value}"
+
 /**
 * Compact sibling of [ModelPickerSheet] for short, ungrouped control lists.
 * Passport selectors use this so profile, personality, and reasoning choices
@@ -0,0 +1,64 @@
+package com.hermesandroid.relay.ui.components
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import androidx.exifinterface.media.ExifInterface
+import java.io.ByteArrayInputStream
+
+internal data class ImageOrientationTransform(
+    val rotationDegrees: Float = 0f,
+    val flipHorizontal: Boolean = false,
+)
+
+internal fun imageOrientationTransform(orientation: Int): ImageOrientationTransform = when (orientation) {
+    ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> ImageOrientationTransform(flipHorizontal = true)
+    ExifInterface.ORIENTATION_ROTATE_180 -> ImageOrientationTransform(rotationDegrees = 180f)
+    ExifInterface.ORIENTATION_FLIP_VERTICAL ->
+        ImageOrientationTransform(rotationDegrees = 180f, flipHorizontal = true)
+    ExifInterface.ORIENTATION_TRANSPOSE ->
+        ImageOrientationTransform(rotationDegrees = 90f, flipHorizontal = true)
+    ExifInterface.ORIENTATION_ROTATE_90 -> ImageOrientationTransform(rotationDegrees = 90f)
+    ExifInterface.ORIENTATION_TRANSVERSE ->
+        ImageOrientationTransform(rotationDegrees = -90f, flipHorizontal = true)
+    ExifInterface.ORIENTATION_ROTATE_270 -> ImageOrientationTransform(rotationDegrees = -90f)
+    else -> ImageOrientationTransform()
+}
+
+/**
+ * Decode image bytes for display and apply their EXIF orientation. BitmapFactory
+ * returns the stored pixel layout and otherwise leaves portrait phone photos
+ * sideways when the camera encoded rotation as metadata.
+ */
+internal fun decodeOrientedBitmap(
+    bytes: ByteArray,
+    options: BitmapFactory.Options? = null,
+): Bitmap? {
+    if (bytes.isEmpty()) return null
+    val decoded = if (options == null) {
+        BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+    } else {
+        BitmapFactory.decodeByteArray(bytes, 0, bytes.size, options)
+    } ?: return null
+
+    val orientation = runCatching {
+        ByteArrayInputStream(bytes).use { stream ->
+            ExifInterface(stream).getAttributeInt(
+                ExifInterface.TAG_ORIENTATION,
+                ExifInterface.ORIENTATION_NORMAL,
+            )
+        }
+    }.getOrDefault(ExifInterface.ORIENTATION_NORMAL)
+    val transform = imageOrientationTransform(orientation)
+    if (transform.rotationDegrees == 0f && !transform.flipHorizontal) return decoded
+
+    val matrix = Matrix().apply {
+        if (transform.rotationDegrees != 0f) postRotate(transform.rotationDegrees)
+        if (transform.flipHorizontal) postScale(-1f, 1f)
+    }
+    return runCatching {
+        Bitmap.createBitmap(decoded, 0, 0, decoded.width, decoded.height, matrix, true)
+    }.getOrNull()?.also { oriented ->
+        if (oriented !== decoded) decoded.recycle()
+    } ?: decoded
+}
@@ -0,0 +1,325 @@
+package com.hermesandroid.relay.ui.components
+
+import android.graphics.BitmapFactory
+import android.util.Base64
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.automirrored.filled.ArrowForward
+import androidx.compose.material.icons.filled.AttachFile
+import androidx.compose.material.icons.filled.BrokenImage
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.R
+import com.hermesandroid.relay.data.Attachment
+import com.hermesandroid.relay.data.AttachmentRenderMode
+import com.hermesandroid.relay.data.AttachmentState
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/**
+ * Pending files shown immediately above the chat composer.
+ *
+ * The owner keeps attachment state and handles the four stable integration
+ * callbacks. [onMove] receives the current and requested indices, allowing a
+ * ViewModel or session-owned draft store to perform one atomic reorder.
+ */
+@Composable
+fun PendingAttachmentComposer(
+    attachments: List<Attachment>,
+    onPreview: (attachment: Attachment, index: Int) -> Unit,
+    onRemove: (index: Int) -> Unit,
+    onMove: (fromIndex: Int, toIndex: Int) -> Unit,
+    modifier: Modifier = Modifier,
+    imageDecoder: suspend (Attachment) -> ImageBitmap? = ::decodePendingAttachmentImage,
+) {
+    if (attachments.isEmpty()) return
+    val attachmentLabel = stringResource(R.string.attachment_title)
+
+    Row(
+        modifier = modifier
+            .fillMaxWidth()
+            .horizontalScroll(rememberScrollState())
+            .semantics {
+                contentDescription = "${attachments.size} $attachmentLabel"
+            }
+            .testTag("pending-attachment-composer"),
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        attachments.forEachIndexed { index, attachment ->
+            PendingAttachmentItem(
+                attachment = attachment,
+                index = index,
+                count = attachments.size,
+                onPreview = { onPreview(attachment, index) },
+                onRemove = { onRemove(index) },
+                onMoveLeft = { onMove(index, index - 1) },
+                onMoveRight = { onMove(index, index + 1) },
+                imageDecoder = imageDecoder,
+            )
+        }
+    }
+}
+
+@Composable
+private fun PendingAttachmentItem(
+    attachment: Attachment,
+    index: Int,
+    count: Int,
+    onPreview: () -> Unit,
+    onRemove: () -> Unit,
+    onMoveLeft: () -> Unit,
+    onMoveRight: () -> Unit,
+    imageDecoder: suspend (Attachment) -> ImageBitmap?,
+) {
+    var previewState by remember(attachment.content, attachment.cachedUri, attachment.state) {
+        mutableStateOf(initialPreviewState(attachment))
+    }
+    LaunchedEffect(attachment.content, attachment.cachedUri, attachment.state) {
+        if (attachment.isImage && attachment.state == AttachmentState.LOADED) {
+            previewState = PendingPreviewState.Loading
+            previewState = imageDecoder(attachment)?.let(PendingPreviewState::Ready)
+                ?: PendingPreviewState.Failed
+        }
+    }
+
+    val name = attachment.fileName?.takeIf(String::isNotBlank)
+        ?: stringResource(R.string.attachment_title)
+    val type = attachmentTypeLabel(attachment.renderMode)
+    val size = attachment.fileSize?.let { formatAttachmentSize(it) }
+    val status = when (previewState) {
+        PendingPreviewState.Loading -> stringResource(R.string.pending_attachment_status_loading)
+        is PendingPreviewState.Ready -> stringResource(R.string.pending_attachment_status_ready)
+        PendingPreviewState.Failed -> attachment.errorMessage?.takeIf(String::isNotBlank)
+            ?: stringResource(R.string.pending_attachment_status_failed)
+    }
+    val summary = listOfNotNull(name, type, size, status).joinToString(", ")
+    val previewEnabled = previewState is PendingPreviewState.Ready
+
+    Surface(
+        modifier = Modifier
+            .width(216.dp)
+            .semantics { contentDescription = summary }
+            .clip(RoundedCornerShape(14.dp))
+            .clickable(
+                enabled = previewEnabled,
+                onClickLabel = stringResource(R.string.pending_attachment_preview_named, name),
+                role = Role.Button,
+                onClick = onPreview,
+            )
+            .testTag("pending-attachment-$index"),
+        shape = RoundedCornerShape(14.dp),
+        color = MaterialTheme.colorScheme.surfaceVariant,
+    ) {
+        Column(modifier = Modifier.padding(8.dp)) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                PendingAttachmentThumbnail(previewState)
+                Spacer(Modifier.width(8.dp))
+                Column(modifier = Modifier.weight(1f)) {
+                    Text(
+                        text = name,
+                        style = MaterialTheme.typography.labelLarge,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                    Text(
+                        text = listOfNotNull(type, size).joinToString(" · "),
+                        style = MaterialTheme.typography.labelSmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                    Text(
+                        text = status,
+                        style = MaterialTheme.typography.labelSmall,
+                        color = if (previewState == PendingPreviewState.Failed) {
+                            MaterialTheme.colorScheme.error
+                        } else {
+                            MaterialTheme.colorScheme.onSurfaceVariant
+                        },
+                    )
+                }
+            }
+            Spacer(Modifier.height(4.dp))
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.End,
+            ) {
+                IconButton(
+                    onClick = onMoveLeft,
+                    enabled = index > 0,
+                    modifier = Modifier
+                        .size(48.dp)
+                        .testTag("pending-attachment-move-left-$index"),
+                ) {
+                    Icon(
+                        Icons.AutoMirrored.Filled.ArrowBack,
+                        contentDescription = stringResource(R.string.pending_attachment_move_left, name),
+                    )
+                }
+                IconButton(
+                    onClick = onMoveRight,
+                    enabled = index < count - 1,
+                    modifier = Modifier
+                        .size(48.dp)
+                        .testTag("pending-attachment-move-right-$index"),
+                ) {
+                    Icon(
+                        Icons.AutoMirrored.Filled.ArrowForward,
+                        contentDescription = stringResource(R.string.pending_attachment_move_right, name),
+                    )
+                }
+                IconButton(
+                    onClick = onRemove,
+                    modifier = Modifier
+                        .size(48.dp)
+                        .testTag("pending-attachment-remove-$index"),
+                ) {
+                    Icon(
+                        Icons.Filled.Close,
+                        contentDescription = stringResource(R.string.pending_attachment_remove, name),
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun PendingAttachmentThumbnail(state: PendingPreviewState) {
+    Box(
+        modifier = Modifier
+            .size(64.dp)
+            .clip(RoundedCornerShape(10.dp))
+            .background(MaterialTheme.colorScheme.surface),
+        contentAlignment = Alignment.Center,
+    ) {
+        when (state) {
+            PendingPreviewState.Loading -> CircularProgressIndicator(
+                modifier = Modifier.size(24.dp),
+                strokeWidth = 2.dp,
+            )
+            is PendingPreviewState.Ready -> if (state.bitmap != null) {
+                Image(
+                    bitmap = state.bitmap,
+                    contentDescription = null,
+                    contentScale = ContentScale.Crop,
+                    modifier = Modifier.size(64.dp),
+                )
+            } else {
+                Icon(Icons.Filled.AttachFile, contentDescription = null)
+            }
+            PendingPreviewState.Failed -> Icon(
+                Icons.Filled.BrokenImage,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.error,
+            )
+        }
+    }
+}
+
+@Composable
+private fun attachmentTypeLabel(mode: AttachmentRenderMode): String = stringResource(
+    when (mode) {
+        AttachmentRenderMode.IMAGE -> R.string.attachment_type_image
+        AttachmentRenderMode.VIDEO -> R.string.attachment_type_video
+        AttachmentRenderMode.AUDIO -> R.string.attachment_type_audio
+        AttachmentRenderMode.PDF -> R.string.attachment_type_pdf
+        AttachmentRenderMode.TEXT -> R.string.attachment_type_text
+        AttachmentRenderMode.GENERIC -> R.string.attachment_type_file
+    },
+)
+
+private fun initialPreviewState(attachment: Attachment): PendingPreviewState = when {
+    attachment.state == AttachmentState.FAILED -> PendingPreviewState.Failed
+    attachment.state == AttachmentState.LOADING -> PendingPreviewState.Loading
+    attachment.isImage -> PendingPreviewState.Loading
+    else -> PendingPreviewState.Ready(bitmap = null)
+}
+
+@Composable
+internal fun formatAttachmentSize(bytes: Long): String {
+    val safeBytes = bytes.coerceAtLeast(0)
+    return when {
+        safeBytes >= 1024L * 1024L * 1024L -> stringResource(
+            R.string.media_bytes_gb,
+            safeBytes / (1024.0 * 1024.0 * 1024.0),
+        )
+        safeBytes >= 1024L * 1024L -> stringResource(
+            R.string.media_bytes_mb,
+            safeBytes / (1024.0 * 1024.0),
+        )
+        safeBytes >= 1024L -> stringResource(R.string.media_bytes_kb, safeBytes / 1024.0)
+        else -> stringResource(R.string.media_bytes_b, safeBytes)
+    }
+}
+
+private suspend fun decodePendingAttachmentImage(attachment: Attachment): ImageBitmap? =
+    withContext(Dispatchers.IO) {
+        runCatching {
+            val bytes = Base64.decode(attachment.content, Base64.DEFAULT)
+            if (bytes.isEmpty()) return@runCatching null
+            val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+            BitmapFactory.decodeByteArray(bytes, 0, bytes.size, bounds)
+            if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return@runCatching null
+
+            var sample = 1
+            while (
+                bounds.outWidth / sample > PENDING_ATTACHMENT_THUMBNAIL_TARGET_PX ||
+                bounds.outHeight / sample > PENDING_ATTACHMENT_THUMBNAIL_TARGET_PX
+            ) {
+                sample *= 2
+            }
+            decodeOrientedBitmap(
+                bytes,
+                BitmapFactory.Options().apply { inSampleSize = sample },
+            )?.asImageBitmap()
+        }.getOrNull()
+    }
+
+private sealed interface PendingPreviewState {
+    data object Loading : PendingPreviewState
+    data class Ready(val bitmap: ImageBitmap?) : PendingPreviewState
+    data object Failed : PendingPreviewState
+}
+
+private const val PENDING_ATTACHMENT_THUMBNAIL_TARGET_PX = 256
@@ -0,0 +1,527 @@
+package com.hermesandroid.relay.ui.components
+
+import androidx.compose.foundation.BorderStroke
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Home
+import androidx.compose.material.icons.filled.Lock
+import androidx.compose.material.icons.filled.MoreHoriz
+import androidx.compose.material.icons.filled.Person
+import androidx.compose.material.icons.filled.Tune
+import androidx.compose.material.icons.filled.Visibility
+import androidx.compose.material.icons.filled.VisibilityOff
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.disabled
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
+import com.hermesandroid.relay.R
+import com.hermesandroid.relay.data.AgentDisplay
+import com.hermesandroid.relay.data.Profile
+import com.hermesandroid.relay.data.ProfilePresentation
+import com.hermesandroid.relay.data.ProfilePresentationPolicy
+import com.hermesandroid.relay.viewmodel.ConnectionViewModel
+import java.io.File
+
+data class ProfileChoice(
+    val key: String,
+    val profile: Profile?,
+) {
+    val isServerDefault: Boolean get() = key == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY
+}
+
+object ProfileShelfPolicy {
+    fun choices(
+        profiles: List<Profile>,
+        presentation: ProfilePresentation,
+        selectedProfileName: String?,
+    ): List<ProfileChoice> {
+        val selectedKey = AgentDisplay.profileSessionKey(selectedProfileName)
+        return ProfilePresentationPolicy
+            .visibleKeys(profiles, presentation, selectedKey)
+            .mapNotNull { key ->
+                if (key == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY) {
+                    ProfileChoice(key, null)
+                } else {
+                    profiles.firstOrNull { it.name == key }?.let { ProfileChoice(key, it) }
+                }
+            }
+    }
+
+    fun canSwitch(isStreaming: Boolean, streamingEndpoint: String): Boolean =
+        !isStreaming || streamingEndpoint == "gateway"
+
+    fun isSelected(choice: ProfileChoice, selectedProfileName: String?): Boolean =
+        choice.key == AgentDisplay.profileSessionKey(selectedProfileName)
+
+    /** Local presentation assets follow the selected choice key, not the sticky profile it resolves to. */
+    fun iconProfileName(choice: ProfileChoice): String? = choice.profile?.name
+}
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun ProfileShelf(
+    connectionViewModel: ConnectionViewModel,
+    profiles: List<Profile>,
+    selectedProfile: Profile?,
+    resolvedProfile: Profile?,
+    presentation: ProfilePresentation,
+    activeDisplayName: String,
+    isProfileLocked: Boolean,
+    lockedProfileName: String?,
+    switchEnabled: Boolean,
+    onSelect: (Profile?) -> Unit,
+    onOpenPassport: () -> Unit,
+    onOpenSwitcher: () -> Unit,
+    onInspect: (String) -> Unit,
+    onLock: (Profile?) -> Unit,
+    onUnlock: () -> Unit,
+    onHide: (String?) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val choices = remember(profiles, presentation, selectedProfile?.name) {
+        ProfileShelfPolicy.choices(profiles, presentation, selectedProfile?.name)
+    }
+    if (choices.size <= 1) return
+
+    var actionChoice by remember { mutableStateOf<ProfileChoice?>(null) }
+    val lockedKey = lockedProfileName ?: AgentDisplay.SERVER_DEFAULT_PROFILE_KEY
+
+    Surface(
+        modifier = modifier.fillMaxWidth(),
+        color = MaterialTheme.colorScheme.surface,
+        tonalElevation = 0.dp,
+    ) {
+        Column {
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .heightIn(min = 55.dp)
+                    .padding(start = 8.dp, end = 4.dp, top = 3.dp, bottom = 3.dp),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Row(
+                    modifier = Modifier
+                        .weight(1f)
+                        .horizontalScroll(rememberScrollState()),
+                    horizontalArrangement = Arrangement.spacedBy(6.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    choices.forEach { choice ->
+                        val selected = ProfileShelfPolicy.isSelected(choice, selectedProfile?.name)
+                        val label = if (selected) {
+                            activeDisplayName
+                        } else {
+                            profileChoiceLabel(choice, resolvedProfile)
+                        }
+                        if (selected) {
+                            val openPassportDescription = stringResource(R.string.profile_shelf_open_passport)
+                            Box(
+                                modifier = Modifier
+                                    .heightIn(min = 48.dp)
+                                    .widthIn(max = 190.dp)
+                                    .combinedClickable(
+                                        role = Role.Button,
+                                        onClick = onOpenPassport,
+                                        onLongClick = { actionChoice = choice },
+                                    )
+                                    .semantics {
+                                        contentDescription = "$label. $openPassportDescription"
+                                    },
+                                contentAlignment = Alignment.Center,
+                            ) {
+                                Surface(
+                                    shape = RoundedCornerShape(22.dp),
+                                    color = MaterialTheme.colorScheme.surfaceContainerLow,
+                                    border = BorderStroke(
+                                        1.dp,
+                                        MaterialTheme.colorScheme.primary.copy(alpha = 0.72f),
+                                    ),
+                                ) {
+                                    Row(
+                                        modifier = Modifier.padding(horizontal = 7.dp, vertical = 4.dp),
+                                        verticalAlignment = Alignment.CenterVertically,
+                                        horizontalArrangement = Arrangement.spacedBy(7.dp),
+                                    ) {
+                                        ProfileChoiceAvatar(
+                                            connectionViewModel,
+                                            choice,
+                                            resolvedProfile,
+                                            label,
+                                            36,
+                                        )
+                                        Text(
+                                            text = label,
+                                            modifier = Modifier.weight(1f, fill = false),
+                                            style = MaterialTheme.typography.labelLarge,
+                                            fontWeight = FontWeight.SemiBold,
+                                            maxLines = 1,
+                                            overflow = TextOverflow.Ellipsis,
+                                        )
+                                        Icon(
+                                            Icons.AutoMirrored.Filled.KeyboardArrowRight,
+                                            contentDescription = null,
+                                            modifier = Modifier.size(18.dp),
+                                            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                                        )
+                                    }
+                                }
+                            }
+                        } else {
+                            val enabled = switchEnabled && !isProfileLocked
+                            val switchToDescription = stringResource(R.string.profile_shelf_switch_to)
+                            Box(
+                                modifier = Modifier
+                                    .size(48.dp)
+                                    .clip(CircleShape)
+                                    .combinedClickable(
+                                        enabled = true,
+                                        role = Role.Button,
+                                        onClick = { if (enabled) onSelect(choice.profile) },
+                                        onLongClick = { actionChoice = choice },
+                                    )
+                                    .semantics {
+                                        if (!enabled) disabled()
+                                        contentDescription = if (enabled) {
+                                            "$label. $switchToDescription"
+                                        } else {
+                                            label
+                                        }
+                                    },
+                                contentAlignment = Alignment.Center,
+                            ) {
+                                ProfileChoiceAvatar(
+                                    connectionViewModel,
+                                    choice,
+                                    resolvedProfile,
+                                    label,
+                                    36,
+                                )
+                            }
+                        }
+                    }
+                }
+                IconButton(
+                    onClick = onOpenSwitcher,
+                    modifier = Modifier.size(48.dp),
+                ) {
+                    Surface(
+                        modifier = Modifier.size(40.dp),
+                        shape = CircleShape,
+                        color = MaterialTheme.colorScheme.surfaceContainerLow,
+                        border = BorderStroke(
+                            1.dp,
+                            MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.42f),
+                        ),
+                    ) {
+                        Box(contentAlignment = Alignment.Center) {
+                            Icon(
+                                Icons.Filled.MoreHoriz,
+                                contentDescription = stringResource(R.string.profile_shelf_all_profiles),
+                                modifier = Modifier.size(20.dp),
+                            )
+                        }
+                    }
+                }
+            }
+            HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.32f))
+        }
+    }
+
+    actionChoice?.let { choice ->
+        val selected = ProfileShelfPolicy.isSelected(choice, selectedProfile?.name)
+        val target = choice.profile ?: resolvedProfile
+        val label = profileChoiceLabel(choice, resolvedProfile)
+        ProfileShelfActionsDialog(
+            label = label,
+            canSwitch = switchEnabled && !isProfileLocked,
+            selected = selected,
+            canInspect = target != null,
+            lockedToChoice = isProfileLocked && lockedKey == choice.key,
+            onInspect = {
+                actionChoice = null
+                target?.name?.let(onInspect)
+            },
+            onPassport = {
+                actionChoice = null
+                if (!selected && switchEnabled && !isProfileLocked) onSelect(choice.profile)
+                onOpenPassport()
+            },
+            onToggleLock = {
+                actionChoice = null
+                if (isProfileLocked && lockedKey == choice.key) onUnlock() else onLock(choice.profile)
+            },
+            onHide = {
+                actionChoice = null
+                onHide(choice.profile?.name)
+            },
+            onDismiss = { actionChoice = null },
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
+@Composable
+fun ProfileSwitcherSheet(
+    connectionViewModel: ConnectionViewModel,
+    profiles: List<Profile>,
+    selectedProfile: Profile?,
+    resolvedProfile: Profile?,
+    presentation: ProfilePresentation,
+    isProfileLocked: Boolean,
+    switchEnabled: Boolean,
+    onSelect: (Profile?) -> Unit,
+    onManageDisplay: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val choices = remember(profiles, presentation, selectedProfile?.name) {
+        ProfileShelfPolicy.choices(profiles, presentation, selectedProfile?.name)
+    }
+    ModalBottomSheet(onDismissRequest = onDismiss) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .heightIn(max = 560.dp)
+                .verticalScroll(rememberScrollState())
+                .padding(bottom = 24.dp),
+        ) {
+            Text(
+                text = stringResource(R.string.profile_shelf_switch_agent),
+                modifier = Modifier.padding(horizontal = 24.dp, vertical = 12.dp),
+                style = MaterialTheme.typography.headlineSmall,
+                fontWeight = FontWeight.SemiBold,
+            )
+            if (isProfileLocked) {
+                Text(
+                    text = stringResource(R.string.profile_shelf_locked_hint),
+                    modifier = Modifier.padding(horizontal = 24.dp, vertical = 4.dp),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            choices.forEach { choice ->
+                val selected = ProfileShelfPolicy.isSelected(choice, selectedProfile?.name)
+                val label = profileChoiceLabel(choice, resolvedProfile)
+                val model = choice.profile?.model?.takeIf { it.isNotBlank() }
+                ListItem(
+                    modifier = Modifier.selectable(
+                        selected = selected,
+                        enabled = selected || (switchEnabled && !isProfileLocked),
+                        role = Role.RadioButton,
+                        onClick = {
+                            if (!selected) onSelect(choice.profile)
+                            onDismiss()
+                        },
+                    ),
+                    headlineContent = {
+                        Text(label, maxLines = 1, overflow = TextOverflow.Ellipsis)
+                    },
+                    supportingContent = if (model != null) {
+                        { Text(model, maxLines = 1, overflow = TextOverflow.Ellipsis) }
+                    } else {
+                        null
+                    },
+                    leadingContent = {
+                        ProfileChoiceAvatar(connectionViewModel, choice, resolvedProfile, label, 42)
+                    },
+                    trailingContent = if (selected) {
+                        { Icon(Icons.Filled.Check, contentDescription = null) }
+                    } else {
+                        null
+                    },
+                )
+            }
+            HorizontalDivider(modifier = Modifier.padding(top = 8.dp))
+            TextButton(
+                onClick = onManageDisplay,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 12.dp, vertical = 4.dp),
+            ) {
+                Icon(Icons.Filled.Tune, contentDescription = null)
+                Spacer(Modifier.size(8.dp))
+                Text(stringResource(R.string.conn_info_manage_profiles))
+            }
+        }
+    }
+}
+
+@Composable
+private fun ProfileChoiceAvatar(
+    connectionViewModel: ConnectionViewModel,
+    choice: ProfileChoice,
+    resolvedProfile: Profile?,
+    label: String,
+    size: Int,
+) {
+    val iconProfileName = ProfileShelfPolicy.iconProfileName(choice)
+    val iconPath by connectionViewModel.profileIconFlow(iconProfileName).collectAsState(initial = null)
+    Box(modifier = Modifier.size(size.dp)) {
+        Surface(
+            modifier = Modifier.fillMaxSize(),
+            shape = CircleShape,
+            color = MaterialTheme.colorScheme.primary,
+            border = BorderStroke(
+                1.dp,
+                MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.55f),
+            ),
+        ) {
+            when {
+                !iconPath.isNullOrBlank() -> AsyncImage(
+                    model = File(iconPath.orEmpty()),
+                    contentDescription = null,
+                    contentScale = ContentScale.Crop,
+                    modifier = Modifier.fillMaxSize(),
+                )
+                resolvedProfile == null && choice.isServerDefault -> Box(contentAlignment = Alignment.Center) {
+                    Icon(
+                        Icons.Filled.Home,
+                        contentDescription = null,
+                        modifier = Modifier.size((size * 0.48f).dp),
+                        tint = MaterialTheme.colorScheme.onPrimary,
+                    )
+                }
+                else -> Box(contentAlignment = Alignment.Center) {
+                    Text(
+                        text = label.trim().firstOrNull()?.uppercase() ?: "H",
+                        color = MaterialTheme.colorScheme.onPrimary,
+                        style = MaterialTheme.typography.labelLarge,
+                        fontWeight = FontWeight.Bold,
+                    )
+                }
+            }
+        }
+        if (choice.isServerDefault && resolvedProfile != null) {
+            Surface(
+                modifier = Modifier
+                    .align(Alignment.BottomStart)
+                    .size((size * 0.38f).dp),
+                shape = CircleShape,
+                color = MaterialTheme.colorScheme.surfaceContainerHighest,
+                border = BorderStroke(1.dp, MaterialTheme.colorScheme.surface),
+            ) {
+                Box(contentAlignment = Alignment.Center) {
+                    Icon(
+                        Icons.Filled.Home,
+                        contentDescription = null,
+                        modifier = Modifier.size((size * 0.22f).dp),
+                        tint = MaterialTheme.colorScheme.onSurface,
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ProfileShelfActionsDialog(
+    label: String,
+    canSwitch: Boolean,
+    selected: Boolean,
+    canInspect: Boolean,
+    lockedToChoice: Boolean,
+    onInspect: () -> Unit,
+    onPassport: () -> Unit,
+    onToggleLock: () -> Unit,
+    onHide: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(label, maxLines = 1, overflow = TextOverflow.Ellipsis) },
+        text = {
+            Column {
+                ProfileActionRow(Icons.Filled.Visibility, stringResource(R.string.profile_shelf_inspect), canInspect, onInspect)
+                ProfileActionRow(
+                    Icons.Filled.Person,
+                    stringResource(R.string.conn_info_agent_passport),
+                    selected || canSwitch,
+                    onPassport,
+                )
+                ProfileActionRow(
+                    Icons.Filled.Lock,
+                    stringResource(if (lockedToChoice) R.string.settings_unlock else R.string.settings_profile_lock),
+                    true,
+                    onToggleLock,
+                )
+                ProfileActionRow(
+                    Icons.Filled.VisibilityOff,
+                    stringResource(R.string.profile_shelf_hide),
+                    !selected,
+                    onHide,
+                )
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.chat_dismiss)) } },
+    )
+}
+
+@Composable
+private fun ProfileActionRow(
+    icon: androidx.compose.ui.graphics.vector.ImageVector,
+    label: String,
+    enabled: Boolean,
+    onClick: () -> Unit,
+) {
+    TextButton(onClick = onClick, enabled = enabled, modifier = Modifier.fillMaxWidth()) {
+        Icon(icon, contentDescription = null)
+        Spacer(Modifier.size(12.dp))
+        Text(label, modifier = Modifier.weight(1f))
+    }
+}
+
+@Composable
+private fun profileChoiceLabel(choice: ProfileChoice, resolvedProfile: Profile?): String =
+    if (choice.isServerDefault) {
+        stringResource(R.string.conn_info_server_default)
+    } else {
+        choice.profile?.let(AgentDisplay::profileDisplayName)
+            ?: choice.profile?.name?.replaceFirstChar { it.uppercase() }
+            ?: resolvedProfile?.let(AgentDisplay::profileDisplayName)
+            ?: stringResource(R.string.chat_agent_default)
+    }
@@ -2,6 +2,7 @@ package com.hermesandroid.relay.ui.components

 import android.util.Log
 import android.view.ViewGroup
+import androidx.activity.compose.BackHandler
 import androidx.camera.core.CameraSelector
 import androidx.camera.core.ImageAnalysis
 import androidx.camera.core.Preview
@@ -13,6 +14,7 @@ import androidx.compose.animation.core.animateFloat
 import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.animation.core.infiniteRepeatable
 import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.snap
 import androidx.compose.animation.core.spring
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
@@ -52,6 +54,11 @@ import androidx.compose.ui.graphics.StrokeCap
 import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.heading
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.paneTitle
+import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.dp
@@ -63,6 +70,7 @@ import com.google.mlkit.vision.barcode.BarcodeScanning
 import com.google.mlkit.vision.barcode.common.Barcode
 import com.google.mlkit.vision.common.InputImage
 import com.hermesandroid.relay.data.ApiEndpoint
+import com.hermesandroid.relay.data.Connection
 import com.hermesandroid.relay.data.DashboardEndpoint
 import com.hermesandroid.relay.data.EndpointCandidate
 import com.hermesandroid.relay.data.RelayEndpoint
@@ -80,6 +88,8 @@ import java.net.URI
 import java.util.concurrent.Executors
 import kotlin.math.max

+internal fun scannerSettleDelayMs(motionEnabled: Boolean): Long = if (motionEnabled) 200L else 0L
+
 /**
 * Parsed result from a Hermes pairing QR code.
 *
@@ -182,7 +192,11 @@ data class HermesPairingPayload(
 ) {
    /** Build the full API server URL from host, port, and tls flag. */
    val serverUrl: String
-        get() = "${if (tls) "https" else "http"}://$host:$port"
+        get() = if (host.isBlank()) "" else "${if (tls) "https" else "http"}://$host:$port"
+
+    /** Whether this setup payload explicitly configures the optional API server. */
+    val hasApiServer: Boolean
+        get() = host.isNotBlank()
 }

 /**
@@ -239,14 +253,17 @@ private val json = Json {
 * Try to parse a scanned string as a Hermes connection QR payload.
 *
 * Accepts v1, v2, and v3 (or anything without a `hermes` field — we default
- * to `1`). Returns null when the payload is not valid JSON, has no `host`
- * field, or fails strict decoding.
+ * to `1`). Returns null when the payload is not valid JSON, configures neither
+ * a recognized API nor Dashboard surface, or fails strict decoding.
 *
 * For standard Hermes setup, also accepts generic API-only QRs:
 *  - a plain `http://host:8642` or `https://host:8642` URL
 *  - JSON with `api_url`, `apiUrl`, `server_url`, `serverUrl`, or `url`, plus
 *    optional `api_key`, `apiKey`, or `key`, and optional `dashboard_url` or
 *    `dashboardUrl`
+ *  - JSON with only `dashboard_url` or `dashboardUrl`, containing a fully
+ *    qualified HTTP(S) Dashboard/Gateway URL. This represents the upstream
+ *    standard surface without inventing an API server or Relay endpoint.
 *
 * **Endpoint synthesis (ADR 24):** when the payload has no `endpoints`
 * array (v1/v2 QRs), a single priority-0 [EndpointCandidate] is materialized
@@ -261,6 +278,7 @@ fun parseHermesPairingQr(raw: String): HermesPairingPayload? {
    val trimmed = raw.trim()
    return parseHermesRelayQr(trimmed)
        ?: parseGenericApiJsonQr(trimmed)
+        ?: parseGenericDashboardJsonQr(trimmed)
        ?: parseGenericApiUrlQr(trimmed)
 }

@@ -327,6 +345,38 @@ private fun parseGenericApiUrlQr(raw: String): HermesPairingPayload? {
    return payloadFromApiUrl(raw, apiKey = "")
 }

+private fun parseGenericDashboardJsonQr(raw: String): HermesPairingPayload? {
+    return try {
+        val obj = json.decodeFromString<JsonObject>(raw)
+        // Do not silently downgrade a malformed API setup into Dashboard-only
+        // setup. When an API alias is present, parseGenericApiJsonQr owns the
+        // payload and must either accept or reject it as a whole.
+        val apiAliases = setOf("api_url", "apiUrl", "server_url", "serverUrl", "url")
+        if (obj.keys.any { it in apiAliases }) return null
+
+        val dashboardUrl = firstString(obj, "dashboard_url", "dashboardUrl")
+            ?.trimEnd('/')
+            ?: return null
+        val uri = runCatching { URI(dashboardUrl) }.getOrNull() ?: return null
+        if (uri.scheme?.lowercase() !in setOf("http", "https") || uri.host.isNullOrBlank()) {
+            return null
+        }
+
+        HermesPairingPayload(
+            dashboardUrl = dashboardUrl,
+            endpoints = listOf(
+                EndpointCandidate(
+                    role = Connection.inferRouteRole(dashboardUrl),
+                    priority = 0,
+                    dashboard = DashboardEndpoint(dashboardUrl),
+                ),
+            ),
+        )
+    } catch (_: Exception) {
+        null
+    }
+}
+
 private fun firstString(obj: JsonObject, vararg names: String): String? {
    return names.firstNotNullOfOrNull { name ->
        obj[name]?.jsonPrimitive?.contentOrNull?.trim()?.takeIf { it.isNotBlank() }
@@ -547,6 +597,12 @@ fun QrPairingScanner(
 ) {
    val context = LocalContext.current
    val lifecycleOwner = LocalLifecycleOwner.current
+    val motion = rememberAccessibleMotionState()
+    val motionEnabled = motion.osAnimations && !motion.touchExploration
+    val scannerPaneTitle = stringResource(
+        if (relayOnly) R.string.qr_scanner_relay_title else R.string.qr_scanner_title,
+    )
+    BackHandler(onBack = onDismiss)
    // Pre-resolve strings used inside non-Composable contexts (CameraX
    // listeners, exception handlers, etc. don't have a Composable scope).
    val cameraErrorMsg = stringResource(R.string.qr_scanner_camera_error)
@@ -609,7 +665,8 @@ fun QrPairingScanner(
    // ~450ms so the user perceives the lock-on, then forward to onPairingDetected.
    LaunchedEffect(lockedPayload) {
        val payload = lockedPayload ?: return@LaunchedEffect
-        kotlinx.coroutines.delay(450)
+        val settleDelayMs = scannerSettleDelayMs(motionEnabled)
+        if (settleDelayMs > 0) kotlinx.coroutines.delay(settleDelayMs)
        onPairingDetected(payload)
    }

@@ -617,6 +674,7 @@ fun QrPairingScanner(
        modifier = Modifier
            .fillMaxSize()
            .background(MaterialTheme.colorScheme.scrim.copy(alpha = 0.95f))
+            .semantics { paneTitle = scannerPaneTitle }
    ) {
        Column(
            modifier = Modifier.fillMaxSize(),
@@ -645,7 +703,7 @@ fun QrPairingScanner(
                    ),
                    style = MaterialTheme.typography.titleMedium,
                    color = MaterialTheme.colorScheme.onSurface,
-                    modifier = Modifier.align(Alignment.Center)
+                    modifier = Modifier.align(Alignment.Center).semantics { heading() }
                )
            }

@@ -796,6 +854,7 @@ fun QrPairingScanner(
                ScannerCornersOverlay(
                    detected = detectedBox,
                    locked = lockedPayload != null,
+                    motionEnabled = motionEnabled,
                    modifier = Modifier.fillMaxSize(),
                )
                }
@@ -833,6 +892,19 @@ fun QrPairingScanner(
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                    textAlign = TextAlign.Center
                )
+                Text(
+                    text = stringResource(
+                        if (lockedPayload == null) R.string.qr_scanner_ready
+                        else R.string.qr_scanner_found,
+                    ),
+                    style = MaterialTheme.typography.labelMedium,
+                    color = if (lockedPayload == null) {
+                        MaterialTheme.colorScheme.onSurfaceVariant
+                    } else {
+                        MaterialTheme.colorScheme.primary
+                    },
+                    modifier = Modifier.semantics { liveRegion = LiveRegionMode.Polite },
+                )
            }
        }
    }
@@ -905,6 +977,7 @@ private fun CameraUnavailableCard(
 private fun ScannerCornersOverlay(
    detected: ViewportRect?,
    locked: Boolean,
+    motionEnabled: Boolean,
    modifier: Modifier = Modifier,
 ) {
    // Themed idle: two-tone gradient between primary (top-left/bottom-right)
@@ -922,22 +995,28 @@ private fun ScannerCornersOverlay(

    // Slow breathing pulse on alpha when idle. Locked state stays solid +
    // gets its own one-shot ramp so the green burst is unmistakable.
-    val infiniteTransition = rememberInfiniteTransition(label = "scan-corners")
-    val idlePulse by infiniteTransition.animateFloat(
-        initialValue = 0.45f,
-        targetValue = 1f,
-        animationSpec = infiniteRepeatable(
-            animation = tween(1400, easing = FastOutSlowInEasing),
-            repeatMode = RepeatMode.Reverse,
-        ),
-        label = "idle-pulse",
-    )
+    val idlePulse = if (motionEnabled) {
+        val infiniteTransition = rememberInfiniteTransition(label = "scan-corners")
+        infiniteTransition.animateFloat(
+            initialValue = 0.45f,
+            targetValue = 1f,
+            animationSpec = infiniteRepeatable(
+                animation = tween(1400, easing = FastOutSlowInEasing),
+                repeatMode = RepeatMode.Reverse,
+            ),
+            label = "idle-pulse",
+        ).value
+    } else {
+        1f
+    }

    // One-shot ramp that fires when `locked` flips true. Drives the
    // outward scale pop on the corners + the green tint flash overlay.
    val lockRamp by animateFloatAsState(
        targetValue = if (locked) 1f else 0f,
-        animationSpec = if (locked) {
+        animationSpec = if (!motionEnabled) {
+            snap()
+        } else if (locked) {
            spring(dampingRatio = 0.55f, stiffness = 220f)
        } else {
            tween(180)
@@ -973,14 +1052,15 @@ private fun ScannerCornersOverlay(
        targetBottom = 0f
    }

-    val springSpec = spring<Float>(
-        dampingRatio = 0.7f,
-        stiffness = 280f,
-    )
-    val animLeft by animateFloatAsState(targetLeft, springSpec, label = "snap-l")
-    val animTop by animateFloatAsState(targetTop, springSpec, label = "snap-t")
-    val animRight by animateFloatAsState(targetRight, springSpec, label = "snap-r")
-    val animBottom by animateFloatAsState(targetBottom, springSpec, label = "snap-b")
+    val positionSpec = if (motionEnabled) {
+        spring<Float>(dampingRatio = 0.7f, stiffness = 280f)
+    } else {
+        snap()
+    }
+    val animLeft by animateFloatAsState(targetLeft, positionSpec, label = "snap-l")
+    val animTop by animateFloatAsState(targetTop, positionSpec, label = "snap-t")
+    val animRight by animateFloatAsState(targetRight, positionSpec, label = "snap-r")
+    val animBottom by animateFloatAsState(targetBottom, positionSpec, label = "snap-b")

    Canvas(
        modifier = modifier.onSizeChanged { size = it }
@@ -1100,7 +1180,7 @@ private fun ScannerCornersOverlay(
        // Lock flash — brief green tint over the entire viewport that fades
        // out as lockRamp settles. Driven by the same spring as the corner
        // pop so they read as one event.
-        if (lockRamp > 0f) {
+        if (motionEnabled && lockRamp > 0f) {
            drawRect(
                color = successCore.copy(alpha = 0.18f * lockRamp),
                topLeft = Offset.Zero,
@@ -41,6 +41,7 @@ import androidx.compose.material.icons.filled.MoreVert
 import androidx.compose.material.icons.filled.Refresh
 import androidx.compose.material.icons.filled.Search
 import androidx.compose.material.icons.filled.Star
+import androidx.compose.material.icons.outlined.StarBorder
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.CircularProgressIndicator
@@ -88,7 +89,7 @@ import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale

-private enum class SessionDrawerFilter {
+internal enum class SessionDrawerFilter {
    All,
    Threads,
    Pinned,
@@ -96,6 +97,25 @@ private enum class SessionDrawerFilter {
 }

 internal const val SESSION_DRAWER_LIST_TAG = "session-drawer-list"
+internal const val UNPINNED_STAR_ALPHA = 0.45f
+
+data class ProfileSessionRow(
+    val profile: String,
+    val session: ChatSession,
+)
+
+internal fun sessionPinIcon(pinned: Boolean) =
+    if (pinned) Icons.Filled.Star else Icons.Outlined.StarBorder
+
+internal fun resolveSessionDrawerFilter(
+    filter: SessionDrawerFilter,
+    showThreads: Boolean,
+    archiveSupported: Boolean,
+): SessionDrawerFilter = when {
+    filter == SessionDrawerFilter.Threads && !showThreads -> SessionDrawerFilter.All
+    filter == SessionDrawerFilter.Archive && !archiveSupported -> SessionDrawerFilter.All
+    else -> filter
+}

@Composable
 fun SessionDrawerContent(
@@ -108,11 +128,14 @@ fun SessionDrawerContent(
    activityStates: Map<String, SessionActivityState> = emptyMap(),
    animationEnabled: Boolean = true,
    autoTitlesSupported: Boolean = true,
+    archiveSupported: Boolean = true,
    onRefresh: (() -> Unit)? = null,
    onNewChat: () -> Unit,
    onSelectSession: (String) -> Unit,
    onDeleteSession: (String) -> Unit,
    onRenameSession: (String, String) -> Unit,
+    onSetSessionPinned: (String, Boolean) -> Unit = { _, _ -> },
+    onSetSessionArchived: (String, Boolean) -> Unit = { _, _ -> },
    onCopySessionId: ((String) -> Unit)? = null,
    /**
     * When true, the Threads affordance (header spool + filter chip) shows even with no
@@ -131,6 +154,10 @@ fun SessionDrawerContent(
    hiddenSources: Set<String> = emptySet(),
    /** Toggle a source's visibility (persisted). Null hides the source filter. */
    onToggleSourceHidden: ((String, Boolean) -> Unit)? = null,
+    allProfileSessions: List<ProfileSessionRow> = emptyList(),
+    allProfileSessionsLoading: Boolean = false,
+    onRefreshAllProfiles: (() -> Unit)? = null,
+    onSelectProfileSession: ((String, String) -> Unit)? = null,
 ) {
    var renameDialogSession by remember { mutableStateOf<ChatSession?>(null) }
    var newThreadDialog by remember { mutableStateOf(false) }
@@ -139,19 +166,14 @@ fun SessionDrawerContent(
    var query by remember { mutableStateOf("") }
    var searchExpanded by remember { mutableStateOf(false) }
    var filter by remember { mutableStateOf(SessionDrawerFilter.All) }
-    var pinnedSessionIds by remember { mutableStateOf<Set<String>>(emptySet()) }
-    var archivedSessionIds by remember { mutableStateOf<Set<String>>(emptySet()) }
+    var allProfilesOpen by remember { mutableStateOf(false) }
    val listState = rememberLazyListState()
    val trimmedQuery = query.trim()
    // Threads affordance shows when the capability is active OR there's already at least one
    // agent Thread (source=phone) in the list. If the filter is on Threads but they've
    // vanished, fall back to All so the drawer never gets stuck on an empty hidden filter.
    val showThreads = threadsCapabilityActive || sessions.any { isThreadSource(it.source) }
-    val activeFilter = if (filter == SessionDrawerFilter.Threads && !showThreads) {
-        SessionDrawerFilter.All
-    } else {
-        filter
-    }
+    val activeFilter = resolveSessionDrawerFilter(filter, showThreads, archiveSupported)
    // External gateway sources present (discord/telegram/cron/…) for the source
    // filter dropdown. Own chats (tui/api_server) + phone Threads aren't listed.
    val presentSources = sessions
@@ -163,14 +185,13 @@ fun SessionDrawerContent(
        .asSequence()
        .filter { session ->
            when (activeFilter) {
-                SessionDrawerFilter.All -> session.sessionId !in archivedSessionIds
+                SessionDrawerFilter.All -> !session.archived
                SessionDrawerFilter.Threads ->
                    isThreadSource(session.source) &&
-                        session.sessionId !in archivedSessionIds
+                        !session.archived
                SessionDrawerFilter.Pinned ->
-                    session.sessionId in pinnedSessionIds &&
-                        session.sessionId !in archivedSessionIds
-                SessionDrawerFilter.Archive -> session.sessionId in archivedSessionIds
+                    session.pinned && !session.archived
+                SessionDrawerFilter.Archive -> session.archived
            }
        }
        .filter { session ->
@@ -188,7 +209,7 @@ fun SessionDrawerContent(
                session.model.orEmpty().contains(needle, ignoreCase = true)
        }
        .sortedWith(
-            compareByDescending<ChatSession> { it.sessionId in pinnedSessionIds }
+            compareByDescending<ChatSession> { it.pinned }
                .thenByDescending { it.activityTimestamp }
                .thenByDescending { it.startTimestamp }
                .thenBy { it.title.orEmpty().lowercase(locale = Locale.ROOT) }
@@ -344,6 +365,16 @@ fun SessionDrawerContent(
                    overflow = TextOverflow.Ellipsis,
                )
            }
+            if (onRefreshAllProfiles != null && onSelectProfileSession != null) {
+                TextButton(
+                    onClick = {
+                        allProfilesOpen = true
+                        onRefreshAllProfiles()
+                    },
+                ) {
+                    Text(stringResource(R.string.drawer_all_profiles))
+                }
+            }

            Spacer(modifier = Modifier.height(8.dp))

@@ -376,7 +407,10 @@ fun SessionDrawerContent(
                horizontalArrangement = Arrangement.spacedBy(6.dp),
            ) {
                SessionDrawerFilter.entries
-                    .filter { it != SessionDrawerFilter.Threads || showThreads }
+                    .filter { item ->
+                        (item != SessionDrawerFilter.Threads || showThreads) &&
+                            (item != SessionDrawerFilter.Archive || archiveSupported)
+                    }
                    .forEach { item ->
                        FilterChip(
                            selected = activeFilter == item,
@@ -496,22 +530,15 @@ fun SessionDrawerContent(
                        isActive = session.sessionId == currentSessionId,
                        activityState = activityStates[session.sessionId],
                        animationEnabled = animationEnabled,
-                        pinned = session.sessionId in pinnedSessionIds,
-                        archived = session.sessionId in archivedSessionIds,
+                        pinned = session.pinned,
+                        archived = session.archived,
+                        archiveSupported = archiveSupported,
                        onClick = { onSelectSession(session.sessionId) },
                        onTogglePinned = {
-                            pinnedSessionIds = if (session.sessionId in pinnedSessionIds) {
-                                pinnedSessionIds - session.sessionId
-                            } else {
-                                pinnedSessionIds + session.sessionId
-                            }
+                            onSetSessionPinned(session.sessionId, !session.pinned)
                        },
                        onToggleArchived = {
-                            archivedSessionIds = if (session.sessionId in archivedSessionIds) {
-                                archivedSessionIds - session.sessionId
-                            } else {
-                                archivedSessionIds + session.sessionId
-                            }
+                            onSetSessionArchived(session.sessionId, !session.archived)
                        },
                        onRename = { renameDialogSession = session },
                        onCopySessionId = { onCopySessionId?.invoke(session.sessionId) },
@@ -613,6 +640,72 @@ fun SessionDrawerContent(
            }
        )
    }
+
+    if (allProfilesOpen) {
+        var allQuery by remember { mutableStateOf("") }
+        val needle = allQuery.trim()
+        val rows = allProfileSessions.filter { row ->
+            needle.isBlank() ||
+                row.profile.contains(needle, ignoreCase = true) ||
+                row.session.title.orEmpty().contains(needle, ignoreCase = true) ||
+                row.session.sessionId.contains(needle, ignoreCase = true)
+        }
+        AlertDialog(
+            onDismissRequest = { allProfilesOpen = false },
+            title = { Text(stringResource(R.string.drawer_all_profiles)) },
+            text = {
+                Column(modifier = Modifier.fillMaxWidth()) {
+                    OutlinedTextField(
+                        value = allQuery,
+                        onValueChange = { allQuery = it },
+                        modifier = Modifier.fillMaxWidth(),
+                        singleLine = true,
+                        leadingIcon = { Icon(Icons.Filled.Search, contentDescription = null) },
+                        placeholder = { Text(stringResource(R.string.drawer_search_placeholder)) },
+                    )
+                    Spacer(modifier = Modifier.height(8.dp))
+                    when {
+                        allProfileSessionsLoading && allProfileSessions.isEmpty() ->
+                            CircularProgressIndicator(modifier = Modifier.align(Alignment.CenterHorizontally))
+                        rows.isEmpty() -> Text(
+                            stringResource(R.string.drawer_no_profile_sessions),
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                        else -> LazyColumn(modifier = Modifier.height(420.dp)) {
+                            items(rows, key = { "${it.profile}:${it.session.sessionId}" }) { row ->
+                                Column(
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .clickable {
+                                            allProfilesOpen = false
+                                            onSelectProfileSession?.invoke(row.profile, row.session.sessionId)
+                                        }
+                                        .padding(vertical = 10.dp, horizontal = 4.dp),
+                                ) {
+                                    Text(
+                                        row.session.title?.takeIf { it.isNotBlank() }
+                                            ?: stringResource(R.string.drawer_untitled),
+                                        maxLines = 2,
+                                        overflow = TextOverflow.Ellipsis,
+                                    )
+                                    Text(
+                                        row.profile,
+                                        style = relayMetadataStyle(),
+                                        color = RelayRefresh.Relay,
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            confirmButton = {
+                TextButton(onClick = { allProfilesOpen = false }) {
+                    Text(stringResource(R.string.drawer_close))
+                }
+            },
+        )
+    }
 }

@Composable
@@ -623,6 +716,7 @@ private fun SessionItem(
    animationEnabled: Boolean,
    pinned: Boolean,
    archived: Boolean,
+    archiveSupported: Boolean,
    onClick: () -> Unit,
    onTogglePinned: () -> Unit,
    onToggleArchived: () -> Unit,
@@ -770,12 +864,12 @@ private fun SessionItem(
                    },
                    leadingIcon = {
                        Icon(
-                            Icons.Filled.Star,
+                            sessionPinIcon(pinned),
                            contentDescription = null,
                            tint = if (pinned) {
                                RelayRefresh.Amber
                            } else {
-                                MaterialTheme.colorScheme.onSurfaceVariant
+                                MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = UNPINNED_STAR_ALPHA)
                            },
                        )
                    },
@@ -804,24 +898,26 @@ private fun SessionItem(
                        onRename()
                    },
                )
-                DropdownMenuItem(
-                    text = { Text(if (archived) stringResource(R.string.drawer_restore) else stringResource(R.string.drawer_archive)) },
-                    leadingIcon = {
-                        Icon(
-                            Icons.Filled.Archive,
-                            contentDescription = null,
-                            tint = if (archived) {
-                                RelayRefresh.Relay
-                            } else {
-                                MaterialTheme.colorScheme.onSurfaceVariant
-                            },
-                        )
-                    },
-                    onClick = {
-                        menuOpen = false
-                        onToggleArchived()
-                    },
-                )
+                if (archiveSupported) {
+                    DropdownMenuItem(
+                        text = { Text(if (archived) stringResource(R.string.drawer_restore) else stringResource(R.string.drawer_archive)) },
+                        leadingIcon = {
+                            Icon(
+                                Icons.Filled.Archive,
+                                contentDescription = null,
+                                tint = if (archived) {
+                                    RelayRefresh.Relay
+                                } else {
+                                    MaterialTheme.colorScheme.onSurfaceVariant
+                                },
+                            )
+                        },
+                        onClick = {
+                            menuOpen = false
+                            onToggleArchived()
+                        },
+                    )
+                }
                DropdownMenuItem(
                    text = {
                        Text(
@@ -0,0 +1,52 @@
+package com.hermesandroid.relay.ui.components
+
+/**
+ * Model identity shown by chat-scoped controls.
+ *
+ * A running/resumed session owns its runtime model. Profile and server values
+ * are defaults only, and may seed a fresh draft, but must never repaint an
+ * existing session merely because a picker or Agent Passport was opened.
+ */
+internal data class SessionModelUiState(
+    val model: String?,
+    val provider: String?,
+    val pickerModel: String?,
+    val pickerProvider: String?,
+    val inheritsProfileDefault: Boolean,
+)
+
+internal fun resolveSessionModelUiState(
+    hasSession: Boolean,
+    pendingModel: String?,
+    pendingProvider: String?,
+    gatewayModel: String?,
+    gatewayProvider: String?,
+    persistedSessionModel: String?,
+    profileDefaultModel: String?,
+    serverDefaultModel: String?,
+): SessionModelUiState {
+    fun String?.present(): String? = this?.trim()?.takeIf(String::isNotEmpty)
+
+    val pending = pendingModel.present()
+    val gateway = gatewayModel.present()
+    val persisted = persistedSessionModel.present()
+    val profileDefault = profileDefaultModel.present()
+    val serverDefault = serverDefaultModel.present()
+    val effectiveModel = if (hasSession) {
+        pending ?: gateway ?: persisted ?: profileDefault ?: serverDefault
+    } else {
+        pending ?: profileDefault ?: gateway ?: serverDefault
+    }
+    val effectiveProvider = pendingProvider.present()
+        ?: gatewayProvider.present()
+
+    return SessionModelUiState(
+        model = effectiveModel,
+        provider = effectiveProvider,
+        // A live session highlights what it is actually running. On a fresh
+        // draft, null remains the explicit "inherit profile default" state.
+        pickerModel = if (hasSession) effectiveModel else pending,
+        pickerProvider = if (hasSession) effectiveProvider else pendingProvider.present(),
+        inheritsProfileDefault = !hasSession && pending == null,
+    )
+}
@@ -0,0 +1,41 @@
+package com.hermesandroid.relay.ui.components
+
+data class SessionReference(val profile: String, val sessionId: String) {
+    val label: String
+        get() = "$profile · ${sessionId.takeLast(10)}"
+}
+
+private val SESSION_REFERENCE = Regex("@session:([A-Za-z0-9_.-]{1,64})/([A-Za-z0-9_.:-]{1,160})")
+
+/** Find session references outside fenced and inline code. */
+internal fun parseSessionReferences(markdown: String): List<SessionReference> {
+    val visible = buildString(markdown.length) {
+        var fenced = false
+        markdown.lineSequence().forEach { line ->
+            if (line.trimStart().startsWith("```")) {
+                fenced = !fenced
+                appendLine()
+            } else if (fenced) {
+                appendLine()
+            } else {
+                var inline = false
+                line.forEach { char ->
+                    if (char == '`') inline = !inline
+                    append(if (inline || char == '`') ' ' else char)
+                }
+                appendLine()
+            }
+        }
+    }
+    return SESSION_REFERENCE.findAll(visible)
+        .map {
+            SessionReference(
+                it.groupValues[1],
+                it.groupValues[2].trimEnd('.', ',', ';', '!', '?', ')', ']', '}'),
+            )
+        }
+        .filter { it.sessionId.isNotBlank() }
+        .distinct()
+        .take(16)
+        .toList()
+}
@@ -0,0 +1,96 @@
+package com.hermesandroid.relay.ui.components
+
+import android.content.Context
+import android.net.Uri
+import android.util.Log
+import kotlinx.serialization.json.Json
+import java.io.File
+import java.io.InputStream
+
+sealed interface SphereSkinImportResult {
+    data class Success(val id: String, val label: String) : SphereSkinImportResult
+    data class Failure(val reason: String) : SphereSkinImportResult
+}
+
+/** Imports one declarative sphere-skin JSON file into app-scoped local storage. */
+object SphereSkinImporter {
+    private const val TAG = "SphereSkinImporter"
+    private const val MAX_BYTES = 256L * 1024L
+
+    private val json = Json {
+        ignoreUnknownKeys = true
+        isLenient = true
+    }
+
+    fun importUri(context: Context, uri: Uri): SphereSkinImportResult {
+        val input = try {
+            context.contentResolver.openInputStream(uri)
+        } catch (t: Throwable) {
+            Log.w(TAG, "openInputStream failed: ${t.message}")
+            null
+        } ?: return SphereSkinImportResult.Failure("Couldn't open that file.")
+
+        return input.use { importStream(it, SphereSkinLoader.userDir(context)) }
+    }
+
+    /** Pure import core used by tests: bounds, parses, validates, then swaps with rollback. */
+    internal fun importStream(input: InputStream, skinsDir: File): SphereSkinImportResult {
+        return try {
+            val bytes = readBounded(input)
+                ?: return SphereSkinImportResult.Failure("That sphere file is too large.")
+            val spec = try {
+                json.decodeFromString(SphereSpec.serializer(), bytes.decodeToString())
+            } catch (_: Throwable) {
+                return SphereSkinImportResult.Failure("That sphere file isn't valid JSON.")
+            }
+            val resolved = spec.copy(id = spec.id.ifBlank { "custom-sphere" })
+            val skin = try {
+                resolved.toSkin()
+            } catch (t: Throwable) {
+                return SphereSkinImportResult.Failure(t.message ?: "That isn't a valid sphere skin.")
+            }
+
+            skinsDir.mkdirs()
+            val target = File(skinsDir, "${safeFileName(skin.id)}.json")
+            val staging = File(skinsDir, ".${target.name}.tmp")
+            val backup = File(skinsDir, ".${target.name}.bak")
+            staging.writeBytes(bytes)
+            if (backup.exists() && !target.exists()) backup.renameTo(target)
+            if (backup.exists() && target.exists()) backup.delete()
+            if (target.exists() && !target.renameTo(backup)) {
+                staging.delete()
+                return SphereSkinImportResult.Failure("Couldn't replace the existing sphere skin.")
+            }
+            if (!staging.renameTo(target)) {
+                staging.delete()
+                if (backup.exists()) backup.renameTo(target)
+                return SphereSkinImportResult.Failure("Couldn't save that sphere skin.")
+            }
+            backup.delete()
+            SphereSkinImportResult.Success(skin.id, skin.label)
+        } catch (t: Throwable) {
+            Log.w(TAG, "import failed: ${t.message}")
+            SphereSkinImportResult.Failure("Couldn't import that sphere skin.")
+        }
+    }
+
+    private fun readBounded(input: InputStream): ByteArray? {
+        val buffer = ByteArray(8 * 1024)
+        val output = java.io.ByteArrayOutputStream()
+        var total = 0L
+        while (true) {
+            val count = input.read(buffer)
+            if (count < 0) break
+            total += count
+            if (total > MAX_BYTES) return null
+            output.write(buffer, 0, count)
+        }
+        return output.toByteArray()
+    }
+
+    private fun safeFileName(id: String): String = id.trim()
+        .map { if (it.isLetterOrDigit() || it == '-' || it == '_' || it == '.') it else '-' }
+        .joinToString("")
+        .trim('.', '-')
+        .ifBlank { "custom-sphere" }
+}
@@ -25,8 +25,11 @@ import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.ExpandLess
 import androidx.compose.material.icons.filled.ExpandMore
 import androidx.compose.material3.Icon
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -73,11 +76,13 @@ fun SubagentLane(
    taskIndex: Int,
    calls: List<ToolCall>,
    modifier: Modifier = Modifier,
+    onSteer: ((subagentId: String, instruction: String) -> Unit)? = null,
 ) {
    val anyRunning = calls.any { !it.isComplete }
    val allComplete = calls.isNotEmpty() && calls.all { it.isComplete }
    val anyFailed = calls.any { it.isComplete && it.success == false }
    val runningCount = calls.count { !it.isComplete }
+    val steerableId = calls.firstNotNullOfOrNull { it.subagentId?.takeIf(String::isNotBlank) }

    val laneLabel = calls.firstNotNullOfOrNull { call ->
        call.taskLabel?.takeIf { it.isNotBlank() }
@@ -106,6 +111,8 @@ fun SubagentLane(
    val failureLabel = stringResource(R.string.cd_subagent_failed)

    var expanded by remember { mutableStateOf(!allComplete) }
+    var showSteerDialog by remember { mutableStateOf(false) }
+    var steerText by remember { mutableStateOf("") }

    // Auto-collapse when the last child completes — same pattern as
    // ToolProgressCard's LaunchedEffect(toolCall.isComplete).
@@ -162,6 +169,12 @@ fun SubagentLane(
                    modifier = Modifier.weight(1f),
                )

+                if (anyRunning && steerableId != null && onSteer != null) {
+                    TextButton(onClick = { showSteerDialog = true }) {
+                        Text("Redirect")
+                    }
+                }
+
                Text(
                    text = statusMeta,
                    style = relayMetadataStyle(),
@@ -202,4 +215,33 @@ fun SubagentLane(
            }
        }
    }
+
+    if (showSteerDialog && steerableId != null && onSteer != null) {
+        AlertDialog(
+            onDismissRequest = { showSteerDialog = false },
+            title = { Text("Redirect subagent") },
+            text = {
+                OutlinedTextField(
+                    value = steerText,
+                    onValueChange = { steerText = it },
+                    label = { Text("New instruction") },
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        val instruction = steerText.trim()
+                        showSteerDialog = false
+                        steerText = ""
+                        onSteer(steerableId, instruction)
+                    },
+                    enabled = steerText.isNotBlank(),
+                ) { Text("Redirect") }
+            },
+            dismissButton = {
+                TextButton(onClick = { showSteerDialog = false }) { Text("Cancel") }
+            },
+        )
+    }
 }
@@ -15,12 +15,11 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ExpandLess
 import androidx.compose.material.icons.filled.ExpandMore
 import androidx.compose.material.icons.filled.Psychology
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -29,6 +28,9 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalLocale
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.stateDescription
+import androidx.compose.ui.semantics.semantics
 import com.hermesandroid.relay.R
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.style.TextOverflow
@@ -49,7 +51,12 @@ fun ThinkingBlock(
    /** Stable key when this interactive block participates in Chat pet terrain. */
    petObstacleKey: String? = null,
 ) {
+    if (thinkingContent.isBlank()) return
    var expanded by remember { mutableStateOf(isStreaming) }
+    var userToggled by remember { mutableStateOf(false) }
+    LaunchedEffect(isStreaming) {
+        if (!userToggled) expanded = isStreaming
+    }
    val locale = LocalLocale.current.platformLocale
    val timeLabel = timestamp?.let {
        remember(it, locale) {
@@ -57,8 +64,13 @@ fun ThinkingBlock(
                .format(java.util.Date(it))
        }
    }
+    val expansionState = if (expanded) {
+        stringResource(R.string.tool_progress_state_expanded)
+    } else {
+        stringResource(R.string.tool_progress_state_collapsed)
+    }

-    Card(
+    Column(
        modifier = modifier
            .then(
                if (petObstacleKey != null) {
@@ -71,18 +83,20 @@ fun ThinkingBlock(
                },
            )
            .fillMaxWidth(),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)
-        )
    ) {
-        Column(modifier = Modifier.padding(8.dp)) {
-            // Header row
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .clickable { expanded = !expanded },
-                verticalAlignment = Alignment.CenterVertically
-            ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable(role = Role.Button) {
+                    userToggled = true
+                    expanded = !expanded
+                }
+                .semantics {
+                    stateDescription = expansionState
+                }
+                .padding(horizontal = 4.dp, vertical = 3.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
                Icon(
                    imageVector = Icons.Filled.Psychology,
                    contentDescription = accessibilityLabel,
@@ -91,9 +105,13 @@ fun ThinkingBlock(
                )
                Spacer(modifier = Modifier.width(6.dp))
                Text(
-                    text = headerText ?: if (isStreaming) stringResource(R.string.thinking_thinking) else stringResource(R.string.thinking_title),
-                    style = MaterialTheme.typography.labelSmall,
-                    color = MaterialTheme.colorScheme.tertiary
+                    text = headerText ?: if (isStreaming) {
+                        stringResource(R.string.thinking_thinking)
+                    } else {
+                        stringResource(R.string.thinking_settled)
+                    },
+                    style = MaterialTheme.typography.labelMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(modifier = Modifier.weight(1f))
                if (!isStreaming && timeLabel != null) {
@@ -110,25 +128,23 @@ fun ThinkingBlock(
                    modifier = Modifier.size(16.dp),
                    tint = MaterialTheme.colorScheme.onSurfaceVariant
                )
-            }
+        }

-            // Collapsible content
-            AnimatedVisibility(
-                visible = expanded,
-                enter = expandVertically(),
-                exit = shrinkVertically()
-            ) {
-                Text(
-                    text = thinkingContent,
-                    style = MaterialTheme.typography.bodySmall.copy(
-                        fontFamily = FontFamily.Default,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    ),
-                    modifier = Modifier.padding(top = 4.dp),
-                    maxLines = if (isStreaming) Int.MAX_VALUE else 50,
-                    overflow = TextOverflow.Ellipsis
-                )
-            }
+        AnimatedVisibility(
+            visible = expanded,
+            enter = expandVertically(),
+            exit = shrinkVertically()
+        ) {
+            Text(
+                text = thinkingContent,
+                style = MaterialTheme.typography.bodySmall.copy(
+                    fontFamily = FontFamily.Default,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                ),
+                modifier = Modifier.padding(start = 26.dp, top = 2.dp, end = 4.dp, bottom = 4.dp),
+                maxLines = if (isStreaming) Int.MAX_VALUE else 50,
+                overflow = TextOverflow.Ellipsis
+            )
        }
    }
 }
@@ -0,0 +1,284 @@
+package com.hermesandroid.relay.ui.components
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ExpandLess
+import androidx.compose.material.icons.filled.ExpandMore
+import androidx.compose.material.icons.filled.MoreHoriz
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalResources
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.stateDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.R
+import com.hermesandroid.relay.data.ToolCall
+import com.hermesandroid.relay.ui.components.pet.petObstacleSurface
+
+private val TOOL_ACTIVITY_PET_ROUTES = setOf("chat")
+private val FILE_EDIT_TOOLS = setOf("edit_file", "write_file", "apply_patch", "patch")
+private val ATTENTION_TOOLS = setOf(
+    "clarify",
+    "delegate_task",
+    "image_generate",
+    "approval",
+    "request_user_input",
+    "ask_user",
+    "sudo",
+    "secret",
+)
+
+internal sealed interface ToolTranscriptItem {
+    data class ActivityRun(val calls: List<ToolCall>) : ToolTranscriptItem
+    data class Standalone(val call: ToolCall) : ToolTranscriptItem
+}
+
+/** Off suppresses diagnostics, never an attention or deliverable surface. */
+internal fun ToolTranscriptItem.isVisibleForToolDisplay(toolDisplay: String): Boolean =
+    this is ToolTranscriptItem.Standalone || toolDisplay != "off"
+
+/**
+ * Preserve source order while folding only routine activity. Calls that are
+ * actionable, security-relevant, failed, or deliver a file/media result split
+ * the run and retain their own surface.
+ */
+internal fun groupTranscriptTools(calls: List<ToolCall>): List<ToolTranscriptItem> {
+    val result = mutableListOf<ToolTranscriptItem>()
+    val run = mutableListOf<ToolCall>()
+
+    fun flushRun() {
+        if (run.isNotEmpty()) {
+            result += ToolTranscriptItem.ActivityRun(run.toList())
+            run.clear()
+        }
+    }
+
+    calls.forEach { call ->
+        if (call.requiresStandaloneToolSurface()) {
+            flushRun()
+            result += ToolTranscriptItem.Standalone(call)
+        } else {
+            run += call
+        }
+    }
+    flushRun()
+    return result
+}
+
+internal fun ToolCall.requiresStandaloneToolSurface(): Boolean {
+    val normalized = name.trim().lowercase()
+    return success == false ||
+        !error.isNullOrBlank() ||
+        outputRisk != null ||
+        normalized in FILE_EDIT_TOOLS ||
+        normalized in ATTENTION_TOOLS
+}
+
+internal data class ToolActivityCounts(
+    val reads: Int = 0,
+    val searches: Int = 0,
+    val commands: Int = 0,
+    val browserActions: Int = 0,
+    val deviceActions: Int = 0,
+    val other: Int = 0,
+)
+
+internal fun countToolActivity(calls: List<ToolCall>): ToolActivityCounts {
+    var counts = ToolActivityCounts()
+    calls.forEach { call ->
+        val name = call.name.trim().lowercase()
+        counts = when {
+            name.contains("search") || name.contains("grep") || name.contains("find") ->
+                counts.copy(searches = counts.searches + 1)
+            name.contains("terminal") || name.contains("shell") || name.contains("exec") ||
+                name.contains("command") || name.contains("bash") || name.contains("powershell") ->
+                counts.copy(commands = counts.commands + 1)
+            name.contains("browser") || name.contains("chrome") || name.contains("playwright") ||
+                name.startsWith("web_") -> counts.copy(browserActions = counts.browserActions + 1)
+            name.contains("android") || name.contains("adb") || name.contains("device") ||
+                name.contains("tap") || name.contains("swipe") ->
+                counts.copy(deviceActions = counts.deviceActions + 1)
+            name.contains("read") || name.contains("list") || name.contains("glob") ||
+                name.contains("open") || name.contains("inspect") -> counts.copy(reads = counts.reads + 1)
+            else -> counts.copy(other = counts.other + 1)
+        }
+    }
+    return counts
+}
+
+@Composable
+fun ToolActivityRun(
+    calls: List<ToolCall>,
+    live: Boolean,
+    detailed: Boolean,
+    modifier: Modifier = Modifier,
+    messageTimestamp: Long? = null,
+    petObstacleKey: String? = null,
+    onExpandedChange: (Boolean) -> Unit = {},
+) {
+    if (calls.isEmpty()) return
+    var expanded by rememberSaveable(calls.first().uiKey) { mutableStateOf(false) }
+    val summary = toolActivitySummary(countToolActivity(calls), live)
+    val stateLabel = if (expanded) {
+        stringResource(R.string.tool_progress_cd_collapse)
+    } else {
+        stringResource(R.string.tool_progress_cd_expand)
+    }
+    val expansionState = if (expanded) {
+        stringResource(R.string.tool_progress_state_expanded)
+    } else {
+        stringResource(R.string.tool_progress_state_collapsed)
+    }
+
+    Column(
+        modifier = modifier
+            .then(
+                if (petObstacleKey != null) {
+                    Modifier.petObstacleSurface(petObstacleKey, TOOL_ACTIVITY_PET_ROUTES)
+                } else {
+                    Modifier
+                },
+            )
+            .fillMaxWidth(),
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable(role = Role.Button) {
+                    expanded = !expanded
+                    onExpandedChange(expanded)
+                }
+                .semantics {
+                    contentDescription = summary
+                    stateDescription = expansionState
+                }
+                .padding(horizontal = 4.dp, vertical = 4.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Icon(
+                imageVector = Icons.Filled.MoreHoriz,
+                contentDescription = null,
+                modifier = Modifier.size(16.dp),
+                tint = if (live) MaterialTheme.colorScheme.tertiary
+                else MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+            Spacer(modifier = Modifier.width(6.dp))
+            Text(
+                text = summary,
+                style = MaterialTheme.typography.labelMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                modifier = Modifier.weight(1f),
+            )
+            Icon(
+                imageVector = if (expanded) Icons.Filled.ExpandLess else Icons.Filled.ExpandMore,
+                contentDescription = stateLabel,
+                modifier = Modifier.size(16.dp),
+                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+
+        if (live && !expanded) {
+            val latest = calls.last()
+            AnimatedContent(
+                targetState = latest.uiKey,
+                transitionSpec = {
+                    (slideInVertically { it / 2 } + fadeIn()) togetherWith
+                        (slideOutVertically { -it / 2 } + fadeOut())
+                },
+                label = "toolActivityTicker",
+            ) { latestKey ->
+                val visible = calls.lastOrNull { it.uiKey == latestKey } ?: latest
+                Text(
+                    text = toolActivityTickerLabel(visible),
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.78f),
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    modifier = Modifier.padding(start = 26.dp, end = 4.dp, bottom = 4.dp),
+                )
+            }
+        }
+
+        AnimatedVisibility(
+            visible = expanded,
+            enter = expandVertically(),
+            exit = shrinkVertically(),
+        ) {
+            Column(modifier = Modifier.padding(start = 22.dp, top = 2.dp)) {
+                calls.forEach { call ->
+                    key(call.uiKey) {
+                        if (detailed) {
+                            ToolProgressCard(
+                                toolCall = call,
+                                messageTimestamp = messageTimestamp,
+                                onExpandedChange = onExpandedChange,
+                            )
+                        } else {
+                            CompactToolCall(toolCall = call)
+                        }
+                        Spacer(modifier = Modifier.height(4.dp))
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun toolActivitySummary(counts: ToolActivityCounts, live: Boolean): String {
+    val resources = LocalResources.current
+    val clauses = buildList {
+        fun addClause(count: Int, liveRes: Int, settledRes: Int) {
+            if (count > 0) add(resources.getQuantityString(if (live) liveRes else settledRes, count, count))
+        }
+        addClause(counts.reads, R.plurals.tool_run_reading, R.plurals.tool_run_read)
+        addClause(counts.searches, R.plurals.tool_run_searching, R.plurals.tool_run_searched)
+        addClause(counts.commands, R.plurals.tool_run_running_commands, R.plurals.tool_run_ran_commands)
+        addClause(counts.browserActions, R.plurals.tool_run_browsing, R.plurals.tool_run_browsed)
+        addClause(counts.deviceActions, R.plurals.tool_run_using_device, R.plurals.tool_run_used_device)
+        addClause(counts.other, R.plurals.tool_run_using_tools, R.plurals.tool_run_used_tools)
+    }
+    return clauses.joinToString(" · ")
+}
+
+@Composable
+private fun toolActivityTickerLabel(call: ToolCall): String {
+    val name = localizeToolName(call.name).ifBlank { stringResource(R.string.tool_preparing) }
+    return when {
+        call.isGenerating && !call.isComplete -> stringResource(R.string.tool_run_preparing, name)
+        !call.isComplete -> stringResource(R.string.tool_run_running, name)
+        else -> stringResource(R.string.tool_run_finished, name)
+    }
+}
@@ -40,7 +40,6 @@ import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -69,15 +68,20 @@ fun ToolProgressCard(
     * message timestamp. Null hides the time.
     */
    messageTimestamp: Long? = null,
+    /**
+     * Reports explicit user expansion so the owning transcript can yield its
+     * live-tail auto-follow while the user inspects arguments or results.
+     */
+    onExpandedChange: (Boolean) -> Unit = {},
 ) {
    // Preparing (tool.generating) starts collapsed — the args preview line
    // under the header is the whole story until tool.start lands.
-    // rememberSaveable (keyed per tool call, namespaced by the message item's
-    // key in the chat LazyColumn) so a manual expand survives scroll-off /
-    // re-render instead of snapping shut every time the row recomposes.
-    var expanded by rememberSaveable(
-        key = "toolcard:" + (toolCall.id ?: "${toolCall.name}:${toolCall.startedAt}"),
-    ) { mutableStateOf(!toolCall.isComplete && !toolCall.isGenerating) }
+    // Use the call identity as an input, not a custom saveable key: custom keys
+    // bypass positional scoping and can share state between nested lazy items.
+    // uiKey survives generating -> running ID adoption and ordinary copies.
+    var expanded by rememberSaveable(toolCall.uiKey) {
+        mutableStateOf(!toolCall.isComplete && !toolCall.isGenerating)
+    }
    val isPreparing = toolCall.isGenerating && !toolCall.isComplete
    val timeMillis = toolCall.completedAt ?: messageTimestamp
    val locale = LocalLocale.current.platformLocale
@@ -88,11 +92,6 @@ fun ToolProgressCard(
        }
    }

-    // Auto-collapse when tool completes
-    LaunchedEffect(toolCall.isComplete) {
-        if (toolCall.isComplete) expanded = false
-    }
-
    val statusIcon: ImageVector
    val statusColor = when {
        toolCall.isComplete && toolCall.success == true -> {
@@ -162,7 +161,10 @@ fun ToolProgressCard(
            Row(
                modifier = Modifier
                    .fillMaxWidth()
-                    .clickable { expanded = !expanded },
+                    .clickable {
+                        expanded = !expanded
+                        onExpandedChange(expanded)
+                    },
                verticalAlignment = Alignment.CenterVertically
            ) {
                // Tool type icon
@@ -0,0 +1,368 @@
+package com.hermesandroid.relay.ui.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.KeyboardArrowDown
+import androidx.compose.material.icons.filled.KeyboardArrowUp
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.data.ChatMessage
+import com.hermesandroid.relay.data.MessageRole
+import com.hermesandroid.relay.ui.theme.LocalBrand
+
+@Immutable
+data class TranscriptMatch(
+    val messageUiKey: String,
+    val messageIndex: Int,
+    val start: Int,
+    val endExclusive: Int,
+)
+
+@Immutable
+data class TranscriptTurnMarker(
+    val messageUiKey: String,
+    val messageIndex: Int,
+    val turnNumber: Int,
+    val label: String,
+    val matchCount: Int,
+    val containsActiveMatch: Boolean,
+)
+
+@Immutable
+data class TranscriptNavigationModel(
+    val matches: List<TranscriptMatch>,
+    val turns: List<TranscriptTurnMarker>,
+)
+
+/**
+ * User-facing copy is injectable so the component remains reusable and its
+ * eventual ChatScreen integration can supply localized resources without
+ * coupling the pure navigation model to Android resources.
+ */
+@Immutable
+data class TranscriptNavigatorStrings(
+    val searchPlaceholder: String = "Search conversation",
+    val previousMatch: String = "Previous match",
+    val nextMatch: String = "Next match",
+    val closeSearch: String = "Close search",
+    val noResults: String = "No results",
+    val resultCount: (current: Int, total: Int) -> String = { current, total -> "$current of $total" },
+    val resultCountDescription: (current: Int, total: Int) -> String = { current, total ->
+        if (total == 0) "No search results" else "Search result $current of $total"
+    },
+    val turnDescription: (turn: Int, label: String, matches: Int) -> String = { turn, label, matches ->
+        val suffix = if (matches == 1) ", 1 match" else if (matches > 1) ", $matches matches" else ""
+        "Jump to turn $turn: $label$suffix"
+    },
+)
+
+object TranscriptNavigatorTestTags {
+    const val Query = "transcript-search-query"
+    const val ResultCount = "transcript-search-result-count"
+    const val Previous = "transcript-search-previous"
+    const val Next = "transcript-search-next"
+    const val Close = "transcript-search-close"
+    const val TurnPrefix = "transcript-turn-"
+}
+
+/**
+ * Compact, self-contained find bar plus prompt rail for an active transcript.
+ * All jump callbacks use [ChatMessage.uiKey], the same stable identity used by
+ * Chat's LazyColumn, so a history reconciliation cannot invalidate a target.
+ */
+@Composable
+fun TranscriptSearchNavigator(
+    messages: List<ChatMessage>,
+    onJumpToMessage: (messageUiKey: String) -> Unit,
+    onClose: () -> Unit,
+    modifier: Modifier = Modifier,
+    initialQuery: String = "",
+    strings: TranscriptNavigatorStrings = TranscriptNavigatorStrings(),
+) {
+    val brand = LocalBrand.current
+    var query by rememberSaveable { mutableStateOf(initialQuery) }
+    var activeMatchIndex by rememberSaveable { mutableIntStateOf(0) }
+    val model = remember(messages, query, activeMatchIndex) {
+        buildTranscriptNavigationModel(messages, query, activeMatchIndex)
+    }
+    val normalizedActiveIndex = activeMatchIndex.coerceIn(0, (model.matches.size - 1).coerceAtLeast(0))
+    val focusRequester = remember { FocusRequester() }
+
+    LaunchedEffect(Unit) {
+        runCatching { focusRequester.requestFocus() }
+    }
+
+    fun selectMatch(index: Int) {
+        if (model.matches.isEmpty()) return
+        val normalized = Math.floorMod(index, model.matches.size)
+        activeMatchIndex = normalized
+        onJumpToMessage(model.matches[normalized].messageUiKey)
+    }
+
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .background(brand.navy)
+            .border(1.dp, brand.line, RoundedCornerShape(14.dp))
+            .padding(horizontal = 8.dp, vertical = 6.dp),
+        verticalArrangement = Arrangement.spacedBy(2.dp),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(2.dp),
+        ) {
+            Row(
+                modifier = Modifier
+                    .weight(1f)
+                    .clip(RoundedCornerShape(10.dp))
+                    .background(brand.surfaceLow)
+                    .border(1.dp, brand.line, RoundedCornerShape(10.dp))
+                    .padding(horizontal = 10.dp, vertical = 8.dp),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                Icon(
+                    imageVector = Icons.Filled.Search,
+                    contentDescription = null,
+                    tint = brand.muted,
+                    modifier = Modifier.size(18.dp),
+                )
+                BasicTextField(
+                    value = query,
+                    onValueChange = {
+                        query = it
+                        activeMatchIndex = 0
+                    },
+                    modifier = Modifier
+                        .weight(1f)
+                        .focusRequester(focusRequester)
+                        .testTag(TranscriptNavigatorTestTags.Query),
+                    singleLine = true,
+                    textStyle = MaterialTheme.typography.bodyMedium.copy(color = brand.ink),
+                    cursorBrush = SolidColor(brand.relay),
+                    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
+                    keyboardActions = KeyboardActions(onSearch = { selectMatch(normalizedActiveIndex) }),
+                    decorationBox = { inner ->
+                        Box {
+                            if (query.isEmpty()) {
+                                Text(
+                                    text = strings.searchPlaceholder,
+                                    color = brand.dim,
+                                    style = MaterialTheme.typography.bodyMedium,
+                                )
+                            }
+                            inner()
+                        }
+                    },
+                )
+            }
+
+            val current = if (model.matches.isEmpty()) 0 else normalizedActiveIndex + 1
+            Text(
+                text = if (model.matches.isEmpty() && query.isNotBlank()) {
+                    strings.noResults
+                } else {
+                    strings.resultCount(current, model.matches.size)
+                },
+                color = brand.muted,
+                style = MaterialTheme.typography.labelSmall,
+                maxLines = 1,
+                modifier = Modifier
+                    .testTag(TranscriptNavigatorTestTags.ResultCount)
+                    .semantics {
+                        contentDescription = strings.resultCountDescription(current, model.matches.size)
+                    },
+            )
+            IconButton(
+                onClick = { selectMatch(normalizedActiveIndex - 1) },
+                enabled = model.matches.isNotEmpty(),
+                modifier = Modifier.testTag(TranscriptNavigatorTestTags.Previous),
+            ) {
+                Icon(Icons.Filled.KeyboardArrowUp, strings.previousMatch, tint = brand.ink)
+            }
+            IconButton(
+                onClick = { selectMatch(normalizedActiveIndex + 1) },
+                enabled = model.matches.isNotEmpty(),
+                modifier = Modifier.testTag(TranscriptNavigatorTestTags.Next),
+            ) {
+                Icon(Icons.Filled.KeyboardArrowDown, strings.nextMatch, tint = brand.ink)
+            }
+            IconButton(
+                onClick = onClose,
+                modifier = Modifier.testTag(TranscriptNavigatorTestTags.Close),
+            ) {
+                Icon(Icons.Filled.Close, strings.closeSearch, tint = brand.ink)
+            }
+        }
+
+        TranscriptTurnRail(
+            turns = model.turns,
+            onJumpToMessage = onJumpToMessage,
+            strings = strings,
+        )
+    }
+}
+
+@Composable
+fun TranscriptTurnRail(
+    turns: List<TranscriptTurnMarker>,
+    onJumpToMessage: (messageUiKey: String) -> Unit,
+    modifier: Modifier = Modifier,
+    strings: TranscriptNavigatorStrings = TranscriptNavigatorStrings(),
+) {
+    if (turns.isEmpty()) return
+    val brand = LocalBrand.current
+    Row(
+        modifier = modifier
+            .fillMaxWidth()
+            .horizontalScroll(rememberScrollState()),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        turns.forEach { turn ->
+            IconButton(
+                onClick = { onJumpToMessage(turn.messageUiKey) },
+                modifier = Modifier
+                    .testTag("${TranscriptNavigatorTestTags.TurnPrefix}${turn.messageUiKey}")
+                    .semantics {
+                        contentDescription = strings.turnDescription(
+                            turn.turnNumber,
+                            turn.label,
+                            turn.matchCount,
+                        )
+                    },
+            ) {
+                Box(
+                    modifier = Modifier
+                        .size(if (turn.containsActiveMatch) 12.dp else 8.dp)
+                        .clip(RoundedCornerShape(50))
+                        .background(
+                            when {
+                                turn.containsActiveMatch -> brand.relay
+                                turn.matchCount > 0 -> brand.purple
+                                else -> brand.dim
+                            },
+                        ),
+                )
+            }
+        }
+    }
+}
+
+internal fun buildTranscriptNavigationModel(
+    messages: List<ChatMessage>,
+    query: String,
+    activeMatchIndex: Int = 0,
+): TranscriptNavigationModel {
+    val needle = query.trim()
+    val matches = if (needle.isEmpty()) {
+        emptyList()
+    } else {
+        buildList {
+            messages.forEachIndexed { messageIndex, message ->
+                val text = message.searchableRenderedText()
+                var start = 0
+                while (start <= text.length - needle.length) {
+                    val found = text.indexOf(needle, startIndex = start, ignoreCase = true)
+                    if (found < 0) break
+                    add(TranscriptMatch(message.uiKey, messageIndex, found, found + needle.length))
+                    start = found + needle.length.coerceAtLeast(1)
+                }
+            }
+        }
+    }
+
+    val activeMatch = matches.getOrNull(activeMatchIndex.coerceIn(0, (matches.size - 1).coerceAtLeast(0)))
+    val userIndexes = messages.indices.filter { messages[it].role == MessageRole.USER }
+    val turns = userIndexes.mapIndexed { ordinal, messageIndex ->
+        val endExclusive = userIndexes.getOrNull(ordinal + 1) ?: messages.size
+        val turnMatches = matches.count { it.messageIndex in messageIndex until endExclusive }
+        val prompt = messages[messageIndex]
+        TranscriptTurnMarker(
+            messageUiKey = prompt.uiKey,
+            messageIndex = messageIndex,
+            turnNumber = ordinal + 1,
+            label = prompt.content.compactTranscriptLabel("Prompt ${ordinal + 1}"),
+            matchCount = turnMatches,
+            containsActiveMatch = activeMatch?.messageIndex?.let { it in messageIndex until endExclusive } == true,
+        )
+    }
+    return TranscriptNavigationModel(matches = matches, turns = turns)
+}
+
+internal fun ChatMessage.searchableRenderedText(): String = buildList {
+    add(content)
+    add(thinkingContent)
+    moaReferences.forEach {
+        add(it.label)
+        add(it.text)
+    }
+    toolCalls.forEach {
+        add(it.name)
+        add(it.taskLabel.orEmpty())
+        add(it.args.orEmpty())
+        add(it.result.orEmpty())
+        add(it.error.orEmpty())
+    }
+    attachments.forEach {
+        add(it.fileName.orEmpty())
+        add(it.errorMessage.orEmpty())
+    }
+    cards.forEach { card ->
+        add(card.title.orEmpty())
+        add(card.subtitle.orEmpty())
+        add(card.body.orEmpty())
+        card.fields.forEach {
+            add(it.label)
+            add(it.value)
+        }
+        card.actions.forEach { add(it.label) }
+        add(card.footer.orEmpty())
+    }
+}.filter(String::isNotBlank).joinToString("\n")
+
+private fun String.compactTranscriptLabel(fallback: String): String {
+    val compact = trim().replace(Regex("\\s+"), " ")
+    return when {
+        compact.isEmpty() -> fallback
+        compact.length <= 64 -> compact
+        else -> compact.take(61).trimEnd() + "…"
+    }
+}
@@ -104,8 +104,8 @@ interface AgentAvatar {
 }

 /**
- * Legacy ambient-visualization seam. The app now provides [SphereAvatar] here;
- * floating companions are published through [LocalFloatingPet].
+ * Central/ambient visualization seam. The app provides the independently saved
+ * Sphere or pet-format background here; floating companions use [LocalFloatingPet].
 */
 val LocalAgentAvatar = staticCompositionLocalOf<AgentAvatar> { SphereAvatar }

@@ -117,14 +117,20 @@ val LocalAvailableAvatars = staticCompositionLocalOf<List<AgentAvatar>> { listOf

 /**
 * The optional floating pet companion. Unlike [LocalAgentAvatar], this does not
- * replace the ambient sphere or the active profile's identity image. `null`
- * means the user has not selected a companion.
+ * replace the independently selected central/background visualization or the
+ * active profile's identity image. `null` means no companion is selected.
 */
 val LocalFloatingPet = staticCompositionLocalOf<AgentAvatar?> { null }

 /** User-installed pets available to the companion picker (sphere excluded). */
 val LocalAvailablePets = staticCompositionLocalOf<List<AgentAvatar>> { emptyList() }

+/** Resolve a central visualization without ever coupling it to floating state. */
+internal fun resolveBackgroundAvatar(
+    selectedId: String,
+    availablePets: List<AgentAvatar>,
+): AgentAvatar = availablePets.firstOrNull { it.id == selectedId } ?: SphereAvatar
+
 /** Ambient sphere/background visibility, independent of the motion setting. */
 val LocalBackgroundVisualizationEnabled = staticCompositionLocalOf { true }

@@ -12,6 +12,8 @@ import androidx.compose.ui.geometry.Rect
 import androidx.compose.ui.layout.boundsInRoot
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
 import com.hermesandroid.relay.ui.components.SphereState
 import com.hermesandroid.relay.ui.components.avatar.AvatarRenderState

@@ -100,6 +102,7 @@ class PetCompanionCoordinator {
    private var renderState by mutableStateOf(AvatarRenderState(SphereState.Idle))
    private var visitRequestState by mutableStateOf(PetVisitRequestState())
    private val surfaces = mutableStateMapOf<String, PetCompanionSurface>()
+    private val interactionLayers = mutableStateMapOf<String, Boolean>()

    val pendingVisitRequest: PetVisitRequest?
        get() = visitRequestState.pending
@@ -141,20 +144,49 @@ class PetCompanionCoordinator {
        surfaces.remove(owner)
    }

+    /** App-wide UI ownership gate for drawers and other same-window overlays. */
+    fun publishInteractionLayer(owner: String, active: Boolean) {
+        require(owner.isNotBlank()) { "Pet interaction-layer owner must not be blank." }
+        if (active) interactionLayers[owner] = true else interactionLayers.remove(owner)
+    }
+
+    fun clearInteractionLayer(owner: String) {
+        interactionLayers.remove(owner)
+    }
+
    fun activityFor(owner: String?): PetCompanionActivity {
        val surface = owner?.let(surfaces::get)
        return PetCompanionActivity(
            renderState = renderState,
            scrolling = surface?.scrolling == true,
-            hidden = surface?.hidden == true,
+            hidden = surface?.hidden == true || interactionLayers.values.any { it },
        )
    }
 }

 private data class PetCompanionSurface(val scrolling: Boolean, val hidden: Boolean)

+/** A pet-owned popup may take window focus without becoming a competing modal. */
+internal fun platformModalOwnsPetLayer(
+    windowFocused: Boolean,
+    petMenuExpanded: Boolean,
+): Boolean = !windowFocused && !petMenuExpanded
+
 val LocalPetCompanionCoordinator = staticCompositionLocalOf { PetCompanionCoordinator() }

+/**
+ * Declares that a same-window interaction layer currently owns input. Platform
+ * dialogs and modal sheets are covered separately by root window-focus state.
+ */
+@Composable
+fun PetInteractionLayer(owner: String, active: Boolean) {
+    val coordinator = LocalPetCompanionCoordinator.current
+    SideEffect { coordinator.publishInteractionLayer(owner, active) }
+    DisposableEffect(coordinator, owner) {
+        onDispose { coordinator.clearInteractionLayer(owner) }
+    }
+}
+
 /**
 * Explicit UI surfaces measured by their owners. Their top edges become
 * walkable perches, matching Hermes Desktop's live-DOM ledge model without
@@ -60,6 +60,7 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import com.hermesandroid.relay.R
+import com.hermesandroid.relay.data.PhysicalKeyboardEnterBehavior
 import com.hermesandroid.relay.network.upstream.GatewayAvailability
 import com.hermesandroid.relay.network.upstream.ServerCapabilities
 import com.hermesandroid.relay.ui.components.ChatTransportStatus
@@ -443,6 +444,48 @@ fun ChatSettingsScreen(

                    HorizontalDivider()

+                    val physicalKeyboardEnterBehavior by
+                        connectionViewModel.physicalKeyboardEnterBehavior.collectAsState()
+                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                        Text(
+                            text = stringResource(R.string.chat_settings_physical_keyboard_enter),
+                            style = MaterialTheme.typography.bodyMedium,
+                        )
+                        Text(
+                            text = stringResource(R.string.chat_settings_physical_keyboard_enter_desc),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                        val enterBehaviors = PhysicalKeyboardEnterBehavior.entries
+                        SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
+                            enterBehaviors.forEachIndexed { index, behavior ->
+                                SegmentedButton(
+                                    shape = SegmentedButtonDefaults.itemShape(
+                                        index = index,
+                                        count = enterBehaviors.size,
+                                    ),
+                                    onClick = {
+                                        connectionViewModel.setPhysicalKeyboardEnterBehavior(behavior)
+                                    },
+                                    selected = behavior == physicalKeyboardEnterBehavior,
+                                ) {
+                                    Text(
+                                        text = stringResource(
+                                            if (behavior == PhysicalKeyboardEnterBehavior.SendMessage) {
+                                                R.string.chat_input_send_message
+                                            } else {
+                                                R.string.chat_settings_insert_newline
+                                            },
+                                        ),
+                                        style = MaterialTheme.typography.labelMedium,
+                                    )
+                                }
+                            }
+                        }
+                    }
+
+                    HorizontalDivider()
+
                    // Background chat-alert toggle. First enable on
                    // API 33+ runs the POST_NOTIFICATIONS request (the
                    // BridgeScreen master-toggle precedent); if the user
@@ -0,0 +1,249 @@
+package com.hermesandroid.relay.ui.screens
+
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.AutoAwesome
+import androidx.compose.material.icons.filled.ContentCopy
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalClipboardManager
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.R
+import com.hermesandroid.relay.viewmodel.ConnectionViewModel
+import kotlinx.coroutines.launch
+
+internal enum class CustomPetKind { STATIC, ANIMATED }
+
+internal fun buildCustomPetPrompt(
+    name: String,
+    description: String,
+    kind: CustomPetKind,
+): String {
+    val safeName = name.trim().ifBlank { "My Hermes companion" }
+    val safeDescription = description.trim().ifBlank {
+        "a friendly companion that remains recognizable at small mobile sizes"
+    }
+    val output = if (kind == CustomPetKind.STATIC) {
+        "Create one transparent PNG or WebP image. Keep the subject centered with generous edge padding."
+    } else {
+        "Create a validated Hermes pet pack ZIP using pet.json plus transparent sprite sheets. " +
+            "Include idle, walk-left/right, thinking or working, writing, speaking, listening, greet, done, and error where practical. " +
+            "Frames must show real motion while keeping the character, scale, baseline, and anchor consistent. " +
+            "At minimum, pet.json must use schemaVersion 1, a stable id and label, and an idle state. " +
+            "A frame-list state is shaped like {\"frames\":[\"idle-01.png\"],\"fps\":8}; a sheet state is shaped like " +
+            "{\"sheet\":\"idle.png\",\"frameWidth\":256,\"frameHeight\":256,\"frameCount\":16,\"fps\":8}. " +
+            "All referenced files must remain inside the pack folder."
+    }
+    return """
+        Help me create a custom floating pet for the Hermes Relay Android app.
+
+        Pet name: $safeName
+        Character direction: $safeDescription
+        Format: ${if (kind == CustomPetKind.STATIC) "single static image" else "animated pet pack"}
+
+        $output
+
+        Follow the current Hermes Relay pet contract above. If the repository docs/pet-spec.md or user-docs/features/custom-avatars.md are available, use them as the final authority. Use image-generation tools only if they are available in this chat. Do not upload my reference image, generated art, or pet pack anywhere except through tools I explicitly approve. Work locally where possible.
+
+        Before returning anything, validate the manifest and every referenced file, reject path traversal, verify decoded image dimensions and safe margins, and check that animated frames differ visibly without drifting. Then show me a concise review summary and attach the final PNG/WebP or ZIP for me to inspect. Do not install, publish, or share it automatically. I will review it and import it from Appearance > Floating pet.
+
+        If you need a visual reference, ask me to attach it in this chat before generating the pet.
+    """.trimIndent()
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
+@Composable
+fun CustomPetGuideScreen(
+    connectionViewModel: ConnectionViewModel,
+    onBack: () -> Unit,
+    onStartNewChat: (String) -> Unit,
+) {
+    var name by remember { mutableStateOf("") }
+    var description by remember { mutableStateOf("") }
+    var kind by remember { mutableStateOf(CustomPetKind.ANIMATED) }
+    val prompt = remember(name, description, kind) { buildCustomPetPrompt(name, description, kind) }
+    val clipboard = LocalClipboardManager.current
+    val copiedMessage = stringResource(R.string.pet_creator_copied)
+    val snackbarHostState = remember { SnackbarHostState() }
+    val scope = rememberCoroutineScope()
+    val importLauncher = rememberLauncherForActivityResult(ActivityResultContracts.OpenDocument()) { uri ->
+        uri?.let(connectionViewModel::importPet)
+    }
+    LaunchedEffect(connectionViewModel) {
+        connectionViewModel.avatarEvents.collect { snackbarHostState.showSnackbar(it) }
+    }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.pet_creator_title)) },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(Icons.AutoMirrored.Filled.ArrowBack, stringResource(R.string.appearance_back))
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(containerColor = MaterialTheme.colorScheme.surface),
+            )
+        },
+        snackbarHost = { SnackbarHost(snackbarHostState) },
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding)
+                .verticalScroll(rememberScrollState())
+                .padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Text(
+                text = stringResource(R.string.pet_creator_intro),
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+
+            GuideCard(step = "1", title = stringResource(R.string.pet_creator_step_idea)) {
+                OutlinedTextField(
+                    value = name,
+                    onValueChange = { name = it },
+                    modifier = Modifier.fillMaxWidth(),
+                    label = { Text(stringResource(R.string.pet_creator_name)) },
+                    singleLine = true,
+                )
+                OutlinedTextField(
+                    value = description,
+                    onValueChange = { description = it },
+                    modifier = Modifier.fillMaxWidth(),
+                    label = { Text(stringResource(R.string.pet_creator_description)) },
+                    supportingText = { Text(stringResource(R.string.pet_creator_description_hint)) },
+                    minLines = 3,
+                )
+                FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    FilterChip(
+                        selected = kind == CustomPetKind.ANIMATED,
+                        onClick = { kind = CustomPetKind.ANIMATED },
+                        label = { Text(stringResource(R.string.pet_creator_animated)) },
+                    )
+                    FilterChip(
+                        selected = kind == CustomPetKind.STATIC,
+                        onClick = { kind = CustomPetKind.STATIC },
+                        label = { Text(stringResource(R.string.pet_creator_static)) },
+                    )
+                }
+            }
+
+            GuideCard(step = "2", title = stringResource(R.string.pet_creator_step_create)) {
+                Text(
+                    text = stringResource(R.string.pet_creator_review_copy),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Card(
+                    colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+                    shape = RoundedCornerShape(12.dp),
+                ) {
+                    Text(
+                        text = prompt,
+                        modifier = Modifier.padding(14.dp),
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                }
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    OutlinedButton(
+                        onClick = {
+                            clipboard.setText(AnnotatedString(prompt))
+                            scope.launch { snackbarHostState.showSnackbar(copiedMessage) }
+                        },
+                        modifier = Modifier.weight(1f),
+                    ) {
+                        Icon(Icons.Filled.ContentCopy, null)
+                        Text(stringResource(R.string.pet_creator_copy), modifier = Modifier.padding(start = 6.dp))
+                    }
+                    Button(
+                        onClick = { onStartNewChat(prompt) },
+                        modifier = Modifier.weight(1f),
+                    ) {
+                        Icon(Icons.Filled.AutoAwesome, null)
+                        Text(stringResource(R.string.pet_creator_new_chat), modifier = Modifier.padding(start = 6.dp))
+                    }
+                }
+            }
+
+            GuideCard(step = "3", title = stringResource(R.string.pet_creator_step_review)) {
+                Text(
+                    text = stringResource(R.string.pet_creator_review_desc),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                OutlinedButton(
+                    onClick = {
+                        importLauncher.launch(arrayOf("application/zip", "image/*", "application/octet-stream", "*/*"))
+                    },
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    Icon(Icons.Filled.Add, null)
+                    Text(stringResource(R.string.pet_creator_import), modifier = Modifier.padding(start = 6.dp))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun GuideCard(step: String, title: String, content: @Composable ColumnScope.() -> Unit) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant),
+        shape = RoundedCornerShape(16.dp),
+    ) {
+        Column(
+            modifier = Modifier.padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            Text(
+                text = "$step  ·  $title",
+                style = MaterialTheme.typography.titleMedium,
+                color = MaterialTheme.colorScheme.primary,
+            )
+            content()
+        }
+    }
+}
@@ -148,6 +148,10 @@ private enum class DashboardManagementSection(val path: String) {
    Catalog("/api/mcp/catalog"),
    CustomEndpoints("/api/providers/custom-endpoints"),
    Profiles("/api/profiles"),
+    Memory("/api/memory"),
+    Learning("/api/learning/graph"),
+    Channels("/api/messaging/platforms"),
+    Operations("/api/status"),
    Models("/api/model/info"),
    Keys("/api/env"),
    Config("/api/config/schema");
@@ -160,6 +164,10 @@ private enum class DashboardManagementSection(val path: String) {
        Catalog -> stringResource(R.string.dashboard_tab_catalog)
        CustomEndpoints -> stringResource(R.string.dashboard_tab_custom_endpoints)
        Profiles -> stringResource(R.string.dashboard_tab_profiles)
+        Memory -> stringResource(R.string.dashboard_tab_memory)
+        Learning -> stringResource(R.string.dashboard_tab_learning)
+        Channels -> stringResource(R.string.dashboard_tab_channels)
+        Operations -> stringResource(R.string.dashboard_tab_operations)
        Models -> stringResource(R.string.dashboard_tab_models)
        Keys -> stringResource(R.string.dashboard_tab_keys)
        Config -> stringResource(R.string.dashboard_tab_config)
@@ -174,6 +182,10 @@ private enum class DashboardManagementSection(val path: String) {
        Catalog -> stringResource(R.string.dashboard_tab_catalog_lower)
        CustomEndpoints -> stringResource(R.string.dashboard_tab_custom_endpoints_lower)
        Profiles -> stringResource(R.string.dashboard_tab_profiles_lower)
+        Memory -> stringResource(R.string.dashboard_tab_memory_lower)
+        Learning -> stringResource(R.string.dashboard_tab_learning_lower)
+        Channels -> stringResource(R.string.dashboard_tab_channels_lower)
+        Operations -> stringResource(R.string.dashboard_tab_operations_lower)
        Models -> stringResource(R.string.dashboard_tab_models_lower)
        Keys -> stringResource(R.string.dashboard_tab_keys_lower)
        Config -> stringResource(R.string.dashboard_tab_config_lower)
@@ -183,7 +195,15 @@ private enum class DashboardManagementSection(val path: String) {
 private val managementSections: List<DashboardManagementSection> = DashboardManagementSection.entries

 internal fun dashboardSectionRequestPath(path: String, profile: String?): String {
-    if (profile.isNullOrBlank() || path !in setOf("/api/mcp/servers", "/api/mcp/catalog")) return path
+    if (
+        profile.isNullOrBlank() ||
+        path !in setOf(
+            "/api/mcp/servers",
+            "/api/mcp/catalog",
+            "/api/providers/custom-endpoints",
+            "/api/learning/graph",
+        )
+    ) return path
    val encoded = java.net.URLEncoder.encode(profile, Charsets.UTF_8.name()).replace("+", "%20")
    return "$path?profile=$encoded"
 }
@@ -225,7 +245,11 @@ internal fun scopeDashboardManageItems(
    profile: String?,
    items: List<DashboardSummaryItem>,
 ): List<DashboardSummaryItem> =
-    if (sectionPath == "/api/mcp/servers" || sectionPath == "/api/mcp/catalog") {
+    if (
+        sectionPath == "/api/mcp/servers" ||
+        sectionPath == "/api/mcp/catalog" ||
+        sectionPath == "/api/providers/custom-endpoints"
+    ) {
        items.map { it.copy(profile = profile) }
    } else {
        items
@@ -350,6 +374,7 @@ private enum class DashboardSectionAction {
    BrowseSkillsHub,
    UpdateSkillsHub,
    AddCustomEndpoint,
+    CreateServerBackup,
 }

 /** Editor session for a profile's SOUL.md — content is the FULL file from GET. */
@@ -754,7 +779,12 @@ fun DashboardManagementScreen(
        }
    }

-    fun submitCreateProfile(name: String, description: String, cloneFromDefault: Boolean) {
+    fun submitCreateProfile(
+        name: String,
+        description: String,
+        cloneFromDefault: Boolean,
+        mcpServers: List<String>,
+    ) {
        if (dashboardUrl.isBlank() || actionInFlight) return
        val actionPayloadKey = payloadKey
        actionInFlight = true
@@ -766,6 +796,7 @@ fun DashboardManagementScreen(
                        name = name,
                        cloneFromDefault = cloneFromDefault,
                        description = description.takeIf { it.isNotBlank() },
+                        mcpServers = mcpServers,
                    )
                }
            } catch (e: Exception) {
@@ -785,6 +816,28 @@ fun DashboardManagementScreen(
        }
    }

+    fun runServerBackup() {
+        if (dashboardUrl.isBlank() || actionInFlight) return
+        actionInFlight = true
+        actionMessage = null
+        scope.launch {
+            val result = try {
+                withDashboardClient(clientFactory) { client -> client.createServerBackup() }
+            } catch (e: Exception) {
+                Result.failure(e)
+            }
+            actionMessage = result.fold(
+                onSuccess = { root ->
+                    root.stringField("message")
+                        ?: root.stringField("filename")?.let { "Server backup ready: $it" }
+                        ?: "Server backup created."
+                },
+                onFailure = { error -> error.message ?: "Server backup failed." },
+            )
+            actionInFlight = false
+        }
+    }
+
    LaunchedEffect(dashboardUrl, selectedTab, reloadNonce, activeConnection?.id, effectiveProfileName) {
        val forceCurrent = forceReloadKey == payloadKey
        loadDashboardSection(
@@ -950,6 +1003,7 @@ fun DashboardManagementScreen(
    if (showCreateProfile) {
        var newProfileName by remember { mutableStateOf("") }
        var newProfileDescription by remember { mutableStateOf("") }
+        var newProfileMcpServers by remember { mutableStateOf("") }
        var cloneFromDefault by remember { mutableStateOf(true) }
        AlertDialog(
            onDismissRequest = { showCreateProfile = false },
@@ -969,6 +1023,13 @@ fun DashboardManagementScreen(
                        modifier = Modifier.fillMaxWidth(),
                        label = { Text(stringResource(R.string.dashboard_description_optional)) },
                    )
+                    OutlinedTextField(
+                        value = newProfileMcpServers,
+                        onValueChange = { newProfileMcpServers = it },
+                        modifier = Modifier.fillMaxWidth(),
+                        label = { Text(stringResource(R.string.dashboard_profile_mcp_servers_optional)) },
+                        supportingText = { Text(stringResource(R.string.dashboard_profile_mcp_servers_help)) },
+                    )
                    Row(
                        modifier = Modifier.fillMaxWidth(),
                        verticalAlignment = Alignment.CenterVertically,
@@ -991,6 +1052,12 @@ fun DashboardManagementScreen(
                            name = newProfileName.trim(),
                            description = newProfileDescription.trim(),
                            cloneFromDefault = cloneFromDefault,
+                            mcpServers = newProfileMcpServers
+                                .split(',', '\n')
+                                .map(String::trim)
+                                .filter(String::isNotBlank)
+                                .distinct()
+                                .take(64),
                        )
                    },
                    enabled = newProfileName.isNotBlank() && !actionInFlight,
@@ -1091,6 +1158,7 @@ fun DashboardManagementScreen(
    if (showCustomEndpointEditor) {
        CustomEndpointDialog(
            existing = customEndpointEditor,
+            profile = effectiveProfileName,
            clientFactory = clientFactory,
            onSaved = {
                showCustomEndpointEditor = false
@@ -1325,6 +1393,8 @@ fun DashboardManagementScreen(
                                                customEndpointEditor = null
                                                showCustomEndpointEditor = true
                                            }
+                                            DashboardSectionAction.CreateServerBackup ->
+                                                runServerBackup()
                                        }
                                    },
                                    mcpOAuthSupported = mcpOAuthStartAllowed,
@@ -1377,6 +1447,26 @@ private fun manageTileSpec(section: DashboardManagementSection): ManageTileSpec
        title = stringResource(R.string.dashboard_tile_profiles_title),
        subtitle = stringResource(R.string.dashboard_tile_profiles_sub),
    )
+    DashboardManagementSection.Memory -> ManageTileSpec(
+        icon = Icons.Filled.AutoAwesome,
+        title = stringResource(R.string.dashboard_tile_memory_title),
+        subtitle = stringResource(R.string.dashboard_tile_memory_sub),
+    )
+    DashboardManagementSection.Learning -> ManageTileSpec(
+        icon = Icons.Filled.AutoAwesome,
+        title = stringResource(R.string.dashboard_tile_learning_title),
+        subtitle = stringResource(R.string.dashboard_tile_learning_sub),
+    )
+    DashboardManagementSection.Channels -> ManageTileSpec(
+        icon = Icons.Filled.Link,
+        title = stringResource(R.string.dashboard_tile_channels_title),
+        subtitle = stringResource(R.string.dashboard_tile_channels_sub),
+    )
+    DashboardManagementSection.Operations -> ManageTileSpec(
+        icon = Icons.Filled.Tune,
+        title = stringResource(R.string.dashboard_tile_operations_title),
+        subtitle = stringResource(R.string.dashboard_tile_operations_sub),
+    )
    DashboardManagementSection.Skills -> ManageTileSpec(
        icon = Icons.Filled.AutoAwesome,
        title = stringResource(R.string.dashboard_tile_skills_title),
@@ -2205,6 +2295,7 @@ private fun LoadedBody(
    val actionLabelBrowseHub = stringResource(R.string.dashboard_section_action_browse_hub)
    val actionLabelUpdateInstalled = stringResource(R.string.dashboard_section_action_update_installed)
    val actionLabelAddEndpoint = stringResource(R.string.dashboard_custom_endpoint_add)
+    val actionLabelServerBackup = stringResource(R.string.dashboard_section_action_server_backup)
    LazyColumn(
        modifier = Modifier.fillMaxSize(),
        contentPadding = androidx.compose.foundation.layout.PaddingValues(
@@ -2232,6 +2323,9 @@ private fun LoadedBody(
            DashboardManagementSection.CustomEndpoints -> listOf(
                DashboardSectionAction.AddCustomEndpoint to actionLabelAddEndpoint,
            )
+            DashboardManagementSection.Operations -> listOf(
+                DashboardSectionAction.CreateServerBackup to actionLabelServerBackup,
+            )
            else -> emptyList()
        }
        if (sectionActions.isNotEmpty()) {
@@ -2833,7 +2927,7 @@ internal fun parseModelOptions(root: JsonObject): List<ModelProviderOption> {
        .mapNotNull { (it as? JsonPrimitive)?.contentOrNull?.trim()?.takeIf(String::isNotBlank) }
        .map { it.lowercase() }
        .toSet()
-    return providers.mapNotNull { element ->
+    val parsed = providers.mapNotNull { element ->
        val obj = element as? JsonObject ?: return@mapNotNull null
        val id = obj.stringField("slug")
            ?: obj.stringField("id")
@@ -2860,10 +2954,25 @@ internal fun parseModelOptions(root: JsonObject): List<ModelProviderOption> {
            // Absent hint field: a row with models is assumed usable; an empty
            // row can only be an unconfigured skeleton, so grey it.
            authenticated = obj.booleanField("authenticated") ?: models.isNotEmpty(),
-            models = models,
+            models = models.distinct(),
            setupHint = obj.stringField("warning"),
        )
-    }.sortedByDescending { it.authenticated }
+    }
+    val merged = linkedMapOf<String, ModelProviderOption>()
+    parsed.forEach { row ->
+        val identity = row.id.trim().lowercase()
+        val existing = merged[identity]
+        merged[identity] = if (existing == null) {
+            row.copy(id = row.id.trim())
+        } else {
+            existing.copy(
+                authenticated = existing.authenticated || row.authenticated,
+                models = (existing.models + row.models).distinct(),
+                setupHint = existing.setupHint ?: row.setupHint,
+            )
+        }
+    }
+    return merged.values.sortedByDescending { it.authenticated }
 }

@Composable
@@ -3464,6 +3573,7 @@ private fun McpOAuthDialog(
@Composable
 private fun CustomEndpointDialog(
    existing: DashboardSummaryItem?,
+    profile: String?,
    clientFactory: () -> DashboardApiClient,
    onSaved: () -> Unit,
    onDismiss: () -> Unit,
@@ -3571,7 +3681,9 @@ private fun CustomEndpointDialog(
                    onClick = {
                        busy = true
                        scope.launch {
-                            val result = withDashboardClient(clientFactory) { it.saveCustomEndpoint(draft()) }
+                            val result = withDashboardClient(clientFactory) {
+                                it.saveCustomEndpoint(draft(), profile = profile)
+                            }
                            result.fold(onSuccess = { onSaved() }, onFailure = {
                                busy = false
                                message = it.message ?: context.getString(R.string.dashboard_custom_endpoint_save_failed)
@@ -3681,6 +3793,16 @@ private fun summarize(
                    ?.map { (name, value) -> summarizeObjectItem(value, name) }
                ?: listOf(summarizeObjectItem(root, "Profile"))
        }
+        DashboardManagementSection.Memory -> summarizeKeyValueOrList(root, "Memory")
+        DashboardManagementSection.Learning ->
+            root.arrayItems("nodes", "items")
+                ?.mapIndexed { index, item -> summarizeObjectItem(item, "Node ${index + 1}") }
+                ?: summarizeKeyValueOrList(root, "Learning")
+        DashboardManagementSection.Channels ->
+            root.arrayItems("platforms", "channels", "items")
+                ?.mapIndexed { index, item -> summarizeObjectItem(item, "Channel ${index + 1}") }
+                ?: summarizeKeyValueOrList(root, "Channel")
+        DashboardManagementSection.Operations -> summarizeKeyValueOrList(root, "Status")
        DashboardManagementSection.Models -> summarizeKeyValueOrList(root, "Model")
        DashboardManagementSection.Keys -> summarizeEnvVars(root)
        DashboardManagementSection.Config -> summarizeKeyValueOrList(root, "Config")
@@ -3721,7 +3843,7 @@ private fun summarizeEnvVars(root: JsonElement): List<DashboardSummaryItem> {
    }.sortedWith(compareByDescending<DashboardSummaryItem> { it.meta?.startsWith("set") == true }.thenBy { it.title })
 }

-private fun summarizeObjectItem(
+internal fun summarizeObjectItem(
    element: JsonElement,
    fallbackTitle: String,
 ): DashboardSummaryItem {
@@ -3753,6 +3875,9 @@ private fun summarizeObjectItem(
        obj.booleanField("installed")?.let { if (it) "installed" else "not installed" },
        obj.booleanField("needs_install")?.let { if (it) "bootstrap install" else null },
        status,
+        obj.stringField("last_status")?.let { "last: $it" },
+        obj.stringField("last_error")?.let { "error: $it" },
+        obj.stringField("last_delivery_error")?.let { "delivery: $it" },
        obj.stringField("provider"),
        obj.stringField("transport"),
        obj.stringField("auth_type"),
@@ -3786,6 +3911,7 @@ internal fun dashboardActionsFor(obj: JsonObject): List<DashboardItemAction> {
    val hasSkillUsage = obj["usage"] != null || obj.stringField("category") != null
    val enabled = obj.booleanField("enabled")
    val paused = obj.booleanField("paused")
+    val completedCron = obj.stringField("state").equals("completed", ignoreCase = true)

    return when {
        isCatalogEntry -> buildList {
@@ -3795,12 +3921,14 @@ internal fun dashboardActionsFor(obj: JsonObject): List<DashboardItemAction> {
        }
        hasSchedule -> buildList {
            add(DashboardItemAction("Runs", DashboardActionKind.ViewCronRuns))
-            if (paused == true) {
-                add(DashboardItemAction("Resume", DashboardActionKind.ResumeCron))
-            } else {
-                add(DashboardItemAction("Pause", DashboardActionKind.PauseCron))
+            if (!completedCron) {
+                if (paused == true) {
+                    add(DashboardItemAction("Resume", DashboardActionKind.ResumeCron))
+                } else {
+                    add(DashboardItemAction("Pause", DashboardActionKind.PauseCron))
+                }
+                add(DashboardItemAction("Run now", DashboardActionKind.TriggerCron))
            }
-            add(DashboardItemAction("Run now", DashboardActionKind.TriggerCron))
            add(DashboardItemAction("Delete", DashboardActionKind.DeleteCron, destructive = true))
        }
        hasTransport -> buildList {
@@ -4092,9 +4220,10 @@ private suspend fun DashboardApiClient.runDashboardAction(
        DashboardActionKind.ViewProfileSoul -> getProfileSoul(id)
        DashboardActionKind.ActivateProfile -> setActiveProfile(id)
        DashboardActionKind.DeleteProfile -> deleteProfile(id)
-        DashboardActionKind.ActivateCustomEndpoint -> activateCustomEndpoint(id)
+        DashboardActionKind.ActivateCustomEndpoint ->
+            activateCustomEndpoint(id, profile = item.profile)
        DashboardActionKind.DeleteCustomEndpoint ->
-            deleteCustomEndpoint(id).map { JsonObject(emptyMap()) }
+            deleteCustomEndpoint(id, profile = item.profile).map { JsonObject(emptyMap()) }
        DashboardActionKind.RevealEnvKey -> revealEnvVar(id)
        DashboardActionKind.ClearEnvKey -> deleteEnvVar(id)
        // Input-backed kinds are intercepted at the onAction layer and routed
@@ -1,5 +1,6 @@
 package com.hermesandroid.relay.ui.screens

+import android.util.Log
 import android.webkit.CookieManager
 import android.webkit.WebChromeClient
 import android.webkit.WebResourceError
@@ -46,6 +47,9 @@ import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.viewinterop.AndroidView
 import com.hermesandroid.relay.R
+import com.hermesandroid.relay.diagnostics.DiagnosticCategory
+import com.hermesandroid.relay.diagnostics.DiagnosticSeverity
+import com.hermesandroid.relay.diagnostics.DiagnosticsLog
 import com.hermesandroid.relay.ui.components.ConnectionSetupTimeline
 import com.hermesandroid.relay.ui.components.ConnectionSetupTimelineStep
 import com.hermesandroid.relay.network.upstream.DashboardApiClient
@@ -58,6 +62,8 @@ import com.hermesandroid.relay.network.upstream.NativeDashboardSignInCoordinator
 import com.hermesandroid.relay.network.upstream.androidDashboardRedirectAuthMode
 import com.hermesandroid.relay.network.upstream.importDashboardCookieHeader
 import com.hermesandroid.relay.network.upstream.isNativeDashboardTransportEligible
+import com.hermesandroid.relay.network.upstream.nativeDashboardSignInFailureDiagnostic
+import com.hermesandroid.relay.network.upstream.nativeDashboardSignInFailureStage
 import com.hermesandroid.relay.viewmodel.ConnectionViewModel
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
@@ -66,6 +72,8 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull

+private const val NATIVE_DASHBOARD_AUTH_LOG_TAG = "HermesNativeAuth"
+
 /**
 * Connection-level Dashboard authentication flow. It is deliberately outside
 * Manage so onboarding, connection setup, Voice, Chat, and Manage can all use
@@ -246,8 +254,24 @@ fun DashboardSignInScreen(
            } catch (cancelled: CancellationException) {
                throw cancelled
            } catch (error: Exception) {
-                actionMessage = error.message
-                    ?: resources.getString(R.string.dashboard_signin_failed)
+                val failureStage = nativeDashboardSignInFailureStage(error)
+                val failureDetail = nativeDashboardSignInFailureDiagnostic(error)
+                DiagnosticsLog.record(
+                    category = DiagnosticCategory.Auth,
+                    severity = DiagnosticSeverity.Error,
+                    title = resources.getString(R.string.dashboard_signin_failed),
+                    detail = failureDetail,
+                    operation = "dashboard_native_pkce",
+                )
+                Log.w(NATIVE_DASHBOARD_AUTH_LOG_TAG, failureDetail)
+                actionMessage = nativeDashboardSignInActionMessage(
+                    failureStage = failureStage,
+                    errorMessage = error.message,
+                    fallbackMessage = resources.getString(R.string.dashboard_signin_failed),
+                    transportRetryMessage = resources.getString(
+                        R.string.dashboard_native_signin_transport_retry,
+                    ),
+                )
                actionIsError = true
            } finally {
                actionInFlight = false
@@ -338,6 +362,17 @@ fun DashboardSignInScreen(
    }
 }

+internal fun nativeDashboardSignInActionMessage(
+    failureStage: String,
+    errorMessage: String?,
+    fallbackMessage: String,
+    transportRetryMessage: String,
+): String = if (failureStage.startsWith("token_transport")) {
+    transportRetryMessage
+} else {
+    errorMessage ?: fallbackMessage
+}
+
@Composable
 private fun DashboardAuthenticationComplete(onContinue: () -> Unit) {
    Column(
@@ -4,12 +4,15 @@ package com.hermesandroid.relay.ui.screens

 import android.widget.Toast
 import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -17,9 +20,14 @@ import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
 import com.hermesandroid.relay.R
 import com.hermesandroid.relay.ui.components.ConnectionWizard
 import com.hermesandroid.relay.viewmodel.ConnectionViewModel
@@ -88,21 +96,47 @@ fun PairScreen(
        Box(
            modifier = Modifier
                .fillMaxSize()
-                .padding(innerPadding)
+                .padding(innerPadding),
+            contentAlignment = Alignment.Center,
        ) {
-            ConnectionWizard(
-                connectionViewModel = connectionViewModel,
-                onComplete = {
-                    Toast.makeText(context, context.getString(R.string.pair_connection_updated), Toast.LENGTH_SHORT).show()
-                    onComplete()
-                },
-                onCancel = onCancel,
-                onManageSignIn = onManageSignIn,
-                showSkip = false,
-                autoStart = autoStart,
-                setupReady = setupReady,
-                onTryDemo = onTryDemo,
-            )
+            if (!setupReady) {
+                // Add connection navigates before its connection-scoped auth
+                // store is ready. Keep one stable surface on screen instead of
+                // composing a disabled wizard that is immediately invalidated
+                // by the placeholder switch's URL/auth/connection emissions.
+                Column(
+                    modifier = Modifier.semantics {
+                        liveRegion = LiveRegionMode.Polite
+                    },
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                    verticalArrangement = Arrangement.spacedBy(12.dp),
+                ) {
+                    CircularProgressIndicator()
+                    Text(
+                        text = stringResource(R.string.cw_preparing_connection),
+                        style = MaterialTheme.typography.titleMedium,
+                    )
+                    Text(
+                        text = stringResource(R.string.cw_preparing_connection_hint),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            } else {
+                ConnectionWizard(
+                    connectionViewModel = connectionViewModel,
+                    onComplete = {
+                        Toast.makeText(context, context.getString(R.string.pair_connection_updated), Toast.LENGTH_SHORT).show()
+                        onComplete()
+                    },
+                    onCancel = onCancel,
+                    onManageSignIn = onManageSignIn,
+                    showSkip = false,
+                    autoStart = autoStart,
+                    setupReady = true,
+                    onTryDemo = onTryDemo,
+                )
+            }
        }
    }
 }
@@ -572,6 +572,18 @@ private fun DeviceCard(
                        style = MaterialTheme.typography.titleSmall,
                        fontWeight = FontWeight.SemiBold
                    )
+                    val deviceDetail = listOf(device.deviceModel, device.devicePlatform)
+                        .map { it.trim() }
+                        .filter { it.isNotBlank() }
+                        .distinct()
+                        .joinToString(" · ")
+                    if (deviceDetail.isNotBlank()) {
+                        Text(
+                            text = deviceDetail,
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
                    if (device.deviceId.isNotBlank()) {
                        Text(
                            text = device.deviceId,
@@ -424,7 +424,6 @@ fun SettingsScreen(
            val lockedDisplayName: String? = when {
                !isProfileLocked -> null
                lockedProfileName == null ||
-                    AgentDisplay.isServerDefaultAlias(lockedProfileName) ||
                    lockedProfileName == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY ->
                    serverDefaultLabel
                else ->
@@ -1055,13 +1054,12 @@ private fun ProfileLockDialog(
    onUnlock: () -> Unit,
    onDismiss: () -> Unit,
 ) {
-    // Selectable rows: a synthetic "Server default" sentinel + the advertised
-    // profiles, minus the synthetic "default" alias (folded into Server default).
-    val selectableProfiles = profiles.filterNot { AgentDisplay.isServerDefaultAlias(it.name) }
+    // Selectable rows: a synthetic "Server default" sentinel + every advertised
+    // profile, including a profile literally named `default`.
+    val selectableProfiles = profiles

-    // Is the stored lock target Server default (sentinel / "default" alias / null)?
+    // Is the stored lock target Server default (sentinel / null)?
    val lockedIsServerDefault = lockedProfileName == null ||
-        AgentDisplay.isServerDefaultAlias(lockedProfileName) ||
        lockedProfileName == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY
    val lockedProfile = if (lockedIsServerDefault) {
        null
@@ -0,0 +1,41 @@
+package com.hermesandroid.relay.ui.theme
+
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Shapes
+import androidx.compose.ui.unit.dp
+
+enum class AppearanceShape(val id: String) {
+    SOFT("soft"),
+    BALANCED("balanced"),
+    SHARP("sharp");
+
+    companion object {
+        val DEFAULT = SOFT
+
+        fun fromId(id: String?): AppearanceShape = entries.firstOrNull { it.id == id } ?: DEFAULT
+    }
+}
+
+fun appearanceShapes(shapeId: String?): Shapes = when (AppearanceShape.fromId(shapeId)) {
+    AppearanceShape.SOFT -> Shapes(
+        extraSmall = RoundedCornerShape(8.dp),
+        small = RoundedCornerShape(12.dp),
+        medium = RoundedCornerShape(18.dp),
+        large = RoundedCornerShape(24.dp),
+        extraLarge = RoundedCornerShape(30.dp),
+    )
+    AppearanceShape.BALANCED -> Shapes(
+        extraSmall = RoundedCornerShape(5.dp),
+        small = RoundedCornerShape(8.dp),
+        medium = RoundedCornerShape(12.dp),
+        large = RoundedCornerShape(16.dp),
+        extraLarge = RoundedCornerShape(20.dp),
+    )
+    AppearanceShape.SHARP -> Shapes(
+        extraSmall = RoundedCornerShape(2.dp),
+        small = RoundedCornerShape(4.dp),
+        medium = RoundedCornerShape(6.dp),
+        large = RoundedCornerShape(8.dp),
+        extraLarge = RoundedCornerShape(10.dp),
+    )
+}
@@ -7,6 +7,7 @@ import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.lerp
+import androidx.compose.ui.graphics.luminance

 /**
 * Theme-scoped brand token bundle.
@@ -79,6 +80,41 @@ val LocalBrand = staticCompositionLocalOf { BrandPalettes.HermesDark }
 private fun Color.lighten(f: Float): Color = lerp(this, Color.White, f)
 private fun Color.darken(f: Float): Color = lerp(this, Color.Black, f)

+/** User-selectable accent seeds. Stored as stable RGB strings in DataStore. */
+val AccentSwatches = listOf(
+    "#356CFF", "#00B5A0", "#62C51E", "#ED4E8B", "#FF4B00",
+)
+
+fun normalizeAccentHex(value: String?): String? {
+    val normalized = value?.trim()?.uppercase()?.let { if (it.startsWith("#")) it else "#$it" }
+    return normalized?.takeIf { it.matches(Regex("#[0-9A-F]{6}")) }
+}
+
+fun accentColor(value: String?): Color? = normalizeAccentHex(value)?.let {
+    Color(0xFF000000L or it.drop(1).toLong(16))
+}
+
+fun contrastRatio(foreground: Color, background: Color): Float {
+    val light = maxOf(foreground.luminance(), background.luminance())
+    val dark = minOf(foreground.luminance(), background.luminance())
+    return (light + 0.05f) / (dark + 0.05f)
+}
+
+fun readableContentColor(background: Color): Color =
+    listOf(Color.Black, Color.White).maxBy { contrastRatio(it, background) }
+
+/** Apply one accent seed without changing surfaces or semantic status colors. */
+fun BrandPalette.withAccent(accentHex: String?): BrandPalette {
+    val accent = accentColor(accentHex) ?: return this
+    return copy(
+        relay = if (isDark) accent.lighten(0.34f) else accent.darken(0.08f),
+        electric = accent,
+        electricMuted = if (isDark) accent.lighten(0.18f) else accent.lighten(0.12f),
+        purple = lerp(accent, purple, 0.38f),
+        cyan = lerp(accent, cyan, 0.45f),
+    )
+}
+
 /**
 * Derive a complete Material 3 [ColorScheme] from the palette. Dark and light
 * palettes use distinct mappings; the "text on a deep accent chip" slots use
@@ -87,15 +123,15 @@ private fun Color.darken(f: Float): Color = lerp(this, Color.Black, f)
 fun BrandPalette.toColorScheme(): ColorScheme = if (isDark) {
    darkColorScheme(
        primary = relay,
-        onPrimary = background,
+        onPrimary = readableContentColor(relay),
        primaryContainer = electric,
-        onPrimaryContainer = paper,
+        onPrimaryContainer = readableContentColor(electric),
        secondary = purple,
-        onSecondary = paper,
+        onSecondary = readableContentColor(purple),
        secondaryContainer = navy3,
        onSecondaryContainer = paper,
        tertiary = cyan,
-        onTertiary = background,
+        onTertiary = readableContentColor(cyan),
        tertiaryContainer = purple.copy(alpha = 0.42f),
        onTertiaryContainer = paper,
        background = background,
@@ -119,15 +155,15 @@ fun BrandPalette.toColorScheme(): ColorScheme = if (isDark) {
 } else {
    lightColorScheme(
        primary = electric,
-        onPrimary = Color.White,
+        onPrimary = readableContentColor(electric),
        primaryContainer = relay.copy(alpha = 0.22f),
        onPrimaryContainer = electric.darken(0.32f),
        secondary = purple,
-        onSecondary = Color.White,
+        onSecondary = readableContentColor(purple),
        secondaryContainer = purple.copy(alpha = 0.16f),
        onSecondaryContainer = purple.darken(0.38f),
        tertiary = cyan,
-        onTertiary = Color.White,
+        onTertiary = readableContentColor(cyan),
        tertiaryContainer = cyan.copy(alpha = 0.16f),
        onTertiaryContainer = cyan.darken(0.42f),
        background = background,
@@ -24,6 +24,7 @@ import androidx.compose.ui.unit.Density
 *   for [ThemeMode.BOTH] themes; fixed-mode themes ignore it.
 * @param appFontId id from [AppFont]; selects the body typeface for the whole
 *   app. Defaults to Inter. Code/metadata styles stay monospaced regardless.
+ * @param accentHex optional locally persisted RGB override for brand accents.
 */
@Composable
 fun HermesRelayTheme(
@@ -31,12 +32,15 @@ fun HermesRelayTheme(
    themePreference: String = "auto",
    fontScale: Float = 1.0f,
    appFontId: String = AppFont.DEFAULT.id,
+    accentHex: String? = null,
+    shapeId: String = AppearanceShape.DEFAULT.id,
    content: @Composable () -> Unit
 ) {
    val appTheme = AppThemes.byId(appThemeId)
    val useDarkTheme = appTheme.resolveDark(themePreference, isSystemInDarkTheme())
-    val palette = appTheme.paletteFor(useDarkTheme)
+    val palette = appTheme.paletteFor(useDarkTheme).withAccent(accentHex)
    val colorScheme = palette.toColorScheme()
+    val shapes = remember(shapeId) { appearanceShapes(shapeId) }

    // Build the Material typography from the selected font. Remembered per id so
    // a recomposition (e.g. theme/mode change) doesn't rebuild the FontFamily
@@ -60,6 +64,7 @@ fun HermesRelayTheme(
            MaterialTheme(
                colorScheme = colorScheme,
                typography = typography,
+                shapes = shapes,
                content = content
            )
        } else {
@@ -72,6 +77,7 @@ fun HermesRelayTheme(
                MaterialTheme(
                    colorScheme = colorScheme,
                    typography = typography,
+                    shapes = shapes,
                    content = content
                )
            }
@@ -0,0 +1,50 @@
+package com.hermesandroid.relay.util
+
+import android.content.Intent
+import java.util.concurrent.atomic.AtomicLong
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+
+data class SharedTextDraftRequest(
+    val id: Long,
+    val text: String,
+)
+
+/**
+ * Process-local handoff from Android's sharesheet entry point to the app-owned
+ * chat runtime. A StateFlow keeps a cold-start request alive until RelayApp has
+ * initialized its ViewModels; [consume] is identity-checked so an older UI
+ * completion cannot clear a newer share intent.
+ */
+object SharedTextRequest {
+    private val nextId = AtomicLong(0L)
+    private val _pending = MutableStateFlow<SharedTextDraftRequest?>(null)
+
+    val pending: StateFlow<SharedTextDraftRequest?> = _pending.asStateFlow()
+
+    fun tryRequest(text: CharSequence?): Boolean {
+        val value = text?.toString()?.takeIf { it.isNotBlank() } ?: return false
+        _pending.value = SharedTextDraftRequest(
+            id = nextId.incrementAndGet(),
+            text = value,
+        )
+        return true
+    }
+
+    fun consume(id: Long) {
+        _pending.update { request -> request?.takeUnless { it.id == id } }
+    }
+}
+
+/** Accept only Android's single-item text share contract. */
+internal fun extractSharedText(
+    action: String?,
+    mimeType: String?,
+    text: CharSequence?,
+): String? {
+    if (action != Intent.ACTION_SEND) return null
+    if (mimeType?.startsWith("text/", ignoreCase = true) != true) return null
+    return text?.toString()?.takeIf { it.isNotBlank() }
+}
@@ -14,10 +14,14 @@ import com.hermesandroid.relay.auth.AuthManager
 import com.hermesandroid.relay.auth.AuthState
 import com.hermesandroid.relay.ui.theme.AppFont
 import com.hermesandroid.relay.ui.theme.AppThemes
+import com.hermesandroid.relay.ui.theme.normalizeAccentHex
+import com.hermesandroid.relay.ui.theme.AppearanceShape
 import com.hermesandroid.relay.ui.components.avatar.PetImporter
 import com.hermesandroid.relay.ui.components.avatar.PetImportResult
 import com.hermesandroid.relay.ui.components.avatar.PetLoader
 import com.hermesandroid.relay.ui.components.avatar.SphereAvatar
+import com.hermesandroid.relay.ui.components.SphereSkinImportResult
+import com.hermesandroid.relay.ui.components.SphereSkinImporter
 import com.hermesandroid.relay.ui.components.pet.PetLogicalEdge
 import com.hermesandroid.relay.ui.components.pet.PetPlacement
 import com.hermesandroid.relay.auth.PairedDeviceInfo
@@ -37,6 +41,8 @@ import com.hermesandroid.relay.data.DEFAULT_PET_SIZE_SCALE
 import com.hermesandroid.relay.data.PetBehaviorPreferences
 import com.hermesandroid.relay.data.PetBehaviorPreferencesRepository
 import com.hermesandroid.relay.data.PetTemperament
+import com.hermesandroid.relay.data.ChatInputPreferencesRepository
+import com.hermesandroid.relay.data.PhysicalKeyboardEnterBehavior
 import com.hermesandroid.relay.data.RelayEndpoint
 import com.hermesandroid.relay.data.primaryRouteUrl
 import com.hermesandroid.relay.data.routeAuthority
@@ -70,6 +76,7 @@ import com.hermesandroid.relay.network.relay.ConnectionState
 import com.hermesandroid.relay.network.upstream.DashboardApiClient
 import com.hermesandroid.relay.network.upstream.DashboardChatDisplaySettings
 import com.hermesandroid.relay.network.upstream.models.MessageItem
+import com.hermesandroid.relay.network.upstream.SessionMessageLoadMode
 import com.hermesandroid.relay.network.upstream.models.SessionItem
 import com.hermesandroid.relay.network.upstream.mirrorDashboardSessionCookies
 import com.hermesandroid.relay.network.upstream.DashboardAuthSession
@@ -343,6 +350,11 @@ internal fun profileApiCredential(
    connectionKey: String,
 ): String = if (usesMultiplexProfileKey) profileKey.orEmpty() else connectionKey

+internal fun migratedBackgroundAvatar(
+    storedBackgroundAvatar: String?,
+    legacyAgentAvatar: String?,
+): String = storedBackgroundAvatar ?: legacyAgentAvatar ?: SphereAvatar.id
+
 class ConnectionViewModel(application: Application) : AndroidViewModel(application) {

    private val ctx: Context get() = getApplication()
@@ -396,6 +408,10 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        // Selected app theme id (palette/personality). Orthogonal to KEY_THEME,
        // which is the light/dark/auto mode axis honored by BOTH-mode themes.
        private val KEY_APP_THEME = stringPreferencesKey("app_theme")
+        // Optional RGB accent override applied on top of the selected preset.
+        // Null means the preset's authored accent remains authoritative.
+        private val KEY_APPEARANCE_ACCENT = stringPreferencesKey("appearance_accent")
+        private val KEY_APPEARANCE_SHAPE = stringPreferencesKey("appearance_shape")
        // Selected app font id (body typeface). Resolved against AppFont at the
        // Compose theme root; defaults to Inter. Orthogonal to KEY_FONT_SCALE
        // (which scales sizes); this picks the family.
@@ -403,12 +419,14 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        // Selected sphere skin id. "auto" (SphereRegistry.AUTO_ID) follows the
        // active theme's preferred skin; any other id pins a specific skin.
        private val KEY_SPHERE_SKIN = stringPreferencesKey("sphere_skin")
-        // Legacy combined sphere/pet choice. Read for one release so existing
-        // users keep their selected pet when the concepts split.
+        // Legacy combined sphere/pet choice. Read during migration so existing
+        // users retain both their prior central visual and companion choice.
        private val KEY_AGENT_AVATAR = stringPreferencesKey("agent_avatar")
        // Optional floating companion id. The explicit sentinel distinguishes
        // "no pet" from a preference that has not yet been migrated.
        private val KEY_FLOATING_PET = stringPreferencesKey("floating_pet")
+        // Central visualization selection, independent from the floating pet.
+        private val KEY_BACKGROUND_AVATAR = stringPreferencesKey("background_avatar")
        // Reserved storage sentinel. Pet ids may legitimately be ordinary words
        // such as "none", so keep the no-selection marker outside that space.
        private const val NO_FLOATING_PET = "__none__"
@@ -466,6 +484,8 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati

    private val petBehaviorPreferencesRepository =
        PetBehaviorPreferencesRepository(application)
+    private val chatInputPreferencesRepository =
+        ChatInputPreferencesRepository(application)

    // --- Core networking components ---

@@ -1302,6 +1322,14 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        }
        .stateIn(viewModelScope, SharingStarted.Eagerly, AppThemes.DEFAULT_ID)

+    val appearanceAccent: StateFlow<String?> = application.relayDataStore.data
+        .map { preferences -> normalizeAccentHex(preferences[KEY_APPEARANCE_ACCENT]) }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, null)
+
+    val appearanceShape: StateFlow<String> = application.relayDataStore.data
+        .map { preferences -> AppearanceShape.fromId(preferences[KEY_APPEARANCE_SHAPE]).id }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, AppearanceShape.DEFAULT.id)
+
    // Selected app font id (body typeface). Defaults to Inter. Resolved against
    // AppFont.byId at the Compose theme root, which rebuilds Typography so the
    // whole app re-themes live when this changes.
@@ -1319,8 +1347,8 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        }
        .stateIn(viewModelScope, SharingStarted.Eagerly, "auto")

-    // Optional floating companion. For one release, an absent new key reads the
-    // legacy combined selection: sphere -> no companion; a pet id -> companion.
+    // Optional floating companion. An absent split key reads the legacy combined
+    // selection: sphere -> no companion; a pet id -> companion.
    val floatingPet: StateFlow<String?> = application.relayDataStore.data
        .map { preferences ->
            val selected = preferences[KEY_FLOATING_PET]
@@ -1330,6 +1358,16 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        }
        .stateIn(viewModelScope, SharingStarted.Eagerly, null)

+    /** Sphere or a validated pet-format asset rendered on central/ambient surfaces. */
+    val backgroundAvatar: StateFlow<String> = application.relayDataStore.data
+        .map { preferences ->
+            migratedBackgroundAvatar(
+                storedBackgroundAvatar = preferences[KEY_BACKGROUND_AVATAR],
+                legacyAgentAvatar = preferences[KEY_AGENT_AVATAR],
+            )
+        }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, SphereAvatar.id)
+
    /** Whether the selected companion may autonomously move between safe perches. */
    val petRoamingEnabled: StateFlow<Boolean> = application.relayDataStore.data
        .map { preferences -> preferences[KEY_PET_ROAMING_ENABLED] ?: false }
@@ -1455,8 +1493,13 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
    suspend fun listProfileScopedSessions(limit: Int = 200): Result<List<SessionItem>>? =
        profileController.listProfileScopedSessions(limit)

-    suspend fun loadProfileScopedMessages(sessionId: String): Result<List<MessageItem>>? =
-        profileController.loadProfileScopedMessages(sessionId)
+    suspend fun listAllProfileSessions(limit: Int = 200): Result<List<SessionItem>>? =
+        profileController.listAllProfileSessions(limit)
+
+    suspend fun loadProfileScopedMessages(
+        sessionId: String,
+        mode: SessionMessageLoadMode = SessionMessageLoadMode.COMPLETE,
+    ): Result<List<MessageItem>>? = profileController.loadProfileScopedMessages(sessionId, mode)

    /**
     * Delete a session scoped to the ACTIVE PROFILE via the dashboard
@@ -1485,6 +1528,18 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        return profileController.renameProfileScopedSession(sessionId, title)
    }

+    suspend fun setProfileScopedSessionPinned(
+        sessionId: String,
+        pinned: Boolean,
+        expectedContextKey: String?,
+    ): Boolean = profileController.setProfileScopedSessionPinned(sessionId, pinned, expectedContextKey)
+
+    suspend fun setProfileScopedSessionArchived(
+        sessionId: String,
+        archived: Boolean,
+        expectedContextKey: String?,
+    ): Boolean = profileController.setProfileScopedSessionArchived(sessionId, archived, expectedContextKey)
+
    val selectedProfile: StateFlow<Profile?> get() = profileController.selectedProfile

    val profilePresentation: StateFlow<ProfilePresentation> get() = profileController.profilePresentation
@@ -1511,6 +1566,9 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
    /** The active profile's local agent-icon path (client-side, never sent to Hermes). */
    val profileIcon: StateFlow<String?> get() = profileController.profileIcon

+    /** A local icon path for a specific profile identity on the active connection. */
+    fun profileIconFlow(profileName: String?) = profileController.profileIconFlow(profileName)
+
    val hostProfileIconImportState: StateFlow<ProfileController.HostIconImportState>
        get() = profileController.hostIconImportState

@@ -1536,7 +1594,7 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati

    /** Lock the active connection to [profile] (null = Server default). */
    fun lockProfile(profile: Profile?) {
-        viewModelScope.launch { profileController.lockProfile(profile) }
+        profileController.lockProfile(profile)
    }

    /** Remove the active connection's profile lock. */
@@ -1799,8 +1857,8 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
    }

    init {
-        // Materialize the split preference once. Keeping the legacy read above
-        // for one release also covers interrupted upgrades and older backups.
+        // Materialize the independent central and floating preferences. Legacy
+        // users retain the prior visual in both roles until they choose otherwise.
        viewModelScope.launch {
            getApplication<Application>().relayDataStore.edit { preferences ->
                if (preferences[KEY_FLOATING_PET] == null) {
@@ -1808,6 +1866,12 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
                        ?.takeUnless { it == SphereAvatar.id }
                        ?: NO_FLOATING_PET
                }
+                if (preferences[KEY_BACKGROUND_AVATAR] == null) {
+                    preferences[KEY_BACKGROUND_AVATAR] = migratedBackgroundAvatar(
+                        storedBackgroundAvatar = null,
+                        legacyAgentAvatar = preferences[KEY_AGENT_AVATAR],
+                    )
+                }
                // Before presence and motion were split, animation_enabled also
                // controlled whether the Sphere was shown. Preserve that choice
                // on upgrade; users can then re-enable a static Sphere separately.
@@ -1938,6 +2002,15 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        }
    }

+    fun setBackgroundAvatar(avatarId: String) {
+        viewModelScope.launch {
+            getApplication<Application>().relayDataStore.edit { preferences ->
+                preferences[KEY_BACKGROUND_AVATAR] = avatarId.ifBlank { SphereAvatar.id }
+                preferences[KEY_BACKGROUND_VISUALIZATION_ENABLED] = true
+            }
+        }
+    }
+
    fun setImageGenerationStyle(value: String) {
        val normalized = value.takeIf {
            it in setOf("rotate", "grid", "sphere", "nodes")
@@ -2041,6 +2114,20 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        }
    }

+    val physicalKeyboardEnterBehavior: StateFlow<PhysicalKeyboardEnterBehavior> =
+        chatInputPreferencesRepository.physicalKeyboardEnterBehavior
+            .stateIn(
+                viewModelScope,
+                SharingStarted.Eagerly,
+                PhysicalKeyboardEnterBehavior.SendMessage,
+            )
+
+    fun setPhysicalKeyboardEnterBehavior(behavior: PhysicalKeyboardEnterBehavior) {
+        viewModelScope.launch {
+            chatInputPreferencesRepository.setPhysicalKeyboardEnterBehavior(behavior)
+        }
+    }
+
    // Turn-complete notification (default ON). RelayApp mirrors this into
    // ChatViewModel.notifyOnTurnComplete; ChatSettingsScreen owns the toggle
    // + the POST_NOTIFICATIONS runtime request on first enable.
@@ -6423,7 +6510,10 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
    fun saveLastSessionId(sessionId: String?) {
        _lastSessionId.value = sessionId
        val connectionId = activeConnectionId.value
-        val profileName = profileController.resolveSessionProfileName()
+        // Last-session persistence follows the selected UI profile identity.
+        // The null Server-default sentinel stays separate from whichever named
+        // profile the server's sticky default currently resolves to.
+        val profileName = profileController.selectedProfile.value?.name
        viewModelScope.launch {
            if (connectionId != null) {
                if (sessionId != null) {
@@ -6455,7 +6545,7 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
                    }
                }
            }
-            if (profileName == null || AgentDisplay.isServerDefaultAlias(profileName)) {
+            if (profileName == null) {
                getApplication<Application>().relayDataStore.edit { preferences ->
                    if (sessionId != null) {
                        preferences[KEY_LAST_SESSION_ID] = sessionId
@@ -6582,6 +6672,59 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
        }
    }

+    /** Apply or reset the local accent override. Invalid values safely reset. */
+    fun setAppearanceAccent(accentHex: String?) {
+        viewModelScope.launch {
+            getApplication<Application>().relayDataStore.edit { preferences ->
+                val normalized = normalizeAccentHex(accentHex)
+                if (normalized == null) preferences.remove(KEY_APPEARANCE_ACCENT)
+                else preferences[KEY_APPEARANCE_ACCENT] = normalized
+            }
+        }
+    }
+
+    fun setAppearanceShape(shapeId: String) {
+        viewModelScope.launch {
+            getApplication<Application>().relayDataStore.edit { preferences ->
+                preferences[KEY_APPEARANCE_SHAPE] = AppearanceShape.fromId(shapeId).id
+            }
+        }
+    }
+
+    /** Import one declarative sphere-skin JSON file, select it, then hot-refresh Appearance. */
+    fun importSphereSkin(uri: Uri) {
+        viewModelScope.launch {
+            val result = withContext(Dispatchers.IO) {
+                SphereSkinImporter.importUri(getApplication<Application>(), uri)
+            }
+            when (result) {
+                is SphereSkinImportResult.Success -> {
+                    setSphereSkin(result.id)
+                    refreshAgentAvatars()
+                    _avatarEvents.tryEmit("Imported “${result.label}”")
+                }
+                is SphereSkinImportResult.Failure -> _avatarEvents.tryEmit(result.reason)
+            }
+        }
+    }
+
+    /** Import a validated pet-format asset for the central/background renderer. */
+    fun importBackgroundAnimation(uri: Uri) {
+        viewModelScope.launch {
+            val result = withContext(Dispatchers.IO) {
+                PetImporter.importUri(getApplication<Application>(), uri)
+            }
+            when (result) {
+                is PetImportResult.Success -> {
+                    setBackgroundAvatar(result.id)
+                    refreshAgentAvatars()
+                    _avatarEvents.tryEmit("Imported background “${result.label}”")
+                }
+                is PetImportResult.Failure -> _avatarEvents.tryEmit(result.reason)
+            }
+        }
+    }
+
    /** Delete a user pet by id; clear it if it was the selected companion. */
    fun deleteUserAvatar(avatarId: String, label: String) {
        viewModelScope.launch {
@@ -6590,6 +6733,7 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati
            }
            if (deleted) {
                if (floatingPet.value == avatarId) setFloatingPet(null)
+                if (backgroundAvatar.value == avatarId) setBackgroundAvatar(SphereAvatar.id)
                refreshAgentAvatars()
                _avatarEvents.tryEmit("Removed “$label”")
            } else {
@@ -93,6 +93,16 @@ import com.hermesandroid.relay.data.VoiceAudioRoute
 */
 enum class VoiceState { Idle, Listening, Transcribing, Thinking, Speaking, Error }

+internal fun canSpeakSettledResponse(
+    state: VoiceUiState,
+    providerRealtimeAgentTurnActive: Boolean,
+): Boolean = state.state == VoiceState.Idle && !providerRealtimeAgentTurnActive
+
+internal fun ownsVoiceAudioCompletion(
+    voiceMode: Boolean,
+    responseSpeechActive: Boolean,
+): Boolean = voiceMode || responseSpeechActive
+
 private enum class StandardSpeechStreamState {
    Idle,
    Opening,
@@ -731,6 +741,10 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
    private val _uiState = MutableStateFlow(VoiceUiState())
    val uiState: StateFlow<VoiceUiState> = _uiState.asStateFlow()

+    /** True only for one-shot narration started from a settled chat message. */
+    private val _responseSpeechActive = MutableStateFlow(false)
+    val responseSpeechActive: StateFlow<Boolean> = _responseSpeechActive.asStateFlow()
+
    private val _voicePreviewState = MutableStateFlow(VoicePreviewUiState())
    val voicePreviewState: StateFlow<VoicePreviewUiState> = _voicePreviewState.asStateFlow()
    private var voicePreviewJob: Job? = null
@@ -2233,7 +2247,7 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
     * per-turn state, and go back to Idle ("stop" means ready to start a
     * new turn on the next mic tap).
     */
-    fun interruptSpeaking(): Job? {
+    fun interruptSpeaking(cancelActiveTurn: Boolean = true): Job? {
        cancelPendingListeningStart()
        Log.i(
            TAG,
@@ -2242,13 +2256,14 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
        // Stop = "stop talking", not "kill my task": with a background run
        // active, silence the audio pipeline below but leave the run alive —
        // the chip's ✕ is the explicit cancel affordance.
-        val realtimeTurnWasActive =
+        _responseSpeechActive.value = false
+        val realtimeTurnWasActive = cancelActiveTurn &&
            voiceEngineMode == VoiceEngineMode.RealtimeAgent && providerRealtimeAgentTurnActive.get()
        val backgroundPhase = _uiState.value.backgroundRun?.phase
-        val backgroundRunActive = preserveRealtimeTurnOnStop(backgroundPhase)
+        val backgroundRunActive = cancelActiveTurn && preserveRealtimeTurnOnStop(backgroundPhase)
        if (backgroundRunActive) {
            Log.i(TAG, "Interrupt with background run active — stopping audio only")
-        } else {
+        } else if (cancelActiveTurn) {
            cancelRealtimeAgentTurn("interrupt")
        }
        if (realtimeTurnWasActive && rtAssistantMessageId.isNotBlank() && !backgroundRunActive) {
@@ -2278,13 +2293,17 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
        drainRealtimeTtsQueue()
        try { player?.stop() } catch (_: Exception) { /* ignore */ }
        try { realtimePcmPlayer?.stop() } catch (_: Exception) { /* ignore */ }
-        // Stop the upstream SSE stream so the agent quits generating tokens.
-        try { chatViewModel?.cancelStream() } catch (_: Exception) { /* ignore */ }
-        streamObserverJob?.cancel()
-        streamObserverJob = null
-        currentTurnJob?.cancel()
-        currentTurnJob = null
-        continuousLoopArmed = false
+        if (cancelActiveTurn) {
+            // Voice-mode Stop owns the turn and cancels generation. A context-
+            // menu narration owns audio only; stopping it must not cancel a new
+            // chat turn the user may have submitted while listening.
+            try { chatViewModel?.cancelStream() } catch (_: Exception) { /* ignore */ }
+            streamObserverJob?.cancel()
+            streamObserverJob = null
+            currentTurnJob?.cancel()
+            currentTurnJob = null
+            continuousLoopArmed = false
+        }
        continuousResumeJob?.cancel()
        continuousResumeJob = null
        realtimeAmplitudeDecayJob?.cancel()
@@ -2336,18 +2355,22 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
        return bargeInReaderRelease
    }

+    /** Stop one-shot message narration without cancelling chat generation. */
+    fun stopResponseSpeech(): Boolean {
+        if (!_responseSpeechActive.value) return false
+        interruptSpeaking(cancelActiveTurn = false)
+        return true
+    }
+
    /**
     * Replays a completed chat response through the currently selected voice
-     * output. The UI exposes this only in idle Conversation mode, but the
-     * state checks remain here so non-UI callers cannot overlap a live turn.
+     * output. This is intentionally independent of Voice Mode: a configured
+     * voice can read a settled chat reply directly from its message menu. The
+     * state checks remain here so non-UI callers cannot overlap live playback.
     */
    fun speakResponse(text: String): Boolean {
        val state = _uiState.value
-        if (
-            !state.voiceMode ||
-            state.state != VoiceState.Idle ||
-            providerRealtimeAgentTurnActive.get()
-        ) {
+        if (!canSpeakSettledResponse(state, providerRealtimeAgentTurnActive.get())) {
            return false
        }

@@ -2355,6 +2378,7 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
        if (spoken.isBlank()) return false

        realtimeAudioSuppressed = false
+        _responseSpeechActive.value = true
        _uiState.update {
            it.copy(
                state = VoiceState.Speaking,
@@ -2365,6 +2389,7 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
        }
        val queued = enqueueSentenceForTts(spoken, immediate = true)
        if (!queued) {
+            _responseSpeechActive.value = false
            _uiState.update {
                it.copy(state = VoiceState.Idle, outputAudioActive = false)
            }
@@ -5435,7 +5460,9 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
            delay(initialDelayMs.coerceIn(AUDIO_COMPLETION_RETRY_MS, AUDIO_COMPLETION_MAX_SLEEP_MS))
            repeat(120) {
                val state = _uiState.value
-                if (!state.voiceMode || isMicCaptureActive()) {
+                if (!ownsVoiceAudioCompletion(state.voiceMode, _responseSpeechActive.value) ||
+                    isMicCaptureActive()
+                ) {
                    return@launch
                }

@@ -5483,7 +5510,10 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {
            estimate
        }
        return decideAgentAudioCompletion(
-            voiceMode = _uiState.value.voiceMode,
+            voiceMode = ownsVoiceAudioCompletion(
+                _uiState.value.voiceMode,
+                _responseSpeechActive.value,
+            ),
            observerStopped = streamObserverJob?.isActive != true,
            pendingTtsWork = pendingInTtsQueue.get() +
                if (standardSpeechStreamState == StandardSpeechStreamState.Opening ||
@@ -5501,6 +5531,7 @@ class VoiceViewModel(application: Application) : AndroidViewModel(application) {

    private fun finishAgentAudioOutput() {
        continuousResumeJob = null
+        _responseSpeechActive.value = false
        stopBargeInListener()
        cancelStandardSpeechStream("audio output finished")
        realtimeAmplitudeDecayJob?.cancel()
@@ -18,11 +18,13 @@ import com.hermesandroid.relay.network.upstream.DashboardApiClient
 import com.hermesandroid.relay.network.upstream.DashboardProfileScope
 import com.hermesandroid.relay.network.upstream.GatewayAvailability
 import com.hermesandroid.relay.network.upstream.models.MessageItem
+import com.hermesandroid.relay.network.upstream.SessionMessageLoadMode
 import com.hermesandroid.relay.network.upstream.models.SessionItem
 import com.hermesandroid.relay.network.relay.RelayHttpClient
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
@@ -181,7 +183,7 @@ class ProfileController(
            // Pending state still points at a previous connection mid-switch —
            // hold until this connection's restore re-stamps the pending name.
            pendingConnId != connId -> false
-            pendingName == null || AgentDisplay.isServerDefaultAlias(pendingName) ->
+            pendingName == null || pendingName == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY ->
                serverDefaultSettled
            // Non-default name pending: settled once the profile list is present
            // (resolution attempted), even if the name turns out to be gone.
@@ -269,6 +271,13 @@ class ProfileController(
        }
    }.stateIn(scope, SharingStarted.Eagerly, null)

+    /** Local icon for any profile identity on the active connection. */
+    fun profileIconFlow(profileName: String?): Flow<String?> = activeConnectionId
+        .flatMapLatest { connectionId ->
+            if (connectionId == null) flowOf(null)
+            else profileIconStore.iconFlow(connectionId, profileName)
+        }
+
    data class HostIconImportState(
        val loading: Boolean = false,
        val error: String? = null,
@@ -332,7 +341,13 @@ class ProfileController(
        val dashboardUrl = activeDashboardUrlProvider() ?: return null
        val profileName = resolveSessionProfileName()
        return dashboardClientFactory(connectionId, dashboardUrl)
-            .listSessions(profile = profileName, limit = limit)
+            .listSessions(profile = profileName, limit = limit, archived = "include")
+    }
+
+    suspend fun listAllProfileSessions(limit: Int = 200): Result<List<SessionItem>>? {
+        val connectionId = activeConnectionId.value ?: return null
+        val dashboardUrl = activeDashboardUrlProvider() ?: return null
+        return dashboardClientFactory(connectionId, dashboardUrl).listAllProfileSessions(limit)
    }

    /**
@@ -340,12 +355,15 @@ class ProfileController(
     * `/api/sessions/{id}/messages?profile=`. Returns `null` off the dashboard
     * surface so the caller falls back to the api_server transcript.
     */
-    suspend fun loadProfileScopedMessages(sessionId: String): Result<List<MessageItem>>? {
+    suspend fun loadProfileScopedMessages(
+        sessionId: String,
+        mode: SessionMessageLoadMode = SessionMessageLoadMode.COMPLETE,
+    ): Result<List<MessageItem>>? {
        val connectionId = activeConnectionId.value ?: return null
        val dashboardUrl = activeDashboardUrlProvider() ?: return null
        val profileName = resolveSessionProfileName()
        return dashboardClientFactory(connectionId, dashboardUrl)
-            .getSessionMessages(sessionId, profileName)
+            .getSessionMessages(sessionId, profileName, mode)
    }

    suspend fun deleteProfileScopedSession(sessionId: String): Boolean {
@@ -364,6 +382,40 @@ class ProfileController(
            .isSuccess
    }

+    suspend fun setProfileScopedSessionPinned(
+        sessionId: String,
+        pinned: Boolean,
+        expectedContextKey: String? = null,
+    ): Boolean {
+        val connectionId = activeConnectionId.value ?: return false
+        val dashboardUrl = activeDashboardUrlProvider() ?: return false
+        val profileName = resolveSessionProfileName()
+        if (
+            expectedContextKey != null &&
+            AgentDisplay.profileContextKey(connectionId, profileName) != expectedContextKey
+        ) return false
+        return dashboardClientFactory(connectionId, dashboardUrl)
+            .setSessionPinned(sessionId, pinned, profileName)
+            .isSuccess
+    }
+
+    suspend fun setProfileScopedSessionArchived(
+        sessionId: String,
+        archived: Boolean,
+        expectedContextKey: String? = null,
+    ): Boolean {
+        val connectionId = activeConnectionId.value ?: return false
+        val dashboardUrl = activeDashboardUrlProvider() ?: return false
+        val profileName = resolveSessionProfileName()
+        if (
+            expectedContextKey != null &&
+            AgentDisplay.profileContextKey(connectionId, profileName) != expectedContextKey
+        ) return false
+        return dashboardClientFactory(connectionId, dashboardUrl)
+            .setSessionArchived(sessionId, archived, profileName)
+            .isSuccess
+    }
+
    fun setProfileDisplayAlias(alias: String?) {
        val connectionId = activeConnectionId.value ?: return
        val profileName = AgentDisplay.profileRequestName(_selectedProfile.value?.name)
@@ -465,8 +517,8 @@ class ProfileController(

    /**
     * The stored lock-token for a (possibly null) profile. Server default —
-     * including the synthetic "default" alias — maps to
-     * [AgentDisplay.SERVER_DEFAULT_PROFILE_KEY]; everything else to its name.
+     * A null selection maps to [AgentDisplay.SERVER_DEFAULT_PROFILE_KEY]; a
+     * profile literally named `default`, like every named profile, maps to its name.
     * Mirrors [AgentDisplay.profileSessionKey] so the lock token and the
     * session/selection key for the same profile always agree.
     */
@@ -576,11 +628,6 @@ class ProfileController(
        }
        val current = _selectedProfile.value
        if (current != null) {
-            if (AgentDisplay.isServerDefaultAlias(current.name)) {
-                _selectedProfile.value = null
-                _pendingSelectedProfileName.value = null
-                return true
-            }
            val refreshed = list.firstOrNull { it.name == current.name }
            if (refreshed != null) {
                if (refreshed != current) {
@@ -594,7 +641,7 @@ class ProfileController(
            return true
        }
        val pendingName = _pendingSelectedProfileName.value ?: return false
-        if (AgentDisplay.isServerDefaultAlias(pendingName)) {
+        if (pendingName == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY) {
            _pendingSelectedProfileName.value = null
            _selectedProfile.value = null
            return true
@@ -618,9 +665,7 @@ class ProfileController(
     *    can name it and so a later list arrival can recover it.
     */
    private fun resolveLockedProfileFrom(token: String, list: List<Profile>): Boolean {
-        if (AgentDisplay.isServerDefaultAlias(token) ||
-            token == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY
-        ) {
+        if (token == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY) {
            _pendingSelectedProfileName.value = null
            val changed = _selectedProfile.value != null
            _selectedProfile.value = null
@@ -644,22 +689,21 @@ class ProfileController(
    /**
     * Lock the active connection to [profile]. A `null` argument locks to
     * **Server default** (stored as the [AgentDisplay.SERVER_DEFAULT_PROFILE_KEY]
-     * sentinel so it's distinct from "unlocked"). Persists the lock, then forces
-     * the selection to the locked target via the normal [selectProfile] path so
+     * sentinel so it's distinct from "unlocked"). Forces the selection at the
+     * ViewModel boundary, then persists the lock so
     * the existing profile-switch machinery (fresh draft, gateway hot-swap, chat
     * API rebuild) runs. Locking to the already-selected profile is effectively
     * a no-op for the selection but still records the lock.
     */
-    suspend fun lockProfile(profile: Profile?) {
+    fun lockProfile(profile: Profile?) {
        val connectionId = activeConnectionId.value ?: return
        val normalizedProfile = AgentDisplay.normalizeSelection(profile)
        val token = lockTokenFor(normalizedProfile)
-        // Persist the lock first, then force-select via the un-gated body so the
-        // switch lands even when re-locking from a different target (the
-        // lockedProfileName StateFlow may still hold the previous token until the
-        // DataStore emission propagates).
-        profileLockStore.setLockedProfile(connectionId, token)
+        // Force-select synchronously so callers can immediately detach/clear the
+        // old Gateway session against the new profile identity. Persistence is
+        // serialized by DataStore and the lock StateFlow catches up afterward.
        applyProfileSelection(normalizedProfile)
+        scope.launch { profileLockStore.setLockedProfile(connectionId, token) }
    }

    /** Remove the lock for the active connection (back to free profile choice). */
@@ -695,7 +739,11 @@ class ProfileController(
        // current transport can't resume is exactly what forks a session
        // mid-conversation on a non-default profile.
        val transport = activeSessionTransport() ?: return
-        val sessionProfileName = resolveSessionProfileName(profileName)
+        // Persist the UI selection identity, not the resolved server route.
+        // Server default may currently route to a sticky profile named
+        // `default` (or any other name), but its last-session slot must remain
+        // distinct from explicitly selecting that named profile.
+        val sessionProfileName = profileName
        scope.launch {
            val profileScoped = profileSessionStore
                .sessionIdFlow(connectionId, sessionProfileName, transport)
@@ -704,7 +752,7 @@ class ProfileController(
            // pre-transport (untransported) pointer is still resumable — surface
            // it as the fallback only for the server-default context.
            val legacyDefault = if (
-                sessionProfileName == null || AgentDisplay.isServerDefaultAlias(sessionProfileName)
+                sessionProfileName == null
            ) {
                legacyDefaultSessionId()
            } else {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Bailey Dixon	7ef2420c85	release(server): server-v1.6.4	2026-08-12 18:38:32 -04:00
Bailey Dixon	6a810c850b	fix(server): route concurrent desktop clients explicitly	2026-08-12 18:38:02 -04:00
Bailey Dixon	4605b87c10	Merge pull request #333 from Codename-11/dev release(server): server-v1.6.3	2026-08-11 22:00:43 -04:00
Bailey Dixon	6a91d6ee7e	fix(android): complete upstream feature translations	2026-08-11 21:46:45 -04:00
Bailey Dixon	95a2813efe	fix(server): validate translated media path components	2026-08-11 21:37:54 -04:00
Bailey Dixon	2ecf521c8c	chore: merge main release history into dev	2026-08-11 21:35:40 -04:00
Bailey Dixon	7752c5c404	release(server): server-v1.6.3	2026-08-11 21:35:05 -04:00
Bailey Dixon	e1d3764cd2	feat(android): browse sessions across profiles	2026-08-11 20:50:36 -04:00
Bailey Dixon	e34171b5ad	feat(android): add gateway message reactions	2026-08-11 20:48:09 -04:00
Bailey Dixon	8040cac39a	feat(android): redirect running subagents	2026-08-11 20:45:33 -04:00
Bailey Dixon	aab70520ca	feat(android): open referenced Hermes sessions	2026-08-11 20:40:27 -04:00
Bailey Dixon	5a0cd8123c	feat(android): expand Hermes management surfaces	2026-08-11 20:37:03 -04:00
Bailey Dixon	4370d9a925	feat(android): adopt richer gateway chat contracts	2026-08-11 20:30:38 -04:00
Bailey Dixon	726308d2ef	fix: harden gateway recovery diagnostics	2026-08-11 20:26:05 -04:00
Bailey Dixon	1acc3a4c80	fix: align app and relay upstream contracts	2026-08-11 20:04:43 -04:00
Bailey Dixon	11ccbd6e5c	Merge pull request #332 from Codename-11/dev release(desktop): desktop-v0.4.0-alpha.7	2026-08-11 19:55:05 -04:00
Bailey Dixon	d13af35357	chore: merge main release history into dev	2026-08-11 19:48:26 -04:00
Bailey Dixon	e3752d43f3	release(desktop): desktop-v0.4.0-alpha.7	2026-08-11 19:48:24 -04:00
Bailey Dixon	97293b62c3	Merge pull request #331 from Codename-11/dev release(desktop): desktop-v0.4.0-alpha.6	2026-08-11 19:33:13 -04:00
Bailey Dixon	454e770648	chore: merge main release history into dev	2026-08-11 19:26:15 -04:00
Bailey Dixon	e18572e8e3	release(desktop): desktop-v0.4.0-alpha.6	2026-08-11 19:24:27 -04:00
Bailey Dixon	83f69725b9	Merge pull request #330 from Codename-11/dev release: Desktop 0.4.0-alpha.5	2026-08-11 19:05:39 -04:00
Bailey Dixon	72aa7c3046	chore: merge main release history into dev	2026-08-11 18:59:06 -04:00
Bailey Dixon	3995c64493	release(desktop): desktop-v0.4.0-alpha.5	2026-08-11 18:59:04 -04:00
Bailey Dixon	ce538ced3d	Merge pull request #329 from Codename-11/dev release: Desktop 0.4.0-alpha.4	2026-08-11 18:43:32 -04:00
Bailey Dixon	352bc5b439	chore: merge main release history into dev	2026-08-11 18:35:52 -04:00
Bailey Dixon	9ec163b27b	release(desktop): desktop-v0.4.0-alpha.4	2026-08-11 18:35:32 -04:00
Bailey Dixon	7a3efa2c4d	Merge pull request #328 from Codename-11/dev release: Desktop 0.4.0-alpha.3 and Server 1.6.2	2026-08-11 18:19:36 -04:00
Bailey Dixon	c28be7c92e	style(desktop): format tray contract test	2026-08-11 18:03:02 -04:00
Bailey Dixon	8d1758ec8b	fix(desktop): build tray assets before Rust checks	2026-08-11 18:01:17 -04:00
Bailey Dixon	ce8b8702c3	test(desktop): make UI install coverage portable	2026-08-11 17:53:56 -04:00
Bailey Dixon	ca0a9eb524	release(desktop): desktop-v0.4.0-alpha.3	2026-08-11 17:51:25 -04:00
Bailey Dixon	b91d8c9a09	release(server): server-v1.6.2	2026-08-11 17:51:13 -04:00
Bailey Dixon	bebd327816	Merge pull request #327 from Codename-11/feature/desktop-relay-management-release feat: ship desktop management UI and paired-device identity	2026-08-11 17:49:18 -04:00
Bailey Dixon	8fa97e0b46	feat(desktop): add host management tray UI	2026-08-11 17:48:47 -04:00
Bailey Dixon	45dc82e573	feat(server): enrich paired device identity	2026-08-11 17:48:09 -04:00
dependabot[bot]	48b23f4d9e	chore(deps): bump gradle-wrapper from 9.6.1 to 9.7.0 (#326 ) Bumps [gradle-wrapper](https://github.com/gradle/gradle) from 9.6.1 to 9.7.0. - [Release notes](https://github.com/gradle/gradle/releases) - [Commits](https://github.com/gradle/gradle/compare/v9.6.1...v9.7.0) --- updated-dependencies: - dependency-name: gradle-wrapper dependency-version: 9.7.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-08-10 11:56:21 +00:00
dependabot[bot]	f708ef3353	chore(deps): bump androidx.media3:media3-exoplayer from 1.10.1 to 1.11.0 (#325 ) Bumps [androidx.media3:media3-exoplayer](https://github.com/androidx/media) from 1.10.1 to 1.11.0. - [Release notes](https://github.com/androidx/media/releases) - [Changelog](https://github.com/androidx/media/blob/release/RELEASENOTES.md) - [Commits](https://github.com/androidx/media/compare/1.10.1...1.11.0) --- updated-dependencies: - dependency-name: androidx.media3:media3-exoplayer dependency-version: 1.11.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-08-10 11:55:39 +00:00
dependabot[bot]	3224595a46	chore(deps): bump gradle/actions from 6.2.0 to 6.3.0 (#324 ) Bumps [gradle/actions](https://github.com/gradle/actions) from 6.2.0 to 6.3.0. - [Release notes](https://github.com/gradle/actions/releases) - [Commits](https://github.com/gradle/actions/compare/v6.2.0...v6.3.0) --- updated-dependencies: - dependency-name: gradle/actions dependency-version: 6.3.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-08-10 11:55:08 +00:00
dependabot[bot]	c0453f040d	chore(deps): bump the testing group with 2 updates (#323 ) Bumps the testing group with 2 updates: [io.github.takahirom.roborazzi:roborazzi](https://github.com/takahirom/roborazzi) and [io.github.takahirom.roborazzi:roborazzi-compose](https://github.com/takahirom/roborazzi). Updates `io.github.takahirom.roborazzi:roborazzi` from 1.70.0 to 1.71.0 - [Release notes](https://github.com/takahirom/roborazzi/releases) - [Commits](https://github.com/takahirom/roborazzi/compare/1.70.0...1.71.0) Updates `io.github.takahirom.roborazzi:roborazzi-compose` from 1.70.0 to 1.71.0 - [Release notes](https://github.com/takahirom/roborazzi/releases) - [Commits](https://github.com/takahirom/roborazzi/compare/1.70.0...1.71.0) --- updated-dependencies: - dependency-name: io.github.takahirom.roborazzi:roborazzi dependency-version: 1.71.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: testing - dependency-name: io.github.takahirom.roborazzi:roborazzi-compose dependency-version: 1.71.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: testing ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-08-10 11:54:54 +00:00
Bailey Dixon	33a0ea3216	chore: merge main back after android-v1.8.1	2026-08-10 00:05:29 -04:00
Bailey Dixon	cec05ceec2	Merge pull request #322 from Codename-11/dev release(android): android-v1.8.1	2026-08-09 23:46:51 -04:00
Bailey Dixon	0e30699fff	release(android): android-v1.8.1	2026-08-09 23:20:15 -04:00
Bailey Dixon	d4041e4528	chore: merge main back after android-v1.8.0	2026-08-09 23:15:39 -04:00
Bailey Dixon	c5ae402cd7	fix(android): align gateway and transcript contracts	2026-08-09 23:08:26 -04:00
Bailey Dixon	56eb213bbf	Merge pull request #321 from Codename-11/dev release(android): android-v1.8.0	2026-08-09 22:53:38 -04:00
Bailey Dixon	3165ebb8ce	release(android): android-v1.8.0	2026-08-09 22:03:44 -04:00
Bailey Dixon	a2457a39d4	Revert "Merge branch 'feature/hermes-management-profile-detail' into dev" This reverts commit `b481f1f337`, reversing changes made to `7b61ed4758`.	2026-08-09 21:35:33 -04:00
Bailey Dixon	c2799082b0	Revert "Merge branch 'feature/hermes-management-detail-surfaces' into dev" This reverts commit `2a467bc03f`, reversing changes made to `44293030c9`.	2026-08-09 21:35:33 -04:00
Bailey Dixon	2a467bc03f	Merge branch 'feature/hermes-management-detail-surfaces' into dev	2026-08-09 21:13:35 -04:00
Bailey Dixon	a30d3dc6ed	feat(android): refine Hermes management surfaces	2026-08-09 21:13:29 -04:00
Bailey Dixon	44293030c9	fix(android): contain appearance header in viewport	2026-08-09 20:50:53 -04:00
Bailey Dixon	42ac8c5589	feat(marketing): refresh product screenshots	2026-08-09 20:08:42 -04:00
Bailey Dixon	b481f1f337	Merge branch 'feature/hermes-management-profile-detail' into dev	2026-08-09 19:59:56 -04:00
Bailey Dixon	62c4017eeb	feat(android): refine Hermes profile management detail	2026-08-09 19:59:40 -04:00
Bailey Dixon	7b61ed4758	Merge branch 'fix/hermes-management-detail-ui' into dev	2026-08-09 19:22:30 -04:00
Bailey Dixon	21259230b2	fix(android): restore Hermes management hub	2026-08-09 19:22:20 -04:00
Bailey Dixon	7ef1e93544	fix(android): reconcile profile shelf chat status	2026-08-09 19:13:34 -04:00
Bailey Dixon	61a50dc968	Merge branch 'feature/hermes-management-ui' into dev	2026-08-09 19:13:16 -04:00
Bailey Dixon	18b9ed005b	chore(marketing): refresh production UI screenshots	2026-08-09 19:13:04 -04:00
Bailey Dixon	c597187fa3	Merge branch 'feature/android-profile-shelf' into dev # Conflicts: # CHANGELOG.md # DEVLOG.md # app/src/main/kotlin/com/hermesandroid/relay/ui/components/ConnectionInfoSheet.kt # app/src/main/kotlin/com/hermesandroid/relay/ui/components/MessageBubble.kt # app/src/main/kotlin/com/hermesandroid/relay/ui/screens/ChatScreen.kt # app/src/main/res/values-b+pt+BR/strings.xml # app/src/main/res/values-b+zh+Hans/strings.xml # app/src/main/res/values-de/strings.xml # app/src/main/res/values-es/strings.xml # app/src/main/res/values-ja/strings.xml # app/src/main/res/values-ru/strings.xml	2026-08-09 19:11:50 -04:00
Bailey Dixon	c97f3a3359	feat(android): streamline Hermes management UI	2026-08-09 19:10:45 -04:00
Bailey Dixon	2d9ccd4712	Revert "Merge branch 'feature/agent-profile-defaults' into dev" This reverts commit `93643be844`, reversing changes made to `1132fdf576`.	2026-08-09 18:37:16 -04:00
Bailey Dixon	93643be844	Merge branch 'feature/agent-profile-defaults' into dev	2026-08-09 18:18:00 -04:00
Bailey Dixon	b82ee95b8f	feat(android): add profile defaults editor	2026-08-09 18:17:53 -04:00
Bailey Dixon	1132fdf576	fix(android): stabilize passport scrolling and model layout	2026-08-09 18:17:31 -04:00
Bailey Dixon	04c69cd15f	fix(android): preserve gateway model during api catalog loads	2026-08-09 18:05:16 -04:00
Bailey Dixon	b4edcad1e7	fix(android): keep passport catalog refresh read only	2026-08-09 17:54:08 -04:00
Bailey Dixon	bef9579917	fix(android): keep passport controls session scoped	2026-08-09 17:11:24 -04:00
Bailey Dixon	c84e037b77	fix(android): stop message narration safely	2026-08-09 16:38:27 -04:00
Bailey Dixon	3ad33691cb	fix(android): recover persisted tool activity and chat speech	2026-08-09 16:21:40 -04:00
Bailey Dixon	bb0a810798	fix(android): protect chat identity from pets	2026-08-09 16:09:09 -04:00
Bailey Dixon	b675c1498c	Merge branch 'feature/android-clean-activity' into dev	2026-08-09 15:46:02 -04:00
Bailey Dixon	6da1ad1a99	Merge branch 'fix/android-avatar-pet-regressions' into dev	2026-08-09 15:46:01 -04:00
Bailey Dixon	380b9e918d	feat(android): clean up transcript activity	2026-08-09 15:44:05 -04:00
Bailey Dixon	d531b4d377	fix(android): restore chat and pet interactions	2026-08-09 15:36:57 -04:00
Bailey Dixon	8cba61d2d8	Merge branch 'fix/android-chat-input-polish' into dev	2026-08-09 13:30:59 -04:00
Bailey Dixon	4106fd4b78	fix(android): polish chat message presentation	2026-08-09 13:30:53 -04:00
Bailey Dixon	47426db290	Merge branch 'feature/appearance-customization' into dev	2026-08-09 13:21:01 -04:00
Bailey Dixon	b7945b072f	feat(android): enhance appearance and visual assets	2026-08-09 13:20:53 -04:00
Bailey Dixon	3aead772a0	Merge branch 'fix/android-chat-input-polish' into dev	2026-08-09 12:41:22 -04:00
Bailey Dixon	ccf94e1d9d	feat(android): refine chat experience	2026-08-09 12:41:17 -04:00
Bailey Dixon	6b6edc1322	Merge branch 'fix/android-pet-ui-awareness' into dev	2026-08-09 12:31:28 -04:00
Bailey Dixon	2644b94fa9	fix(android): keep floating pets clear of UI	2026-08-09 12:31:14 -04:00
Bailey Dixon	440e3d5bb9	fix(android): unbox thinking status	2026-08-08 22:40:07 -04:00
Bailey Dixon	97158bc861	fix(android): stabilize server-default shelf avatar	2026-08-08 22:35:32 -04:00
Bailey Dixon	d5a313ab5d	feat(android): refine profile and chat handoffs	2026-08-08 20:27:01 -04:00
Bailey Dixon	3033e331b0	chore: backmerge Android 1.7.1 and Server 1.6.1 releases	2026-08-08 20:06:51 -04:00
Bailey Dixon	ca98f2ae97	Merge pull request #317 from Codename-11/dev Release Android 1.7.1 and Server 1.6.1	2026-08-08 19:44:56 -04:00
Bailey Dixon	07bbb16671	feat(android): add profile shelf	2026-08-08 19:25:20 -04:00
Bailey Dixon	ee08187c67	release(server): server-v1.6.1	2026-08-08 19:15:32 -04:00
Bailey Dixon	7ccde11a2d	release(android): android-v1.7.1	2026-08-08 19:15:31 -04:00
Bailey Dixon	2378e6ab9f	Merge branch 'fix/android-stream-tail-follow' into dev	2026-08-08 18:37:07 -04:00
Bailey Dixon	9045550317	fix(android): follow growing streamed replies	2026-08-08 18:37:01 -04:00
Bailey Dixon	7074920625	test(android): reconcile post-release issue coverage	2026-08-08 18:01:50 -04:00
Bailey Dixon	cac8a517b4	Merge branch 'fix/android-nous-hosted-onboarding' into dev	2026-08-08 16:26:38 -04:00
Bailey Dixon	c27019cdbb	fix(connections): stabilize hosted Hermes onboarding	2026-08-08 16:26:33 -04:00
Bailey Dixon	d0b060fe12	Merge branch 'fix/android-session-owned-queue' into dev # Conflicts: # CHANGELOG.md # DEVLOG.md # app/src/main/kotlin/com/hermesandroid/relay/viewmodel/ChatViewModel.kt	2026-08-08 13:48:09 -04:00
Bailey Dixon	098cc82711	Merge branch 'fix/android-agent-passport-safety-sheet' into dev # Conflicts: # CHANGELOG.md # DEVLOG.md	2026-08-08 13:30:55 -04:00
Bailey Dixon	98a311afb5	fix(android): keep queued messages with origin session	2026-08-08 13:29:21 -04:00
Bailey Dixon	cb1560fff3	fix(android): improve agent passport safety controls	2026-08-08 13:27:32 -04:00
Bailey Dixon	76bb9f8dcb	Merge branch 'fix/issue-316-markdown-completion' into dev # Conflicts: # CHANGELOG.md # DEVLOG.md	2026-08-08 12:39:54 -04:00
Bailey Dixon	1eb0393dd9	fix(android): render markdown when replies complete	2026-08-08 12:38:13 -04:00
Bailey Dixon	96e6d29c9e	Merge branch 'fix/android-approval-explicit-consent' into dev	2026-08-08 12:34:55 -04:00
Bailey Dixon	f9bf4e384f	fix(android): require explicit approval decisions	2026-08-08 12:34:46 -04:00
Bailey Dixon	615119b100	Merge branch 'fix/android-session-pin-archive' into dev # Conflicts: # CHANGELOG.md # docs/decisions.md	2026-08-08 09:24:40 -04:00
Bailey Dixon	cfe86b6cc3	fix(android): persist session pin and archive state	2026-08-08 08:56:55 -04:00
Bailey Dixon	677914a51d	Merge branch 'fix/android-active-tool-card-expansion' into dev	2026-08-08 08:47:13 -04:00
Bailey Dixon	8b3adf10c6	fix(android): preserve live tool card expansion	2026-08-08 08:47:07 -04:00
Bailey Dixon	5cc8e7187b	Merge branch 'fix/android-model-inventory-identity' into dev	2026-08-08 08:42:55 -04:00
Bailey Dixon	ece46cae24	fix(android): normalize model inventory identities	2026-08-08 08:42:47 -04:00
Bailey Dixon	c4d3934cfe	chore: backmerge Android 1.7.0 and Server 1.6.0 releases	2026-08-06 21:59:49 -04:00