Merge pull request #321 from Codename-11/dev

release(android): android-v1.8.0
2026-08-09 22:53:38 -04:00 · 2026-08-09 22:03:44 -04:00 · 2026-08-09 21:35:33 -04:00 · 2026-08-09 21:35:33 -04:00 · 2026-08-09 21:13:35 -04:00 · 2026-08-09 21:13:29 -04:00
221 changed files with 14150 additions and 1936 deletions
@@ -11,6 +11,47 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 - **Issue area labels require maintainer review.** The unreliable keyword-based auto-labeling workflow no longer assigns ownership from ambiguous issue text.
 - **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.

+## [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,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,17 @@
 # Hermes-Relay-Server v__VERSION__

-**Release Date:** August 6, 2026
+**Release Date:** August 8, 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 makes the optional Dashboard plugin's Android setup handoff reliable for hosted Hermes connections.

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

 ## What's changed

-### Added
+### Fixed

- **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.
+- **Canonical hosted-Hermes setup handoff.** The Dashboard plugin supplies the verified Dashboard address Android needs to continue through the official system-browser authentication flow.
+- **Contained dialog focus behavior.** Mobile setup dialogs retain their own focus and keyboard handling without disrupting the surrounding Dashboard.

 ## Install / update

@@ -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>
@@ -1,10 +1,10 @@
-# Hermes-Relay-Android v1.7.0
+# Hermes-Relay-Android v1.8.0

-**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.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).

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

@@ -12,39 +12,43 @@ 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.
+This release makes mobile conversations calmer and more capable: richer message
+actions and attachments, concise reasoning and tool activity, immediate profile
+switching, and deeper appearance customization without mixing session identity.

 ## 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.
+- Quote or edit a message, attach and reorder files with previews, search the
+  conversation, and jump between prompt turns without losing session context.
+- Switch agents from the compact Profile Shelf while preserving each profile's
+  last session and the server-default identity.
+- Share text from another Android app into a fresh reviewed Chat draft.
+- Customize theme accents and shapes, import Sphere skins, and create or install
+  pets from one live-preview Appearance workflow.
+
+## Changed
+
+- Live reasoning opens inline and settles to a compact Thought disclosure.
+  Routine tool work groups into a concise activity surface, while approvals,
+  failures, generated media, edits, risks, and delegated work stay distinct.
+- Agent Passport controls remain session-scoped: model and reasoning choices no
+  longer overwrite server defaults merely by inspecting or switching profiles.

 ## 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.
+- Configured voice can speak any completed assistant message without requiring
+  Voice Mode, and the same message menu exposes Stop during playback.
+- Quotes remain readable inside bubbles, portrait images honor EXIF rotation,
+  and keyboard controls follow standard capitalization and Enter behavior.
+- Persisted Gateway history recovers missing structured tool activity without
+  republishing healthy transcript state or duplicating cards.
+- Floating pets avoid chat identity rows and controls while scrolling, remain
+  touchable for their menu, and Appearance stays clear of system status bars.

 ## Install / Verify

- App version: **1.7.0** (versionCode **39**).
- Standard Chat, model selection, and Vanilla Hermes voice continue to work
+- App version: **1.8.0** (versionCode **41**).
+- 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.
@@ -1274,7 +1274,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)
@@ -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.
+Quote, edit, search, and attach files without losing chat context. Switch profiles from Chat while each agent keeps its own session. Thinking and routine tool activity are cleaner, message actions can speak or stop completed replies, Appearance adds live theme and companion previews, and floating pets avoid controls while scrolling.
@@ -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,68 @@
 {
 "versions": [
+  {
+   "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,7 @@
-v1.7.0 - Smarter controls, steadier sessions
+v1.8.0 - Conversations with more context

-* 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.
+* Quote, edit, search, and attach files without losing the active chat context.
+* Switch profiles quickly from Chat while each agent keeps its own session.
+* Read quieter thinking and grouped tool activity, with important actions kept distinct.
+* Speak or stop completed replies directly from message actions.
+* Customize themes, Sphere skins, and pets from a live Appearance preview.
@@ -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(
@@ -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,
    /**
@@ -373,6 +372,12 @@ data class ToolCall(
    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 +387,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 +416,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(
@@ -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
        }
    }
@@ -1909,6 +1909,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 +1993,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 +2041,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.
     */
@@ -2726,6 +2779,7 @@ class ChatHandler {
        messageId: String,
        toolCallId: String,
        toolName: String,
+        argsPreview: String? = null,
        runId: String? = null,
        provenance: String? = null,
    ) {
@@ -2753,6 +2807,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 +2820,7 @@ class ChatHandler {
                            toolCalls = msg.toolCalls + ToolCall(
                                id = toolCallId,
                                name = toolName,
-                                args = null,
+                                args = argsPreview,
                                result = null,
                                success = null,
                                isComplete = false,
@@ -2786,7 +2841,7 @@ class ChatHandler {
                        ToolCall(
                            id = toolCallId,
                            name = toolName,
-                            args = null,
+                            args = argsPreview,
                            result = null,
                            success = null,
                            isComplete = false,
@@ -832,6 +832,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
@@ -1122,41 +1122,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 +1182,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 +1192,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 +1449,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") ?: "",
@@ -2141,13 +2166,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 +2189,7 @@ class GatewayChatClient(
                    unmatchedTurnCompleteListener?.invoke(
                        GatewayBackgroundTurnCompletion(
                            storedSessionId = backgroundTurn.storedSessionId,
+                            liveSessionId = eventSessionId,
                            profile = backgroundTurn.profile,
                            expectedAssistantText = expectedText,
                        ),
@@ -2237,6 +2264,7 @@ class GatewayChatClient(
                    unmatchedTurnCompleteListener?.invoke(
                        GatewayBackgroundTurnCompletion(
                            storedSessionId = storedId,
+                            liveSessionId = eventSessionId,
                            profile = liveSessionProfile,
                            expectedAssistantText = expectedText,
                        ),
@@ -2645,6 +2673,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 +3005,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 +3021,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
@@ -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,10 @@ class GatewayEventMapper(
                    }
                    else -> syntheticToolId(name)
                }
-                callbacks.onToolCallStart(toolId, name)
+                val argsPreview = payload.string("args_text")
+                    ?.takeIf { it.isNotBlank() }
+                    ?: payload.string("context")?.takeIf { it.isNotBlank() }
+                callbacks.onToolCallStart(toolId, name, argsPreview)
            }

            "tool.complete" -> {
@@ -210,7 +223,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)
                }
            }

@@ -371,6 +387,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 +432,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 +506,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,
@@ -364,11 +366,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 +384,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 +503,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 +582,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 +615,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
@@ -27,6 +27,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 +214,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 +326,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,6 +685,34 @@ class HermesApiClient(
        }
    }

+    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 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) {
+                    Log.w(TAG, "Set session $field failed: HTTP ${response.code}")
+                }
+                response.isSuccessful
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to set session $field: ${e.message}")
+            false
+        }
+    }
+
    suspend fun getMessages(sessionId: String): List<MessageItem> = withContext(Dispatchers.IO) {
        try {
            val request = authRequest("$baseUrl/api/sessions/$sessionId/messages")
@@ -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("'")
+        }
+    }
 }
@@ -165,6 +165,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
@@ -180,6 +180,8 @@ internal class HermesRuntimeBinder(
        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),
+                    )
+                }
+            }
+        }
+    }
+}
@@ -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,7 +37,12 @@ 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
@@ -40,7 +50,6 @@ 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 +80,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 +100,27 @@ 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,
    /**
     * 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,6 +166,7 @@ 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
@@ -203,18 +220,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 +240,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 +288,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 +352,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 +401,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 +431,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 || showEditAction || showSpeakAction || showStopSpeakingAction) {
            DropdownMenu(
                expanded = showMessageActions,
                onDismissRequest = { showMessageActions = false },
@@ -420,7 +458,7 @@ fun MessageBubble(
                    text = { Text(stringResource(R.string.msg_bubble_copy)) },
                    onClick = {
                        showMessageActions = false
-                        onCopyMessage(message.content)
+                        onCopyMessage(visibleMessageContent)
                    },
                )
                if (onQuoteMessage != null) {
@@ -428,7 +466,7 @@ fun MessageBubble(
                        text = { Text(stringResource(R.string.msg_bubble_quote)) },
                        onClick = {
                            showMessageActions = false
-                            onQuoteMessage(message.content)
+                            onQuoteMessage(message.copy(content = visibleMessageContent))
                        },
                    )
                }
@@ -443,7 +481,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 +545,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 +583,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 +607,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 +625,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(
@@ -687,64 +753,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 +779,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 +803,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 +997,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 +1043,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,20 @@ private enum class SessionDrawerFilter {
 }

 internal const val SESSION_DRAWER_LIST_TAG = "session-drawer-list"
+internal const val UNPINNED_STAR_ALPHA = 0.45f
+
+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 +123,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
@@ -139,19 +157,13 @@ 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()) }
    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 +175,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 +199,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) }
@@ -376,7 +387,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 +510,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) },
@@ -623,6 +630,7 @@ private fun SessionItem(
    animationEnabled: Boolean,
    pinned: Boolean,
    archived: Boolean,
+    archiveSupported: Boolean,
    onClick: () -> Unit,
    onTogglePinned: () -> Unit,
    onToggleArchived: () -> Unit,
@@ -770,12 +778,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 +812,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,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" }
+}
@@ -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()
+        }
+    }
+}
@@ -2833,7 +2833,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 +2860,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
@@ -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,
+                )
+            }
        }
    }
 }
@@ -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
@@ -343,6 +349,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 +407,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 +418,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 +483,8 @@ class ConnectionViewModel(application: Application) : AndroidViewModel(applicati

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

    // --- Core networking components ---

@@ -1302,6 +1321,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 +1346,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 +1357,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 }
@@ -1485,6 +1522,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 +1560,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 +1588,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 +1851,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 +1860,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 +1996,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 +2108,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 +6504,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 +6539,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 +6666,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 +6727,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()
@@ -23,6 +23,7 @@ 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 +182,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 +270,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 +340,7 @@ 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")
    }

    /**
@@ -364,6 +372,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 +507,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 +618,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 +631,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 +655,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 +679,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 +729,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 +742,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 {
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="pending_attachment_preview_named">Prévia de %1$s</string>
+    <string name="pending_attachment_remove">Remover %1$s</string>
+    <string name="pending_attachment_move_left">Mover %1$s para a esquerda</string>
+    <string name="pending_attachment_move_right">Mover %1$s para a direita</string>
+    <string name="pending_attachment_status_loading">Preparando prévia</string>
+    <string name="pending_attachment_status_ready">Pronto</string>
+    <string name="pending_attachment_status_failed">Prévia indisponível</string>
+</resources>
@@ -272,6 +272,27 @@
    <!-- Connection wizard — Connect page essentials -->
    <string name="cw_connect_to_hermes">Conectar ao Hermes</string>
    <string name="cw_nearby_description">Vamos procurar o Hermes nesta rede. O Painel e o Gateway fornecem a conexão padrão para Chat, Gerenciar e Voz.</string>
+    <string name="cw_connection_chooser_description">Escolha a configuração que você tem. O Hermes Relay é opcional.</string>
+    <string name="cw_scan_setup_qr_title">Ler QR de configuração do Hermes</string>
+    <string name="cw_scan_setup_qr_subtitle">Configure rotas locais, remotas e do Relay disponíveis</string>
+    <string name="cw_recommended">Recomendado</string>
+    <string name="cw_other_ways_to_connect">Outras formas de conectar</string>
+    <string name="cw_advanced">Avançado</string>
+    <string name="cw_cloud_title">Hermes hospedado pela Nous</string>
+    <string name="cw_cloud_subtitle">Conecte ao seu agente hospedado</string>
+    <string name="cw_server_vps_title">Servidor ou VPS</string>
+    <string name="cw_server_vps_subtitle">Insira um endereço seguro do Painel</string>
+    <string name="cw_relay_optional_note">Chat, Gerenciar e Voz padrão funcionam sem o Relay. QRs de configuração compatíveis adicionam recursos avançados do Relay quando disponíveis.</string>
+    <string name="cw_cloud_entry_title">Conectar ao Hermes hospedado pela Nous</string>
+    <string name="cw_cloud_entry_description">Insira o endereço do agente mostrado no Nous Portal. Você entrará com segurança depois que o Hermes for encontrado.</string>
+    <string name="cw_cloud_agent_name">Endereço do agente</string>
+    <string name="cw_cloud_slug_placeholder">seu-agente</string>
+    <string name="cw_cloud_slug_hint">Conectaremos a seu-agente.agents.nousresearch.com.</string>
+    <string name="cw_cloud_slug_error">Insira exatamente as letras, os números e os hifens antes de .agents.nousresearch.com.</string>
+    <string name="cw_cloud_address_placeholder">https://seu-agente.example.com</string>
+    <string name="cw_cloud_address_hint">Use o endereço HTTPS completo exibido para seu agente hospedado.</string>
+    <string name="cw_cloud_use_custom_address">Usar URL personalizada</string>
+    <string name="cw_cloud_use_nous_address">Usar endereço hospedado pela Nous</string>
    <string name="cw_before_connecting">Antes de conectar</string>
    <string name="cw_connect_step_server_title">Inicie o Hermes no computador</string>
    <string name="cw_connect_step_server_body">Inicie o Painel no computador com Hermes. No primeiro acesso pela rede local, use o guia abaixo para torná-lo acessível pelo celular e ativar o login.</string>
@@ -673,6 +694,9 @@
    <string name="chat_settings_recent_prompt_chips_desc">Mostre suas mensagens recentes como chips tocáveis acima do editor para enviá-las novamente. Desativado por padrão.</string>
    <string name="chat_settings_keep_keyboard_open">Manter o teclado aberto ao enviar</string>
    <string name="chat_settings_keep_keyboard_open_desc">Permaneça no editor após enviar. Desative para fechar o teclado depois de cada mensagem enviada.</string>
+    <string name="chat_settings_physical_keyboard_enter">Tecla Enter do teclado físico</string>
+    <string name="chat_settings_physical_keyboard_enter_desc">Escolha se Enter envia ou insere uma nova linha. Ctrl+Enter sempre envia.</string>
+    <string name="chat_settings_insert_newline">Inserir nova linha</string>
    <string name="chat_settings_notify_when_finishes">Alertas de chat em segundo plano</string>
    <string name="chat_settings_notify_when_finishes_desc">Notifique quando o Hermes precisar de uma resposta ou terminar em segundo plano</string>
    <string name="chat_settings_share_phone_status">Compartilhar o status do celular com o agente</string>
@@ -2167,8 +2191,10 @@
    <string name="conn_info_customize_identity">Personalizar identidade</string>
    <string name="conn_info_agent_passport">Passaporte do agente</string>
    <string name="conn_info_chat_override">Substituição do chat</string>
+    <string name="conn_info_chat_override_inherited_desc">Use a política de aprovação do perfil para este chat.</string>
    <string name="conn_info_fast_tier">Nível rápido</string>
    <string name="conn_info_fast">Rápido</string>
+    <string name="conn_info_normal_tier_desc">Use o nível de processamento padrão.</string>
    <string name="conn_info_context">Contexto</string>
    <string name="conn_info_profile_already_bypasses">As aprovações já são ignoradas pelo perfil.</string>
    <string name="conn_info_start_new_chat">Iniciar novo chat</string>
@@ -2422,6 +2448,23 @@
    <string name="image_generation_rendering">Gerando imagem</string>
    <string name="tool_progress_cd_collapse">Recolher</string>
    <string name="tool_progress_cd_expand">Expandir</string>
+    <string name="tool_progress_state_expanded">Expandido</string>
+    <string name="tool_progress_state_collapsed">Recolhido</string>
+    <string name="tool_run_preparing">Preparando %1$s</string>
+    <string name="tool_run_running">Executando %1$s</string>
+    <string name="tool_run_finished">%1$s concluído</string>
+    <plurals name="tool_run_reading"><item quantity="one">Lendo %d item</item><item quantity="many">Lendo %d itens</item><item quantity="other">Lendo %d itens</item></plurals>
+    <plurals name="tool_run_read"><item quantity="one">Leu %d item</item><item quantity="many">Leu %d itens</item><item quantity="other">Leu %d itens</item></plurals>
+    <plurals name="tool_run_searching"><item quantity="one">Pesquisando %d fonte</item><item quantity="many">Pesquisando %d fontes</item><item quantity="other">Pesquisando %d fontes</item></plurals>
+    <plurals name="tool_run_searched"><item quantity="one">Pesquisou %d fonte</item><item quantity="many">Pesquisou %d fontes</item><item quantity="other">Pesquisou %d fontes</item></plurals>
+    <plurals name="tool_run_running_commands"><item quantity="one">Executando %d comando</item><item quantity="many">Executando %d comandos</item><item quantity="other">Executando %d comandos</item></plurals>
+    <plurals name="tool_run_ran_commands"><item quantity="one">Executou %d comando</item><item quantity="many">Executou %d comandos</item><item quantity="other">Executou %d comandos</item></plurals>
+    <plurals name="tool_run_browsing"><item quantity="one">Executando %d ação do navegador</item><item quantity="many">Executando %d ações do navegador</item><item quantity="other">Executando %d ações do navegador</item></plurals>
+    <plurals name="tool_run_browsed"><item quantity="one">Executou %d ação do navegador</item><item quantity="many">Executou %d ações do navegador</item><item quantity="other">Executou %d ações do navegador</item></plurals>
+    <plurals name="tool_run_using_device"><item quantity="one">Executando %d ação do dispositivo</item><item quantity="many">Executando %d ações do dispositivo</item><item quantity="other">Executando %d ações do dispositivo</item></plurals>
+    <plurals name="tool_run_used_device"><item quantity="one">Executou %d ação do dispositivo</item><item quantity="many">Executou %d ações do dispositivo</item><item quantity="other">Executou %d ações do dispositivo</item></plurals>
+    <plurals name="tool_run_using_tools"><item quantity="one">Usando %d ferramenta</item><item quantity="many">Usando %d ferramentas</item><item quantity="other">Usando %d ferramentas</item></plurals>
+    <plurals name="tool_run_used_tools"><item quantity="one">Usou %d ferramenta</item><item quantity="many">Usou %d ferramentas</item><item quantity="other">Usou %d ferramentas</item></plurals>
    <!-- AgentIconRow -->
    <string name="agent_icon_title">Ícone do agente</string>
    <string name="agent_icon_set">Escolher arquivo</string>
@@ -2540,6 +2583,8 @@
    <string name="qr_scanner_title">Ler QR do Hermes</string>
    <string name="qr_scanner_instruction">Leia um QR de configuração do Hermes</string>
    <string name="qr_scanner_subtext">Escaneie um QR de configuração do Hermes ou de pareamento do Relay. Conexões padrão pelo Dashboard não exigem uma chave de API.</string>
+    <string name="qr_scanner_ready">Pronto para ler</string>
+    <string name="qr_scanner_found">QR de configuração do Hermes encontrado</string>
    <string name="qr_scanner_relay_title">Escanear QR do Relay</string>
    <string name="qr_scanner_relay_instruction">Escaneie um QR de pareamento do Relay</string>
    <string name="qr_scanner_relay_subtext">Abra o QR de pareamento do Relay no seu servidor Hermes. A conexão do Dashboard e as rotas existentes não serão alteradas.</string>
@@ -3258,6 +3303,7 @@
    <string name="dashboard_native_signin_cancelled">Login pelo navegador cancelado.</string>
    <string name="dashboard_native_signin_requires_https">O login seguro pelo navegador exige um endereço HTTPS do painel.</string>
    <string name="dashboard_native_signin_unavailable">O login seguro pelo navegador não está disponível para esta conexão. Atualize a conexão e tente novamente.</string>
+    <string name="dashboard_native_signin_transport_retry">A conexão segura foi interrompida. Toque no botão de login para tentar novamente.</string>
    <string name="conn_info_yolo_mode_desc_ephemeral">Ignore as solicitações de aprovação somente neste chat. A opção é redefinida quando a sessão muda.</string>
    <string name="conn_info_yolo_mode_profile_off">As aprovações do perfil estão desativadas, então este chat já ignora as solicitações. Escolha Manual ou Inteligente antes de usar a exceção por chat.</string>
    <string name="conn_info_approval_mode_title">Modo de aprovação do perfil</string>
@@ -3457,6 +3503,7 @@
    <string name="tool_name_android">Ação no telefone</string>
    <string name="timeline_no_checks">sem verificações</string>
    <string name="thinking_title">Processo de raciocínio</string>
+    <string name="thinking_settled">Pensamento</string>
    <string name="thinking_thinking_short">Pensando</string>
    <string name="thinking_thinking">Pensando...</string>
    <string name="task_status_working">Trabalhando</string>
@@ -3582,6 +3629,7 @@
    <string name="voice_overlay_attachment_ready">Anexo pronto</string>
    <string name="conn_info_active_profile">Perfil ativo</string>
    <string name="msg_bubble_speak_response">Falar resposta</string>
+    <string name="msg_bubble_stop_speaking">Parar fala</string>
    <string name="voice_overlay_engine_standard">Modo padrão</string>
    <string name="voice_overlay_caption_hermes">Hermes</string>
    <string name="voice_overlay_open_hermes">Abrir Hermes</string>
@@ -3700,4 +3748,81 @@
    <string name="support_bundle_copied">Informações de suporte copiadas</string>
    <string name="support_bundle_no_share">Informações de suporte copiadas — nenhum app encontrado para compartilhar</string>
    <string name="support_bundle_share_title">Compartilhar informações de suporte do Hermes-Relay</string>
+    <string name="chat_search_conversation">Pesquisar conversa</string>
+    <string name="chat_search_close">Fechar pesquisa</string>
+    <string name="chat_search_no_results">Nenhum resultado</string>
+    <string name="chat_search_result_count">%1$d de %2$d</string>
+    <string name="msg_bubble_queued">Na fila</string>
+    <string name="msg_bubble_steered">Correção enviada</string>
+    <string name="chat_quote_you">Você</string>
+    <string name="chat_quote_hermes">Hermes</string>
+    <string name="chat_quote_open">Abrir mensagem original de %1$s</string>
+    <string name="chat_quote_remove">Remover citação</string>
+    <string name="profile_shelf_switch_agent">Trocar agente</string>
+    <string name="profile_shelf_all_profiles">Abrir todos os perfis de agente</string>
+    <string name="profile_shelf_open_passport">Abrir Passaporte do agente</string>
+    <string name="profile_shelf_switch_to">Trocar para este agente</string>
+    <string name="profile_shelf_locked_hint">A troca de perfil está bloqueada. Toque e segure o agente ativo para desbloquear.</string>
+    <string name="profile_shelf_inspect">Inspecionar perfil</string>
+    <string name="profile_shelf_hide">Ocultar da estante de perfis</string>
+    <string name="profile_shelf_expand">Expandir a estante de perfis</string>
+    <string name="profile_shelf_collapse">Recolher a estante de perfis</string>
+    <string name="appearance_intro">Escolha uma predefinição e veja o resultado ao vivo na prévia.</string>
+    <string name="appearance_preset_gallery">Galeria de predefinições</string>
+    <string name="appearance_preview_relay">Prévia · Relay</string>
+    <string name="appearance_preview_user_message">Dê três dicas rápidas para uma manhã focada.</string>
+    <string name="appearance_preview_agent">Hermes</string>
+    <string name="appearance_preview_agent_message">1. Escolha uma conquista real antes de conferir os feeds.\n2. Reserve os primeiros 45–90 minutos.\n3. Comece com um ritual de preparação, não com “motivação”.</string>
+    <string name="appearance_preview_time">19:00</string>
+    <string name="appearance_preview_voice">Voz</string>
+    <string name="appearance_preview_tool_meta">tool_executor  ·  206 tokens  ·  137,2 mil</string>
+    <string name="appearance_preview_message_placeholder">Mensagem…</string>
+    <string name="appearance_preview_gateway">Gateway   ·   LAN   ·   gpt-5.5 / perfil: padrão</string>
+    <string name="appearance_preview_live_note">Esta prévia é atualizada imediatamente com a predefinição, o modo, a fonte e a aparência da Sphere.</string>
+    <string name="appearance_customize_theme">Personalizar %1$s</string>
+    <string name="appearance_accent_preset">Cor de destaque predefinida</string>
+    <string name="appearance_accent_custom">Cor de destaque personalizada aplicada</string>
+    <string name="appearance_accent_preview_only">As alterações ficam na prévia até você aplicá-las.</string>
+    <string name="appearance_accent_preview_only_short">Somente prévia</string>
+    <string name="appearance_apply_changes">Aplicar alterações</string>
+    <string name="appearance_customize_summary">Destaque, superfícies, forma e densidade</string>
+    <string name="appearance_shape">Forma</string>
+    <string name="appearance_shape_soft">Suave</string>
+    <string name="appearance_shape_balanced">Equilibrada</string>
+    <string name="appearance_shape_sharp">Angular</string>
+    <string name="appearance_contrast_passes">Contraste aprovado</string>
+    <string name="appearance_contrast_fails">O contraste precisa melhorar</string>
+    <string name="appearance_contrast_aa">AA para texto normal</string>
+    <string name="appearance_typography_density">Tipografia e densidade</string>
+    <string name="appearance_readability">Legibilidade</string>
+    <string name="appearance_default">Padrão</string>
+    <string name="appearance_font_normal_summary">Tamanho da fonte: Normal</string>
+    <string name="appearance_reset_draft">Redefinir rascunho</string>
+    <string name="appearance_accent">Cor de destaque</string>
+    <string name="appearance_contrast_status">Contraste legível · %1$.1f:1</string>
+    <string name="appearance_typography_density_summary">A tipografia e a densidade usam os controles específicos de Fonte e Tamanho da fonte abaixo.</string>
+    <string name="appearance_readability_summary">Ajuste a densidade do texto aqui; escolha a tipografia na seção Fonte abaixo.</string>
+    <string name="appearance_reset">Redefinir</string>
+    <string name="appearance_apply">Aplicar</string>
+    <string name="appearance_background_installed">Animações instaladas</string>
+    <string name="appearance_import_background">Importar animação de fundo</string>
+    <string name="appearance_import_background_desc">Importa o mesmo ZIP seguro de pet do Relay ou formato de imagem única, mas o usa apenas na visualização central ou de fundo. Não ativa a movimentação nem altera o pet flutuante.</string>
+    <string name="appearance_import_sphere">Importar aparência da Sphere</string>
+    <string name="appearance_create_pet">Criar um pet personalizado</string>
+    <string name="pet_creator_title">Criar um pet personalizado</string>
+    <string name="pet_creator_intro">Descreva seu companheiro, revise as instruções geradas e escolha onde criá-lo. Nada é enviado até você mesmo enviar o novo chat.</string>
+    <string name="pet_creator_step_idea">Escolher a ideia</string>
+    <string name="pet_creator_name">Nome do pet</string>
+    <string name="pet_creator_description">Direção do personagem</string>
+    <string name="pet_creator_description_hint">Descreva o personagem, os materiais, as cores, o clima e qualquer imagem de referência que você pretende anexar.</string>
+    <string name="pet_creator_animated">Pacote animado</string>
+    <string name="pet_creator_static">Imagem estática</string>
+    <string name="pet_creator_step_create">Revisar e criar</string>
+    <string name="pet_creator_review_copy">Estas instruções completas incluem o formato atual de pets e os limites de validação, privacidade e revisão.</string>
+    <string name="pet_creator_copy">Copiar</string>
+    <string name="pet_creator_copied">Instruções copiadas</string>
+    <string name="pet_creator_new_chat">Novo chat</string>
+    <string name="pet_creator_step_review">Revisar e importar</string>
+    <string name="pet_creator_review_desc">Inspecione primeiro a imagem ou o ZIP retornado. A importação copia os arquivos validados para o armazenamento do app; ela não os publica.</string>
+    <string name="pet_creator_import">Importar pet concluído</string>
 </resources>
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="pending_attachment_preview_named">预览 %1$s</string>
+    <string name="pending_attachment_remove">移除 %1$s</string>
+    <string name="pending_attachment_move_left">将 %1$s 向左移动</string>
+    <string name="pending_attachment_move_right">将 %1$s 向右移动</string>
+    <string name="pending_attachment_status_loading">正在准备预览</string>
+    <string name="pending_attachment_status_ready">已就绪</string>
+    <string name="pending_attachment_status_failed">预览不可用</string>
+</resources>
@@ -293,6 +293,27 @@
    <!-- 连接向导 —— Connect 页核心文案 -->
    <string name="cw_connect_to_hermes">连接 Hermes</string>
    <string name="cw_nearby_description">我们将在此网络中查找 Hermes。仪表板和网关提供聊天、管理和语音的标准连接。</string>
+    <string name="cw_connection_chooser_description">请选择你现有的设置方式。Hermes Relay 为可选功能。</string>
+    <string name="cw_scan_setup_qr_title">扫描 Hermes 设置二维码</string>
+    <string name="cw_scan_setup_qr_subtitle">配置本地、远程及可用的 Relay 路由</string>
+    <string name="cw_recommended">推荐</string>
+    <string name="cw_other_ways_to_connect">其他连接方式</string>
+    <string name="cw_advanced">高级</string>
+    <string name="cw_cloud_title">Nous 托管的 Hermes</string>
+    <string name="cw_cloud_subtitle">连接到你的托管智能体</string>
+    <string name="cw_server_vps_title">服务器或 VPS</string>
+    <string name="cw_server_vps_subtitle">输入安全的 Dashboard 地址</string>
+    <string name="cw_relay_optional_note">标准聊天、管理和语音功能无需 Relay 即可使用。兼容的设置二维码会在可用时添加 Relay 高级功能。</string>
+    <string name="cw_cloud_entry_title">连接到 Nous 托管的 Hermes</string>
+    <string name="cw_cloud_entry_description">输入 Nous Portal 中显示的智能体地址。找到 Hermes 后，你将安全登录。</string>
+    <string name="cw_cloud_agent_name">智能体地址</string>
+    <string name="cw_cloud_slug_placeholder">your-agent</string>
+    <string name="cw_cloud_slug_hint">我们将连接到 your-agent.agents.nousresearch.com。</string>
+    <string name="cw_cloud_slug_error">请准确输入 .agents.nousresearch.com 前的字母、数字和连字符。</string>
+    <string name="cw_cloud_address_placeholder">https://your-agent.example.com</string>
+    <string name="cw_cloud_address_hint">请使用为托管智能体显示的完整 HTTPS 地址。</string>
+    <string name="cw_cloud_use_custom_address">使用自定义网址</string>
+    <string name="cw_cloud_use_nous_address">使用 Nous 托管地址</string>
    <string name="cw_before_connecting">连接之前</string>
    <string name="cw_connect_step_server_title">在电脑上启动 Hermes</string>
    <string name="cw_connect_step_server_body">在 Hermes 电脑上启动仪表板。首次通过局域网访问时，请使用下方的设置指南，让手机能够访问并启用登录。</string>
@@ -715,6 +736,9 @@
    <string name="chat_settings_recent_prompt_chips_desc">在输入栏上方显示最近消息为可点击的标签以便重发。默认关闭。</string>
    <string name="chat_settings_keep_keyboard_open">发送时保持键盘打开</string>
    <string name="chat_settings_keep_keyboard_open_desc">发送后留在输入栏。关闭则在每条消息发送后收起键盘。</string>
+    <string name="chat_settings_physical_keyboard_enter">实体键盘 Enter 键</string>
+    <string name="chat_settings_physical_keyboard_enter_desc">选择按 Enter 是发送消息还是插入新行。Ctrl+Enter 始终发送。</string>
+    <string name="chat_settings_insert_newline">插入新行</string>
    <string name="chat_settings_notify_when_finishes">后台聊天提醒</string>
    <string name="chat_settings_notify_when_finishes_desc">Hermes 在后台需要输入或完成回复时通知</string>
    <string name="chat_settings_share_phone_status">与代理分享手机状态</string>
@@ -2261,8 +2285,10 @@
    <string name="conn_info_customize_identity">自定义身份</string>
    <string name="conn_info_agent_passport">智能体档案</string>
    <string name="conn_info_chat_override">对话覆盖</string>
+    <string name="conn_info_chat_override_inherited_desc">此聊天使用配置文件的审批策略。</string>
    <string name="conn_info_fast_tier">快速层级</string>
    <string name="conn_info_fast">快速</string>
+    <string name="conn_info_normal_tier_desc">使用标准处理层级。</string>
    <string name="conn_info_context">上下文</string>
    <string name="conn_info_profile_already_bypasses">此配置已绕过审批。</string>
    <string name="conn_info_start_new_chat">开始新对话</string>
@@ -2531,6 +2557,23 @@
    <string name="image_generation_rendering">正在生成图像</string>
    <string name="tool_progress_cd_collapse">折叠</string>
    <string name="tool_progress_cd_expand">展开</string>
+    <string name="tool_progress_state_expanded">已展开</string>
+    <string name="tool_progress_state_collapsed">已折叠</string>
+    <string name="tool_run_preparing">正在准备%1$s</string>
+    <string name="tool_run_running">正在运行%1$s</string>
+    <string name="tool_run_finished">已完成%1$s</string>
+    <plurals name="tool_run_reading"><item quantity="other">正在读取 %d 项</item></plurals>
+    <plurals name="tool_run_read"><item quantity="other">已读取 %d 项</item></plurals>
+    <plurals name="tool_run_searching"><item quantity="other">正在搜索 %d 个来源</item></plurals>
+    <plurals name="tool_run_searched"><item quantity="other">已搜索 %d 个来源</item></plurals>
+    <plurals name="tool_run_running_commands"><item quantity="other">正在运行 %d 个命令</item></plurals>
+    <plurals name="tool_run_ran_commands"><item quantity="other">已运行 %d 个命令</item></plurals>
+    <plurals name="tool_run_browsing"><item quantity="other">正在执行 %d 个浏览器操作</item></plurals>
+    <plurals name="tool_run_browsed"><item quantity="other">已执行 %d 个浏览器操作</item></plurals>
+    <plurals name="tool_run_using_device"><item quantity="other">正在执行 %d 个设备操作</item></plurals>
+    <plurals name="tool_run_used_device"><item quantity="other">已执行 %d 个设备操作</item></plurals>
+    <plurals name="tool_run_using_tools"><item quantity="other">正在使用 %d 个工具</item></plurals>
+    <plurals name="tool_run_used_tools"><item quantity="other">已使用 %d 个工具</item></plurals>

    <!-- AgentIconRow -->
    <string name="agent_icon_title">代理图标</string>
@@ -2659,6 +2702,8 @@
    <string name="qr_scanner_title">扫描 Hermes QR</string>
    <string name="qr_scanner_instruction">扫描 Hermes 设置二维码</string>
    <string name="qr_scanner_subtext">扫描 Hermes 设置二维码或 Relay 配对二维码。标准 Dashboard 连接不需要 API 密钥。</string>
+    <string name="qr_scanner_ready">准备扫描</string>
+    <string name="qr_scanner_found">已找到 Hermes 设置二维码</string>
    <string name="qr_scanner_relay_title">扫描 Relay 二维码</string>
    <string name="qr_scanner_relay_instruction">扫描 Relay 配对二维码</string>
    <string name="qr_scanner_relay_subtext">在 Hermes 服务器上打开 Relay 配对二维码。现有 Dashboard 连接和路由将保持不变。</string>
@@ -3351,6 +3396,7 @@
    <string name="dashboard_native_signin_cancelled">已取消浏览器登录。</string>
    <string name="dashboard_native_signin_requires_https">安全浏览器登录需要 HTTPS 控制面板地址。</string>
    <string name="dashboard_native_signin_unavailable">此连接无法使用安全浏览器登录。请刷新连接后重试。</string>
+    <string name="dashboard_native_signin_transport_retry">安全连接已中断。请点按登录按钮重试。</string>
    <string name="conn_info_yolo_mode_desc_ephemeral">仅在此聊天中跳过批准提示。会在会话更改时重置。</string>
    <string name="conn_info_yolo_mode_profile_off">配置文件批准已关闭，因此此聊天已经会跳过提示。使用单聊天例外前，请选择手动或智能。</string>
    <string name="conn_info_approval_mode_title">配置文件批准模式</string>
@@ -3545,6 +3591,7 @@
    <string name="tool_name_android">手机操作</string>
    <string name="timeline_no_checks">无检查</string>
    <string name="thinking_title">思考过程</string>
+    <string name="thinking_settled">思考</string>
    <string name="thinking_thinking_short">思考中</string>
    <string name="thinking_thinking">思考中…</string>
    <string name="task_status_working">处理中</string>
@@ -3670,6 +3717,7 @@
    <string name="voice_overlay_attachment_ready">附件已就绪</string>
    <string name="conn_info_active_profile">活跃个人资料</string>
    <string name="msg_bubble_speak_response">朗读回复</string>
+    <string name="msg_bubble_stop_speaking">停止朗读</string>
    <string name="voice_overlay_engine_standard">标准模式</string>
    <string name="voice_overlay_caption_hermes">Hermes</string>
    <string name="voice_overlay_open_hermes">打开 Hermes</string>
@@ -3788,4 +3836,81 @@
    <string name="support_bundle_copied">支持信息已复制</string>
    <string name="support_bundle_no_share">支持信息已复制 — 未找到可分享的应用</string>
    <string name="support_bundle_share_title">分享 Hermes-Relay 支持信息</string>
+    <string name="chat_search_conversation">搜索对话</string>
+    <string name="chat_search_close">关闭搜索</string>
+    <string name="chat_search_no_results">无结果</string>
+    <string name="chat_search_result_count">%1$d / %2$d</string>
+    <string name="msg_bubble_queued">已排队</string>
+    <string name="msg_bubble_steered">更正已发送</string>
+    <string name="chat_quote_you">你</string>
+    <string name="chat_quote_hermes">Hermes</string>
+    <string name="chat_quote_open">打开 %1$s 的原始消息</string>
+    <string name="chat_quote_remove">移除引用</string>
+    <string name="profile_shelf_switch_agent">切换智能体</string>
+    <string name="profile_shelf_all_profiles">打开所有智能体配置</string>
+    <string name="profile_shelf_open_passport">打开智能体护照</string>
+    <string name="profile_shelf_switch_to">切换到此智能体</string>
+    <string name="profile_shelf_locked_hint">配置切换已锁定。长按当前智能体即可解锁。</string>
+    <string name="profile_shelf_inspect">查看配置</string>
+    <string name="profile_shelf_hide">从配置架中隐藏</string>
+    <string name="profile_shelf_expand">展开配置架</string>
+    <string name="profile_shelf_collapse">收起配置架</string>
+    <string name="appearance_intro">选择一个预设，即时查看预览效果。</string>
+    <string name="appearance_preset_gallery">预设库</string>
+    <string name="appearance_preview_relay">预览 · Relay</string>
+    <string name="appearance_preview_user_message">给我三个专注开启早晨的小建议。</string>
+    <string name="appearance_preview_agent">Hermes</string>
+    <string name="appearance_preview_agent_message">1. 查看信息流之前，先选定一个真正的成果。\n2. 留出最初的 45–90 分钟。\n3. 从准备仪式开始，而不是等待“动力”。</string>
+    <string name="appearance_preview_time">晚上 7:00</string>
+    <string name="appearance_preview_voice">语音</string>
+    <string name="appearance_preview_tool_meta">tool_executor  ·  206 个 token  ·  137.2K</string>
+    <string name="appearance_preview_message_placeholder">消息…</string>
+    <string name="appearance_preview_gateway">Gateway   ·   LAN   ·   gpt-5.5 / 配置文件：默认</string>
+    <string name="appearance_preview_live_note">更改预设、模式、字体或 Sphere 皮肤后，此预览会立即更新。</string>
+    <string name="appearance_customize_theme">自定义 %1$s</string>
+    <string name="appearance_accent_preset">预设强调色</string>
+    <string name="appearance_accent_custom">已应用自定义强调色</string>
+    <string name="appearance_accent_preview_only">应用之前，更改只会显示在预览中。</string>
+    <string name="appearance_accent_preview_only_short">仅预览</string>
+    <string name="appearance_apply_changes">应用更改</string>
+    <string name="appearance_customize_summary">强调色、表面、形状和密度</string>
+    <string name="appearance_shape">形状</string>
+    <string name="appearance_shape_soft">柔和</string>
+    <string name="appearance_shape_balanced">均衡</string>
+    <string name="appearance_shape_sharp">锐利</string>
+    <string name="appearance_contrast_passes">对比度达标</string>
+    <string name="appearance_contrast_fails">对比度需要改进</string>
+    <string name="appearance_contrast_aa">普通文本 AA 标准</string>
+    <string name="appearance_typography_density">排版和密度</string>
+    <string name="appearance_readability">可读性</string>
+    <string name="appearance_default">默认</string>
+    <string name="appearance_font_normal_summary">字体大小：标准</string>
+    <string name="appearance_reset_draft">重置草稿</string>
+    <string name="appearance_accent">强调色</string>
+    <string name="appearance_contrast_status">易读对比度 · %1$.1f:1</string>
+    <string name="appearance_typography_density_summary">排版和密度使用下方独立的字体和字体大小控件。</string>
+    <string name="appearance_readability_summary">在此调整文本密度；在下方的字体部分选择字形。</string>
+    <string name="appearance_reset">重置</string>
+    <string name="appearance_apply">应用</string>
+    <string name="appearance_background_installed">已安装的动画</string>
+    <string name="appearance_import_background">导入背景动画</string>
+    <string name="appearance_import_background_desc">导入与安全 Relay 宠物 ZIP 或单张图片相同的格式，但仅用于中央或背景可视化。它不会启用漫游，也不会更改悬浮宠物。</string>
+    <string name="appearance_import_sphere">导入 Sphere 皮肤</string>
+    <string name="appearance_create_pet">创建自定义宠物</string>
+    <string name="pet_creator_title">创建自定义宠物</string>
+    <string name="pet_creator_intro">描述你的伙伴，检查生成的说明，然后选择创建位置。在你自行发送新聊天之前，不会发送任何内容。</string>
+    <string name="pet_creator_step_idea">选择构思</string>
+    <string name="pet_creator_name">宠物名称</string>
+    <string name="pet_creator_description">角色方向</string>
+    <string name="pet_creator_description_hint">描述角色、材质、颜色、氛围以及计划附加的参考图片。</string>
+    <string name="pet_creator_animated">动画包</string>
+    <string name="pet_creator_static">静态图片</string>
+    <string name="pet_creator_step_create">检查并创建</string>
+    <string name="pet_creator_review_copy">这些完整说明涵盖当前宠物格式、验证、隐私和审查边界。</string>
+    <string name="pet_creator_copy">复制</string>
+    <string name="pet_creator_copied">说明已复制</string>
+    <string name="pet_creator_new_chat">新聊天</string>
+    <string name="pet_creator_step_review">检查并导入</string>
+    <string name="pet_creator_review_desc">请先检查返回的图片或 ZIP。导入会将经过验证的文件复制到应用专属存储空间，不会发布它们。</string>
+    <string name="pet_creator_import">导入完成的宠物</string>
 </resources>
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="pending_attachment_preview_named">Vorschau für %1$s</string>
+    <string name="pending_attachment_remove">%1$s entfernen</string>
+    <string name="pending_attachment_move_left">%1$s nach links verschieben</string>
+    <string name="pending_attachment_move_right">%1$s nach rechts verschieben</string>
+    <string name="pending_attachment_status_loading">Vorschau wird vorbereitet</string>
+    <string name="pending_attachment_status_ready">Bereit</string>
+    <string name="pending_attachment_status_failed">Vorschau nicht verfügbar</string>
+</resources>
@@ -293,6 +293,27 @@
    <!-- Connection wizard — Connect page essentials -->
    <string name="cw_connect_to_hermes">Mit Hermes verbinden</string>
    <string name="cw_nearby_description">Wir suchen in diesem Netzwerk nach Hermes. Dashboard und Gateway stellen die Standardverbindung für Chat, Verwaltung und Sprache bereit.</string>
+    <string name="cw_connection_chooser_description">Wähle deine vorhandene Einrichtung. Hermes Relay ist optional.</string>
+    <string name="cw_scan_setup_qr_title">Hermes-Einrichtungs-QR-Code scannen</string>
+    <string name="cw_scan_setup_qr_subtitle">Lokale, entfernte und verfügbare Relay-Routen konfigurieren</string>
+    <string name="cw_recommended">Empfohlen</string>
+    <string name="cw_other_ways_to_connect">Weitere Verbindungsmöglichkeiten</string>
+    <string name="cw_advanced">Erweitert</string>
+    <string name="cw_cloud_title">Von Nous gehostetes Hermes</string>
+    <string name="cw_cloud_subtitle">Mit deinem gehosteten Agenten verbinden</string>
+    <string name="cw_server_vps_title">Server oder VPS</string>
+    <string name="cw_server_vps_subtitle">Sichere Dashboard-Adresse eingeben</string>
+    <string name="cw_relay_optional_note">Standard-Chat, Verwaltung und Sprache funktionieren ohne Relay. Kompatible Einrichtungs-QR-Codes fügen verfügbare Relay-Power-Funktionen hinzu.</string>
+    <string name="cw_cloud_entry_title">Mit von Nous gehostetem Hermes verbinden</string>
+    <string name="cw_cloud_entry_description">Gib die im Nous Portal angezeigte Agentenadresse ein. Nach dem Auffinden von Hermes meldest du dich sicher an.</string>
+    <string name="cw_cloud_agent_name">Agentenadresse</string>
+    <string name="cw_cloud_slug_placeholder">dein-agent</string>
+    <string name="cw_cloud_slug_hint">Wir verbinden dich mit dein-agent.agents.nousresearch.com.</string>
+    <string name="cw_cloud_slug_error">Gib exakt die Buchstaben, Zahlen und Bindestriche vor .agents.nousresearch.com ein.</string>
+    <string name="cw_cloud_address_placeholder">https://dein-agent.example.com</string>
+    <string name="cw_cloud_address_hint">Verwende die vollständige HTTPS-Adresse, die für deinen gehosteten Agenten angezeigt wird.</string>
+    <string name="cw_cloud_use_custom_address">Benutzerdefinierte URL verwenden</string>
+    <string name="cw_cloud_use_nous_address">Von Nous gehostete Adresse verwenden</string>
    <string name="cw_before_connecting">Vor dem Verbinden</string>
    <string name="cw_connect_step_server_title">Hermes auf dem Computer starten</string>
    <string name="cw_connect_step_server_body">Starte das Dashboard auf dem Hermes-Computer. Verwende für den ersten LAN-Zugriff die Anleitung unten, um es vom Smartphone erreichbar zu machen und die Anmeldung einzurichten.</string>
@@ -715,6 +736,9 @@
    <string name="chat_settings_recent_prompt_chips_desc">Letzte Nachrichten als antippbare Chips über dem Eingabefeld anzeigen, um sie erneut zu senden. Standardmäßig aus.</string>
    <string name="chat_settings_keep_keyboard_open">Tastatur nach dem Senden geöffnet lassen</string>
    <string name="chat_settings_keep_keyboard_open_desc">Nach dem Senden im Eingabefeld bleiben. Ausschalten, um die Tastatur nach jeder gesendeten Nachricht zu schließen.</string>
+    <string name="chat_settings_physical_keyboard_enter">Eingabetaste der physischen Tastatur</string>
+    <string name="chat_settings_physical_keyboard_enter_desc">Wähle, ob die Eingabetaste sendet oder eine neue Zeile einfügt. Strg+Eingabetaste sendet immer.</string>
+    <string name="chat_settings_insert_newline">Neue Zeile einfügen</string>
    <string name="chat_settings_notify_when_finishes">Chat-Benachrichtigungen im Hintergrund</string>
    <string name="chat_settings_notify_when_finishes_desc">Benachrichtigen, wenn Hermes Eingaben benötigt oder im Hintergrund fertig wird</string>
    <string name="chat_settings_share_phone_status">Smartphone-Status mit Agent teilen</string>
@@ -2266,8 +2290,10 @@
    <string name="conn_info_customize_identity">Identität anpassen</string>
    <string name="conn_info_agent_passport">Agentenpass</string>
    <string name="conn_info_chat_override">Chat-Überschreibung</string>
+    <string name="conn_info_chat_override_inherited_desc">Verwende die Genehmigungsrichtlinie des Profils für diesen Chat.</string>
    <string name="conn_info_fast_tier">Schnellstufe</string>
    <string name="conn_info_fast">Schnell</string>
+    <string name="conn_info_normal_tier_desc">Verwende die Standardverarbeitungsstufe.</string>
    <string name="conn_info_context">Kontext</string>
    <string name="conn_info_profile_already_bypasses">Genehmigungen werden bereits vom Profil umgangen.</string>
    <string name="conn_info_start_new_chat">Neuen Chat starten</string>
@@ -2534,6 +2560,23 @@
    <string name="image_generation_rendering">Bild wird erstellt</string>
    <string name="tool_progress_cd_collapse">Einklappen</string>
    <string name="tool_progress_cd_expand">Ausklappen</string>
+    <string name="tool_progress_state_expanded">Ausgeklappt</string>
+    <string name="tool_progress_state_collapsed">Eingeklappt</string>
+    <string name="tool_run_preparing">%1$s wird vorbereitet</string>
+    <string name="tool_run_running">%1$s wird ausgeführt</string>
+    <string name="tool_run_finished">%1$s abgeschlossen</string>
+    <plurals name="tool_run_reading"><item quantity="one">%d Element wird gelesen</item><item quantity="other">%d Elemente werden gelesen</item></plurals>
+    <plurals name="tool_run_read"><item quantity="one">%d Element gelesen</item><item quantity="other">%d Elemente gelesen</item></plurals>
+    <plurals name="tool_run_searching"><item quantity="one">%d Quelle wird durchsucht</item><item quantity="other">%d Quellen werden durchsucht</item></plurals>
+    <plurals name="tool_run_searched"><item quantity="one">%d Quelle durchsucht</item><item quantity="other">%d Quellen durchsucht</item></plurals>
+    <plurals name="tool_run_running_commands"><item quantity="one">%d Befehl wird ausgeführt</item><item quantity="other">%d Befehle werden ausgeführt</item></plurals>
+    <plurals name="tool_run_ran_commands"><item quantity="one">%d Befehl ausgeführt</item><item quantity="other">%d Befehle ausgeführt</item></plurals>
+    <plurals name="tool_run_browsing"><item quantity="one">%d Browseraktion wird ausgeführt</item><item quantity="other">%d Browseraktionen werden ausgeführt</item></plurals>
+    <plurals name="tool_run_browsed"><item quantity="one">%d Browseraktion ausgeführt</item><item quantity="other">%d Browseraktionen ausgeführt</item></plurals>
+    <plurals name="tool_run_using_device"><item quantity="one">%d Geräteaktion wird ausgeführt</item><item quantity="other">%d Geräteaktionen werden ausgeführt</item></plurals>
+    <plurals name="tool_run_used_device"><item quantity="one">%d Geräteaktion ausgeführt</item><item quantity="other">%d Geräteaktionen ausgeführt</item></plurals>
+    <plurals name="tool_run_using_tools"><item quantity="one">%d Werkzeug wird verwendet</item><item quantity="other">%d Werkzeuge werden verwendet</item></plurals>
+    <plurals name="tool_run_used_tools"><item quantity="one">%d Werkzeug verwendet</item><item quantity="other">%d Werkzeuge verwendet</item></plurals>

    <!-- AgentIconRow -->
    <string name="agent_icon_title">Agentensymbol</string>
@@ -2663,6 +2706,8 @@
    <string name="qr_scanner_title">Hermes-QR-Code scannen</string>
    <string name="qr_scanner_instruction">Hermes-Einrichtungs-QR-Code scannen</string>
    <string name="qr_scanner_subtext">Scanne einen Hermes-Einrichtungs- oder Relay-Kopplungs-QR-Code. Standard-Dashboard-Verbindungen benötigen keinen API-Schlüssel.</string>
+    <string name="qr_scanner_ready">Bereit zum Scannen</string>
+    <string name="qr_scanner_found">Hermes-Einrichtungs-QR-Code gefunden</string>
    <string name="qr_scanner_relay_title">Relay-QR scannen</string>
    <string name="qr_scanner_relay_instruction">Einen Relay-Kopplungs-QR-Code scannen</string>
    <string name="qr_scanner_relay_subtext">Öffne den Relay-Kopplungs-QR-Code auf deinem Hermes-Server. Deine bestehende Dashboard-Verbindung und Routen bleiben unverändert.</string>
@@ -3418,6 +3463,7 @@
    <string name="dashboard_native_signin_cancelled">Browser-Anmeldung abgebrochen.</string>
    <string name="dashboard_native_signin_requires_https">Die sichere Browser-Anmeldung erfordert eine HTTPS-Dashboard-Adresse.</string>
    <string name="dashboard_native_signin_unavailable">Die sichere Browser-Anmeldung ist für diese Verbindung nicht verfügbar. Aktualisiere die Verbindung und versuche es erneut.</string>
+    <string name="dashboard_native_signin_transport_retry">Die sichere Verbindung wurde unterbrochen. Tippe auf die Anmeldeschaltfläche, um es erneut zu versuchen.</string>
    <string name="conn_info_yolo_mode_desc_ephemeral">Umgehe Bestätigungsabfragen nur für diesen Chat. Wird beim Sitzungswechsel zurückgesetzt.</string>
    <string name="conn_info_yolo_mode_profile_off">Profilbestätigungen sind deaktiviert, daher umgeht dieser Chat bereits Abfragen. Wähle Manuell oder Smart, bevor du die chatbezogene Ausnahme verwendest.</string>
    <string name="conn_info_approval_mode_title">Profil-Bestätigungsmodus</string>
@@ -3612,6 +3658,7 @@
    <string name="tool_name_android">Telefonaktion</string>
    <string name="timeline_no_checks">keine Prüfungen</string>
    <string name="thinking_title">Denkprozess</string>
+    <string name="thinking_settled">Gedanke</string>
    <string name="thinking_thinking_short">Denkt nach</string>
    <string name="thinking_thinking">Denkt nach…</string>
    <string name="task_status_working">In Arbeit</string>
@@ -3742,6 +3789,7 @@
    <string name="voice_overlay_attachment_ready">Anhang bereit</string>
    <string name="conn_info_active_profile">Aktives Profil</string>
    <string name="msg_bubble_speak_response">Antwort vorlesen</string>
+    <string name="msg_bubble_stop_speaking">Wiedergabe stoppen</string>
    <string name="voice_overlay_engine_standard">Standardmodus</string>
    <string name="voice_overlay_caption_hermes">Hermes</string>
    <string name="voice_overlay_open_hermes">Hermes öffnen</string>
@@ -3860,4 +3908,81 @@
    <string name="support_bundle_copied">Supportinformationen kopiert</string>
    <string name="support_bundle_no_share">Supportinformationen kopiert — keine App zum Teilen gefunden</string>
    <string name="support_bundle_share_title">Hermes-Relay-Supportinformationen teilen</string>
+    <string name="chat_search_conversation">Unterhaltung durchsuchen</string>
+    <string name="chat_search_close">Suche schließen</string>
+    <string name="chat_search_no_results">Keine Ergebnisse</string>
+    <string name="chat_search_result_count">%1$d von %2$d</string>
+    <string name="msg_bubble_queued">In Warteschlange</string>
+    <string name="msg_bubble_steered">Korrektur gesendet</string>
+    <string name="chat_quote_you">Du</string>
+    <string name="chat_quote_hermes">Hermes</string>
+    <string name="chat_quote_open">Ursprüngliche Nachricht von %1$s öffnen</string>
+    <string name="chat_quote_remove">Zitat entfernen</string>
+    <string name="profile_shelf_switch_agent">Agent wechseln</string>
+    <string name="profile_shelf_all_profiles">Alle Agentenprofile öffnen</string>
+    <string name="profile_shelf_open_passport">Agentenpass öffnen</string>
+    <string name="profile_shelf_switch_to">Zu diesem Agenten wechseln</string>
+    <string name="profile_shelf_locked_hint">Der Profilwechsel ist gesperrt. Halten Sie den aktiven Agenten gedrückt, um die Sperre aufzuheben.</string>
+    <string name="profile_shelf_inspect">Profil prüfen</string>
+    <string name="profile_shelf_hide">Aus der Profilablage ausblenden</string>
+    <string name="profile_shelf_expand">Profilablage erweitern</string>
+    <string name="profile_shelf_collapse">Profilablage einklappen</string>
+    <string name="appearance_intro">Wählen Sie eine Vorlage und sehen Sie sie direkt in der Vorschau.</string>
+    <string name="appearance_preset_gallery">Vorlagengalerie</string>
+    <string name="appearance_preview_relay">Vorschau · Relay</string>
+    <string name="appearance_preview_user_message">Gib mir drei kurze Tipps für einen konzentrierten Morgen.</string>
+    <string name="appearance_preview_agent">Hermes</string>
+    <string name="appearance_preview_agent_message">1. Wähle einen echten Erfolg, bevor du Feeds prüfst.\n2. Blockiere die ersten 45–90 Minuten.\n3. Beginne mit einem Einrichtungsritual statt mit „Motivation“.</string>
+    <string name="appearance_preview_time">19:00</string>
+    <string name="appearance_preview_voice">Sprache</string>
+    <string name="appearance_preview_tool_meta">tool_executor  ·  206 Token  ·  137,2K</string>
+    <string name="appearance_preview_message_placeholder">Nachricht…</string>
+    <string name="appearance_preview_gateway">Gateway   ·   LAN   ·   gpt-5.5 / Profil: Standard</string>
+    <string name="appearance_preview_live_note">Diese Vorschau wird sofort mit Vorlage, Modus, Schrift und Sphere-Skin aktualisiert.</string>
+    <string name="appearance_customize_theme">%1$s anpassen</string>
+    <string name="appearance_accent_preset">Voreingestellte Akzentfarbe</string>
+    <string name="appearance_accent_custom">Eigene Akzentfarbe angewendet</string>
+    <string name="appearance_accent_preview_only">Änderungen bleiben in der Vorschau, bis Sie sie anwenden.</string>
+    <string name="appearance_accent_preview_only_short">Nur Vorschau</string>
+    <string name="appearance_apply_changes">Änderungen anwenden</string>
+    <string name="appearance_customize_summary">Akzent, Flächen, Form &amp; Dichte</string>
+    <string name="appearance_shape">Form</string>
+    <string name="appearance_shape_soft">Weich</string>
+    <string name="appearance_shape_balanced">Ausgewogen</string>
+    <string name="appearance_shape_sharp">Kantig</string>
+    <string name="appearance_contrast_passes">Kontrast ausreichend</string>
+    <string name="appearance_contrast_fails">Kontrast muss verbessert werden</string>
+    <string name="appearance_contrast_aa">AA für normalen Text</string>
+    <string name="appearance_typography_density">Typografie &amp; Dichte</string>
+    <string name="appearance_readability">Lesbarkeit</string>
+    <string name="appearance_default">Standard</string>
+    <string name="appearance_font_normal_summary">Schriftgröße: Normal</string>
+    <string name="appearance_reset_draft">Entwurf zurücksetzen</string>
+    <string name="appearance_accent">Akzentfarbe</string>
+    <string name="appearance_contrast_status">Lesbarer Kontrast · %1$.1f:1</string>
+    <string name="appearance_typography_density_summary">Typografie und Dichte verwenden die gezielten Einstellungen für Schrift und Schriftgröße unten.</string>
+    <string name="appearance_readability_summary">Passen Sie hier die Textdichte an; wählen Sie die Schriftart im Abschnitt „Schrift“ unten.</string>
+    <string name="appearance_reset">Zurücksetzen</string>
+    <string name="appearance_apply">Anwenden</string>
+    <string name="appearance_background_installed">Installierte Animationen</string>
+    <string name="appearance_import_background">Hintergrundanimation importieren</string>
+    <string name="appearance_import_background_desc">Importiert dasselbe sichere Relay-Pet-ZIP- oder Einzelbildformat, verwendet es aber nur für die zentrale Hintergrunddarstellung. Roaming wird nicht aktiviert und das schwebende Pet nicht geändert.</string>
+    <string name="appearance_import_sphere">Sphere-Skin importieren</string>
+    <string name="appearance_create_pet">Eigenes Pet erstellen</string>
+    <string name="pet_creator_title">Eigenes Pet erstellen</string>
+    <string name="pet_creator_intro">Beschreiben Sie Ihren Begleiter, prüfen Sie die erzeugten Anweisungen und wählen Sie dann, wo Sie ihn erstellen. Es wird nichts gesendet, bis Sie den neuen Chat selbst absenden.</string>
+    <string name="pet_creator_step_idea">Idee auswählen</string>
+    <string name="pet_creator_name">Pet-Name</string>
+    <string name="pet_creator_description">Charakterrichtung</string>
+    <string name="pet_creator_description_hint">Beschreiben Sie Charakter, Materialien, Farben, Stimmung und alle Referenzbilder, die Sie anhängen möchten.</string>
+    <string name="pet_creator_animated">Animiertes Paket</string>
+    <string name="pet_creator_static">Statisches Bild</string>
+    <string name="pet_creator_step_create">Prüfen und erstellen</string>
+    <string name="pet_creator_review_copy">Diese vollständigen Anweisungen enthalten das aktuelle Pet-Format sowie Validierungs-, Datenschutz- und Prüfgrenzen.</string>
+    <string name="pet_creator_copy">Kopieren</string>
+    <string name="pet_creator_copied">Anweisungen kopiert</string>
+    <string name="pet_creator_new_chat">Neuer Chat</string>
+    <string name="pet_creator_step_review">Prüfen und importieren</string>
+    <string name="pet_creator_review_desc">Prüfen Sie zuerst das zurückgegebene Bild oder ZIP. Beim Import werden die validierten Dateien in den App-Speicher kopiert; sie werden nicht veröffentlicht.</string>
+    <string name="pet_creator_import">Fertiges Pet importieren</string>
 </resources>
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="pending_attachment_preview_named">Vista previa de %1$s</string>
+    <string name="pending_attachment_remove">Quitar %1$s</string>
+    <string name="pending_attachment_move_left">Mover %1$s a la izquierda</string>
+    <string name="pending_attachment_move_right">Mover %1$s a la derecha</string>
+    <string name="pending_attachment_status_loading">Preparando vista previa</string>
+    <string name="pending_attachment_status_ready">Listo</string>
+    <string name="pending_attachment_status_failed">Vista previa no disponible</string>
+</resources>
@@ -255,6 +255,27 @@
    <string name="error_classify_open_settings">Abrir configuración</string>
    <string name="cw_connect_to_hermes">Conéctese a Hermes</string>
    <string name="cw_nearby_description">Buscaremos Hermes en esta red. El panel y la puerta de enlace proporcionan la conexión estándar para Chat, Administrar y Voz.</string>
+    <string name="cw_connection_chooser_description">Elige la configuración que tengas. Hermes Relay es opcional.</string>
+    <string name="cw_scan_setup_qr_title">Escanear QR de configuración de Hermes</string>
+    <string name="cw_scan_setup_qr_subtitle">Configura rutas locales, remotas y de Relay disponibles</string>
+    <string name="cw_recommended">Recomendado</string>
+    <string name="cw_other_ways_to_connect">Otras formas de conectarse</string>
+    <string name="cw_advanced">Avanzado</string>
+    <string name="cw_cloud_title">Hermes alojado por Nous</string>
+    <string name="cw_cloud_subtitle">Conéctate a tu agente alojado</string>
+    <string name="cw_server_vps_title">Servidor o VPS</string>
+    <string name="cw_server_vps_subtitle">Introduce una dirección segura del panel</string>
+    <string name="cw_relay_optional_note">Chat, Administrar y Voz estándar funcionan sin Relay. Los QR de configuración compatibles añaden funciones avanzadas de Relay cuando están disponibles.</string>
+    <string name="cw_cloud_entry_title">Conectarse a Hermes alojado por Nous</string>
+    <string name="cw_cloud_entry_description">Introduce la dirección del agente que aparece en Nous Portal. Iniciarás sesión de forma segura después de encontrar Hermes.</string>
+    <string name="cw_cloud_agent_name">Dirección del agente</string>
+    <string name="cw_cloud_slug_placeholder">tu-agente</string>
+    <string name="cw_cloud_slug_hint">Nos conectaremos a tu-agente.agents.nousresearch.com.</string>
+    <string name="cw_cloud_slug_error">Introduce exactamente las letras, números y guiones anteriores a .agents.nousresearch.com.</string>
+    <string name="cw_cloud_address_placeholder">https://tu-agente.example.com</string>
+    <string name="cw_cloud_address_hint">Usa la dirección HTTPS completa que aparece para tu agente alojado.</string>
+    <string name="cw_cloud_use_custom_address">Usar URL personalizada</string>
+    <string name="cw_cloud_use_nous_address">Usar dirección alojada por Nous</string>
    <string name="cw_before_connecting">Antes de conectar</string>
    <string name="cw_connect_step_server_title">Inicia Hermes en tu ordenador</string>
    <string name="cw_connect_step_server_body">Inicia el panel en el ordenador con Hermes. Para el primer acceso por LAN, usa la guía inferior para hacerlo accesible desde el teléfono y habilitar el inicio de sesión.</string>
@@ -640,6 +661,9 @@
    <string name="chat_settings_recent_prompt_chips_desc">Muestre sus mensajes recientes como chips que se pueden tocar encima del redactor para enviarlos nuevamente. Desactivado de forma predeterminada.</string>
    <string name="chat_settings_keep_keyboard_open">Mantener el teclado abierto al enviar</string>
    <string name="chat_settings_keep_keyboard_open_desc">Permanece en el compositor después del envío. Desactívelo para descartar el teclado después de cada mensaje enviado.</string>
+    <string name="chat_settings_physical_keyboard_enter">Tecla Intro del teclado físico</string>
+    <string name="chat_settings_physical_keyboard_enter_desc">Elige si Intro envía o inserta una línea nueva. Ctrl+Intro siempre envía.</string>
+    <string name="chat_settings_insert_newline">Insertar línea nueva</string>
    <string name="chat_settings_notify_when_finishes">Alertas de chat en segundo plano</string>
    <string name="chat_settings_notify_when_finishes_desc">Notificar cuando Hermes necesite información o termine en segundo plano</string>
    <string name="chat_settings_share_phone_status">Compartir el estado del teléfono con el agente</string>
@@ -2071,8 +2095,10 @@
    <string name="conn_info_customize_identity">Personalizar identidad</string>
    <string name="conn_info_agent_passport">Pasaporte del agente</string>
    <string name="conn_info_chat_override">Anulación del chat</string>
+    <string name="conn_info_chat_override_inherited_desc">Usa la política de aprobación del perfil para este chat.</string>
    <string name="conn_info_fast_tier">Nivel rápido</string>
    <string name="conn_info_fast">Rápido</string>
+    <string name="conn_info_normal_tier_desc">Usa el nivel de procesamiento estándar.</string>
    <string name="conn_info_context">Contexto</string>
    <string name="conn_info_profile_already_bypasses">El perfil ya omite las aprobaciones.</string>
    <string name="conn_info_start_new_chat">Iniciar nuevo chat</string>
@@ -2307,6 +2333,23 @@
    <string name="image_generation_rendering">Generando imagen</string>
    <string name="tool_progress_cd_collapse">Colapsar</string>
    <string name="tool_progress_cd_expand">Expandir</string>
+    <string name="tool_progress_state_expanded">Expandido</string>
+    <string name="tool_progress_state_collapsed">Contraído</string>
+    <string name="tool_run_preparing">Preparando %1$s</string>
+    <string name="tool_run_running">Ejecutando %1$s</string>
+    <string name="tool_run_finished">%1$s finalizado</string>
+    <plurals name="tool_run_reading"><item quantity="one">Leyendo %d elemento</item><item quantity="other">Leyendo %d elementos</item></plurals>
+    <plurals name="tool_run_read"><item quantity="one">Se leyó %d elemento</item><item quantity="other">Se leyeron %d elementos</item></plurals>
+    <plurals name="tool_run_searching"><item quantity="one">Buscando en %d fuente</item><item quantity="other">Buscando en %d fuentes</item></plurals>
+    <plurals name="tool_run_searched"><item quantity="one">Se buscó en %d fuente</item><item quantity="other">Se buscó en %d fuentes</item></plurals>
+    <plurals name="tool_run_running_commands"><item quantity="one">Ejecutando %d comando</item><item quantity="other">Ejecutando %d comandos</item></plurals>
+    <plurals name="tool_run_ran_commands"><item quantity="one">Se ejecutó %d comando</item><item quantity="other">Se ejecutaron %d comandos</item></plurals>
+    <plurals name="tool_run_browsing"><item quantity="one">Ejecutando %d acción del navegador</item><item quantity="other">Ejecutando %d acciones del navegador</item></plurals>
+    <plurals name="tool_run_browsed"><item quantity="one">Se ejecutó %d acción del navegador</item><item quantity="other">Se ejecutaron %d acciones del navegador</item></plurals>
+    <plurals name="tool_run_using_device"><item quantity="one">Ejecutando %d acción del dispositivo</item><item quantity="other">Ejecutando %d acciones del dispositivo</item></plurals>
+    <plurals name="tool_run_used_device"><item quantity="one">Se ejecutó %d acción del dispositivo</item><item quantity="other">Se ejecutaron %d acciones del dispositivo</item></plurals>
+    <plurals name="tool_run_using_tools"><item quantity="one">Usando %d herramienta</item><item quantity="other">Usando %d herramientas</item></plurals>
+    <plurals name="tool_run_used_tools"><item quantity="one">Se usó %d herramienta</item><item quantity="other">Se usaron %d herramientas</item></plurals>
    <string name="agent_icon_title">Icono de agente</string>
    <string name="agent_icon_set">Elegir archivo</string>
    <string name="agent_icon_change">Elegir archivo</string>
@@ -2414,6 +2457,8 @@
    <string name="qr_scanner_title">Escanear Hermes QR</string>
    <string name="qr_scanner_instruction">Escanear una configuración Hermes QR</string>
    <string name="qr_scanner_subtext">Escanee un QR de configuración de Hermes o de vinculación con Relay. Las conexiones estándar mediante Dashboard no necesitan una clave API.</string>
+    <string name="qr_scanner_ready">Listo para escanear</string>
+    <string name="qr_scanner_found">QR de configuración de Hermes encontrado</string>
    <string name="qr_scanner_relay_title">Escanear QR de Relay</string>
    <string name="qr_scanner_relay_instruction">Escanee un QR de vinculación con Relay</string>
    <string name="qr_scanner_relay_subtext">Abra el QR de vinculación con Relay en su servidor Hermes. La conexión de Dashboard y las rutas existentes no cambiarán.</string>
@@ -3103,6 +3148,7 @@
    <string name="dashboard_native_signin_cancelled">Inicio de sesión en el navegador cancelado.</string>
    <string name="dashboard_native_signin_requires_https">El inicio de sesión seguro en el navegador requiere una dirección HTTPS del panel.</string>
    <string name="dashboard_native_signin_unavailable">El inicio de sesión seguro en el navegador no está disponible para esta conexión. Actualiza la conexión e inténtalo de nuevo.</string>
+    <string name="dashboard_native_signin_transport_retry">Se interrumpió la conexión segura. Toca el botón de inicio de sesión para volver a intentarlo.</string>
    <string name="conn_info_yolo_mode_desc_ephemeral">Omite las solicitudes de aprobación solo para este chat. Se restablece al cambiar de sesión.</string>
    <string name="conn_info_yolo_mode_profile_off">Las aprobaciones del perfil están desactivadas, por lo que este chat ya omite las solicitudes. Elige Manual o Inteligente antes de usar la excepción por chat.</string>
    <string name="conn_info_approval_mode_title">Modo de aprobación del perfil</string>
@@ -3297,6 +3343,7 @@
    <string name="tool_name_android">Acción en el teléfono</string>
    <string name="timeline_no_checks">sin comprobaciones</string>
    <string name="thinking_title">Proceso de pensamiento</string>
+    <string name="thinking_settled">Pensamiento</string>
    <string name="thinking_thinking_short">Pensando</string>
    <string name="thinking_thinking">Pensando…</string>
    <string name="task_status_working">Trabajando</string>
@@ -3427,6 +3474,7 @@
    <string name="voice_overlay_attachment_ready">Adjunto listo</string>
    <string name="conn_info_active_profile">Perfil activo</string>
    <string name="msg_bubble_speak_response">Leer respuesta</string>
+    <string name="msg_bubble_stop_speaking">Detener lectura</string>
    <string name="voice_overlay_engine_standard">Modo estándar</string>
    <string name="voice_overlay_caption_hermes">Hermes</string>
    <string name="voice_overlay_open_hermes">Abrir Hermes</string>
@@ -3545,4 +3593,81 @@
    <string name="support_bundle_copied">Información de soporte copiada</string>
    <string name="support_bundle_no_share">Información de soporte copiada — no se encontró una aplicación para compartir</string>
    <string name="support_bundle_share_title">Compartir información de soporte de Hermes-Relay</string>
+    <string name="chat_search_conversation">Buscar en la conversación</string>
+    <string name="chat_search_close">Cerrar búsqueda</string>
+    <string name="chat_search_no_results">Sin resultados</string>
+    <string name="chat_search_result_count">%1$d de %2$d</string>
+    <string name="msg_bubble_queued">En cola</string>
+    <string name="msg_bubble_steered">Corrección enviada</string>
+    <string name="chat_quote_you">Tú</string>
+    <string name="chat_quote_hermes">Hermes</string>
+    <string name="chat_quote_open">Abrir mensaje original de %1$s</string>
+    <string name="chat_quote_remove">Quitar cita</string>
+    <string name="profile_shelf_switch_agent">Cambiar de agente</string>
+    <string name="profile_shelf_all_profiles">Abrir todos los perfiles de agente</string>
+    <string name="profile_shelf_open_passport">Abrir Pasaporte del agente</string>
+    <string name="profile_shelf_switch_to">Cambiar a este agente</string>
+    <string name="profile_shelf_locked_hint">El cambio de perfil está bloqueado. Mantén pulsado el agente activo para desbloquearlo.</string>
+    <string name="profile_shelf_inspect">Inspeccionar perfil</string>
+    <string name="profile_shelf_hide">Ocultar de la bandeja de perfiles</string>
+    <string name="profile_shelf_expand">Expandir la bandeja de perfiles</string>
+    <string name="profile_shelf_collapse">Contraer la bandeja de perfiles</string>
+    <string name="appearance_intro">Elige un ajuste predefinido y míralo al instante en la vista previa.</string>
+    <string name="appearance_preset_gallery">Galería de ajustes</string>
+    <string name="appearance_preview_relay">Vista previa · Relay</string>
+    <string name="appearance_preview_user_message">Dame tres consejos rápidos para una mañana productiva.</string>
+    <string name="appearance_preview_agent">Hermes</string>
+    <string name="appearance_preview_agent_message">1. Elige un logro real antes de revisar tus novedades.\n2. Reserva los primeros 45–90 minutos.\n3. Empieza con un ritual de preparación, no con «motivación».</string>
+    <string name="appearance_preview_time">19:00</string>
+    <string name="appearance_preview_voice">Voz</string>
+    <string name="appearance_preview_tool_meta">tool_executor  ·  206 tokens  ·  137,2K</string>
+    <string name="appearance_preview_message_placeholder">Mensaje…</string>
+    <string name="appearance_preview_gateway">Gateway   ·   LAN   ·   gpt-5.5 / perfil: predeterminado</string>
+    <string name="appearance_preview_live_note">Esta vista previa se actualiza al instante con el ajuste, modo, fuente y aspecto de Sphere.</string>
+    <string name="appearance_customize_theme">Personalizar %1$s</string>
+    <string name="appearance_accent_preset">Color de acento predefinido</string>
+    <string name="appearance_accent_custom">Color de acento personalizado aplicado</string>
+    <string name="appearance_accent_preview_only">Los cambios permanecen en la vista previa hasta que los apliques.</string>
+    <string name="appearance_accent_preview_only_short">Solo vista previa</string>
+    <string name="appearance_apply_changes">Aplicar cambios</string>
+    <string name="appearance_customize_summary">Acento, superficies, forma y densidad</string>
+    <string name="appearance_shape">Forma</string>
+    <string name="appearance_shape_soft">Suave</string>
+    <string name="appearance_shape_balanced">Equilibrada</string>
+    <string name="appearance_shape_sharp">Angular</string>
+    <string name="appearance_contrast_passes">El contraste es suficiente</string>
+    <string name="appearance_contrast_fails">El contraste necesita mejoras</string>
+    <string name="appearance_contrast_aa">AA para texto normal</string>
+    <string name="appearance_typography_density">Tipografía y densidad</string>
+    <string name="appearance_readability">Legibilidad</string>
+    <string name="appearance_default">Predeterminado</string>
+    <string name="appearance_font_normal_summary">Tamaño de fuente: Normal</string>
+    <string name="appearance_reset_draft">Restablecer borrador</string>
+    <string name="appearance_accent">Color de acento</string>
+    <string name="appearance_contrast_status">Contraste legible · %1$.1f:1</string>
+    <string name="appearance_typography_density_summary">La tipografía y la densidad usan los controles específicos de Fuente y Tamaño de fuente de abajo.</string>
+    <string name="appearance_readability_summary">Ajusta aquí la densidad del texto; elige la tipografía en la sección Fuente de abajo.</string>
+    <string name="appearance_reset">Restablecer</string>
+    <string name="appearance_apply">Aplicar</string>
+    <string name="appearance_background_installed">Animaciones instaladas</string>
+    <string name="appearance_import_background">Importar animación de fondo</string>
+    <string name="appearance_import_background_desc">Importa el mismo ZIP seguro de mascota de Relay o formato de imagen única, pero lo usa solo para la visualización central o de fondo. No activa el movimiento ni cambia tu mascota flotante.</string>
+    <string name="appearance_import_sphere">Importar aspecto de Sphere</string>
+    <string name="appearance_create_pet">Crear una mascota personalizada</string>
+    <string name="pet_creator_title">Crear una mascota personalizada</string>
+    <string name="pet_creator_intro">Describe a tu acompañante, revisa las instrucciones generadas y elige dónde crearlo. No se envía nada hasta que tú mismo envíes el nuevo chat.</string>
+    <string name="pet_creator_step_idea">Elegir la idea</string>
+    <string name="pet_creator_name">Nombre de la mascota</string>
+    <string name="pet_creator_description">Dirección del personaje</string>
+    <string name="pet_creator_description_hint">Describe el personaje, materiales, colores, ambiente y cualquier imagen de referencia que quieras adjuntar.</string>
+    <string name="pet_creator_animated">Paquete animado</string>
+    <string name="pet_creator_static">Imagen estática</string>
+    <string name="pet_creator_step_create">Revisar y crear</string>
+    <string name="pet_creator_review_copy">Estas instrucciones completas incluyen el formato actual de mascotas y los límites de validación, privacidad y revisión.</string>
+    <string name="pet_creator_copy">Copiar</string>
+    <string name="pet_creator_copied">Instrucciones copiadas</string>
+    <string name="pet_creator_new_chat">Nuevo chat</string>
+    <string name="pet_creator_step_review">Revisar e importar</string>
+    <string name="pet_creator_review_desc">Inspecciona primero la imagen o el ZIP recibido. Al importar se copian los archivos validados al almacenamiento de la aplicación; no se publican.</string>
+    <string name="pet_creator_import">Importar mascota terminada</string>
 </resources>
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="pending_attachment_preview_named">%1$sをプレビュー</string>
+    <string name="pending_attachment_remove">%1$sを削除</string>
+    <string name="pending_attachment_move_left">%1$sを左へ移動</string>
+    <string name="pending_attachment_move_right">%1$sを右へ移動</string>
+    <string name="pending_attachment_status_loading">プレビューを準備中</string>
+    <string name="pending_attachment_status_ready">準備完了</string>
+    <string name="pending_attachment_status_failed">プレビューできません</string>
+</resources>
@@ -293,6 +293,27 @@
    <!-- Connection wizard — Connect page essentials -->
    <string name="cw_connect_to_hermes">Hermes に接続します</string>
    <string name="cw_nearby_description">このネットワーク上の Hermes を検索します。ダッシュボードとゲートウェイが、チャット、管理、音声の標準接続を提供します。</string>
+    <string name="cw_connection_chooser_description">利用するセットアップを選択してください。Hermes Relay は任意です。</string>
+    <string name="cw_scan_setup_qr_title">Hermes セットアップ QR をスキャン</string>
+    <string name="cw_scan_setup_qr_subtitle">ローカル、リモート、および利用可能な Relay ルートを設定します</string>
+    <string name="cw_recommended">推奨</string>
+    <string name="cw_other_ways_to_connect">その他の接続方法</string>
+    <string name="cw_advanced">詳細設定</string>
+    <string name="cw_cloud_title">Nous ホスト版 Hermes</string>
+    <string name="cw_cloud_subtitle">ホスト済みエージェントに接続します</string>
+    <string name="cw_server_vps_title">サーバーまたは VPS</string>
+    <string name="cw_server_vps_subtitle">安全な Dashboard アドレスを入力します</string>
+    <string name="cw_relay_optional_note">標準のチャット、管理、音声は Relay なしで動作します。互換性のあるセットアップ QR では、利用可能な場合に Relay の拡張機能も追加されます。</string>
+    <string name="cw_cloud_entry_title">Nous ホスト版 Hermes に接続</string>
+    <string name="cw_cloud_entry_description">Nous Portal に表示されるエージェントのアドレスを入力してください。Hermes が見つかった後、安全にサインインします。</string>
+    <string name="cw_cloud_agent_name">エージェントのアドレス</string>
+    <string name="cw_cloud_slug_placeholder">your-agent</string>
+    <string name="cw_cloud_slug_hint">your-agent.agents.nousresearch.com に接続します。</string>
+    <string name="cw_cloud_slug_error">.agents.nousresearch.com の前にある英字、数字、ハイフンを正確に入力してください。</string>
+    <string name="cw_cloud_address_placeholder">https://your-agent.example.com</string>
+    <string name="cw_cloud_address_hint">ホスト済みエージェントに表示される完全な HTTPS アドレスを使用してください。</string>
+    <string name="cw_cloud_use_custom_address">カスタム URL を使用</string>
+    <string name="cw_cloud_use_nous_address">Nous ホスト版アドレスを使用</string>
    <string name="cw_before_connecting">接続する前に</string>
    <string name="cw_connect_step_server_title">パソコンで Hermes を起動</string>
    <string name="cw_connect_step_server_body">Hermes のパソコンでダッシュボードを起動します。初めて LAN から接続する場合は、下のセットアップガイドでスマートフォンからアクセス可能にし、サインインを有効にしてください。</string>
@@ -715,6 +736,9 @@
    <string name="chat_settings_recent_prompt_chips_desc">最近のメッセージをコンポーザーの上にタップ可能なチップとして表示し、再送信します。デフォルトではオフです。</string>
    <string name="chat_settings_keep_keyboard_open">送信時にキーボードを開いたままにする</string>
    <string name="chat_settings_keep_keyboard_open_desc">送信後はコンポーザー内に留まります。メッセージを送信するたびにキーボードを閉じるには、オフにします。</string>
+    <string name="chat_settings_physical_keyboard_enter">物理キーボードの Enter キー</string>
+    <string name="chat_settings_physical_keyboard_enter_desc">Enter で送信するか改行するかを選択します。Ctrl+Enter は常に送信します。</string>
+    <string name="chat_settings_insert_newline">改行を挿入</string>
    <string name="chat_settings_notify_when_finishes">バックグラウンドのチャット通知</string>
    <string name="chat_settings_notify_when_finishes_desc">バックグラウンドで Hermes が入力を必要としたとき、または完了したときに通知します</string>
    <string name="chat_settings_share_phone_status">電話のステータスをエージェントと共有する</string>
@@ -2277,8 +2301,10 @@
    <string name="conn_info_customize_identity">アイデンティティをカスタマイズ</string>
    <string name="conn_info_agent_passport">エージェントパスポート</string>
    <string name="conn_info_chat_override">チャットの上書き</string>
+    <string name="conn_info_chat_override_inherited_desc">このチャットではプロフィールの承認ポリシーを使用します。</string>
    <string name="conn_info_fast_tier">高速ティア</string>
    <string name="conn_info_fast">高速</string>
+    <string name="conn_info_normal_tier_desc">標準の処理ティアを使用します。</string>
    <string name="conn_info_context">コンテキスト</string>
    <string name="conn_info_profile_already_bypasses">承認はプロファイルですでにバイパスされています。</string>
    <string name="conn_info_start_new_chat">新しいチャットを開始</string>
@@ -2545,6 +2571,23 @@
    <string name="image_generation_rendering">画像を生成中</string>
    <string name="tool_progress_cd_collapse">崩壊</string>
    <string name="tool_progress_cd_expand">拡大する</string>
+    <string name="tool_progress_state_expanded">展開済み</string>
+    <string name="tool_progress_state_collapsed">折りたたみ済み</string>
+    <string name="tool_run_preparing">%1$s を準備中</string>
+    <string name="tool_run_running">%1$s を実行中</string>
+    <string name="tool_run_finished">%1$s が完了</string>
+    <plurals name="tool_run_reading"><item quantity="other">%d 件を読み取り中</item></plurals>
+    <plurals name="tool_run_read"><item quantity="other">%d 件を読み取り</item></plurals>
+    <plurals name="tool_run_searching"><item quantity="other">%d 件のソースを検索中</item></plurals>
+    <plurals name="tool_run_searched"><item quantity="other">%d 件のソースを検索</item></plurals>
+    <plurals name="tool_run_running_commands"><item quantity="other">%d 件のコマンドを実行中</item></plurals>
+    <plurals name="tool_run_ran_commands"><item quantity="other">%d 件のコマンドを実行</item></plurals>
+    <plurals name="tool_run_browsing"><item quantity="other">%d 件のブラウザー操作を実行中</item></plurals>
+    <plurals name="tool_run_browsed"><item quantity="other">%d 件のブラウザー操作を実行</item></plurals>
+    <plurals name="tool_run_using_device"><item quantity="other">%d 件のデバイス操作を実行中</item></plurals>
+    <plurals name="tool_run_used_device"><item quantity="other">%d 件のデバイス操作を実行</item></plurals>
+    <plurals name="tool_run_using_tools"><item quantity="other">%d 個のツールを使用中</item></plurals>
+    <plurals name="tool_run_used_tools"><item quantity="other">%d 個のツールを使用</item></plurals>

    <!-- AgentIconRow -->
    <string name="agent_icon_title">エージェントアイコン</string>
@@ -2673,6 +2716,8 @@
    <string name="qr_scanner_title">Hermes QR をスキャン</string>
    <string name="qr_scanner_instruction">Hermes セットアップ QR をスキャンします</string>
    <string name="qr_scanner_subtext">Hermes セットアップ QR または Relay ペアリング QR をスキャンします。標準の Dashboard 接続に API キーは必要ありません。</string>
+    <string name="qr_scanner_ready">スキャン準備完了</string>
+    <string name="qr_scanner_found">Hermes セットアップ QR が見つかりました</string>
    <string name="qr_scanner_relay_title">Relay QR をスキャン</string>
    <string name="qr_scanner_relay_instruction">Relay ペアリング QR をスキャンします</string>
    <string name="qr_scanner_relay_subtext">Hermes サーバーで Relay ペアリング QR を開きます。既存の Dashboard 接続とルートは変更されません。</string>
@@ -3417,6 +3462,7 @@
    <string name="dashboard_native_signin_cancelled">ブラウザでのサインインをキャンセルしました。</string>
    <string name="dashboard_native_signin_requires_https">安全なブラウザサインインには、HTTPSのダッシュボードアドレスが必要です。</string>
    <string name="dashboard_native_signin_unavailable">この接続では安全なブラウザサインインを利用できません。接続を更新して、もう一度お試しください。</string>
+    <string name="dashboard_native_signin_transport_retry">安全な接続が中断されました。サインインボタンをタップして、もう一度お試しください。</string>
    <string name="conn_info_yolo_mode_desc_ephemeral">このチャットでのみ承認確認を省略します。セッションが変わるとリセットされます。</string>
    <string name="conn_info_yolo_mode_profile_off">プロフィールの承認がオフのため、このチャットではすでに確認を省略しています。チャット単位の例外を使う前に、手動またはスマートを選択してください。</string>
    <string name="conn_info_approval_mode_title">プロフィール承認モード</string>
@@ -3616,6 +3662,7 @@
    <string name="tool_name_android">電話アクション</string>
    <string name="timeline_no_checks">チェックなし</string>
    <string name="thinking_title">思考プロセス</string>
+    <string name="thinking_settled">思考</string>
    <string name="thinking_thinking_short">考え中</string>
    <string name="thinking_thinking">考え中…</string>
    <string name="task_status_working">作業中</string>
@@ -3741,6 +3788,7 @@
    <string name="voice_overlay_attachment_ready">添付ファイルの準備ができました</string>
    <string name="conn_info_active_profile">アクティブなプロフィール</string>
    <string name="msg_bubble_speak_response">応答を読み上げる</string>
+    <string name="msg_bubble_stop_speaking">読み上げを停止</string>
    <string name="voice_overlay_engine_standard">標準モード</string>
    <string name="voice_overlay_caption_hermes">Hermes</string>
    <string name="voice_overlay_open_hermes">Hermes を開く</string>
@@ -3859,4 +3907,81 @@
    <string name="support_bundle_copied">サポート情報をコピーしました</string>
    <string name="support_bundle_no_share">サポート情報をコピーしました — 共有できるアプリがありません</string>
    <string name="support_bundle_share_title">Hermes-Relay サポート情報を共有</string>
+    <string name="chat_search_conversation">会話を検索</string>
+    <string name="chat_search_close">検索を閉じる</string>
+    <string name="chat_search_no_results">結果なし</string>
+    <string name="chat_search_result_count">%1$d / %2$d</string>
+    <string name="msg_bubble_queued">キュー済み</string>
+    <string name="msg_bubble_steered">修正を送信しました</string>
+    <string name="chat_quote_you">あなた</string>
+    <string name="chat_quote_hermes">Hermes</string>
+    <string name="chat_quote_open">%1$s の元のメッセージを開く</string>
+    <string name="chat_quote_remove">引用を削除</string>
+    <string name="profile_shelf_switch_agent">エージェントを切り替え</string>
+    <string name="profile_shelf_all_profiles">すべてのエージェントプロフィールを開く</string>
+    <string name="profile_shelf_open_passport">エージェントパスポートを開く</string>
+    <string name="profile_shelf_switch_to">このエージェントに切り替え</string>
+    <string name="profile_shelf_locked_hint">プロフィールの切り替えはロックされています。解除するには、使用中のエージェントを長押ししてください。</string>
+    <string name="profile_shelf_inspect">プロフィールを確認</string>
+    <string name="profile_shelf_hide">プロフィールシェルフに表示しない</string>
+    <string name="profile_shelf_expand">プロフィールシェルフを展開</string>
+    <string name="profile_shelf_collapse">プロフィールシェルフを折りたたむ</string>
+    <string name="appearance_intro">プリセットを選ぶと、プレビューですぐに確認できます。</string>
+    <string name="appearance_preset_gallery">プリセットギャラリー</string>
+    <string name="appearance_preview_relay">プレビュー · Relay</string>
+    <string name="appearance_preview_user_message">集中できる朝のための簡単なヒントを3つ教えて。</string>
+    <string name="appearance_preview_agent">Hermes</string>
+    <string name="appearance_preview_agent_message">1. フィードを見る前に、確実に達成することを1つ決めます。\n2. 最初の45〜90分を確保します。\n3. 「やる気」ではなく準備の習慣から始めます。</string>
+    <string name="appearance_preview_time">19:00</string>
+    <string name="appearance_preview_voice">音声</string>
+    <string name="appearance_preview_tool_meta">tool_executor  ·  206トークン  ·  137.2K</string>
+    <string name="appearance_preview_message_placeholder">メッセージ…</string>
+    <string name="appearance_preview_gateway">Gateway   ·   LAN   ·   gpt-5.5 / プロファイル: デフォルト</string>
+    <string name="appearance_preview_live_note">このプレビューには、プリセット、モード、フォント、Sphereスキンの変更がすぐに反映されます。</string>
+    <string name="appearance_customize_theme">%1$sをカスタマイズ</string>
+    <string name="appearance_accent_preset">プリセットのアクセント</string>
+    <string name="appearance_accent_custom">カスタムアクセントを適用済み</string>
+    <string name="appearance_accent_preview_only">適用するまで変更はプレビュー内だけに反映されます。</string>
+    <string name="appearance_accent_preview_only_short">プレビューのみ</string>
+    <string name="appearance_apply_changes">変更を適用</string>
+    <string name="appearance_customize_summary">アクセント、サーフェス、形状、密度</string>
+    <string name="appearance_shape">形状</string>
+    <string name="appearance_shape_soft">ソフト</string>
+    <string name="appearance_shape_balanced">バランス</string>
+    <string name="appearance_shape_sharp">シャープ</string>
+    <string name="appearance_contrast_passes">コントラスト基準を満たしています</string>
+    <string name="appearance_contrast_fails">コントラストの改善が必要です</string>
+    <string name="appearance_contrast_aa">通常テキストのAA基準</string>
+    <string name="appearance_typography_density">文字と密度</string>
+    <string name="appearance_readability">読みやすさ</string>
+    <string name="appearance_default">デフォルト</string>
+    <string name="appearance_font_normal_summary">フォントサイズ: 標準</string>
+    <string name="appearance_reset_draft">下書きをリセット</string>
+    <string name="appearance_accent">アクセントカラー</string>
+    <string name="appearance_contrast_status">読みやすいコントラスト · %1$.1f:1</string>
+    <string name="appearance_typography_density_summary">文字と密度には、下にあるフォントとフォントサイズの専用設定が使用されます。</string>
+    <string name="appearance_readability_summary">ここで文字の密度を調整し、下のフォントセクションで書体を選択します。</string>
+    <string name="appearance_reset">リセット</string>
+    <string name="appearance_apply">適用</string>
+    <string name="appearance_background_installed">インストール済みアニメーション</string>
+    <string name="appearance_import_background">背景アニメーションをインポート</string>
+    <string name="appearance_import_background_desc">安全なRelayペットZIPまたは単一画像と同じ形式を読み込み、中央または背景の表示だけに使用します。移動は有効にならず、フローティングペットも変更されません。</string>
+    <string name="appearance_import_sphere">Sphereスキンをインポート</string>
+    <string name="appearance_create_pet">カスタムペットを作成</string>
+    <string name="pet_creator_title">カスタムペットを作成</string>
+    <string name="pet_creator_intro">コンパニオンを説明し、生成された手順を確認してから作成場所を選びます。新しいチャットを自分で送信するまで何も送られません。</string>
+    <string name="pet_creator_step_idea">アイデアを選ぶ</string>
+    <string name="pet_creator_name">ペットの名前</string>
+    <string name="pet_creator_description">キャラクターの方向性</string>
+    <string name="pet_creator_description_hint">キャラクター、素材、色、雰囲気、添付予定の参照画像について説明します。</string>
+    <string name="pet_creator_animated">アニメーションパック</string>
+    <string name="pet_creator_static">静止画像</string>
+    <string name="pet_creator_step_create">確認して作成</string>
+    <string name="pet_creator_review_copy">この完全な手順には、現在のペット形式、検証、プライバシー、確認の境界が含まれています。</string>
+    <string name="pet_creator_copy">コピー</string>
+    <string name="pet_creator_copied">手順をコピーしました</string>
+    <string name="pet_creator_new_chat">新しいチャット</string>
+    <string name="pet_creator_step_review">確認してインポート</string>
+    <string name="pet_creator_review_desc">返された画像またはZIPを最初に確認してください。インポートすると検証済みファイルがアプリ専用ストレージにコピーされますが、公開はされません。</string>
+    <string name="pet_creator_import">完成したペットをインポート</string>
 </resources>
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="pending_attachment_preview_named">Предпросмотр: %1$s</string>
+    <string name="pending_attachment_remove">Удалить %1$s</string>
+    <string name="pending_attachment_move_left">Переместить %1$s влево</string>
+    <string name="pending_attachment_move_right">Переместить %1$s вправо</string>
+    <string name="pending_attachment_status_loading">Подготовка предпросмотра</string>
+    <string name="pending_attachment_status_ready">Готово</string>
+    <string name="pending_attachment_status_failed">Предпросмотр недоступен</string>
+</resources>
@@ -276,6 +276,27 @@
    <string name="error_classify_open_settings">Открыть настройки</string>
    <string name="cw_connect_to_hermes">Подключение к Гермесу</string>
    <string name="cw_nearby_description">Мы будем искать Гермеса в этой сети. Панель управления и шлюз обеспечивают стандартное подключение для чата, управления и голоса.</string>
+    <string name="cw_connection_chooser_description">Выберите доступный способ настройки. Hermes Relay необязателен.</string>
+    <string name="cw_scan_setup_qr_title">Сканировать QR-код настройки Hermes</string>
+    <string name="cw_scan_setup_qr_subtitle">Настройте локальные, удалённые и доступные маршруты Relay</string>
+    <string name="cw_recommended">Рекомендуется</string>
+    <string name="cw_other_ways_to_connect">Другие способы подключения</string>
+    <string name="cw_advanced">Расширенные настройки</string>
+    <string name="cw_cloud_title">Hermes на хостинге Nous</string>
+    <string name="cw_cloud_subtitle">Подключитесь к своему размещённому агенту</string>
+    <string name="cw_server_vps_title">Сервер или VPS</string>
+    <string name="cw_server_vps_subtitle">Введите защищённый адрес Dashboard</string>
+    <string name="cw_relay_optional_note">Стандартные чат, управление и голос работают без Relay. Совместимые QR-коды настройки добавляют расширенные функции Relay, когда они доступны.</string>
+    <string name="cw_cloud_entry_title">Подключиться к Hermes на хостинге Nous</string>
+    <string name="cw_cloud_entry_description">Введите адрес агента, указанный в Nous Portal. После обнаружения Hermes вы безопасно войдёте в систему.</string>
+    <string name="cw_cloud_agent_name">Адрес агента</string>
+    <string name="cw_cloud_slug_placeholder">ваш-агент</string>
+    <string name="cw_cloud_slug_hint">Будет выполнено подключение к ваш-агент.agents.nousresearch.com.</string>
+    <string name="cw_cloud_slug_error">Точно введите буквы, цифры и дефисы перед .agents.nousresearch.com.</string>
+    <string name="cw_cloud_address_placeholder">https://your-agent.example.com</string>
+    <string name="cw_cloud_address_hint">Используйте полный HTTPS-адрес, указанный для вашего размещённого агента.</string>
+    <string name="cw_cloud_use_custom_address">Использовать собственный URL</string>
+    <string name="cw_cloud_use_nous_address">Использовать адрес хостинга Nous</string>
    <string name="cw_before_connecting">Перед подключением</string>
    <string name="cw_connect_step_server_title">Запустите Гермеса на вашем компьютере</string>
    <string name="cw_connect_step_server_body">Запустите панель управления на компьютере с Гермесом. Для первого доступа к локальной сети используйте руководство по настройке ниже, чтобы сделать его доступным с телефона и включить вход.</string>
@@ -683,6 +704,9 @@
    <string name="chat_settings_recent_prompt_chips_desc">Показывать ваши недавние сообщения как нажимаемые чипы над композитором, чтобы отправить их снова. По умолчанию выключено.</string>
    <string name="chat_settings_keep_keyboard_open">Оставить клавиатуру открытой при отправке</string>
    <string name="chat_settings_keep_keyboard_open_desc">Оставаться в композиторе после отправки. Выключите, чтобы скрыть клавиатуру после каждого отправленного сообщения.</string>
+    <string name="chat_settings_physical_keyboard_enter">Клавиша Enter на физической клавиатуре</string>
+    <string name="chat_settings_physical_keyboard_enter_desc">Выберите, отправляет ли Enter сообщение или добавляет новую строку. Ctrl+Enter всегда отправляет.</string>
+    <string name="chat_settings_insert_newline">Вставить новую строку</string>
    <string name="chat_settings_notify_when_finishes">Уведомления о фоновом чате</string>
    <string name="chat_settings_notify_when_finishes_desc">Уведомлять, когда Гермес требует ввода или заканчивает работу, когда приложение находится в фоновом режиме</string>
    <string name="chat_settings_share_phone_status">Поделиться статусом телефона с агентом</string>
@@ -1797,6 +1821,7 @@
    <string name="dashboard_native_signin_cancelled">Вход в браузере отменен.</string>
    <string name="dashboard_native_signin_requires_https">Безопасный вход в браузере требует HTTPS-адреса панели управления.</string>
    <string name="dashboard_native_signin_unavailable">Безопасный вход в браузере недоступен для этого подключения. Обновите подключение и попробуйте снова.</string>
+    <string name="dashboard_native_signin_transport_retry">Защищённое соединение было прервано. Нажмите кнопку входа, чтобы повторить попытку.</string>
    <string name="dashboard_close_signin">Закрыть вход</string>
    <string name="dashboard_error_title">Панель управления недоступна</string>
    <string name="dashboard_error_target">Не удалось загрузить из %1$s</string>
@@ -2255,8 +2280,10 @@
    <string name="conn_info_customize_identity">Настроить идентичность</string>
    <string name="conn_info_agent_passport">Паспорт агента</string>
    <string name="conn_info_chat_override">Переопределение чата</string>
+    <string name="conn_info_chat_override_inherited_desc">Использовать политику подтверждений профиля для этого чата.</string>
    <string name="conn_info_fast_tier">Быстрый уровень</string>
    <string name="conn_info_fast">Быстрый</string>
+    <string name="conn_info_normal_tier_desc">Использовать стандартный уровень обработки.</string>
    <string name="conn_info_context">Контекст</string>
    <string name="conn_info_profile_already_bypasses">Утверждения уже пропущены профилем.</string>
    <string name="conn_info_start_new_chat">Начать новый чат</string>
@@ -2509,6 +2536,23 @@
    <string name="image_generation_rendering">Рендеринг изображения</string>
    <string name="tool_progress_cd_collapse">Свернуть</string>
    <string name="tool_progress_cd_expand">Развернуть</string>
+    <string name="tool_progress_state_expanded">Развернуто</string>
+    <string name="tool_progress_state_collapsed">Свернуто</string>
+    <string name="tool_run_preparing">Подготовка: %1$s</string>
+    <string name="tool_run_running">Выполняется: %1$s</string>
+    <string name="tool_run_finished">Завершено: %1$s</string>
+    <plurals name="tool_run_reading"><item quantity="one">Чтение %d элемента</item><item quantity="few">Чтение %d элементов</item><item quantity="many">Чтение %d элементов</item><item quantity="other">Чтение %d элементов</item></plurals>
+    <plurals name="tool_run_read"><item quantity="one">Прочитан %d элемент</item><item quantity="few">Прочитано %d элемента</item><item quantity="many">Прочитано %d элементов</item><item quantity="other">Прочитано %d элементов</item></plurals>
+    <plurals name="tool_run_searching"><item quantity="one">Поиск в %d источнике</item><item quantity="few">Поиск в %d источниках</item><item quantity="many">Поиск в %d источниках</item><item quantity="other">Поиск в %d источниках</item></plurals>
+    <plurals name="tool_run_searched"><item quantity="one">Выполнен поиск в %d источнике</item><item quantity="few">Выполнен поиск в %d источниках</item><item quantity="many">Выполнен поиск в %d источниках</item><item quantity="other">Выполнен поиск в %d источниках</item></plurals>
+    <plurals name="tool_run_running_commands"><item quantity="one">Выполняется %d команда</item><item quantity="few">Выполняется %d команды</item><item quantity="many">Выполняется %d команд</item><item quantity="other">Выполняется %d команд</item></plurals>
+    <plurals name="tool_run_ran_commands"><item quantity="one">Выполнена %d команда</item><item quantity="few">Выполнено %d команды</item><item quantity="many">Выполнено %d команд</item><item quantity="other">Выполнено %d команд</item></plurals>
+    <plurals name="tool_run_browsing"><item quantity="one">Выполняется %d действие браузера</item><item quantity="few">Выполняется %d действия браузера</item><item quantity="many">Выполняется %d действий браузера</item><item quantity="other">Выполняется %d действий браузера</item></plurals>
+    <plurals name="tool_run_browsed"><item quantity="one">Выполнено %d действие браузера</item><item quantity="few">Выполнено %d действия браузера</item><item quantity="many">Выполнено %d действий браузера</item><item quantity="other">Выполнено %d действий браузера</item></plurals>
+    <plurals name="tool_run_using_device"><item quantity="one">Выполняется %d действие устройства</item><item quantity="few">Выполняется %d действия устройства</item><item quantity="many">Выполняется %d действий устройства</item><item quantity="other">Выполняется %d действий устройства</item></plurals>
+    <plurals name="tool_run_used_device"><item quantity="one">Выполнено %d действие устройства</item><item quantity="few">Выполнено %d действия устройства</item><item quantity="many">Выполнено %d действий устройства</item><item quantity="other">Выполнено %d действий устройства</item></plurals>
+    <plurals name="tool_run_using_tools"><item quantity="one">Используется %d инструмент</item><item quantity="few">Используется %d инструмента</item><item quantity="many">Используется %d инструментов</item><item quantity="other">Используется %d инструментов</item></plurals>
+    <plurals name="tool_run_used_tools"><item quantity="one">Использован %d инструмент</item><item quantity="few">Использовано %d инструмента</item><item quantity="many">Использовано %d инструментов</item><item quantity="other">Использовано %d инструментов</item></plurals>
    <string name="agent_icon_title">Иконка агента</string>
    <string name="agent_icon_set">Выбрать файл</string>
    <string name="agent_icon_change">Выбрать файл</string>
@@ -2621,6 +2665,8 @@
    <string name="qr_scanner_title">Сканировать QR-код Гермеса</string>
    <string name="qr_scanner_instruction">Сканируйте QR-код настройки Гермеса</string>
    <string name="qr_scanner_subtext">Сканируйте QR-код настройки Гермеса или пары Relay. Стандартные подключения к панели управления не требуют API-ключа.</string>
+    <string name="qr_scanner_ready">Готово к сканированию</string>
+    <string name="qr_scanner_found">QR-код настройки Hermes найден</string>
    <string name="qr_scanner_relay_title">Сканируйте QR-код Relay</string>
    <string name="qr_scanner_relay_instruction">Сканируйте QR-код пары Relay</string>
    <string name="qr_scanner_relay_subtext">Откройте QR-код пары Relay на вашем сервере Гермеса. Ваши существующие подключения к панели управления и маршруты останутся без изменений.</string>
@@ -3237,6 +3283,7 @@
    </plurals>
    <string name="tool_preparing">Подготовка инструмента…</string>
    <string name="thinking_title">Ход мыслей</string>
+    <string name="thinking_settled">Мысль</string>
    <string name="thinking_thinking">Обдумывает...</string>
    <string name="thinking_thinking_short">Обдумывает</string>
    <string name="task_background_prefix">Фоновая задача, </string>
@@ -3465,6 +3512,7 @@
    <string name="voice_overlay_attachment_ready">Вложение готово</string>
    <string name="conn_info_active_profile">Активный профиль</string>
    <string name="msg_bubble_speak_response">Озвучить ответ</string>
+    <string name="msg_bubble_stop_speaking">Остановить озвучивание</string>
    <string name="voice_overlay_engine_standard">Стандартный режим</string>
    <string name="voice_overlay_caption_hermes">Hermes</string>
    <string name="voice_overlay_open_hermes">Открыть Hermes</string>
@@ -3581,4 +3629,81 @@
    <string name="support_bundle_copied">Сведения для поддержки скопированы</string>
    <string name="support_bundle_no_share">Сведения для поддержки скопированы — приложение для отправки не найдено</string>
    <string name="support_bundle_share_title">Поделиться сведениями поддержки Hermes-Relay</string>
+    <string name="chat_search_conversation">Поиск по беседе</string>
+    <string name="chat_search_close">Закрыть поиск</string>
+    <string name="chat_search_no_results">Ничего не найдено</string>
+    <string name="chat_search_result_count">%1$d из %2$d</string>
+    <string name="msg_bubble_queued">В очереди</string>
+    <string name="msg_bubble_steered">Исправление отправлено</string>
+    <string name="chat_quote_you">Вы</string>
+    <string name="chat_quote_hermes">Hermes</string>
+    <string name="chat_quote_open">Открыть исходное сообщение от %1$s</string>
+    <string name="chat_quote_remove">Убрать цитату</string>
+    <string name="profile_shelf_switch_agent">Сменить агента</string>
+    <string name="profile_shelf_all_profiles">Открыть все профили агентов</string>
+    <string name="profile_shelf_open_passport">Открыть паспорт агента</string>
+    <string name="profile_shelf_switch_to">Переключиться на этого агента</string>
+    <string name="profile_shelf_locked_hint">Переключение профилей заблокировано. Нажмите и удерживайте активного агента, чтобы снять блокировку.</string>
+    <string name="profile_shelf_inspect">Просмотреть профиль</string>
+    <string name="profile_shelf_hide">Скрыть с полки профилей</string>
+    <string name="profile_shelf_expand">Развернуть полку профилей</string>
+    <string name="profile_shelf_collapse">Свернуть полку профилей</string>
+    <string name="appearance_intro">Выберите шаблон и сразу посмотрите результат.</string>
+    <string name="appearance_preset_gallery">Галерея шаблонов</string>
+    <string name="appearance_preview_relay">Предпросмотр · Relay</string>
+    <string name="appearance_preview_user_message">Дай три коротких совета для продуктивного утра.</string>
+    <string name="appearance_preview_agent">Hermes</string>
+    <string name="appearance_preview_agent_message">1. Выберите одну реальную цель до просмотра ленты.\n2. Выделите первые 45–90 минут.\n3. Начните с ритуала подготовки, а не с «мотивации».</string>
+    <string name="appearance_preview_time">19:00</string>
+    <string name="appearance_preview_voice">Голос</string>
+    <string name="appearance_preview_tool_meta">tool_executor  ·  206 токенов  ·  137,2 тыс.</string>
+    <string name="appearance_preview_message_placeholder">Сообщение…</string>
+    <string name="appearance_preview_gateway">Gateway   ·   LAN   ·   gpt-5.5 / профиль: по умолчанию</string>
+    <string name="appearance_preview_live_note">Предпросмотр сразу обновляется при изменении шаблона, режима, шрифта и оформления Sphere.</string>
+    <string name="appearance_customize_theme">Настроить %1$s</string>
+    <string name="appearance_accent_preset">Предустановленный акцент</string>
+    <string name="appearance_accent_custom">Пользовательский акцент применён</string>
+    <string name="appearance_accent_preview_only">Изменения остаются в предпросмотре, пока вы их не примените.</string>
+    <string name="appearance_accent_preview_only_short">Только предпросмотр</string>
+    <string name="appearance_apply_changes">Применить изменения</string>
+    <string name="appearance_customize_summary">Акцент, поверхности, форма и плотность</string>
+    <string name="appearance_shape">Форма</string>
+    <string name="appearance_shape_soft">Мягкая</string>
+    <string name="appearance_shape_balanced">Сбалансированная</string>
+    <string name="appearance_shape_sharp">Угловатая</string>
+    <string name="appearance_contrast_passes">Контраст достаточный</string>
+    <string name="appearance_contrast_fails">Контраст нужно улучшить</string>
+    <string name="appearance_contrast_aa">AA для обычного текста</string>
+    <string name="appearance_typography_density">Типографика и плотность</string>
+    <string name="appearance_readability">Читаемость</string>
+    <string name="appearance_default">По умолчанию</string>
+    <string name="appearance_font_normal_summary">Размер шрифта: обычный</string>
+    <string name="appearance_reset_draft">Сбросить черновик</string>
+    <string name="appearance_accent">Цвет акцента</string>
+    <string name="appearance_contrast_status">Читаемый контраст · %1$.1f:1</string>
+    <string name="appearance_typography_density_summary">Типографика и плотность используют отдельные настройки шрифта и его размера ниже.</string>
+    <string name="appearance_readability_summary">Настройте здесь плотность текста, а гарнитуру выберите в разделе «Шрифт» ниже.</string>
+    <string name="appearance_reset">Сбросить</string>
+    <string name="appearance_apply">Применить</string>
+    <string name="appearance_background_installed">Установленные анимации</string>
+    <string name="appearance_import_background">Импортировать фоновую анимацию</string>
+    <string name="appearance_import_background_desc">Импортирует тот же безопасный ZIP питомца Relay или одно изображение, но использует его только для центральной или фоновой визуализации. Это не включает перемещение и не меняет плавающего питомца.</string>
+    <string name="appearance_import_sphere">Импортировать оформление Sphere</string>
+    <string name="appearance_create_pet">Создать своего питомца</string>
+    <string name="pet_creator_title">Создать своего питомца</string>
+    <string name="pet_creator_intro">Опишите спутника, проверьте созданные инструкции и выберите, где его создать. Ничего не отправляется, пока вы сами не отправите новый чат.</string>
+    <string name="pet_creator_step_idea">Выбрать идею</string>
+    <string name="pet_creator_name">Имя питомца</string>
+    <string name="pet_creator_description">Образ персонажа</string>
+    <string name="pet_creator_description_hint">Опишите персонажа, материалы, цвета, настроение и изображения-образцы, которые планируете прикрепить.</string>
+    <string name="pet_creator_animated">Анимированный пакет</string>
+    <string name="pet_creator_static">Статичное изображение</string>
+    <string name="pet_creator_step_create">Проверить и создать</string>
+    <string name="pet_creator_review_copy">Эти полные инструкции включают текущий формат питомца, проверку, конфиденциальность и границы проверки.</string>
+    <string name="pet_creator_copy">Копировать</string>
+    <string name="pet_creator_copied">Инструкции скопированы</string>
+    <string name="pet_creator_new_chat">Новый чат</string>
+    <string name="pet_creator_step_review">Проверить и импортировать</string>
+    <string name="pet_creator_review_desc">Сначала проверьте полученное изображение или ZIP. При импорте проверенные файлы копируются в хранилище приложения и не публикуются.</string>
+    <string name="pet_creator_import">Импортировать готового питомца</string>
 </resources>
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="pending_attachment_preview_named">Preview %1$s</string>
+    <string name="pending_attachment_remove">Remove %1$s</string>
+    <string name="pending_attachment_move_left">Move %1$s left</string>
+    <string name="pending_attachment_move_right">Move %1$s right</string>
+    <string name="pending_attachment_status_loading">Preparing preview</string>
+    <string name="pending_attachment_status_ready">Ready</string>
+    <string name="pending_attachment_status_failed">Preview unavailable</string>
+</resources>
@@ -133,6 +133,10 @@

    <!-- Chat screen UI chrome -->
    <string name="chat_share_conversation">Share conversation</string>
+    <string name="chat_search_conversation">Search conversation</string>
+    <string name="chat_search_close">Close search</string>
+    <string name="chat_search_no_results">No results</string>
+    <string name="chat_search_result_count">%1$d of %2$d</string>
    <string name="chat_retry">Retry</string>
    <string name="chat_dismiss">Dismiss</string>
    <string name="chat_open_settings">Open Settings</string>
@@ -295,6 +299,27 @@
    <!-- Connection wizard — Connect page essentials -->
    <string name="cw_connect_to_hermes">Connect to Hermes</string>
    <string name="cw_nearby_description">We’ll look for Hermes on this network. Dashboard and Gateway provide the standard Chat, Manage, and Voice connection.</string>
+    <string name="cw_connection_chooser_description">Choose the setup you have. Hermes Relay is optional.</string>
+    <string name="cw_scan_setup_qr_title">Scan Hermes setup QR</string>
+    <string name="cw_scan_setup_qr_subtitle">Configure local, remote, and available Relay routes</string>
+    <string name="cw_recommended">Recommended</string>
+    <string name="cw_other_ways_to_connect">Other ways to connect</string>
+    <string name="cw_advanced">Advanced</string>
+    <string name="cw_cloud_title">Nous-hosted Hermes</string>
+    <string name="cw_cloud_subtitle">Connect to your hosted agent</string>
+    <string name="cw_server_vps_title">Server or VPS</string>
+    <string name="cw_server_vps_subtitle">Enter a secure Dashboard address</string>
+    <string name="cw_relay_optional_note">Standard Chat, Manage, and Voice work without Relay. Compatible setup QRs add Relay power features when available.</string>
+    <string name="cw_cloud_entry_title">Connect to Nous-hosted Hermes</string>
+    <string name="cw_cloud_entry_description">Enter the agent address shown in Nous Portal. You’ll sign in securely after Hermes is found.</string>
+    <string name="cw_cloud_agent_name">Agent address</string>
+    <string name="cw_cloud_slug_placeholder">your-agent</string>
+    <string name="cw_cloud_slug_hint">We’ll connect to your-agent.agents.nousresearch.com.</string>
+    <string name="cw_cloud_slug_error">Enter the exact letters, numbers, and hyphens before .agents.nousresearch.com.</string>
+    <string name="cw_cloud_address_placeholder">https://your-agent.example.com</string>
+    <string name="cw_cloud_address_hint">Use the complete HTTPS address shown for your hosted agent.</string>
+    <string name="cw_cloud_use_custom_address">Use custom URL</string>
+    <string name="cw_cloud_use_nous_address">Use Nous-hosted address</string>
    <string name="cw_before_connecting">Before you connect</string>
    <string name="cw_connect_step_server_title">Start Hermes on your computer</string>
    <string name="cw_connect_step_server_body">Start the Dashboard on the Hermes computer. For first-time LAN access, use Setup Guide below to make it phone-reachable and enable sign-in.</string>
@@ -734,6 +759,9 @@
    <string name="chat_settings_recent_prompt_chips_desc">Show your recent messages as tappable chips above the composer to send them again. Off by default.</string>
    <string name="chat_settings_keep_keyboard_open">Keep keyboard open on send</string>
    <string name="chat_settings_keep_keyboard_open_desc">Stay in the composer after sending. Turn off to dismiss the keyboard after each sent message.</string>
+    <string name="chat_settings_physical_keyboard_enter">Physical keyboard Enter key</string>
+    <string name="chat_settings_physical_keyboard_enter_desc">Choose whether Enter sends or inserts a new line. Ctrl+Enter always sends.</string>
+    <string name="chat_settings_insert_newline">Insert new line</string>
    <string name="chat_settings_notify_when_finishes">Background chat alerts</string>
    <string name="chat_settings_notify_when_finishes_desc">Notify when Hermes needs input or finishes while the app is in the background</string>
    <string name="chat_settings_share_phone_status">Share phone status with agent</string>
@@ -1212,6 +1240,18 @@

    <!-- P1: AppearanceSettingsScreen -->
    <string name="appearance_title">Appearance</string>
+    <string name="appearance_intro">Pick a preset. See it live in the preview.</string>
+    <string name="appearance_preset_gallery">Preset gallery</string>
+    <string name="appearance_preview_relay">Preview · Relay</string>
+    <string name="appearance_preview_user_message">Give me three quick tips for a focused morning.</string>
+    <string name="appearance_preview_agent">Hermes</string>
+    <string name="appearance_preview_agent_message">1. Pick one real win before checking feeds.\n2. Block the first 45–90 minutes.\n3. Start with a setup ritual, not “motivation.”</string>
+    <string name="appearance_preview_time">7:00 PM</string>
+    <string name="appearance_preview_voice">Voice</string>
+    <string name="appearance_preview_tool_meta">tool_executor  ·  206 tokens  ·  137.2K</string>
+    <string name="appearance_preview_message_placeholder">Message…</string>
+    <string name="appearance_preview_gateway">Gateway   ·   LAN   ·   gpt-5.5 / profile: default</string>
+    <string name="appearance_preview_live_note">This preview updates immediately with your preset, mode, font, and sphere skin.</string>
    <string name="appearance_back">Back</string>
    <string name="appearance_remove_pet_title">Remove pet?</string>
    <string name="appearance_remove_pet_body">Remove \"%1$s\"? You can re-import it later.</string>
@@ -1231,6 +1271,31 @@
    <string name="appearance_language_russian">Русский</string>
    <string name="appearance_appearance">Appearance</string>
    <string name="appearance_light_dark">Light / Dark</string>
+    <string name="appearance_customize_theme">Customize %1$s</string>
+    <string name="appearance_accent_preset">Preset accent</string>
+    <string name="appearance_accent_custom">Custom accent applied</string>
+    <string name="appearance_accent_preview_only">Changes stay in the preview until you apply them.</string>
+    <string name="appearance_accent_preview_only_short">Preview only</string>
+    <string name="appearance_apply_changes">Apply changes</string>
+    <string name="appearance_customize_summary">Accent, surfaces, shape &amp; density</string>
+    <string name="appearance_shape">Shape</string>
+    <string name="appearance_shape_soft">Soft</string>
+    <string name="appearance_shape_balanced">Balanced</string>
+    <string name="appearance_shape_sharp">Sharp</string>
+    <string name="appearance_contrast_passes">Contrast passes</string>
+    <string name="appearance_contrast_fails">Contrast needs work</string>
+    <string name="appearance_contrast_aa">AA for normal text</string>
+    <string name="appearance_typography_density">Typography &amp; density</string>
+    <string name="appearance_readability">Readability</string>
+    <string name="appearance_default">Default</string>
+    <string name="appearance_font_normal_summary">Font size: Normal</string>
+    <string name="appearance_reset_draft">Reset draft</string>
+    <string name="appearance_accent">Accent color</string>
+    <string name="appearance_contrast_status">Readable contrast · %1$.1f:1</string>
+    <string name="appearance_typography_density_summary">Typography and density use the focused Font and Font size controls below.</string>
+    <string name="appearance_readability_summary">Tune text density here; choose the typeface in the focused Font section below.</string>
+    <string name="appearance_reset">Reset</string>
+    <string name="appearance_apply">Apply</string>
    <string name="appearance_fixed_light">%1$s is a fixed light theme.</string>
    <string name="appearance_fixed_dark">%1$s is a fixed dark theme. Switch to Hermes Relay for light/dark control.</string>
    <string name="appearance_font_size">Font size</string>
@@ -1261,7 +1326,8 @@
    <string name="appearance_stabilize_desc">Auto-centers each frame so the pet doesn\'t drift or jump between frames (fixes wobbly AI sheets).</string>
    <string name="appearance_preview">Preview</string>
    <string name="appearance_sphere_skin">Sphere skin — choose the orb\'s look.</string>
-    <string name="appearance_sphere_custom_desc">Add your own: drop a sphere JSON spec into the app\'s private spheres/ folder, then reopen this screen. See docs/sphere-spec.md for the format.</string>
+    <string name="appearance_sphere_custom_desc">Import a declarative sphere JSON file. It stays on this device, is validated before use, and can never run code.</string>
+    <string name="appearance_import_sphere">Import sphere skin</string>
    <string name="appearance_greet">Greet</string>
    <string name="appearance_done">Done</string>
    <string name="appearance_preview_tip">Tap a state to preview it; Greet/Done replay the one-shot reactions. Reflects the speed and stabilize settings above.</string>
@@ -1884,6 +1950,7 @@
    <string name="dashboard_native_signin_cancelled">Browser sign-in cancelled.</string>
    <string name="dashboard_native_signin_requires_https">Secure browser sign-in requires an HTTPS dashboard address.</string>
    <string name="dashboard_native_signin_unavailable">Secure browser sign-in is unavailable for this connection. Refresh the connection and try again.</string>
+    <string name="dashboard_native_signin_transport_retry">The secure connection was interrupted. Tap the sign-in button to try again.</string>
    <string name="dashboard_close_signin">Close sign-in</string>

    <!-- Error body -->
@@ -2385,7 +2452,17 @@
    <string name="conn_info_bypassed">Bypassed</string>
    <string name="conn_info_customize_identity">Customize identity</string>
    <string name="conn_info_agent_passport">Agent Passport</string>
+    <string name="profile_shelf_switch_agent">Switch agent</string>
+    <string name="profile_shelf_all_profiles">Open all agent profiles</string>
+    <string name="profile_shelf_open_passport">Open Agent Passport</string>
+    <string name="profile_shelf_switch_to">Switch to this agent</string>
+    <string name="profile_shelf_locked_hint">Profile switching is locked. Long-press the active agent to unlock.</string>
+    <string name="profile_shelf_inspect">Inspect profile</string>
+    <string name="profile_shelf_hide">Hide from Profile Shelf</string>
+    <string name="profile_shelf_expand">Expand Profile Shelf</string>
+    <string name="profile_shelf_collapse">Collapse Profile Shelf</string>
    <string name="conn_info_chat_override">Chat override</string>
+    <string name="conn_info_chat_override_inherited_desc">Use the profile approval policy for this chat.</string>
    <string name="conn_info_fast_tier">Fast tier</string>
    <string name="conn_info_fast">Fast</string>
    <string name="conn_info_context">Context</string>
@@ -2406,6 +2483,7 @@
    <string name="conn_info_expires">Expires</string>
    <string name="conn_info_failed_reason">Failed: %1$s</string>
    <string name="conn_info_fast_mode_desc">Priority processing tier (model-gated).</string>
+    <string name="conn_info_normal_tier_desc">Use the standard processing tier.</string>
    <string name="conn_info_fast_mode_title">Fast mode</string>
    <string name="conn_info_gateway_idle">Gateway idle</string>
    <string name="conn_info_gateway_running">Gateway running</string>
@@ -2666,6 +2744,23 @@
    <string name="image_generation_rendering">Rendering image</string>
    <string name="tool_progress_cd_collapse">Collapse</string>
    <string name="tool_progress_cd_expand">Expand</string>
+    <string name="tool_progress_state_expanded">Expanded</string>
+    <string name="tool_progress_state_collapsed">Collapsed</string>
+    <string name="tool_run_preparing">Preparing %1$s</string>
+    <string name="tool_run_running">Running %1$s</string>
+    <string name="tool_run_finished">Finished %1$s</string>
+    <plurals name="tool_run_reading"><item quantity="one">Reading %d item</item><item quantity="other">Reading %d items</item></plurals>
+    <plurals name="tool_run_read"><item quantity="one">Read %d item</item><item quantity="other">Read %d items</item></plurals>
+    <plurals name="tool_run_searching"><item quantity="one">Searching %d source</item><item quantity="other">Searching %d sources</item></plurals>
+    <plurals name="tool_run_searched"><item quantity="one">Searched %d source</item><item quantity="other">Searched %d sources</item></plurals>
+    <plurals name="tool_run_running_commands"><item quantity="one">Running %d command</item><item quantity="other">Running %d commands</item></plurals>
+    <plurals name="tool_run_ran_commands"><item quantity="one">Ran %d command</item><item quantity="other">Ran %d commands</item></plurals>
+    <plurals name="tool_run_browsing"><item quantity="one">Running %d browser action</item><item quantity="other">Running %d browser actions</item></plurals>
+    <plurals name="tool_run_browsed"><item quantity="one">Ran %d browser action</item><item quantity="other">Ran %d browser actions</item></plurals>
+    <plurals name="tool_run_using_device"><item quantity="one">Running %d device action</item><item quantity="other">Running %d device actions</item></plurals>
+    <plurals name="tool_run_used_device"><item quantity="one">Ran %d device action</item><item quantity="other">Ran %d device actions</item></plurals>
+    <plurals name="tool_run_using_tools"><item quantity="one">Using %d tool</item><item quantity="other">Using %d tools</item></plurals>
+    <plurals name="tool_run_used_tools"><item quantity="one">Used %d tool</item><item quantity="other">Used %d tools</item></plurals>

    <!-- AgentIconRow -->
    <string name="agent_icon_title">Agent icon</string>
@@ -2795,6 +2890,8 @@
    <string name="qr_scanner_title">Scan Hermes QR</string>
    <string name="qr_scanner_instruction">Scan a Hermes setup QR</string>
    <string name="qr_scanner_subtext">Scan a Hermes setup or Relay pairing QR. Standard Dashboard connections do not require an API key.</string>
+    <string name="qr_scanner_ready">Ready to scan</string>
+    <string name="qr_scanner_found">Hermes setup QR found</string>
    <string name="qr_scanner_relay_title">Scan Relay QR</string>
    <string name="qr_scanner_relay_instruction">Scan a Relay pairing QR</string>
    <string name="qr_scanner_relay_subtext">Open the Relay pairing QR on your Hermes server. Your existing Dashboard connection and routes will stay unchanged.</string>
@@ -2870,6 +2967,12 @@
    <string name="msg_bubble_reconnecting">Reconnecting to your answer&#8230;</string>
    <string name="msg_bubble_still_working">Still working&#8230;</string>
    <string name="msg_bubble_sending">Sending&#8230;</string>
+    <string name="msg_bubble_queued">Queued</string>
+    <string name="msg_bubble_steered">Correction sent</string>
+    <string name="chat_quote_you">You</string>
+    <string name="chat_quote_hermes">Hermes</string>
+    <string name="chat_quote_open">Open original message from %1$s</string>
+    <string name="chat_quote_remove">Remove quote</string>
    <string name="msg_bubble_delivered">Delivered</string>
    <string name="msg_bubble_not_sent">Not sent</string>

@@ -3524,6 +3627,7 @@
    </plurals>
    <string name="tool_preparing">Preparing tool…</string>
    <string name="thinking_title">Thought process</string>
+    <string name="thinking_settled">Thought</string>
    <string name="thinking_thinking">Thinking...</string>
    <string name="thinking_thinking_short">Thinking</string>
    <string name="task_background_prefix">Background task, </string>
@@ -3666,9 +3770,12 @@
    <string name="chat_copy_session_id">Copy session ID</string>
    <string name="voice_no_speech_try_again">I didn’t catch that. Tap the mic and try again.</string>
    <string name="appearance_background_visualization">Background visualization</string>
-    <string name="appearance_background_visualization_desc">Choose the ambient visualization behind chat. This is separate from your floating pet.</string>
+    <string name="appearance_background_visualization_desc">Choose the central animation used in chat, clean mode, ambient mode, and voice. This is separate from your floating pet.</string>
    <string name="appearance_background_off">Off</string>
    <string name="appearance_background_sphere">Sphere</string>
+    <string name="appearance_background_installed">Installed animations</string>
+    <string name="appearance_import_background">Import background animation</string>
+    <string name="appearance_import_background_desc">Imports the same safe Relay pet ZIP or single-image format, but uses it only for the central/background visualization. It does not enable roaming or change your floating pet.</string>
    <string name="appearance_floating_pet">Floating pet</string>
    <string name="appearance_floating_pet_desc">Choose a companion that floats near the conversation. It does not replace the agent\'s profile avatar.</string>
    <string name="appearance_floating_pet_none">None</string>
@@ -3699,6 +3806,23 @@
    <string name="floating_pet_state_speaking">Speaking</string>
    <string name="floating_pet_state_error">Error</string>
    <string name="appearance_browse_petdex">Browse Petdex</string>
+    <string name="appearance_create_pet">Create a custom pet</string>
+    <string name="pet_creator_title">Create a custom pet</string>
+    <string name="pet_creator_intro">Describe your companion, review the generated instructions, then choose where to create it. Nothing is sent until you submit the new chat yourself.</string>
+    <string name="pet_creator_step_idea">Choose the idea</string>
+    <string name="pet_creator_name">Pet name</string>
+    <string name="pet_creator_description">Character direction</string>
+    <string name="pet_creator_description_hint">Describe the character, materials, colors, mood, and any reference image you plan to attach.</string>
+    <string name="pet_creator_animated">Animated pack</string>
+    <string name="pet_creator_static">Static image</string>
+    <string name="pet_creator_step_create">Review and create</string>
+    <string name="pet_creator_review_copy">These complete instructions include the current pet format, validation, privacy, and review boundaries.</string>
+    <string name="pet_creator_copy">Copy</string>
+    <string name="pet_creator_copied">Instructions copied</string>
+    <string name="pet_creator_new_chat">New chat</string>
+    <string name="pet_creator_step_review">Review and import</string>
+    <string name="pet_creator_review_desc">Inspect the returned image or ZIP first. Importing copies the validated files into app-scoped storage; it does not publish them.</string>
+    <string name="pet_creator_import">Import finished pet</string>
    <string name="petdex_title">Browse Petdex</string>
    <string name="petdex_description">Browse the public Petdex catalog. Catalog entries are cached briefly; pet files download only when you tap Install.</string>
    <string name="petdex_source_link">Open petdex.dev</string>
@@ -3750,6 +3874,7 @@
    <string name="voice_overlay_attachment_ready">Attachment ready</string>
    <string name="conn_info_active_profile">Active profile</string>
    <string name="msg_bubble_speak_response">Speak response</string>
+    <string name="msg_bubble_stop_speaking">Stop speaking</string>
    <string name="voice_overlay_engine_standard">Standard mode</string>
    <string name="voice_overlay_caption_hermes">Hermes</string>
    <string name="voice_overlay_open_hermes">Open Hermes</string>
@@ -238,17 +238,18 @@ class AgentDisplayTest {
    }

    @Test
-    fun profileRequestName_normalizesDefaultAliasAndDropsBlankOrNull() {
+    fun profileRequestName_keepsLiteralDefaultDistinctFromServerDefault() {
        assertNull(AgentDisplay.profileRequestName(null))
        assertNull(AgentDisplay.profileRequestName("  "))
-        assertNull(AgentDisplay.profileRequestName(" default "))
+        assertEquals("default", AgentDisplay.profileRequestName(" default "))
+        assertNull(AgentDisplay.profileRequestName(AgentDisplay.SERVER_DEFAULT_PROFILE_KEY))
        assertEquals("mizu", AgentDisplay.profileRequestName("mizu"))
    }

    @Test
    fun effectiveSessionProfileName_resolvesServerDefaultWithoutOverridingExplicitPick() {
        assertEquals("victor", AgentDisplay.effectiveSessionProfileName(null, " victor "))
-        assertEquals("victor", AgentDisplay.effectiveSessionProfileName("default", "victor"))
+        assertEquals("default", AgentDisplay.effectiveSessionProfileName("default", "victor"))
        assertEquals("default", AgentDisplay.effectiveSessionProfileName(null, "default"))
        assertEquals("mizu", AgentDisplay.effectiveSessionProfileName("mizu", "victor"))
        assertNull(AgentDisplay.effectiveSessionProfileName(null, null))
@@ -262,17 +263,18 @@ class AgentDisplayTest {
    }

    @Test
-    fun normalizeSelection_collapsesSyntheticDefaultProfile() {
-        assertNull(AgentDisplay.normalizeSelection(defaultProfile))
+    fun normalizeSelection_keepsLiteralDefaultProfile() {
+        assertEquals(defaultProfile, AgentDisplay.normalizeSelection(defaultProfile))
        assertEquals(mizu, AgentDisplay.normalizeSelection(mizu))
    }

    @Test
-    fun profileContextKey_treatsDefaultAliasAsServerDefault() {
+    fun profileContextKey_distinguishesLiteralDefaultFromServerDefault() {
        assertEquals(
-            "conn::__server_default__",
+            "conn::default",
            AgentDisplay.profileContextKey("conn", "default"),
        )
+        assertEquals("conn::__server_default__", AgentDisplay.profileContextKey("conn", null))
        assertEquals("conn::mizu", AgentDisplay.profileContextKey("conn", "mizu"))
    }
 }
@@ -0,0 +1,133 @@
+package com.hermesandroid.relay.data
+
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ChatComposerDraftStoreTest {
+    private val store = InMemoryChatComposerDraftStore()
+
+    @Test
+    fun draftsAreIsolatedByCompleteOwnerIdentity() {
+        val original = key(connection = "connection-a", profile = "coder", session = "session-a")
+        val otherConnection = original.copy(connectionId = "connection-b")
+        val otherProfile = original.copy(profileId = "default")
+        val otherSession = original.copy(sessionId = "session-b")
+        val otherSlot = original.copy(draftId = "alternate")
+
+        store.save(original, ChatComposerDraft(text = "owned by original"))
+
+        assertEquals("owned by original", store.snapshot(original).text)
+        listOf(otherConnection, otherProfile, otherSession, otherSlot).forEach { owner ->
+            assertEquals(ChatComposerDraft(), store.snapshot(owner))
+        }
+    }
+
+    @Test
+    fun preservesSelectionContextAndPendingAttachments() {
+        val attachment = Attachment(
+            contentType = "image/jpeg",
+            content = "base64-payload",
+            fileName = "portrait.jpg",
+            fileSize = 42L,
+        )
+        val pendingAttachments = mutableListOf(attachment)
+        val draft = ChatComposerDraft(
+            text = "hello world",
+            selectionStart = 2,
+            selectionEnd = 7,
+            context = ChatComposerDraftContext(
+                quotedMessageId = "quoted-message",
+                editingMessageId = "edited-message",
+            ),
+            attachments = pendingAttachments,
+        )
+
+        store.save(key(), draft)
+        pendingAttachments.clear()
+
+        assertEquals("hello world", store.snapshot(key()).text)
+        assertEquals(2, store.snapshot(key()).selectionStart)
+        assertEquals(7, store.snapshot(key()).selectionEnd)
+        assertEquals("quoted-message", store.snapshot(key()).context.quotedMessageId)
+        assertEquals("edited-message", store.snapshot(key()).context.editingMessageId)
+        assertEquals(listOf(attachment), store.snapshot(key()).attachments)
+    }
+
+    @Test
+    fun updateUsesCurrentSessionDraftWithoutTouchingAnotherSession() {
+        val first = key(session = "first")
+        val second = key(session = "second")
+        store.save(first, ChatComposerDraft(text = "one"))
+        store.save(second, ChatComposerDraft(text = "two"))
+
+        store.update(first) { it.copy(text = "one updated", selectionStart = 3) }
+
+        assertEquals("one updated", store.snapshot(first).text)
+        assertEquals(3, store.snapshot(first).selectionStart)
+        assertEquals("two", store.snapshot(second).text)
+    }
+
+    @Test
+    fun invalidSelectionIsClampedAndOrderedWhenSaved() {
+        store.save(
+            key(),
+            ChatComposerDraft(text = "hello", selectionStart = 99, selectionEnd = -4),
+        )
+
+        assertEquals(0, store.snapshot(key()).selectionStart)
+        assertEquals(5, store.snapshot(key()).selectionEnd)
+    }
+
+    @Test
+    fun blankContextIdsNormalizeAndEmptyDraftRemovesStoredState() = runBlocking {
+        val owner = key()
+        store.save(owner, ChatComposerDraft(text = "temporary"))
+
+        store.save(
+            owner,
+            ChatComposerDraft(
+                context = ChatComposerDraftContext(
+                    quotedMessageId = " ",
+                    editingMessageId = "",
+                ),
+            ),
+        )
+
+        assertEquals(ChatComposerDraft(), store.snapshot(owner))
+        assertEquals(ChatComposerDraft(), store.observe(owner).first())
+    }
+
+    @Test
+    fun removeSessionClearsEveryDraftSlotOnlyForExactNamespace() {
+        val primary = key()
+        val alternate = primary.copy(draftId = "alternate")
+        val otherProfile = primary.copy(profileId = "other")
+        store.save(primary, ChatComposerDraft(text = "primary"))
+        store.save(alternate, ChatComposerDraft(text = "alternate"))
+        store.save(otherProfile, ChatComposerDraft(text = "keep"))
+
+        store.removeSession(primary.connectionId, primary.profileId, primary.sessionId)
+
+        assertTrue(store.snapshot(primary).isEmpty)
+        assertTrue(store.snapshot(alternate).isEmpty)
+        assertEquals("keep", store.snapshot(otherProfile).text)
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun blankIdentityIsRejected() {
+        key(session = "")
+    }
+
+    private fun key(
+        connection: String = "connection-a",
+        profile: String = "coder",
+        session: String = "session-a",
+    ) = ChatComposerDraftKey(
+        connectionId = connection,
+        profileId = profile,
+        sessionId = session,
+    )
+}
@@ -0,0 +1,58 @@
+package com.hermesandroid.relay.data
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.emptyPreferences
+import androidx.datastore.preferences.core.mutablePreferencesOf
+import androidx.datastore.preferences.core.stringPreferencesKey
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class ChatInputPreferencesTest {
+
+    @Test
+    fun `enter defaults to send and unknown values fall back safely`() = runTest {
+        assertEquals(
+            PhysicalKeyboardEnterBehavior.SendMessage,
+            ChatInputPreferencesRepository(InMemoryChatInputDataStore())
+                .physicalKeyboardEnterBehavior.first(),
+        )
+        val futureStore = InMemoryChatInputDataStore(
+            mutablePreferencesOf(
+                ChatInputPreferencesRepository.KEY_PHYSICAL_KEYBOARD_ENTER to "future_mode",
+            ),
+        )
+        assertEquals(
+            PhysicalKeyboardEnterBehavior.SendMessage,
+            ChatInputPreferencesRepository(futureStore).physicalKeyboardEnterBehavior.first(),
+        )
+    }
+
+    @Test
+    fun `all enter behaviors round trip without replacing unrelated settings`() = runTest {
+        val unrelatedKey = stringPreferencesKey("unrelated_chat_input_test")
+        val store = InMemoryChatInputDataStore(mutablePreferencesOf(unrelatedKey to "keep-me"))
+        val repository = ChatInputPreferencesRepository(store)
+
+        PhysicalKeyboardEnterBehavior.entries.forEach { behavior ->
+            repository.setPhysicalKeyboardEnterBehavior(behavior)
+            assertEquals(behavior, repository.physicalKeyboardEnterBehavior.first())
+            assertEquals("keep-me", store.data.first()[unrelatedKey])
+        }
+    }
+}
+
+private class InMemoryChatInputDataStore(
+    initial: Preferences = emptyPreferences(),
+) : DataStore<Preferences> {
+    private val state = MutableStateFlow(initial)
+    override val data: Flow<Preferences> = state
+
+    override suspend fun updateData(
+        transform: suspend (t: Preferences) -> Preferences,
+    ): Preferences = transform(state.value).also { state.value = it }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
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