fix(android): guard unresolved profile assets and verify identity controls

# Conflicts:
#	CHANGELOG.md

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,38 +0,0 @@
-## Summary
-
-<!-- Brief description of what this PR does -->
-
-## Changes
-
--
-
-## Verification
-
-<!-- List the checks you ran, or explain why a check is not applicable. -->
-
--
-
-## Lineage / contributor credit
-
-<!--
-If this PR salvages or supersedes earlier work, link every source PR and name
-the original contributor(s). Preserve original commit authors where practical;
-otherwise use verified Co-authored-by trailers. Write "N/A" for original work.
--->
-
-- Source PR(s): N/A
-- Attribution preserved by: N/A
-
-## Checklist
-
-- [ ] Target branch is `dev`, unless this is a `dev` → `main` release PR or a focused production-tag hotfix PR to `main`
-- [ ] Android changes: lint and focused unit tests ran, or rationale is listed above
-- [ ] Translation changes: locale status/review references are accurate, `python scripts/check-android-locales.py` ran, and device/emulator review is documented, or N/A
-- [ ] Server changes: focused `python -m unittest ...` checks ran, or rationale is listed above
-- [ ] Desktop changes: `npm run build` or a narrower documented check ran, or rationale is listed above
-- [ ] Docs/site changes: docs build or link check ran, or rationale is listed above
-- [ ] UI changes were tested on emulator/device or desktop surface when applicable
-- [ ] Commit messages follow [Conventional Commits](https://www.conventionalcommits.org/)
-- [ ] CHANGELOG.md updated (if user-facing)
-- [ ] Public writing hygiene checked: no secrets, private infrastructure, personal names, or AI/process narration
-- [ ] Salvaged work links the source PR and preserves contributor authorship, or N/A

.github/copilot-instructions.md

@@ -5,9 +5,8 @@ not `AGENTS.md`) picks up the project's agent guidance.
 
 **Read [AGENTS.md](../AGENTS.md) first — it is the single source of truth**
 for agent guidance: the entry point, the non-negotiables, and the public-repo
-writing hygiene. It links on to `CLAUDE.md` for the deep reference
-(architecture, upstream Hermes API, repository layout, per-language code style,
-the dev loop, and the Key Files map). Follow those; don't restate them here.
+writing hygiene. `CLAUDE.md` imports that same canonical file. Follow
+`AGENTS.md` and its linked project records; don't restate them here.
 
 Quick non-negotiables (the full list and rationale are in `AGENTS.md`):
 
@@ -17,6 +16,8 @@ Quick non-negotiables (the full list and rationale are in `AGENTS.md`):
 - **Conventional Commits**, `main`/`dev` branching — feature branches off
   `dev`, `--no-ff` merges, tags cut from `main`.
 - **Android:** Jetpack Compose (no XML), kotlinx.serialization (no Gson),
-  OkHttp (no Ktor), `wss://` only; run `./gradlew lint` before pushing Kotlin.
+  OkHttp (no Ktor), `wss://` only. Narrow local checks use the Android lane;
+  pushed exact SHAs prefer `Android On-Demand` for heavy verification; full
+  local pre-push remains an explicit fallback.
 - **Public repo:** no personal names, no private infrastructure, no
   AI/assistant self-narration in committed prose.

.github/scripts/classify-ci-paths.cjs

@@ -4,6 +4,7 @@ function classifyCiPaths(paths) {
   const forceAll = paths.some((path) => [
     '.github/workflows/ci-required.yml',
     '.github/workflows/release-backmerge.yml',
+    '.github/workflows/approve-release-train.yml',
     '.github/scripts/classify-ci-paths.cjs',
     '.github/scripts/classify-ci-paths.test.cjs',
     'scripts/plan_release_backmerge.py',
@@ -13,25 +14,34 @@ function classifyCiPaths(paths) {
   const under = (prefixes) => paths.some((path) => prefixes.some((prefix) => path.startsWith(prefix)));
 
   return {
-    android: forceAll || under(['app/', 'relay-core/', 'relay-ui/', 'ui-preview/', 'quest/', 'gradle/']) || exact([
+    android: forceAll || under(['app/', 'gradle/']) || exact([
       'build.gradle.kts', 'settings.gradle.kts', 'gradle.properties', 'gradlew', 'gradlew.bat',
       'scripts/check-android-locales.py', 'scripts/android-locale-harness.py',
       'scripts/check-android-collection-apis.py', 'scripts/check-android-native-compat.py',
       'scripts/check-android-release-notes.py',
+      'scripts/android_release_artifacts.py',
+      'scripts/android-lane.ps1', 'scripts/android-prepush.py', 'scripts/dev.bat', 'scripts/dev.sh',
+      'scripts/tests/android_prepush_test.py',
       'scripts/tests/check_android_native_compat_test.py',
-      'scripts/tests/check_android_release_notes_test.py', '.github/workflows/ci-android.yml',
+      'scripts/tests/check_android_release_notes_test.py',
+      'scripts/tests/android_release_artifacts_test.py',
+      '.github/workflows/android-on-demand.yml', '.github/workflows/ci-android.yml',
       '.github/workflows/play-preflight-android.yml',
       '.github/workflows/approve-release-android.yml',
       '.github/workflows/release-android.yml',
     ]),
     desktop: forceAll || under(['desktop/']) || exact([
       '.github/workflows/ci-desktop.yml',
+      '.github/workflows/approve-release-extensions.yml',
+      '.github/workflows/release-cli.yml',
     ]),
     plugin: forceAll || paths.some((path) => /^plugin\/[^/]+\.py$/.test(path)) ||
       under(['plugin/relay/', 'plugin/tools/', 'plugin/tests/', 'relay_server/', 'hermes_relay_bootstrap/']) || exact([
         'plugin/plugin.yaml', 'pyproject.toml', 'scripts/check-plugin-version-sync.py',
         'scripts/check-server-version-sync.py', 'scripts/bump-plugin-version.sh',
         'scripts/bump-server-version.sh', '.github/workflows/ci-plugin.yml',
+        '.github/workflows/approve-release-extensions.yml',
+        '.github/workflows/release-plugin.yml',
       ]),
     dashboard: forceAll || under(['plugin/dashboard/']) || exact([
       '.github/workflows/ci-dashboard.yml',

.github/scripts/classify-ci-paths.test.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 const assert = require('node:assert/strict');
+const { readFileSync } = require('node:fs');
+const { join } = require('node:path');
 const { classifyCiPaths } = require('./classify-ci-paths.cjs');
 
 const none = {
@@ -14,10 +16,25 @@ const none = {
 
 assert.deepEqual(classifyCiPaths(['README.md']), none);
 assert.deepEqual(classifyCiPaths(['desktop/src/cli.ts']), { ...none, desktop: true });
-assert.deepEqual(classifyCiPaths(['relay-core/src/main/kotlin/Wire.kt']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['experiments/quest/src/main/kotlin/Quest.kt']), none);
 assert.deepEqual(classifyCiPaths(['scripts/check-android-release-notes.py']), { ...none, android: true });
 assert.deepEqual(classifyCiPaths(['scripts/check-android-native-compat.py']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['scripts/android_release_artifacts.py']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['scripts/tests/android_release_artifacts_test.py']), { ...none, android: true });
 assert.deepEqual(classifyCiPaths(['scripts/tests/check_android_native_compat_test.py']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['scripts/android-lane.ps1']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['scripts/android-prepush.py']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['scripts/dev.bat']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['scripts/dev.sh']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['scripts/tests/android_prepush_test.py']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['.github/workflows/android-on-demand.yml']), { ...none, android: true });
+assert.deepEqual(classifyCiPaths(['.github/workflows/approve-release-extensions.yml']), {
+  ...none,
+  desktop: true,
+  plugin: true,
+});
+assert.deepEqual(classifyCiPaths(['.github/workflows/release-cli.yml']), { ...none, desktop: true });
+assert.deepEqual(classifyCiPaths(['.github/workflows/release-plugin.yml']), { ...none, plugin: true });
 assert.deepEqual(classifyCiPaths(['plugin/relay/server.py']), { ...none, plugin: true });
 assert.deepEqual(classifyCiPaths(['plugin/dashboard/src/App.tsx']), { ...none, dashboard: true });
 assert.deepEqual(classifyCiPaths(['user-docs/index.md']), { ...none, docs: true });
@@ -41,5 +58,73 @@ assert.deepEqual(classifyCiPaths(['.github/workflows/release-backmerge.yml']), {
   contract: true,
   docs: true,
 });
+assert.deepEqual(classifyCiPaths(['.github/workflows/approve-release-train.yml']), {
+  android: true,
+  desktop: true,
+  plugin: true,
+  dashboard: true,
+  contract: true,
+  docs: true,
+});
+
+const repoRoot = join(__dirname, '..', '..');
+const approvalWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'approve-release-extensions.yml'),
+  'utf8',
+);
+const cliReleaseWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'release-cli.yml'),
+  'utf8',
+);
+const pluginReleaseWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'release-plugin.yml'),
+  'utf8',
+);
+const desktopCiWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'ci-desktop.yml'),
+  'utf8',
+);
+const androidPreflightWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'play-preflight-android.yml'),
+  'utf8',
+);
+const androidApprovalWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'approve-release-android.yml'),
+  'utf8',
+);
+const androidReleaseWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'release-android.yml'),
+  'utf8',
+);
+const requiredChecksWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'ci-required.yml'),
+  'utf8',
+);
+const releaseTrainWorkflow = readFileSync(
+  join(repoRoot, '.github', 'workflows', 'approve-release-train.yml'),
+  'utf8',
+);
+
+assert.match(approvalWorkflow, /permissions:\r?\n  contents: read/);
+assert.match(
+  approvalWorkflow,
+  /approve:[\s\S]*?permissions:\r?\n      actions: write\r?\n      contents: write/,
+);
+assert.match(
+  approvalWorkflow,
+  /ref: \$\{\{ contains\(inputs\.version, '-'\) && 'dev' \|\| 'main' \}\}/,
+);
+assert.match(cliReleaseWorkflow, /workflow_dispatch:[\s\S]*?Approved CLI\+UI version/);
+assert.match(cliReleaseWorkflow, /name: Restore exact-source tray build cache[\s\S]*?actions\/cache@v6/);
+assert.match(desktopCiWorkflow, /name: Restore exact-source tray build cache[\s\S]*?actions\/cache@v6/);
+assert.match(pluginReleaseWorkflow, /workflow_dispatch:[\s\S]*?Approved Plugin version/);
+assert.match(androidPreflightWorkflow, /Package immutable preflight artifacts/);
+assert.match(androidApprovalWorkflow, /Android public approval accepts stable SemVer only/);
+assert.match(androidReleaseWorkflow, /Download exact stable preflight artifacts/);
+assert.match(androidReleaseWorkflow, /artifact-ids: \$\{\{ needs\.validate\.outputs\.preflight_artifact_id \}\}/);
+assert.match(requiredChecksWorkflow, /name: Reuse exact-tree required checks/);
+assert.match(requiredChecksWorkflow, /name: required-checks-\$\{\{ needs\.changes\.outputs\.tree \}\}/);
+assert.match(releaseTrainWorkflow, /name: Hermes-Relay Coordinated Release Approval/);
+assert.match(releaseTrainWorkflow, /Coordinated Android approval is stable-only/);
 
 console.log('CI path classification tests passed.');

.github/workflows/android-on-demand.yml

@@ -0,0 +1,226 @@
+name: Android On-Demand
+
+run-name: Android ${{ inputs.preset }} · ${{ inputs.head_sha }}
+
+on:
+  workflow_call:
+    inputs:
+      head_sha:
+        required: true
+        type: string
+      preset:
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+concurrency:
+  group: android-on-demand-${{ inputs.head_sha }}-${{ inputs.preset }}
+  cancel-in-progress: false
+
+jobs:
+  validate:
+    name: Validate exact SHA
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Validate input shape
+        shell: bash
+        env:
+          REQUESTED_SHA: ${{ inputs.head_sha }}
+          REQUESTED_PRESET: ${{ inputs.preset }}
+        run: |
+          if [[ ! "$REQUESTED_SHA" =~ ^[0-9a-f]{40}$ ]]; then
+            echo "head_sha must be a full lowercase 40-character commit SHA" >&2
+            exit 2
+          fi
+          case "$REQUESTED_PRESET" in
+            focused|lint|assemble-debug|release-smoke|all-final) ;;
+            *)
+              echo "unsupported Android preset: $REQUESTED_PRESET" >&2
+              exit 2
+              ;;
+          esac
+
+      - name: Checkout exact commit
+        uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.head_sha }}
+          fetch-depth: 1
+
+      - name: Confirm checkout identity
+        shell: bash
+        env:
+          REQUESTED_SHA: ${{ inputs.head_sha }}
+        run: test "$(git rev-parse HEAD)" = "$REQUESTED_SHA"
+
+  focused:
+    name: Focused Android checks
+    needs: validate
+    if: ${{ inputs.preset == 'focused' || inputs.preset == 'all-final' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.head_sha }}
+
+      - uses: actions/setup-java@v6
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - uses: gradle/actions/setup-gradle@v6.3.0
+        with:
+          cache-read-only: true
+
+      - name: Run repository checks and focused sideload tests
+        run: python3 scripts/android-prepush.py --skip-lint
+
+      - name: Run the same focused tests for Google Play
+        shell: bash
+        run: |
+          mapfile -t focused_tests < <(python3 -c \
+            "import runpy; print(*runpy.run_path('scripts/android-prepush.py')['FOCUSED_TESTS'], sep='\n')")
+          test_args=()
+          for test_name in "${focused_tests[@]}"; do
+            test_args+=(--tests "$test_name")
+          done
+          ./gradlew :app:testGooglePlayDebugUnitTest "${test_args[@]}" --console=plain
+
+      - name: Upload failed test reports
+        uses: actions/upload-artifact@v7
+        if: failure()
+        with:
+          name: focused-test-reports-${{ inputs.head_sha }}
+          path: app/build/reports/tests/
+          if-no-files-found: ignore
+          retention-days: 7
+
+  lint:
+    name: Android lint
+    needs: validate
+    if: ${{ inputs.preset == 'lint' || inputs.preset == 'all-final' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.head_sha }}
+
+      - uses: actions/setup-java@v6
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - uses: gradle/actions/setup-gradle@v6.3.0
+        with:
+          cache-read-only: true
+
+      - name: Validate Android repository inputs
+        run: |
+          python3 scripts/check-android-locales.py
+          python3 scripts/check-user-docs-locales.py
+          python3 scripts/check-android-collection-apis.py
+          python3 scripts/check-android-release-notes.py
+          python3 scripts/check-version-tracks.py
+          if [[ -f scripts/tests/android_prepush_test.py ]]; then
+            python3 -m unittest scripts.tests.android_prepush_test
+          fi
+          python3 -m unittest scripts.tests.check_android_release_notes_test
+          python3 -m unittest scripts.tests.check_android_native_compat_test
+
+      - name: Run Android lint
+        run: ./gradlew lint --console=plain
+
+      - name: Upload lint reports
+        uses: actions/upload-artifact@v7
+        if: always()
+        with:
+          name: lint-reports-${{ inputs.head_sha }}
+          path: app/build/reports/lint-results*
+          if-no-files-found: ignore
+          retention-days: 7
+
+  assemble-debug:
+    name: Assemble both debug flavors
+    needs: validate
+    if: ${{ inputs.preset == 'assemble-debug' || inputs.preset == 'all-final' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 25
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.head_sha }}
+
+      - uses: actions/setup-java@v6
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - uses: gradle/actions/setup-gradle@v6.3.0
+        with:
+          cache-read-only: true
+
+      - name: Build debug APKs
+        run: ./gradlew assembleDebug --console=plain
+
+      - name: Verify packaged native compatibility
+        run: |
+          python3 scripts/check-android-native-compat.py \
+            app/build/outputs/apk/googlePlay/debug/*.apk \
+            app/build/outputs/apk/sideload/debug/*.apk
+
+      - name: Upload debug APKs
+        uses: actions/upload-artifact@v7
+        with:
+          name: debug-apks-${{ inputs.head_sha }}
+          path: app/build/outputs/apk/*/debug/*.apk
+          if-no-files-found: error
+          retention-days: 7
+
+  release-smoke:
+    name: Release build smoke
+    needs: validate
+    if: ${{ inputs.preset == 'release-smoke' || inputs.preset == 'all-final' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 35
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.head_sha }}
+
+      - uses: actions/setup-java@v6
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - uses: gradle/actions/setup-gradle@v6.3.0
+        with:
+          cache-read-only: true
+
+      - name: Build release bundles and APKs
+        run: ./gradlew bundleRelease assembleRelease --console=plain
+
+      - name: Scan release DEX for unsupported collection APIs
+        run: |
+          python3 scripts/check-android-collection-apis.py \
+            --apk app/build/outputs/apk/googlePlay/release/*.apk \
+            --apk app/build/outputs/apk/sideload/release/*.apk
+
+      - name: Verify packaged native compatibility
+        run: |
+          python3 scripts/check-android-native-compat.py \
+            app/build/outputs/apk/googlePlay/release/*.apk \
+            app/build/outputs/apk/sideload/release/*.apk
+
+      - name: Upload release smoke artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: release-smoke-${{ inputs.head_sha }}
+          path: |
+            app/build/outputs/apk/*/release/*.apk
+            app/build/outputs/bundle/**/*.aab
+          if-no-files-found: error
+          retention-days: 7

.github/workflows/approve-release-android.yml

@@ -40,6 +40,10 @@ jobs:
             echo "::error::Hermes-Relay Android Release Approval must run from main, not $GITHUB_REF"
             exit 1
           fi
+          if [[ ! "$REQUESTED_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "::error::Android public approval accepts stable SemVer only: $REQUESTED_VERSION"
+            exit 1
+          fi
           TOML_VERSION=$(grep -oP 'appVersionName\s*=\s*"\K[^"]+' gradle/libs.versions.toml)
           if [ "$REQUESTED_VERSION" != "$TOML_VERSION" ]; then
             echo "::error::Requested version $REQUESTED_VERSION does not match appVersionName $TOML_VERSION"
@@ -56,13 +60,21 @@ jobs:
           RELEASE_TREE: ${{ steps.metadata.outputs.tree }}
         run: |
           ARTIFACT_NAME="play-preflight-${VERSION}-${RELEASE_TREE}"
-          COUNT=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/artifacts?name=${ARTIFACT_NAME}" \
-            --jq '[.artifacts[] | select(.expired == false)] | length')
-          if [ "$COUNT" -lt 1 ]; then
+          ARTIFACT=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/artifacts?name=${ARTIFACT_NAME}" \
+            --jq '[.artifacts[] | select(.expired == false)] | sort_by(.created_at) | last')
+          RUN_ID=$(jq -r '.workflow_run.id // empty' <<<"$ARTIFACT")
+          if [ -z "$RUN_ID" ]; then
             echo "::error::No successful Play preflight found for version $VERSION with tree $RELEASE_TREE"
             exit 1
           fi
-          echo "Verified Play preflight proof: $ARTIFACT_NAME"
+          RUN=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/runs/${RUN_ID}")
+          CONCLUSION=$(jq -r '.conclusion' <<<"$RUN")
+          WORKFLOW_PATH=$(jq -r '.path' <<<"$RUN")
+          if [ "$WORKFLOW_PATH" != ".github/workflows/play-preflight-android.yml" ] || [ "$CONCLUSION" != "success" ]; then
+            echo "::error::Preflight artifact came from ${WORKFLOW_PATH} with conclusion ${CONCLUSION}"
+            exit 1
+          fi
+          echo "Verified immutable Play preflight artifacts: $ARTIFACT_NAME (run $RUN_ID)"
 
       - name: Ensure release tag does not already exist
         env:

.github/workflows/approve-release-extensions.yml

@@ -0,0 +1,158 @@
+name: Hermes-Relay Plugin and CLI+UI Release Approval
+
+on:
+  workflow_dispatch:
+    inputs:
+      surface:
+        description: "Release surface"
+        required: true
+        type: choice
+        options:
+          - plugin
+          - desktop
+      version:
+        description: "Approved version (for example 1.11.2 or 0.4.0-beta.7)"
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+concurrency:
+  group: approve-${{ inputs.surface }}-release
+  cancel-in-progress: false
+
+jobs:
+  validate:
+    name: Validate release source and metadata
+    runs-on: ubuntu-latest
+    outputs:
+      source_branch: ${{ steps.metadata.outputs.source_branch }}
+      source_sha: ${{ steps.metadata.outputs.source_sha }}
+      tag: ${{ steps.metadata.outputs.tag }}
+      workflow: ${{ steps.metadata.outputs.workflow }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+          ref: ${{ contains(inputs.version, '-') && 'dev' || 'main' }}
+
+      - name: Validate approval request
+        id: metadata
+        env:
+          REQUESTED_SURFACE: ${{ inputs.surface }}
+          REQUESTED_VERSION: ${{ inputs.version }}
+        run: |
+          set -euo pipefail
+          if [[ ! "$REQUESTED_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$ ]]; then
+            echo "::error::Version must be SemVer with an optional prerelease suffix: $REQUESTED_VERSION"
+            exit 1
+          fi
+
+          if [[ "$REQUESTED_VERSION" == *-* ]]; then
+            source_branch="dev"
+          else
+            source_branch="main"
+          fi
+          if [ "$GITHUB_REF" != "refs/heads/main" ]; then
+            echo "::error::Release approval must run from the trusted main workflow definition, not $GITHUB_REF"
+            exit 1
+          fi
+          git fetch origin "$source_branch" --no-tags
+          source_sha="$(git rev-parse HEAD)"
+          expected_sha="$(git rev-parse FETCH_HEAD)"
+          if [ "$source_sha" != "$expected_sha" ]; then
+            echo "::error::Checked out $source_sha, but origin/$source_branch is $expected_sha"
+            exit 1
+          fi
+
+          case "$REQUESTED_SURFACE" in
+            plugin)
+              tag="server-v${REQUESTED_VERSION}"
+              workflow="release-plugin.yml"
+              python3 scripts/check-plugin-version-sync.py --expect "$REQUESTED_VERSION"
+              if ! grep -Eq "^## \[Plugin ${REQUESTED_VERSION}\]" CHANGELOG.md; then
+                echo "::error::CHANGELOG.md has no Plugin release heading for $REQUESTED_VERSION"
+                exit 1
+              fi
+              ;;
+            desktop)
+              tag="desktop-v${REQUESTED_VERSION}"
+              workflow="release-cli.yml"
+              node desktop/scripts/cli-version-sync.mjs --expect "$REQUESTED_VERSION"
+              if ! grep -Fq "## [$REQUESTED_VERSION]" CHANGELOG.md; then
+                echo "::error::CHANGELOG.md has no CLI+UI release heading for $REQUESTED_VERSION"
+                exit 1
+              fi
+              ;;
+            *)
+              echo "::error::Unsupported release surface: $REQUESTED_SURFACE"
+              exit 1
+              ;;
+          esac
+
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+          echo "workflow=$workflow" >> "$GITHUB_OUTPUT"
+          echo "source_branch=$source_branch" >> "$GITHUB_OUTPUT"
+          echo "source_sha=$source_sha" >> "$GITHUB_OUTPUT"
+
+  approve:
+    name: Create release tag and start publication
+    needs: validate
+    permissions:
+      actions: write
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Verify release source has not moved
+        env:
+          GH_TOKEN: ${{ github.token }}
+          SOURCE_BRANCH: ${{ needs.validate.outputs.source_branch }}
+          SOURCE_SHA: ${{ needs.validate.outputs.source_sha }}
+        run: |
+          current_sha=$(gh api "/repos/${GITHUB_REPOSITORY}/git/ref/heads/${SOURCE_BRANCH}" --jq .object.sha)
+          if [ "$current_sha" != "$SOURCE_SHA" ]; then
+            echo "::error::$SOURCE_BRANCH moved from $SOURCE_SHA to $current_sha; run approval again"
+            exit 1
+          fi
+
+      - name: Ensure release tag does not already exist
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ needs.validate.outputs.tag }}
+        run: |
+          if gh api "/repos/${GITHUB_REPOSITORY}/git/ref/tags/${RELEASE_TAG}" >/dev/null 2>&1; then
+            echo "::error::Tag $RELEASE_TAG already exists"
+            exit 1
+          fi
+
+      - name: Create approved release tag
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ needs.validate.outputs.tag }}
+          RELEASE_SHA: ${{ needs.validate.outputs.source_sha }}
+        run: |
+          gh api --method POST "/repos/${GITHUB_REPOSITORY}/git/refs" \
+            -f ref="refs/tags/${RELEASE_TAG}" \
+            -f sha="$RELEASE_SHA"
+
+      - name: Start the immutable tag release workflow
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_WORKFLOW: ${{ needs.validate.outputs.workflow }}
+          RELEASE_VERSION: ${{ inputs.version }}
+        run: |
+          # A tag created by GITHUB_TOKEN does not recursively start workflows.
+          # Dispatch the trusted definition from main; release jobs check out
+          # and validate the immutable tag created above.
+          gh workflow run "$RELEASE_WORKFLOW" \
+            --repo "$GITHUB_REPOSITORY" \
+            --ref main \
+            -f version="$RELEASE_VERSION"
+
+      - name: Approval summary
+        run: |
+          echo "## Release approved" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "Created \`${{ needs.validate.outputs.tag }}\` from \`${{ needs.validate.outputs.source_branch }}\` at \`${{ needs.validate.outputs.source_sha }}\`." >> "$GITHUB_STEP_SUMMARY"
+          echo "Dispatched \`${{ needs.validate.outputs.workflow }}\` to validate and publish that immutable tag." >> "$GITHUB_STEP_SUMMARY"

.github/workflows/approve-release-train.yml

@@ -0,0 +1,120 @@
+name: Hermes-Relay Coordinated Release Approval
+
+on:
+  workflow_dispatch:
+    inputs:
+      android:
+        description: "Approve Hermes-Relay Android"
+        required: true
+        default: false
+        type: boolean
+      android_version:
+        description: "Android version when selected"
+        required: false
+        type: string
+      plugin:
+        description: "Approve Hermes-Relay Plugin"
+        required: true
+        default: false
+        type: boolean
+      plugin_version:
+        description: "Plugin version when selected"
+        required: false
+        type: string
+      desktop:
+        description: "Approve Hermes-Relay CLI+UI"
+        required: true
+        default: false
+        type: boolean
+      desktop_version:
+        description: "CLI+UI version when selected"
+        required: false
+        type: string
+
+permissions:
+  actions: write
+  contents: read
+
+concurrency:
+  group: approve-coordinated-release
+  cancel-in-progress: false
+
+jobs:
+  validate:
+    name: Validate selected release surfaces
+    runs-on: ubuntu-latest
+    steps:
+      - name: Require versions for every selected surface
+        env:
+          ANDROID: ${{ inputs.android }}
+          ANDROID_VERSION: ${{ inputs.android_version }}
+          PLUGIN: ${{ inputs.plugin }}
+          PLUGIN_VERSION: ${{ inputs.plugin_version }}
+          DESKTOP: ${{ inputs.desktop }}
+          DESKTOP_VERSION: ${{ inputs.desktop_version }}
+        run: |
+          set -euo pipefail
+          if [ "$ANDROID" != "true" ] && [ "$PLUGIN" != "true" ] && [ "$DESKTOP" != "true" ]; then
+            echo "::error::Select at least one release surface"
+            exit 1
+          fi
+          for pair in \
+            "$ANDROID:$ANDROID_VERSION:Android" \
+            "$PLUGIN:$PLUGIN_VERSION:Plugin" \
+            "$DESKTOP:$DESKTOP_VERSION:CLI+UI"; do
+            IFS=: read -r selected version label <<<"$pair"
+            if [ "$selected" = "true" ] && [[ ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$ ]]; then
+              echo "::error::$label requires a valid SemVer version"
+              exit 1
+            fi
+          done
+          if [ "$ANDROID" = "true" ] && [[ "$ANDROID_VERSION" == *-* ]]; then
+            echo "::error::Coordinated Android approval is stable-only; use a dev candidate tag for prereleases"
+            exit 1
+          fi
+
+  android:
+    name: Approve Hermes-Relay Android
+    needs: validate
+    if: inputs.android
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dispatch Android approval
+        env:
+          GH_TOKEN: ${{ github.token }}
+          VERSION: ${{ inputs.android_version }}
+        run: gh workflow run approve-release-android.yml --repo "$GITHUB_REPOSITORY" --ref main -f version="$VERSION"
+
+  plugin:
+    name: Approve Hermes-Relay Plugin
+    needs: validate
+    if: inputs.plugin
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dispatch Plugin approval
+        env:
+          GH_TOKEN: ${{ github.token }}
+          VERSION: ${{ inputs.plugin_version }}
+        run: |
+          gh workflow run approve-release-extensions.yml \
+            --repo "$GITHUB_REPOSITORY" \
+            --ref main \
+            -f surface=plugin \
+            -f version="$VERSION"
+
+  desktop:
+    name: Approve Hermes-Relay CLI+UI
+    needs: validate
+    if: inputs.desktop
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dispatch CLI+UI approval
+        env:
+          GH_TOKEN: ${{ github.token }}
+          VERSION: ${{ inputs.desktop_version }}
+        run: |
+          gh workflow run approve-release-extensions.yml \
+            --repo "$GITHUB_REPOSITORY" \
+            --ref main \
+            -f surface=desktop \
+            -f version="$VERSION"

.github/workflows/ci-android.yml

@@ -20,16 +20,17 @@ on:
     branches: [main, dev]
     paths:
       - "app/**"
-      - "relay-core/**"
-      - "relay-ui/**"
-      - "ui-preview/**"
-      - "quest/**"
       - "gradle/**"
       - "build.gradle.kts"
       - "settings.gradle.kts"
       - "gradle.properties"
       - "gradlew"
       - "gradlew.bat"
+      - "scripts/android-lane.ps1"
+      - "scripts/android-prepush.py"
+      - "scripts/dev.bat"
+      - "scripts/dev.sh"
+      - "scripts/tests/android_prepush_test.py"
       - "scripts/check-android-locales.py"
       - "scripts/android-locale-harness.py"
       - "scripts/check-android-collection-apis.py"
@@ -38,6 +39,7 @@ on:
       - "scripts/tests/check_android_native_compat_test.py"
       - "scripts/tests/check_android_release_notes_test.py"
       - ".github/workflows/ci-android.yml"
+      - ".github/workflows/android-on-demand.yml"
       - ".github/workflows/play-preflight-android.yml"
       - ".github/workflows/approve-release-android.yml"
       - ".github/workflows/release-android.yml"
@@ -61,7 +63,7 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17
@@ -80,6 +82,7 @@ jobs:
       - name: Validate Android release notes
         run: |
           python3 scripts/check-android-release-notes.py
+          python3 -m unittest scripts.tests.android_prepush_test
           python3 -m unittest scripts.tests.check_android_release_notes_test
 
       - name: Test Android native compatibility checker
@@ -101,7 +104,7 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17
@@ -151,7 +154,7 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17
@@ -215,7 +218,7 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17

.github/workflows/ci-desktop.yml

@@ -107,6 +107,18 @@ jobs:
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@stable
 
+      - name: Restore exact-source tray build cache
+        uses: actions/cache@v6
+        with:
+          path: |
+            ~/.cargo/registry/index
+            ~/.cargo/registry/cache
+            ~/.cargo/git/db
+            desktop/tray/target
+          key: ${{ runner.os }}-tray-rust-${{ hashFiles('desktop/tray/Cargo.lock') }}-${{ hashFiles('desktop/tray/Cargo.toml', 'desktop/tray/build.rs', 'desktop/tray/src/**/*.rs') }}
+          restore-keys: |
+            ${{ runner.os }}-tray-rust-${{ hashFiles('desktop/tray/Cargo.lock') }}-
+
       - name: Install deps
         run: npm ci && npm --prefix tray ci
 

.github/workflows/ci-plugin.yml

@@ -101,6 +101,7 @@ jobs:
       - name: Run focused Plugin tests
         run: |
           python -m pytest \
+            plugin/tests/test_manifest_compatibility.py \
             plugin/tests/test_relay_security.py \
             plugin/tests/test_voice_routes.py \
             plugin/tests/test_session_grants.py \
@@ -110,4 +111,8 @@ jobs:
             plugin/tests/test_git_state.py \
             plugin/tests/test_git_state_write.py \
             plugin/tests/test_git_state_extras.py \
-            plugin/tests/test_mobile_plugin_store.py
+            plugin/tests/test_mobile_plugin_store.py \
+            plugin/tests/test_android_tool.py \
+            plugin/tests/test_android_navigate.py \
+            plugin/tests/test_phone_platform.py \
+            plugin/tests/test_desktop_tool_availability.py

.github/workflows/ci-required.yml

@@ -20,13 +20,26 @@ on:
         description: "Exact candidate commit to check"
         required: true
         type: string
+      android_preset:
+        description: "Optional Android-only compute lane"
+        required: false
+        default: auto
+        type: choice
+        options:
+          - auto
+          - focused
+          - lint
+          - assemble-debug
+          - release-smoke
+          - all-final
 
 permissions:
+  actions: read
   contents: read
   pull-requests: read
 
 concurrency:
-  group: ci-required-${{ github.ref }}
+  group: ci-required-${{ github.event_name == 'workflow_dispatch' && format('{0}-{1}', inputs.head_sha, inputs.android_preset) || github.ref }}
   cancel-in-progress: true
 
 jobs:
@@ -40,6 +53,8 @@ jobs:
       dashboard: ${{ steps.filter.outputs.dashboard }}
       contract: ${{ steps.filter.outputs.contract }}
       docs: ${{ steps.filter.outputs.docs }}
+      release_pr: ${{ steps.release.outputs.release_pr }}
+      tree: ${{ steps.tree.outputs.tree }}
     steps:
       - name: Checkout pull request merge
         if: github.event_name == 'pull_request'
@@ -57,6 +72,26 @@ jobs:
       - name: Test path classifier
         run: node .github/scripts/classify-ci-paths.test.cjs
 
+      - name: Record checked tree
+        id: tree
+        run: echo "tree=$(git rev-parse 'HEAD^{tree}')" >> "$GITHUB_OUTPUT"
+
+      - name: Detect canonical release promotion
+        id: release
+        env:
+          BASE_REF: ${{ github.base_ref }}
+          HEAD_REF: ${{ github.head_ref }}
+          HEAD_REPOSITORY: ${{ github.event.pull_request.head.repo.full_name }}
+        run: |
+          if [ "$GITHUB_EVENT_NAME" = "pull_request" ] && \
+             [ "$BASE_REF" = "main" ] && \
+             [ "$HEAD_REF" = "dev" ] && \
+             [ "$HEAD_REPOSITORY" = "$GITHUB_REPOSITORY" ]; then
+            echo "release_pr=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "release_pr=false" >> "$GITHUB_OUTPUT"
+          fi
+
       - name: Classify changed files
         id: filter
         uses: actions/github-script@v8
@@ -111,35 +146,117 @@ jobs:
             core.notice(`Changed paths: ${paths.join(', ')}`);
             core.notice(`Selected checks: ${Object.entries(outputs).filter(([, value]) => value).map(([key]) => key).join(', ') || 'none'}`);
 
-  android:
+  release-proof:
+    name: Reuse exact-tree required checks
     needs: changes
-    if: needs.changes.outputs.android == 'true'
+    if: needs.changes.outputs.release_pr == 'true'
+    runs-on: ubuntu-latest
+    outputs:
+      reuse: ${{ steps.proof.outputs.reuse }}
+      artifact_id: ${{ steps.proof.outputs.artifact_id }}
+      run_id: ${{ steps.proof.outputs.run_id }}
+      tree: ${{ steps.proof.outputs.tree }}
+    steps:
+      - name: Checkout simulated release merge
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - name: Locate exact-tree proof
+        id: proof
+        env:
+          GH_TOKEN: ${{ github.token }}
+          DEV_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          set -euo pipefail
+          merge_tree=$(git rev-parse 'HEAD^{tree}')
+          dev_tree=$(git rev-parse "${DEV_SHA}^{tree}")
+          echo "reuse=false" >> "$GITHUB_OUTPUT"
+          echo "tree=$dev_tree" >> "$GITHUB_OUTPUT"
+          if [ "$merge_tree" != "$dev_tree" ]; then
+            echo "Release merge changes the dev tree ($dev_tree -> $merge_tree); running full CI."
+            exit 0
+          fi
+
+          artifact_name="required-checks-${dev_tree}"
+          artifact=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/artifacts?name=${artifact_name}" \
+            --jq '[.artifacts[] | select(.expired == false)] | sort_by(.created_at) | last')
+          artifact_id=$(jq -r '.id // empty' <<<"$artifact")
+          run_id=$(jq -r '.workflow_run.id // empty' <<<"$artifact")
+          if [ -z "$artifact_id" ] || [ -z "$run_id" ]; then
+            echo "No reusable proof exists for tree $dev_tree; running full CI."
+            exit 0
+          fi
+
+          run=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/runs/${run_id}")
+          conclusion=$(jq -r '.conclusion' <<<"$run")
+          workflow_path=$(jq -r '.path' <<<"$run")
+          if [ "$workflow_path" != ".github/workflows/ci-required.yml" ] || [ "$conclusion" != "success" ]; then
+            echo "::error::Required-check proof came from ${workflow_path} with conclusion ${conclusion}"
+            exit 1
+          fi
+          echo "artifact_id=$artifact_id" >> "$GITHUB_OUTPUT"
+          echo "run_id=$run_id" >> "$GITHUB_OUTPUT"
+          echo "reuse=true" >> "$GITHUB_OUTPUT"
+
+      - name: Download exact-tree proof
+        if: steps.proof.outputs.reuse == 'true'
+        uses: actions/download-artifact@v8
+        with:
+          artifact-ids: ${{ steps.proof.outputs.artifact_id }}
+          github-token: ${{ github.token }}
+          repository: ${{ github.repository }}
+          run-id: ${{ steps.proof.outputs.run_id }}
+          path: required-check-proof
+
+      - name: Verify exact-tree proof
+        if: steps.proof.outputs.reuse == 'true'
+        env:
+          EXPECTED_TREE: ${{ steps.proof.outputs.tree }}
+        run: |
+          jq -e \
+            --arg repository "$GITHUB_REPOSITORY" \
+            --arg tree "$EXPECTED_TREE" \
+            '.schemaVersion == 1 and .repository == $repository and .tree == $tree' \
+            required-check-proof/required-checks.json
+
+  android:
+    needs: [changes, release-proof]
+    if: ${{ always() && needs.changes.result == 'success' && needs.changes.outputs.android == 'true' && needs.release-proof.outputs.reuse != 'true' && (github.event_name != 'workflow_dispatch' || inputs.android_preset == 'auto') }}
     uses: ./.github/workflows/ci-android.yml
 
+  android_on_demand:
+    needs: [changes, release-proof]
+    if: ${{ always() && needs.changes.result == 'success' && needs.release-proof.outputs.reuse != 'true' && github.event_name == 'workflow_dispatch' && inputs.android_preset != 'auto' }}
+    uses: ./.github/workflows/android-on-demand.yml
+    with:
+      head_sha: ${{ inputs.head_sha }}
+      preset: ${{ inputs.android_preset }}
+
   desktop:
-    needs: changes
-    if: needs.changes.outputs.desktop == 'true'
+    needs: [changes, release-proof]
+    if: ${{ always() && needs.changes.result == 'success' && needs.changes.outputs.desktop == 'true' && needs.release-proof.outputs.reuse != 'true' && (github.event_name != 'workflow_dispatch' || inputs.android_preset == 'auto') }}
     uses: ./.github/workflows/ci-desktop.yml
 
   plugin:
-    needs: changes
-    if: needs.changes.outputs.plugin == 'true'
+    needs: [changes, release-proof]
+    if: ${{ always() && needs.changes.result == 'success' && needs.changes.outputs.plugin == 'true' && needs.release-proof.outputs.reuse != 'true' && (github.event_name != 'workflow_dispatch' || inputs.android_preset == 'auto') }}
     uses: ./.github/workflows/ci-plugin.yml
 
   dashboard:
-    needs: changes
-    if: needs.changes.outputs.dashboard == 'true'
+    needs: [changes, release-proof]
+    if: ${{ always() && needs.changes.result == 'success' && needs.changes.outputs.dashboard == 'true' && needs.release-proof.outputs.reuse != 'true' && (github.event_name != 'workflow_dispatch' || inputs.android_preset == 'auto') }}
     uses: ./.github/workflows/ci-dashboard.yml
 
   contract:
-    needs: changes
-    if: needs.changes.outputs.contract == 'true'
+    needs: [changes, release-proof]
+    if: ${{ always() && needs.changes.result == 'success' && needs.changes.outputs.contract == 'true' && needs.release-proof.outputs.reuse != 'true' && (github.event_name != 'workflow_dispatch' || inputs.android_preset == 'auto') }}
     uses: ./.github/workflows/ci-contract.yml
 
   docs:
     name: Build public docs
-    needs: changes
-    if: needs.changes.outputs.docs == 'true'
+    needs: [changes, release-proof]
+    if: ${{ always() && needs.changes.result == 'success' && needs.changes.outputs.docs == 'true' && needs.release-proof.outputs.reuse != 'true' && (github.event_name != 'workflow_dispatch' || inputs.android_preset == 'auto') }}
     runs-on: ubuntu-latest
     defaults:
       run:
@@ -161,11 +278,14 @@ jobs:
   guard:
     name: Required checks
     if: always()
-    needs: [changes, android, desktop, plugin, dashboard, contract, docs]
+    needs: [changes, release-proof, android, android_on_demand, desktop, plugin, dashboard, contract, docs]
     runs-on: ubuntu-latest
     env:
       CHANGES_RESULT: ${{ needs.changes.result }}
+      RELEASE_PROOF_RESULT: ${{ needs.release-proof.result }}
+      REUSED_REQUIRED_CHECKS: ${{ needs.release-proof.outputs.reuse }}
       ANDROID_RESULT: ${{ needs.android.result }}
+      ANDROID_ON_DEMAND_RESULT: ${{ needs.android_on_demand.result }}
       DESKTOP_RESULT: ${{ needs.desktop.result }}
       PLUGIN_RESULT: ${{ needs.plugin.result }}
       DASHBOARD_RESULT: ${{ needs.dashboard.result }}
@@ -176,7 +296,7 @@ jobs:
         shell: bash
         run: |
           failed=0
-          for check in CHANGES ANDROID DESKTOP PLUGIN DASHBOARD CONTRACT DOCS; do
+          for check in CHANGES RELEASE_PROOF ANDROID ANDROID_ON_DEMAND DESKTOP PLUGIN DASHBOARD CONTRACT DOCS; do
             result_var="${check}_RESULT"
             result="${!result_var}"
             echo "$check: $result"
@@ -186,3 +306,26 @@ jobs:
             esac
           done
           exit "$failed"
+
+      - name: Write exact-tree proof
+        if: ${{ needs.release-proof.outputs.reuse != 'true' }}
+        env:
+          CHECKED_TREE: ${{ needs.changes.outputs.tree }}
+        run: |
+          mkdir -p required-check-proof
+          jq -n \
+            --arg repository "$GITHUB_REPOSITORY" \
+            --arg tree "$CHECKED_TREE" \
+            --arg commit "$GITHUB_SHA" \
+            --arg run_id "$GITHUB_RUN_ID" \
+            '{schemaVersion: 1, repository: $repository, tree: $tree, commit: $commit, runId: $run_id}' \
+            > required-check-proof/required-checks.json
+
+      - name: Upload exact-tree proof
+        if: ${{ needs.release-proof.outputs.reuse != 'true' }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: required-checks-${{ needs.changes.outputs.tree }}
+          path: required-check-proof/required-checks.json
+          if-no-files-found: error
+          retention-days: 30

.github/workflows/play-listing.yml

@@ -70,7 +70,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17

.github/workflows/play-preflight-android.yml

@@ -2,10 +2,11 @@
 #
 # Run manually from the final dev or untagged main tree before creating
 # android-v*. The job
-# builds the same signed release artifacts, scans final DEX, and uploads the
-# Google Play bundle as a production DRAFT. A successful upload is the automated
-# Play gate while no public GitHub Release or sideload APK exists. Console-only
-# pre-review and pre-launch reports are informational and do not block release.
+# builds the signed release artifacts once, scans the final packages, and uploads
+# the Google Play bundle as a production DRAFT. The exact signed APK/AAB,
+# mappings, manifest, and checksums remain private Actions artifacts until
+# approval publishes those same bytes. Console-only pre-review and pre-launch
+# reports are informational and do not block release.
 
 name: Hermes-Relay Android Play Preflight
 
@@ -68,7 +69,7 @@ jobs:
           fi
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17
@@ -98,7 +99,12 @@ jobs:
           HERMES_KEYSTORE_PASSWORD: ${{ secrets.HERMES_KEYSTORE_PASSWORD }}
           HERMES_KEY_ALIAS: ${{ secrets.HERMES_KEY_ALIAS }}
           HERMES_KEY_PASSWORD: ${{ secrets.HERMES_KEY_PASSWORD }}
-        run: ./gradlew bundleRelease assembleRelease --console=plain
+        run: |
+          ./gradlew \
+            :app:bundleGooglePlayRelease \
+            :app:assembleGooglePlayRelease \
+            :app:assembleSideloadRelease \
+            --console=plain
 
       - name: Scan final release DEX
         run: |
@@ -106,6 +112,12 @@ jobs:
             --apk app/build/outputs/apk/googlePlay/release/*.apk \
             --apk app/build/outputs/apk/sideload/release/*.apk
 
+      - name: Verify packaged native compatibility
+        run: |
+          python3 scripts/check-android-native-compat.py \
+            app/build/outputs/apk/googlePlay/release/*.apk \
+            app/build/outputs/apk/sideload/release/*.apk
+
       - name: Upload private production draft to Play
         env:
           PLAY_SERVICE_ACCOUNT_JSON: ${{ secrets.PLAY_SERVICE_ACCOUNT_JSON }}
@@ -121,27 +133,27 @@ jobs:
             --resolution-strategy=ignore \
             --release-name="Hermes-Relay Android v${{ steps.metadata.outputs.version }}"
 
-      - name: Record successful preflight for the exact commit
+      - name: Package immutable preflight artifacts
         run: |
-          mkdir -p app/build/reports
-          cat > app/build/reports/play-preflight.json <<EOF
-          {
-            "version": "${{ steps.metadata.outputs.version }}",
-            "versionCode": "${{ steps.metadata.outputs.version_code }}",
-            "commit": "$GITHUB_SHA",
-            "tree": "${{ steps.metadata.outputs.tree }}",
-            "track": "production",
-            "status": "draft"
-          }
-          EOF
+          python3 scripts/android_release_artifacts.py package \
+            --version "${{ steps.metadata.outputs.version }}" \
+            --version-code "${{ steps.metadata.outputs.version_code }}" \
+            --commit "$GITHUB_SHA" \
+            --tree "${{ steps.metadata.outputs.tree }}" \
+            --sideload-apk app/build/outputs/apk/sideload/release/*.apk \
+            --google-play-aab app/build/outputs/bundle/googlePlayRelease/*.aab \
+            --sideload-mapping app/build/outputs/mapping/sideloadRelease/mapping.txt \
+            --google-play-mapping app/build/outputs/mapping/googlePlayRelease/mapping.txt \
+            --output app/build/preflight-artifacts
 
-      - name: Upload preflight proof
+      - name: Upload immutable preflight artifacts
         uses: actions/upload-artifact@v7
         with:
           name: play-preflight-${{ steps.metadata.outputs.version }}-${{ steps.metadata.outputs.tree }}
-          path: app/build/reports/play-preflight.json
+          path: app/build/preflight-artifacts/*
           if-no-files-found: error
           retention-days: 30
+          compression-level: 0
 
       - name: Preflight summary
         run: |
@@ -152,4 +164,4 @@ jobs:
           echo "- Release tree: \`${{ steps.metadata.outputs.tree }}\`" >> "$GITHUB_STEP_SUMMARY"
           echo "- Play track/status: **Production draft**" >> "$GITHUB_STEP_SUMMARY"
           echo "" >> "$GITHUB_STEP_SUMMARY"
-          echo "The signed build, DEX scan, and Play draft upload passed. Ensure this exact release tree is on main, then run **Hermes-Relay Android Release Approval** from main. Console-only reports are informational and non-blocking." >> "$GITHUB_STEP_SUMMARY"
+          echo "The signed build, package scans, and Play draft upload passed. Approval will publish these exact private artifacts if the unchanged tree reaches main. Console-only reports are informational and non-blocking." >> "$GITHUB_STEP_SUMMARY"

.github/workflows/release-android.yml

@@ -36,6 +36,9 @@ jobs:
       version: ${{ steps.version.outputs.version }}
       version_code: ${{ steps.version.outputs.version_code }}
       prerelease: ${{ steps.version.outputs.prerelease }}
+      release_tree: ${{ steps.version.outputs.release_tree }}
+      preflight_artifact_id: ${{ steps.preflight.outputs.artifact_id }}
+      preflight_run_id: ${{ steps.preflight.outputs.run_id }}
     steps:
       - uses: actions/checkout@v7
         with:
@@ -66,6 +69,7 @@ jobs:
           echo "version=$REF_VERSION" >> "$GITHUB_OUTPUT"
           echo "version_code=$VERSION_CODE" >> "$GITHUB_OUTPUT"
           echo "prerelease=$PRERELEASE" >> "$GITHUB_OUTPUT"
+          echo "release_tree=$(git rev-parse 'HEAD^{tree}')" >> "$GITHUB_OUTPUT"
 
       - name: Verify version sync
         run: |
@@ -110,25 +114,38 @@ jobs:
           fi
 
       - name: Require successful Play preflight for this exact release tree
+        id: preflight
         if: ${{ !contains(steps.version.outputs.version, '-') }}
         env:
           GH_TOKEN: ${{ github.token }}
           VERSION: ${{ steps.version.outputs.version }}
         run: |
-          RELEASE_TREE=$(git rev-parse 'HEAD^{tree}')
+          RELEASE_TREE="${{ steps.version.outputs.release_tree }}"
           ARTIFACT_NAME="play-preflight-${VERSION}-${RELEASE_TREE}"
-          COUNT=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/artifacts?name=${ARTIFACT_NAME}" \
-            --jq '[.artifacts[] | select(.expired == false)] | length')
-          if [ "$COUNT" -lt 1 ]; then
+          ARTIFACT=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/artifacts?name=${ARTIFACT_NAME}" \
+            --jq '[.artifacts[] | select(.expired == false)] | sort_by(.created_at) | last')
+          ARTIFACT_ID=$(jq -r '.id // empty' <<<"$ARTIFACT")
+          RUN_ID=$(jq -r '.workflow_run.id // empty' <<<"$ARTIFACT")
+          if [ -z "$ARTIFACT_ID" ] || [ -z "$RUN_ID" ]; then
             echo "::error::No successful Play preflight found for version $VERSION with tree $RELEASE_TREE"
             echo "Run Hermes-Relay Android Play Preflight from the final dev tree, merge that unchanged tree to main, then approve the release."
             exit 1
           fi
-          echo "Play preflight proof found: $ARTIFACT_NAME"
+          RUN=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/runs/${RUN_ID}")
+          CONCLUSION=$(jq -r '.conclusion' <<<"$RUN")
+          WORKFLOW_PATH=$(jq -r '.path' <<<"$RUN")
+          if [ "$WORKFLOW_PATH" != ".github/workflows/play-preflight-android.yml" ] || [ "$CONCLUSION" != "success" ]; then
+            echo "::error::Preflight artifact came from ${WORKFLOW_PATH} with conclusion ${CONCLUSION}"
+            exit 1
+          fi
+          echo "artifact_id=$ARTIFACT_ID" >> "$GITHUB_OUTPUT"
+          echo "run_id=$RUN_ID" >> "$GITHUB_OUTPUT"
+          echo "Play preflight artifacts verified: $ARTIFACT_NAME (run $RUN_ID, artifact $ARTIFACT_ID)"
 
   ci:
-    name: CI Checks
+    name: CI Checks (prerelease only)
     needs: validate
+    if: ${{ needs.validate.outputs.prerelease == 'true' }}
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
@@ -137,7 +154,7 @@ jobs:
           ref: ${{ github.event_name == 'workflow_dispatch' && format('android-v{0}', inputs.version) || github.ref }}
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17
@@ -168,6 +185,7 @@ jobs:
   release:
     name: Build & Publish Release
     needs: [validate, ci]
+    if: ${{ always() && needs.validate.result == 'success' && (needs.ci.result == 'success' || needs.ci.result == 'skipped') }}
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
@@ -176,7 +194,7 @@ jobs:
           ref: ${{ github.event_name == 'workflow_dispatch' && format('android-v{0}', inputs.version) || github.ref }}
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17
@@ -186,31 +204,33 @@ jobs:
         with:
           cache-read-only: false
 
-      - name: Decode release keystore
+      - name: Download exact stable preflight artifacts
+        if: ${{ needs.validate.outputs.prerelease != 'true' }}
+        uses: actions/download-artifact@v8
+        with:
+          artifact-ids: ${{ needs.validate.outputs.preflight_artifact_id }}
+          github-token: ${{ github.token }}
+          repository: ${{ github.repository }}
+          run-id: ${{ needs.validate.outputs.preflight_run_id }}
+          path: app/build/preflight-artifacts
+
+      - name: Verify exact stable preflight artifacts
+        if: ${{ needs.validate.outputs.prerelease != 'true' }}
+        run: |
+          python3 scripts/android_release_artifacts.py verify \
+            --version "${{ needs.validate.outputs.version }}" \
+            --version-code "${{ needs.validate.outputs.version_code }}" \
+            --tree "${{ needs.validate.outputs.release_tree }}" \
+            --directory app/build/preflight-artifacts
+
+      - name: Decode release keystore for candidate build
         env:
           HERMES_KEYSTORE_BASE64: ${{ secrets.HERMES_KEYSTORE_BASE64 }}
-        if: env.HERMES_KEYSTORE_BASE64 != ''
+        if: ${{ needs.validate.outputs.prerelease == 'true' && env.HERMES_KEYSTORE_BASE64 != '' }}
         run: |
           echo "$HERMES_KEYSTORE_BASE64" | base64 -d > "$RUNNER_TEMP/release.keystore"
           echo "HERMES_KEYSTORE_PATH=$RUNNER_TEMP/release.keystore" >> "$GITHUB_ENV"
 
-      - name: Build stable release artifacts (APK + AAB)
-        if: ${{ needs.validate.outputs.prerelease != 'true' }}
-        env:
-          HERMES_KEYSTORE_PASSWORD: ${{ secrets.HERMES_KEYSTORE_PASSWORD }}
-          HERMES_KEY_ALIAS: ${{ secrets.HERMES_KEY_ALIAS }}
-          HERMES_KEY_PASSWORD: ${{ secrets.HERMES_KEY_PASSWORD }}
-        # `assembleRelease` and `bundleRelease` are flavor-wide task aliases
-        # (added by `flavorDimensions += "track"` in app/build.gradle.kts), so
-        # this one line builds ALL four artifacts at once. Filenames come from
-        # `archivesName` (set in app/build.gradle.kts) which injects the app
-        # version, so `<version>` below is `libs.versions.appVersionName`:
-        #   app/build/outputs/apk/googlePlay/release/hermes-relay-<version>-googlePlay-release.apk
-        #   app/build/outputs/apk/sideload/release/hermes-relay-<version>-sideload-release.apk
-        #   app/build/outputs/bundle/googlePlayRelease/hermes-relay-<version>-googlePlay-release.aab
-        #   app/build/outputs/bundle/sideloadRelease/hermes-relay-<version>-sideload-release.aab
-        run: ./gradlew bundleRelease assembleRelease
-
       - name: Build side-by-side release candidate APK
         if: ${{ needs.validate.outputs.prerelease == 'true' }}
         env:
@@ -234,10 +254,10 @@ jobs:
         if: ${{ needs.validate.outputs.prerelease != 'true' }}
         uses: actions/upload-artifact@v7
         with:
-          name: android-r8-mappings-${{ needs.validate.outputs.version }}-${{ github.sha }}
+          name: android-r8-mappings-${{ needs.validate.outputs.version }}-${{ needs.validate.outputs.release_tree }}
           path: |
-            app/build/outputs/mapping/googlePlayRelease/mapping.txt
-            app/build/outputs/mapping/sideloadRelease/mapping.txt
+            app/build/preflight-artifacts/mapping-googlePlayRelease.txt
+            app/build/preflight-artifacts/mapping-sideloadRelease.txt
           if-no-files-found: error
           retention-days: 90
 
@@ -254,8 +274,7 @@ jobs:
         if: ${{ needs.validate.outputs.prerelease != 'true' }}
         run: |
           python3 scripts/check-android-collection-apis.py \
-            --apk app/build/outputs/apk/googlePlay/release/*.apk \
-            --apk app/build/outputs/apk/sideload/release/*.apk
+            --apk app/build/preflight-artifacts/*-sideload-release.apk
 
       - name: Scan candidate DEX for unsupported collection APIs
         if: ${{ needs.validate.outputs.prerelease == 'true' }}
@@ -267,8 +286,7 @@ jobs:
         if: ${{ needs.validate.outputs.prerelease != 'true' }}
         run: |
           python3 scripts/check-android-native-compat.py \
-            app/build/outputs/apk/googlePlay/release/*.apk \
-            app/build/outputs/apk/sideload/release/*.apk
+            app/build/preflight-artifacts/*-sideload-release.apk
 
       - name: Verify candidate packaged ONNX Runtime compatibility
         if: ${{ needs.validate.outputs.prerelease == 'true' }}
@@ -278,23 +296,10 @@ jobs:
 
       - name: List produced artifacts (debug aid)
         run: |
-          echo "=== APK outputs ==="
+          echo "=== Reused stable artifacts ==="
+          find app/build/preflight-artifacts -maxdepth 1 -type f -print 2>/dev/null || true
+          echo "=== Candidate APK outputs ==="
           find app/build/outputs/apk -name '*.apk' -print 2>/dev/null || true
-          echo "=== AAB outputs ==="
-          find app/build/outputs/bundle -name '*.aab' -print 2>/dev/null || true
-
-      - name: Generate stable checksums
-        if: ${{ needs.validate.outputs.prerelease != 'true' }}
-        # Flavor dimension adds an extra path segment to the AGP output layout.
-        # APKs live under `apk/<flavor>/release/`, AABs under `bundle/<flavor>Release/`
-        # (note the concatenated camelCase — AGP path quirk, documented but
-        # different between APK and AAB). Checksums cover EXACTLY the files
-        # attached to the GitHub Release (see the 2-asset policy on the
-        # release step below) so SHA256SUMS.txt matches the assets 1:1.
-        run: |
-          cd app/build/outputs
-          sha256sum apk/sideload/release/*.apk bundle/googlePlayRelease/*.aab > SHA256SUMS.txt
-          cat SHA256SUMS.txt
 
       - name: Generate candidate checksums
         if: ${{ needs.validate.outputs.prerelease == 'true' }}
@@ -340,9 +345,9 @@ jobs:
           # Deliberate 2-asset policy (#144): attach ONLY the installable
           # sideload APK and Play AAB, plus checksums covering those files.
           files: |
-            app/build/outputs/apk/sideload/release/*.apk
-            app/build/outputs/bundle/googlePlayRelease/*.aab
-            app/build/outputs/SHA256SUMS.txt
+            app/build/preflight-artifacts/*-sideload-release.apk
+            app/build/preflight-artifacts/*-googlePlay-release.aab
+            app/build/preflight-artifacts/SHA256SUMS.txt
 
       - name: Create candidate GitHub prerelease
         if: ${{ needs.validate.outputs.prerelease == 'true' }}
@@ -364,18 +369,17 @@ jobs:
         run: |
           echo "## Hermes-Relay Android v${{ needs.validate.outputs.version }}" >> "$GITHUB_STEP_SUMMARY"
           echo "" >> "$GITHUB_STEP_SUMMARY"
-          if [ "$PRERELEASE" = "true" ] && [ -n "$HERMES_KEYSTORE_BASE64" ]; then
-            echo "✅ **Release-signed HR Candidate app** — separate package ID; never uploaded to Play" >> "$GITHUB_STEP_SUMMARY"
-          elif [ "$PRERELEASE" = "true" ]; then
-            echo "⚠️ **Debug-signed HR Candidate app** — separate package ID; never uploaded to Play" >> "$GITHUB_STEP_SUMMARY"
+          if [ "$PRERELEASE" != "true" ]; then
+            echo "✅ **Published the exact signed Play-preflight artifacts**" >> "$GITHUB_STEP_SUMMARY"
           elif [ -n "$HERMES_KEYSTORE_BASE64" ]; then
-            echo "✅ **Signed with release keystore** — suitable for Play Store upload" >> "$GITHUB_STEP_SUMMARY"
+            echo "✅ **Release-signed HR Candidate app** — separate package ID; never uploaded to Play" >> "$GITHUB_STEP_SUMMARY"
           else
-            echo "⚠️ **Debug-signed** (no \`HERMES_KEYSTORE_BASE64\` secret) — NOT suitable for Play Store. Add the secret in repo settings to enable release signing." >> "$GITHUB_STEP_SUMMARY"
+            echo "⚠️ **Debug-signed HR Candidate app** — separate package ID; never uploaded to Play" >> "$GITHUB_STEP_SUMMARY"
           fi
           echo "" >> "$GITHUB_STEP_SUMMARY"
           echo "### Artifacts" >> "$GITHUB_STEP_SUMMARY"
           echo '```' >> "$GITHUB_STEP_SUMMARY"
+          find app/build/preflight-artifacts -maxdepth 1 -type f -exec ls -la {} + >> "$GITHUB_STEP_SUMMARY" 2>/dev/null || true
           find app/build/outputs/apk -name '*.apk' -exec ls -la {} + >> "$GITHUB_STEP_SUMMARY" 2>/dev/null || true
           find app/build/outputs/bundle -name '*.aab' -exec ls -la {} + >> "$GITHUB_STEP_SUMMARY" 2>/dev/null || true
           echo '```' >> "$GITHUB_STEP_SUMMARY"

.github/workflows/release-cli.yml

@@ -3,6 +3,12 @@ name: Hermes-Relay CLI+UI Release
 on:
   push:
     tags: ['desktop-v*']
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Approved CLI+UI version"
+        required: true
+        type: string
 
 permissions:
   contents: write
@@ -20,6 +26,7 @@ jobs:
       - uses: actions/checkout@v7
         with:
           fetch-depth: 0
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('desktop-v{0}', inputs.version) || github.ref }}
 
       - name: Setup Node.js
         uses: actions/setup-node@v7
@@ -34,10 +41,16 @@ jobs:
       - name: Extract and validate tag version
         id: version
         shell: bash
+        env:
+          DISPATCHED_VERSION: ${{ inputs.version }}
         run: |
           set -euo pipefail
-          version="${GITHUB_REF_NAME#desktop-v}"
-          if [[ -z "$version" || "$version" == "$GITHUB_REF_NAME" ]]; then
+          if [ -n "$DISPATCHED_VERSION" ]; then
+            version="$DISPATCHED_VERSION"
+          else
+            version="${GITHUB_REF_NAME#desktop-v}"
+          fi
+          if [ -z "$version" ] || { [ -z "$DISPATCHED_VERSION" ] && [ "$version" = "$GITHUB_REF_NAME" ]; }; then
             echo "Expected a desktop-v* tag, got $GITHUB_REF_NAME" >&2
             exit 1
           fi
@@ -51,11 +64,12 @@ jobs:
       - name: Verify tag belongs to the correct integration branch
         shell: bash
         working-directory: .
+        env:
+          TAG_VERSION: ${{ steps.version.outputs.version }}
         run: |
           set -euo pipefail
-          version="${GITHUB_REF_NAME#desktop-v}"
-          tag_commit="$(git rev-parse "${GITHUB_REF_NAME}^{commit}")"
-          if [[ "$version" == *-* ]]; then
+          tag_commit="$(git rev-parse HEAD)"
+          if [[ "$TAG_VERSION" == *-* ]]; then
             git fetch origin dev --no-tags
             if ! git merge-base --is-ancestor "$tag_commit" origin/dev; then
               echo "CLI+UI prereleases must be tagged from dev; $tag_commit is not in origin/dev" >&2
@@ -78,6 +92,8 @@ jobs:
         working-directory: desktop
     steps:
       - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('desktop-v{0}', inputs.version) || github.ref }}
 
       - name: Setup Node.js (for npm ci + tsc)
         uses: actions/setup-node@v7
@@ -271,6 +287,8 @@ jobs:
         working-directory: desktop
     steps:
       - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('desktop-v{0}', inputs.version) || github.ref }}
 
       - name: Setup Node.js
         uses: actions/setup-node@v7
@@ -289,6 +307,18 @@ jobs:
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@stable
 
+      - name: Restore exact-source tray build cache
+        uses: actions/cache@v6
+        with:
+          path: |
+            ~/.cargo/registry/index
+            ~/.cargo/registry/cache
+            ~/.cargo/git/db
+            desktop/tray/target
+          key: ${{ runner.os }}-tray-rust-${{ hashFiles('desktop/tray/Cargo.lock') }}-${{ hashFiles('desktop/tray/Cargo.toml', 'desktop/tray/build.rs', 'desktop/tray/src/**/*.rs') }}
+          restore-keys: |
+            ${{ runner.os }}-tray-rust-${{ hashFiles('desktop/tray/Cargo.lock') }}-
+
       - name: Install deps
         run: npm ci && npm --prefix tray ci
 
@@ -411,6 +441,11 @@ jobs:
             if ($versionOutput -ne "hermes-relay $env:EXPECTED_DESKTOP_VERSION") {
               throw "installed CLI version mismatch: expected $env:EXPECTED_DESKTOP_VERSION, got '$versionOutput'"
             }
+            $tray = Join-Path $installDir 'hermes-relay-tray.exe'
+            $trayVersion = (Get-Item -LiteralPath $tray).VersionInfo.ProductVersion
+            if ($trayVersion -ne $env:EXPECTED_DESKTOP_VERSION) {
+              throw "installed UI version mismatch: expected $env:EXPECTED_DESKTOP_VERSION, got '$trayVersion'"
+            }
             $helpOutput = (& $cli --help | Out-String)
             if ($LASTEXITCODE -ne 0 -or $helpOutput -notmatch 'Usage:') {
               throw 'installed CLI --help smoke failed'
@@ -451,7 +486,7 @@ jobs:
               throw "installer lifecycle changed the pre-existing tray startup preference"
             }
 
-            Write-Host "packaged installer lifecycle smoke OK version=$versionOutput install=$installDir"
+            Write-Host "packaged installer lifecycle smoke OK cli=$versionOutput ui=$trayVersion install=$installDir"
           } finally {
             Get-Process -Name 'hermes-relay-tray' -ErrorAction SilentlyContinue |
               Stop-Process -Force -ErrorAction SilentlyContinue
@@ -483,6 +518,7 @@ jobs:
     name: Publish GitHub Release
     runs-on: ubuntu-latest
     needs:
+      - validate-release
       - build-cli-binaries
       - smoke-windows-cli-release-asset
       - smoke-macos-cli-release-asset
@@ -492,10 +528,8 @@ jobs:
       # Needed so CLI_RELEASE_NOTES.md is available to render into the release body
       # (the other publish-release steps only consume downloaded build artifacts).
       - uses: actions/checkout@v7
-
-      - name: Extract CLI+UI version
-        id: version
-        run: echo "version=${GITHUB_REF_NAME#desktop-v}" >> "$GITHUB_OUTPUT"
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('desktop-v{0}', inputs.version) || github.ref }}
 
       - uses: actions/download-artifact@v8
         with:
@@ -515,8 +549,8 @@ jobs:
       # (desktop-v0.3.0) so install/pin commands stay accurate without manual edits.
       - name: Render release notes
         env:
-          VERSION: ${{ steps.version.outputs.version }}
-          TAG: ${{ github.ref_name }}
+          VERSION: ${{ needs.validate-release.outputs.version }}
+          TAG: desktop-v${{ needs.validate-release.outputs.version }}
         run: |
           sed -e "s/__VERSION__/${VERSION}/g" -e "s/__TAG__/${TAG}/g" \
             CLI_RELEASE_NOTES.md > cli_release_notes_rendered.md
@@ -525,10 +559,10 @@ jobs:
       - name: Publish GitHub Release
         uses: softprops/action-gh-release@v3
         with:
-          name: Hermes-Relay CLI+UI v${{ steps.version.outputs.version }}
-          tag_name: ${{ github.ref_name }}
+          name: Hermes-Relay CLI+UI v${{ needs.validate-release.outputs.version }}
+          tag_name: desktop-v${{ needs.validate-release.outputs.version }}
           draft: false
-          prerelease: ${{ contains(steps.version.outputs.version, 'alpha') || contains(steps.version.outputs.version, 'beta') || contains(steps.version.outputs.version, 'rc') }}
+          prerelease: ${{ contains(needs.validate-release.outputs.version, '-') }}
           fail_on_unmatched_files: true
           body_path: cli_release_notes_rendered.md
           files: |

.github/workflows/release-plugin.yml

@@ -4,6 +4,12 @@ on:
   push:
     tags:
       - "server-v*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Approved Plugin version"
+        required: true
+        type: string
 
 permissions:
   contents: write
@@ -19,10 +25,19 @@ jobs:
       - uses: actions/checkout@v7
         with:
           fetch-depth: 0
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('server-v{0}', inputs.version) || github.ref }}
 
       - name: Extract version from tag
         id: version
-        run: echo "version=${GITHUB_REF#refs/tags/server-v}" >> "$GITHUB_OUTPUT"
+        env:
+          DISPATCHED_VERSION: ${{ inputs.version }}
+        run: |
+          if [ -n "$DISPATCHED_VERSION" ]; then
+            version="$DISPATCHED_VERSION"
+          else
+            version="${GITHUB_REF#refs/tags/server-v}"
+          fi
+          echo "version=$version" >> "$GITHUB_OUTPUT"
 
       - name: Verify Plugin version sync and changelog
         run: |
@@ -61,6 +76,8 @@ jobs:
     timeout-minutes: 15
     steps:
       - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('server-v{0}', inputs.version) || github.ref }}
 
       - name: Set up Python 3.11
         uses: actions/setup-python@v7
@@ -85,11 +102,16 @@ jobs:
       - name: Run focused Plugin tests
         run: |
           python -m pytest \
+            plugin/tests/test_manifest_compatibility.py \
             plugin/tests/test_relay_security.py \
             plugin/tests/test_voice_routes.py \
             plugin/tests/test_session_grants.py \
             plugin/tests/test_proactive_channel.py \
-            plugin/tests/test_android_phone_status.py
+            plugin/tests/test_android_phone_status.py \
+            plugin/tests/test_android_tool.py \
+            plugin/tests/test_android_navigate.py \
+            plugin/tests/test_phone_platform.py \
+            plugin/tests/test_desktop_tool_availability.py
 
   package:
     name: Build and publish Plugin package
@@ -98,6 +120,8 @@ jobs:
     timeout-minutes: 15
     steps:
       - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('server-v{0}', inputs.version) || github.ref }}
 
       - name: Set up Python 3.11
         uses: actions/setup-python@v7

.github/workflows/review-bundle.yml

@@ -83,7 +83,7 @@ jobs:
         run: test "$(git rev-parse HEAD)" = "$EXPECTED_SHA"
 
       - name: Set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
         with:
           distribution: temurin
           java-version: 17

.gitignore

@@ -24,10 +24,7 @@ Thumbs.db
 local.properties
 /build/
 /app/build/
-/relay-core/build/
-/relay-ui/build/
-/ui-preview/build/
-/quest/build/
+/experiments/quest/**/build/
 /app/release/
 *.apk
 *.aab

AGENTS.md

@@ -7,14 +7,17 @@ coding agent (Claude Code, Codex, Cursor, etc.).
 
 This file is the provider-neutral canonical agent context. Read it before
 touching code, then `docs/spec.md` and `docs/decisions.md`. Provider adapters
-such as **[CLAUDE.md](CLAUDE.md)** may add tool-specific guidance, but they do
-not redefine the branch, release, or hotfix policy here and in `RELEASE.md`.
+such as **[CLAUDE.md](CLAUDE.md)** import this file instead of duplicating
+policy. They do not redefine the branch, release, hotfix, or verification
+contract here and in `RELEASE.md`.
 
 - Release process → **[RELEASE.md](RELEASE.md)**
 - Contributor setup → **[CONTRIBUTING.md](CONTRIBUTING.md)**
 - Gateway/session/reconnect testing → **[docs/gateway-contract-testing.md](docs/gateway-contract-testing.md)**
+- Android local/cloud verification → **[docs/android-build-lane.md](docs/android-build-lane.md)**
+- Android emulator lanes → **[docs/android-emulator-testing.md](docs/android-emulator-testing.md)** — suggest the smallest relevant API 36 lanes; never run the full matrix automatically
 - `android_*` toolset + MCP → **[docs/mcp-tooling.md](docs/mcp-tooling.md)**
-- Follow-ups / deferred work / known gaps → **[TODO.md](TODO.md)** (the single home for "what's next" — never DEVLOG, never scattered code comments)
+- Follow-ups / deferred work / known gaps → **[docs/project/TODO.md](docs/project/TODO.md)** (the single home for "what's next" — never DEVLOG, never scattered code comments)
 
 ## Branch contract
 
@@ -62,8 +65,10 @@ PR; never resolve those cases by choosing a side automatically.
 
 - **Vanilla Hermes path = upstream-only.** The standard (no-plugin) connection
   uses the upstream Dashboard/Gateway for chat, authentication, Manage, sessions,
-  and Vanilla Hermes voice. The API server is an optional automatic fallback and
-  advanced headless-compatibility surface; Relay adds optional extensions. This
+  and Vanilla Hermes voice. The API server is an explicit API-only/headless
+  compatibility surface; Relay adds optional extensions. A Gateway-owned
+  conversation never changes transport because Gateway auth or reachability
+  changes. This
   path must work against unmodified upstream hermes-agent. Server-side needs go
   through upstream PRs or the optional relay plugin, never fork patches.
 - **Verify endpoints against upstream** (`gateway/platforms/api_server.py` /
@@ -83,16 +88,21 @@ PR; never resolve those cases by choosing a side automatically.
   Version bumps happen only on a release-prep branch targeting `dev`, and
   production tags are cut only from `main`.
 - **Android:** Jetpack Compose only (no XML), kotlinx.serialization (no Gson),
-  OkHttp (no Ktor), `wss://` only. Run `./gradlew lint` before pushing Kotlin.
-  For interactive device-review loops, run focused tests plus the affected
-  assemble/install task; run the full affected-variant lint once when the
-  combined candidate is final, or earlier only for lint-sensitive resource,
-  manifest, dependency, or build-configuration changes. Do not repeat full
-  variant lint after every small Kotlin iteration.
+  OkHttp (no Ktor), `wss://` only. While editing, use only the narrow local
+  compile or focused test needed for feedback, through `scripts/android-lane.ps1`
+  on Windows. Once an exact commit is already pushed, prefer the `Android
+  On-Demand` workflow for lint, the focused shards, both-flavor assemblies, and
+  release smoke; isolated cloud jobs may run concurrently. Do not push solely
+  to obtain cloud compute without push authorization, and do not duplicate a
+  preset already running for the same SHA. Full local verification remains
+  available through `scripts/dev.bat prepush` (or `./scripts/dev.sh prepush`)
+  when explicitly wanted or when cloud execution is unavailable.
+  Physical-device checks and APK installation remain separately owned local
+  evidence.
 - **Plugin (Python 3.11+):** aiohttp + asyncio (no threading), type hints
   everywhere, structured `logging` (no `print`). **Desktop CLI (Node ≥21):**
-  zero runtime deps, strict TS + ES modules, ship compiled `dist/`. Full
-  per-language style and the dev loop live in CLAUDE.md → "Code Style".
+  zero runtime deps, strict TS + ES modules, ship compiled `dist/`. Contributor
+  commands and the development loop live in `CONTRIBUTING.md`.
 
 ## Review guidelines
 

CHANGELOG.md

@@ -8,7 +8,89 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 
 ### Fixed
 
+- Android shows Hermes profile display names and groups the resolved server default under its agent identity, while preserving explicit profile selection and saved conversations.
+
+## [Android 1.16.1] - 2026-09-12
+
+### Fixed
+
+- Android Dashboard-only connections start the profile-scoped session directory before Gateway readiness, so a cold launch no longer leaves both the directory and passive Gateway socket waiting on each other. (#495, #528)
+
+## [Android 1.16.0] - 2026-09-10
+
+### Fixed
+
+- Android no longer crashes when a route probe finishes while a network change invalidates the endpoint cache.
+- Android opens an authenticated Gateway chat on the first foreground launch instead of waiting for a background-and-resume cycle to leave the waking state. (#495, #528)
+- Android Dashboard sign-in removes pasted line breaks from username and password fields, matching the browser login while preserving every other credential character. (#541)
+- Android keeps saved Dashboard sign-ins bound to their connection when switching gateways, rather than letting a stale resolver route invalidate another connection's session.
+- Bot Mode no longer crashes when different connections have bots with the same profile name. Both the conversation list and Active Now strip preserve each bot's connection, and opening progress appears only on the selected bot.
+- Android feedback uses themed banners and action cards instead of platform toasts and default snackbars. Dashboard errors no longer misidentify missing resources as an outdated Relay. Developer settings includes local-only message previews.
+- Missing chat attachments show their error and retry in the attachment card without repeated global popups. Global action messages occupy the top message area instead of covering the composer.
+- Chat distinguishes session preparation from response streaming and retains initialization errors that arrive before the session acknowledgement. Long-press the agent header to open a live session-diagnostics drawer.
+- Delegated-agent activity survives parent replies and leaves compact history entries for later read-only review. The activity strip appears only while work runs; historical process views cannot stop or dismiss live work. (#447)
+
+## [Plugin 1.11.2] - 2026-09-10
+
+### Fixed
+
+- **Relay tool availability avoids repeated Windows loopback delays and preserves multi-PC capabilities.** Host-local Android, Desktop, and Phone paths use explicit IPv4 loopback, while Desktop checks share a bounded health snapshot that preserves per-client advertisements and fails closed when Hermes-Relay is unavailable. (#562, #563)
+- **`android_*` tools resolve bridge credentials written after host startup.** Requests retry profile-scoped env and active bridge-session credentials after a stale token is rejected, and vision navigation now shares the same current Relay transport instead of the retired standalone default.
+- **`android_setup` accepts both its canonical and legacy schema keys.** `bridge_session_token` and `pairing_code` are accepted, while a missing token returns a structured error.
+- **Android tool setup tests use a temporary Hermes home.** Test runs no longer write bridge settings into a developer environment.
+
+## [Android 1.15.1] - 2026-09-02
+
+### Changed
+
+- Chat and Bot Chat offer a compact Correct now / Queue next tray behind the composer. Chat settings sets the default; each message can override it. Stop pauses pending work until Resume, and editing or removing queued messages preserves the remaining order.
+- Wider Chat and Voice layouts keep text and controls centered and readable, including landscape Voice Focus.
+
+### Fixed
+
+- Delivery and correction labels remain readable inside user-message bubbles.
+- Voice errors use a scrollable dialog with separate Retry and Dismiss actions.
+- Attachment previews stay open through rotation, and videos retain their original proportions. (#483)
+- Release builds preserve the native configuration names required for wake-word startup. (#444)
+- Standard Hermes attachments stream to disk while enforcing download size limits. (#531)
+- Session refresh no longer sustains a request loop. History loads, chat rendering, image previews, and media exports keep memory use bounded.
+- Image-generation progress remains visible between interim replies and media delivery.
+- New Gateway chats wait for session readiness before the first prompt; ownership refusals preserve the retryable prompt and server error.
+
+## [0.4.0-beta.7] - 2026-09-02
+
+### Fixed
+
+- Windows updates detect a colocated management UI, report both installed versions, and update the CLI and UI together through the verified bundle installer. CLI-only installations keep their standalone updater.
+
+## [Android 1.15.0] - 2026-08-31
+
+### Changed
+
+- **Android prefers current upstream Hermes for standard media, Git, usage, and notices.** Authenticated Dashboard file delivery, current-session `/api/git/*`, Gateway `usage.bars`, and keyed agent notices work without the optional Hermes-Relay Plugin; Relay remains additive for older-host media compatibility, sensitivity metadata, repository discovery and guarded mutations, multi-provider usage, and true Relay tools.
+- **Android Settings separates standard Hermes from Relay tools.** Media now sits with Chat and Voice under Hermes, while proactive Threads, Terminal, Notification Companion, Relay sessions, and Device Control remain clearly grouped behind the optional plugin.
+- **Android Supervised Mode uses app-specific parent access.** Parents choose a six-digit PIN or password, receive a shareable six-word recovery phrase, and can remove the credential without losing their supervised profile, capability, appearance, visibility, session, or relock settings. Android device credentials and biometrics no longer grant parent access.
+- **Android What's New now provides a readable, complete release record.** One overall title and summary lead into selected highlights, every remaining user-visible addition, improvement, and fix, and relevant compatibility boundaries. Toast counts and previews are derived from that same inventory, so View all no longer promises details the expanded dialog and history cannot show.
+
+### Fixed
+
+- **Standard Hermes attachments no longer demand Relay pairing.** Host-local images, audio, video, and files download through the authenticated Dashboard, stay loaded across history reconciliation, and fall back to one neutral compatibility card on older hosts instead of flashing `Relay URL not configured` or retrying indefinitely.
+- **Removing optional Relay does not strand Standard voice or leak preferences across connections.** Runtime fallback keeps Dashboard voice usable, preserves configured choices through temporary outages, and normalizes only connection-scoped named-profile settings after explicit Relay removal.
+- **Passively observed Desktop/TUI turns now show live activity in the Android session drawer.** A uniquely matched selected session projects Working or Waiting without Android resuming, activating, or interrupting the external runtime; ambiguous cross-profile matches remain neutral. (Related: #365)
+- **Android Chat keeps one transport owner through sign-out and outages.** Dashboard/Gateway conversations now preserve their transcript, draft, profile, and session for sign-in or retry instead of silently sending the next turn to a reachable Direct API database. Legacy API-only connections and explicitly selected Direct API chats remain supported.
+- **Android keeps completed chat text visible when Dashboard sign-in expires.** Generic and reason-coded history `401` responses settle the local turn, preserve its transcript, and surface the existing sign-in recovery without reading another profile's API history.
+- **Android keeps long-running context compaction alive.** A client-visible compaction status extends and refreshes the Gateway turn watchdog instead of interrupting healthy compression after the ordinary idle window. (Supersedes #484.)
 - **Android Bot Chats render loaded history immediately.** Route-owned chat screens observe their own handler state from first composition, including fast history loads that settle before another frame. (Supersedes #453.)
+- **Android Chat settles an owned Gateway turn when its terminal frame is lost.** An exact idle `session.active_list` snapshot now completes the matching local stream, reconciles durable history, and drains its queued follow-up without interrupting or claiming Desktop/TUI work.
+- **Supervised Gateway setup stays parent-owned.** Add Gateway is single-flight and checks live parent authority before allocating a draft, relock/back cancels the exact pending setup, and the locked Chat footer no longer attempts protected navigation.
+- **Generated images stay visible and use their intended Chat animation.** Completed image media survives a marker-lagging history refresh, and both the built-in `image_generate` tool and profile tools ending in `_create_image` use the image-generation presentation.
+
+## [Plugin 1.11.1] - 2026-08-31
+
+### Fixed
+
+- **Hermes-Relay Plugin installs through the native Hermes command again.** The manifest remains fully described for current hosts while avoiding the installer/runtime schema mismatch in affected Hermes releases.
+- **Relay prompt context advertises only real callable phone tools.** Phone-control and cross-platform delivery guidance now follows the exact selected session/profile tool catalog instead of implying unavailable `android_*` or `send_message` capabilities.
 
 ## [Android 1.14.0] - 2026-08-30
 
@@ -58,7 +140,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 - **Dense pairing QRs scan reliably.** Dashboard, CLI, and TUI render integer-sized modules with a full quiet zone.
 - **Remote-access migration keeps existing listeners safe.** Recommended setup avoids taking over `:443`, explicit legacy cleanup remains available, and default disable actions remove only the listeners they own.
 
-## [0.4.0-beta.6] - 2026-08-30
+## [0.4.0-beta.6] - 2026-08-31
 
 ### Changed
 
@@ -1246,7 +1328,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 
 - **Voice-exit chime firing on every Add-connection tap.** `ConnectionSwitchCoordinator.switchConnection` fires the `voiceStopCallback` unconditionally at step 3 (correct for connection-to-connection switches while voice is active), but `beginAddConnection` also routes through `switchConnection` to bind the placeholder Connection's auth store before the pair wizard runs — and `VoiceViewModel.exitVoiceMode()` was playing `sfxPlayer.playExit()` regardless of whether voice mode was actually on. Logcat confirmed the chime on every Add-connection FAB tap. Fix adds an idempotence guard at the top of `exitVoiceMode()`: early-return when `_uiState.value.voiceMode` is already false. Teardown is still safe to skip because every inner statement is null-guarded + try/catch-wrapped and would be a no-op on an already-stopped voice session; the only meaningful line is the `playExit()` SFX, which is what we're silencing.
 - **500 ms freeze on every Add-connection tap.** `ConnectionSwitchCoordinator.switchConnection` runs a `withTimeoutOrNull(AUTH_HYDRATE_TIMEOUT_MS = 500L)` block at step 10 to wait for the freshly-bound `AuthManager` to flip `AuthState` from `Loading` to `Paired`. The comment acknowledged Add-connection is the common path and the 500 ms was meant to be "imperceptible," but on-device it wasn't — the user perceived the delay (and the voice chime masking it) on every tap. The placeholder Connection created by `beginAddConnection` has `pairedAt == null` and an empty EncryptedSharedPreferences store, so `AuthState` will NEVER reach `Paired` — the 500 ms is pure stall. Fix short-circuits the hydrate wait when `target.pairedAt == null`: skip `withTimeoutOrNull` entirely for placeholders and log at DEBUG instead of the misleading "auth hydrate timeout" INFO. Real paired-to-paired switches still run the full hydrate wait because both sides have `pairedAt != null`.
-- **KDoc nested-comment trap in `ConnectionViewModel.relayReady` doc block.** A literal `/voice/*` path pattern inside the `relayReady` KDoc opened a nested block comment (Kotlin supports nested `/* */`, Java does not) whose `*/` then closed only the nested level — leaving the outer `/**` open for the remaining ~2200 lines of the file. Symptom: `MainActivity.kt:67` "Unresolved reference 'isReady'" plus ~50 cascading "Cannot infer type" errors across `PairedDevicesScreen`, `SettingsScreen`, `TerminalScreen`. Real errors (`Missing '}`, `Unclosed comment`) were the last two lines of `./gradlew compileGooglePlayDebugKotlin` output, easy to miss. Fix was a two-character rewrite: path patterns now wrapped in backticks AND `/*` → `/...` so the glob-looking character isn't in a block-comment position. Lesson logged in `DEVLOG.md` 2026-04-21; worth a sweep of other KDoc blocks for shell/regex-looking patterns before the next large diff.
+- **KDoc nested-comment trap in `ConnectionViewModel.relayReady` doc block.** A literal `/voice/*` path pattern inside the `relayReady` KDoc opened a nested block comment (Kotlin supports nested `/* */`, Java does not) whose `*/` then closed only the nested level — leaving the outer `/**` open for the remaining ~2200 lines of the file. Symptom: `MainActivity.kt:67` "Unresolved reference 'isReady'" plus ~50 cascading "Cannot infer type" errors across `PairedDevicesScreen`, `SettingsScreen`, `TerminalScreen`. Real errors (`Missing '}`, `Unclosed comment`) were the last two lines of `./gradlew compileGooglePlayDebugKotlin` output, easy to miss. Fix was a two-character rewrite: path patterns now wrapped in backticks AND `/*` → `/...` so the glob-looking character isn't in a block-comment position. Lesson logged in `docs/project/DEVLOG.md` 2026-04-21; worth a sweep of other KDoc blocks for shell/regex-looking patterns before the next large diff.
 
 - **Orphan placeholder connections from abandoned Add-connection flows.** The `beginAddConnection` path pre-creates a placeholder Connection and switches to it before the pair wizard runs — so `applyPairingPayload` lands the token in the right auth store. Previously, cleanup of the placeholder was wired only to the explicit Cancel button and TopAppBar back arrow. System back (gesture back / predictive back) bypassed that branch, leaving the placeholder in the connection list forever. Two-part fix: (a) `PairScreen` now installs a `BackHandler` that routes system back through the same `onCancel` → `discardPlaceholderConnection` branch the explicit back arrow uses; (b) `ConnectionViewModel.init` sweeps for any existing orphans (tuple: `pairedAt == null && apiServerUrl.isBlank() && label == PLACEHOLDER_LABEL`) on cold start and removes them — the tuple cannot be produced by any real pairing, so the sweep is safe without a dry-run. If the active connection at startup points at an orphan, the sweep switches to the first surviving real connection before deleting. Fixes the "why does my chip say 'New connection…'" symptom on devices that were affected pre-fix.
 - **Pair flow now auto-starts the camera on Add connection.** `ConnectionWizard` gains an `autoStart: String?` param (currently only `"scan"` is honored). The Add-connection FAB on `ConnectionsSettingsScreen` passes it so the wizard fires the camera permission launcher on first composition instead of forcing users through the Method chooser — one obvious next step, one-tap flow. Re-pair surfaces intentionally leave `autoStart` null so the full Scan / Enter code / Show code chooser stays available there. The deep-link arg is plumbed through `Screen.Pair`'s route (`pair?connectionId=...&autoStart=...`) and `PairScreen`'s new `autoStart` param; unrecognized values fall through to the default Method step so future builds can add more targets without breaking old ones.
@@ -2063,7 +2145,7 @@ picker.
 - **`CLAUDE.md`** — updated Git section with the new branching policy,
   added file-table entries for `hermes-relay-update`,
   `register_code_command`, and the expanded `install.sh`
-- **`TODO.md`** — captures open research questions around proper
+- **`docs/project/TODO.md`** — captures open research questions around proper
   Hermes plugin/skill/tool distribution
 - **`user-docs` vitepress site** — new "For AI Agents" copy-paste
   block on the home view, Feature Matrix component, two-track explainer,

CLAUDE.md

@@ -1,525 +1 @@
-# Hermes-Relay — Claude Code Adapter
-
-> Read [AGENTS.md](AGENTS.md) first. It is the provider-neutral canonical agent
-> context. Branch, release, staging, and hotfix rules live in `AGENTS.md` and
-> [RELEASE.md](RELEASE.md); this file only adds Claude-specific project and tool
-> guidance. Then read `docs/spec.md` and `docs/decisions.md`.
-
-## What This Is
-
-A native Android app (Kotlin + Jetpack Compose) paired with an optional Python relay plugin/server (aiohttp) for the Hermes agent platform. Vanilla Hermes chat, Manage, and dashboard voice work against unmodified upstream Hermes. The Relay plugin adds phone control, terminal, remote desktop tooling, extra voice engines, and dashboard Relay management via the official Hermes web dashboard.
-
-**Current state:** Reference latest released version for stable state and current dev branch for working state. The default no-plugin path supports chat, Manage, and voice on vanilla upstream Hermes. Chat auto-prefers the dashboard `/api/ws` gateway transport when Manage auth is ready, then falls back to API-server SSE routes. Vanilla Hermes voice uses dashboard `/api/audio/*` with the Manage session. Relay remains an additive power path for terminal, bridge/device control, notification companion, extra/provider-native voice, remote access, and desktop tooling. Two Android product flavors ship: `googlePlay` (conservative, no unattended Device Control surface) and `sideload` (full-capability).
-
-## Architecture
-
-```
-Phone (WS)       -> Hermes dashboard (:9119)     [vanilla Hermes gateway chat, live thinking]
-Phone (HTTP/SSE) -> Hermes API Server (:8642)    [vanilla Hermes chat fallback, sessions, runs]
-Phone (HTTP)     -> Hermes dashboard (:9119)     [vanilla Hermes Manage + voice]
-Phone (WSS/HTTP) -> Relay plugin/server (:8767)  [optional bridge, terminal, relay voice, remote tools]
-```
-
-The Vanilla Hermes path must stay upstream-only. API-server bearer auth and dashboard cookie auth are separate. Terminal and bridge require Relay pairing; Vanilla Hermes chat, Manage, and dashboard voice must not.
-
-### Upstream Hermes API Reference
-
-**IMPORTANT:** Always verify endpoints against the actual hermes-agent source (`gateway/platforms/api_server.py`). The upstream repo is the source of truth — not our docs, not our memory, not assumptions from other frontends.
-
-**Vanilla Hermes endpoints (confirmed in hermes-agent source):**
-
-
-| Endpoint                                | Purpose                                                  | Tool Call Format                                                                                                               |
-| --------------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
-| `POST /v1/chat/completions`             | OpenAI-compatible chat (stream=true for SSE)             | Inline markdown text (``💻 terminal``) — no separate tool events                                                               |
-| `POST /v1/runs`                         | Start an agent run                                       | Returns `run_id`                                                                                                               |
-| `GET /v1/runs/{run_id}/events`          | SSE stream of run lifecycle events                       | **Structured events**: `tool.started`, `tool.completed`, `message.delta`, `reasoning.available`, `run.completed`, `run.failed` |
-| `POST /v1/responses`                    | OpenAI Responses API format                              | Structured `function_call` objects (non-streaming only)                                                                        |
-| `GET /v1/capabilities`                  | Machine-readable feature + endpoint discovery            | Use before assuming optional surfaces exist                                                                                    |
-| `GET /v1/models`                        | List available models                                    | —                                                                                                                              |
-| `GET /v1/skills`                        | Read-only skill list for the API-server agent            | `{"object":"list","data":[...]}`                                                                                               |
-| `GET /v1/toolsets`                      | Read-only API-server toolset inventory                   | `{"object":"list","platform":"api_server","data":[...]}`                                                                       |
-| `GET/POST/PATCH/DELETE /api/sessions/*` | Native session CRUD, messages, fork, sync chat, SSE chat | Upstream merged via NousResearch/hermes-agent PR #33134                                                                        |
-| `GET /health`                           | Health check                                             | —                                                                                                                              |
-| `GET/POST/PATCH/DELETE /api/jobs/*`     | Cron job management (api_server surface)                 | —                                                                                                                              |
-
-
-**Compatibility endpoints (not all native upstream API-server routes):**
-
-Upstream main now contains the focused session-control API (`#33134`) and read-only skills/toolsets (`#33016`). The original broad PR [#8556](https://github.com/NousResearch/hermes-agent/pull/8556) was closed as superseded. Keep these distinctions straight:
-
-1. **Native upstream** — `/api/sessions`, `/api/sessions/{id}/messages`, `/api/sessions/{id}/chat`, `/api/sessions/{id}/chat/stream`, `/v1/capabilities`, `/v1/skills`, and `/v1/toolsets` exist in current `gateway/platforms/api_server.py`.
-2. **Bootstrap compatibility** (`plugin/hermes_relay_bootstrap/`) — monkey-patches aiohttp on startup via `.pth` file, injecting only compatibility-only surfaces (session search, memory, legacy skill detail/toggle, config, available-models, slash middleware). Sessions CRUD/messages/fork and the legacy skills list are **retired** — native upstream owns them (#33134/#33016) and the bootstrap carries no fallback for old builds. Native routes still win per method/path for the remaining set. The repo-root `hermes_relay_bootstrap/` package is a legacy import shim.
-3. **Legacy fork branches** — useful as lineage only. Do not cite `feat/session-api` / `#8556` as the current upstream contract.
-
-
-| Endpoint                               | Purpose                                | Provided by                                                                            |
-| -------------------------------------- | -------------------------------------- | -------------------------------------------------------------------------------------- |
-| `GET /api/sessions` (CRUD)             | Session list/create/rename/delete/fork | Native upstream (#33134); bootstrap injection retired                                  |
-| `GET /api/sessions/{id}/messages`      | Conversation history                   | Native upstream (#33134); bootstrap injection retired                                  |
-| `POST /api/sessions/{id}/chat`         | Synchronous session chat               | Native upstream (#33134)                                                               |
-| `POST /api/sessions/{id}/chat/stream`  | Session-based SSE chat                 | Native upstream (#33134); bootstrap does NOT inject                                    |
-| `GET /v1/skills`, `GET /v1/toolsets`   | Read-only skill/toolset discovery      | Native upstream (#33016)                                                               |
-| `GET /api/sessions/search`             | Full-text message search               | Bootstrap/fork legacy; not in current upstream main                                    |
-| `GET /api/config`, `PATCH /api/config` | Personalities + model config           | Bootstrap/fork legacy or dashboard web-server surface; not current API-server upstream |
-| `GET /api/skills/{name}`               | Legacy skill detail                    | Bootstrap compat; list (`GET /api/skills`) retired — use native `/v1/skills`           |
-| `PUT /api/skills/toggle`               | Enable/disable installed skill         | `hermes_cli/web_server.py` dashboard surface; bootstrap stub returns 501               |
-| `GET/POST/PATCH/DELETE /api/memory`    | Memory CRUD                            | Bootstrap/fork legacy; not current API-server upstream                                 |
-| `GET /api/available-models`            | Provider model list                    | Bootstrap/fork legacy; not current API-server upstream                                 |
-
-
-The Android client probes per-endpoint capability via `HermesApiClient.probeCapabilities()` (returns `ServerCapabilities`). When `streamingEndpoint = "auto"`, `ConnectionViewModel.resolveStreamingEndpoint()` picks `sessions`, `completions`, or `runs` based on the capability snapshot.
-
-**Dashboard web server (separate surface — standard Manage / Desktop remote gateway):**
-
-hermes-agent ships a second web server at `hermes_cli/web_server.py` that hosts the React admin dashboard at `hermes_cli/web_dist/`. It has its **own** `/api/*` routes that **do not live on `api_server.py`** — notably: `GET/PUT /api/config` (full tree), `GET /api/config/schema`, `GET /api/config/defaults`, `GET/PUT /api/config/raw` (YAML text), `GET/PUT/DELETE /api/env` + `POST /api/env/reveal`, `PUT /api/skills/toggle`, `/api/cron/jobs/*` (different shape from `/api/jobs/*`), `/api/providers/oauth/*`, `/api/dashboard/themes`, `/api/dashboard/plugins`, `/api/model/info` + `/api/model/options` + `POST /api/model/set`, `/api/profiles/*` (CRUD, `POST /api/profiles/active`, per-profile soul/description/model), `/api/mcp/*`, `/api/logs`, `/api/analytics/usage`, and `**POST /api/audio/transcribe` + `POST /api/audio/speak`** (base64 data-url contract, built for hermes-desktop voice). The API server has **no audio routes** — its `/v1/capabilities` advertises `audio_api: false`; PR #8199 (`/v1/audio/*`) is the canonical future surface but is unmerged. Android's **Vanilla Hermes (no-plugin) voice** therefore rides this dashboard surface via `StandardHermesVoiceClient` with the per-connection dashboard cookie session (Manage sign-in unlocks voice); `AutoVoiceAudioClient` prefers Relay when paired and falls back to standard.
-
-Current upstream supports two auth modes on this surface. Loopback dashboards still use the injected `window.__HERMES_SESSION_TOKEN__` path. Remote/non-loopback dashboards use the Desktop-style dashboard auth gate: `/api/status` advertises `auth_required` and providers, `/auth/password-login` handles password providers, `/auth/login?provider=...` handles Nous/OIDC redirects, `/api/auth/me` returns the verified session, and `/api/auth/ws-ticket` mints a short-lived ticket for `/api/ws` / `/api/pty`. This dashboard session is **not** an `API_SERVER_KEY`. Android uses it for Manage, Vanilla Hermes voice, and the gateway chat transport. `/api/ws` is backed by `tui_gateway/server.py` (what hermes-desktop + the Ink TUI speak) and is the only upstream surface with **live** `reasoning.delta`/`thinking.delta` streaming; the api_server SSE paths remain the SSE fallback. Relay-only capabilities remain behind Relay pairing. **Do not proxy dashboard auth or dashboard admin APIs over the relay.**
-
-**Tool call rendering paths:**
-
-1. **Runs API** — Emits `tool.started`/`tool.completed` as real SSE events → `ToolProgressCard` in real-time.
-2. **Sessions API** — Native upstream emits structured SSE (`run.started`, `message.started`, `assistant.delta`, `tool.progress`, `tool.started/completed/failed`, `assistant.completed`, `run.completed`, `done`). `run.completed.messages` can reconcile authoritative per-turn transcript.
-3. **Annotation parser** — Fallback for servers emitting inline markdown annotations (``💻 terminal``).
-
-## Key Instructions
-
-- **Vanilla Hermes path = upstream-only.** The default (no-plugin) connection path — gateway/API chat, Manage, and Vanilla Hermes voice via the dashboard surface — must work against **unmodified upstream hermes-agent**: no fork patches, no bespoke server config as a dependency. The app ships on Google Play to users whose servers we don't control. Features that need server-side changes go through upstream PRs (with graceful degradation until merged) or live behind the opt-in relay plugin.
-- **Always verify upstream before assuming an endpoint exists.** Check `gateway/platforms/api_server.py` in hermes-agent. If an endpoint isn't there, document whether bootstrap injects it or it requires the fork.
-- If we use a non-standard endpoint, ensure `probeCapabilities()` covers it and the auto-resolver degrades gracefully.
-- **Bootstrap maintenance:** Retire `plugin/hermes_relay_bootstrap/` per surface. Done: sessions CRUD/messages/fork and the legacy skills list are retired from the bootstrap (native upstream #33134/#33016, no old-build fallback kept). Remaining: config, memory, legacy skill detail/toggle, available-models, session search, and slash middleware still need explicit replacement decisions before full removal.
-
-## Repository Layout
-
-```
-hermes-android/
-├── app/src/main/kotlin/com/hermesandroid/relay/
-│   ├── ui/                  # Screens, components, theme
-│   ├── network/             # ConnectionManager, ChannelMultiplexer, handlers
-│   ├── auth/                # AuthManager (pairing + tokens)
-│   ├── viewmodel/           # ChatViewModel, ConnectionViewModel
-│   ├── data/                # ChatMessage, ToolCall models, FeatureFlags
-│   ├── audio/               # VoiceRecorder, VoicePlayer, VoiceSfxPlayer
-│   ├── voice/               # VoiceViewModel, VoiceBridgeIntentHandler
-│   ├── accessibility/       # HermesAccessibilityService, ScreenReader, ActionExecutor
-│   ├── bridge/              # BridgeSafetyManager, BridgeForegroundService, BridgeStatusOverlay
-│   └── notifications/       # HermesNotificationCompanion
-├── relay-core/              ← [EXPERIMENTAL] Quest/XR shared core lib (com.axiomlabs.hermesrelay.core) — pairing, transport, terminal, voice, wire
-├── relay-ui/                ← [EXPERIMENTAL] Quest/XR shared Compose UI lib — sphere, terminal WebView, QR scanner
-├── quest/                   ← [EXPERIMENTAL] Meta Spatial SDK Quest/XR app (gradle includeBuild; in development, not shipped)
-├── ui-preview/              ← Desktop Compose Hot Reload harness for PC UI iteration (NOT shipped; shares MorphingSphereCore)
-├── desktop/                 ← Node thin-client CLI (`@hermes-relay/cli`)
-│   ├── bin/hermes-relay.js  # #!/usr/bin/env node shim → dist/cli.js
-│   ├── src/
-│   │   ├── cli.ts           # argv parser + subcommand dispatcher (bare → shell)
-│   │   ├── commands/        # chat, shell, pair, status, tools, devices
-│   │   ├── banner.ts        # contextual connect line (LAN / Tailscale / Plain / Secure)
-│   │   ├── renderer.ts      # GatewayEvent → plain-line stdout formatter (chat only)
-│   │   ├── endpoint.ts      # ADR 24 EndpointCandidate + role helpers
-│   │   ├── pairingQr.ts     # v3 QR decode + priority-raced reachability probe
-│   │   ├── pairing.ts       # readline 6-char prompt + payload validator
-│   │   ├── credentials.ts   # token → pair-qr → code → stored → prompt precedence
-│   │   ├── certPin.ts       # TOFU SPKI sha256 extract / pinKey / compare
-│   │   ├── tools/           # desktop.command router + fs/terminal/search handlers + consent
-│   │   ├── transport/       # RelayTransport (reconnect state machine + TLS probe TOFU)
-│   │   └── lib/             # gracefulExit, rpc, circularBuffer (vendored)
-│   └── scripts/             # install.sh + install.ps1 curl/iwr one-liners
-├── website/                 ← Astro product/marketing site (static Coolify/Nixpacks deployment)
-├── plugin/                  ← Hermes agent plugin
-│   ├── android_tool.py      # 18 android_* tool handlers
-│   ├── pair.py              # QR pairing implementation
-│   ├── relay/               # Canonical WSS relay (server.py, auth.py, channels/, media.py, voice.py)
-│   ├── tools/               # android_navigate.py, android_notifications.py
-│   └── dashboard/           # hermes-agent dashboard plugin — manifest, React UI, FastAPI proxy
-├── relay_server/            ← Thin compat shim → plugin.relay (legacy entrypoint)
-├── hermes_relay_bootstrap/  ← Legacy import shim for older startup hooks
-├── skills/devops/hermes-relay-pair/  ← /hermes-relay-pair slash command
-├── scripts/                 ← dev.bat, bridge-smoke.sh, bump-version.sh
-└── docs/                    ← spec, decisions, security, relay-server, mcp-tooling
-```
-
-## Project Conventions
-
-### File Structure
-
-- **Root-level:** README.md, CLAUDE.md, AGENTS.md, DEVLOG.md, TODO.md, .gitignore
-- **docs/** — spec, decisions, security, and any other long-form documentation
-- **DEVLOG.md** — update at end of each work session with what was done + verification (the factual record of *what happened*). It churns; do NOT park forward work here.
-- **TODO.md** — the single home for follow-ups / deferred work / known gaps ("what's next"). Record them here — never buried in DEVLOG or scattered through code/doc comments where they get lost.
-- **CLAUDE.md hygiene:** Key Files entries must stay one line — implementation detail belongs in the file or `docs/`. Run `/revise-claude-md` after feature-heavy sessions to trim drift.
-
-### Public-repo writing hygiene
-
-This is a **public, distributed repo** — every committed file (CHANGELOG, DEVLOG, README, docs, release notes) is public-facing. Write accordingly:
-
-- **No personal names** in prose — attribute impersonally ("a user reported", "observed"). Author identity lives in git history + the signing cert, not the changelog.
-- **No private infrastructure** — real server hostnames/IPs, internal deployment names, `~/SYSTEM.md` contents. (Generic example IPs like `192.168.1.100` in setup docs are fine.)
-- **No AI/assistant process self-narration** — no "I should have…", no course-correction confessionals. State the technical conclusion, not the path to it.
-- **No internal jargon / fork-branch plumbing** in user-facing notes — keep *what changed*, drop *where we staged it*.
-- **CHANGELOG** uses Keep-a-Changelog grouping (Added / Changed / Fixed). Detail may accumulate during iteration, but at **release-prep the version block is condensed to crisp public bullets** (1–2 lines each) — deep "how we debugged it" stays in commits/DEVLOG. See [RELEASE.md](RELEASE.md) §2 "Scrub for public distribution".
-- **DEVLOG.md** is a committed, factual engineering log — what changed, why, and verification — depersonalized and third-person, not a diary.
-
-### Code Style — Android (Kotlin)
-
-- **Jetpack Compose** — no XML layouts. Material 3 / Material You.
-- **kotlinx.serialization** — not Gson. Type-safe, faster.
-- **OkHttp** for WebSocket + SSE — `okhttp` for WSS relay, `okhttp-sse` for API streaming
-- **Single-activity** — Compose Navigation for all routing
-- **Namespace (Kotlin source tree):** `com.hermesandroid.relay` — stable, drives on-disk layout + class FQCNs
-- **applicationId:** `com.axiomlabs.hermesrelay` (googlePlay), `com.axiomlabs.hermesrelay.sideload` (sideload)
-- **Min SDK 26, Target SDK 35, Compile SDK 37** / **Kotlin 2.0+**, JVM toolchain 17
-
-### Code Style — Desktop CLI (Node/TypeScript)
-
-- **Node ≥21** — uses built-in global `WebSocket` (no `ws`/`undici` dep). Strict TS, ES modules, `NodeNext` resolution.
-- **Zero runtime deps** — `@types/node` + `tsx`/`rimraf`/`typescript` are devDeps only. Ship compiled `dist/`, not tsx.
-- **One binary, subcommands** — idiomatic for Node CLIs (codex, continue, vite pattern). Bare invocation is `chat`.
-- **Vendor-for-now** — transport/gateway/types are copied verbatim from `hermes-agent-tui-smoke/ui-tui/src/` with a header note. Extract to a shared package when the TUI and CLI stabilize.
-- **Dev loop:** `npx tsx src/cli.ts <args>` (no rebuild). `npm run build` + `npm link` before pushing to verify the bin shim. Never ship tsx in the published tarball — pre-build with `tsc` so Windows `npm install -g` can cmd-shim the JS directly.
-
-### Code Style — Server (Python)
-
-- **aiohttp** — async, matches existing Hermes relay patterns
-- **Type hints everywhere** — Python 3.11+ syntax
-- **asyncio** — no threading; **structured logging** — use `logging`, not print()
-
-### Git
-
-- **Conventional Commits:** `feat`, `fix`, `docs`, `refactor`, `test`, `chore`
-- **Branch/release policy:** follow the branch-contract table in `AGENTS.md` and
-  the executable release and hotfix procedures in `RELEASE.md`. Do not maintain
-  a Claude-specific parallel policy here.
-
-### Testing
-
-- **Android:** JUnit + Compose testing for UI, MockK for mocks
-- **Gateway/session/reconnect work:** follow the on-demand scenario,
-  current-upstream conformance, Android instrumentation, and physical-proof
-  routing in `docs/gateway-contract-testing.md`; do not infer device behavior
-  from fixture or source checks.
-- **Python:** `python -m unittest plugin.tests.test_<name>` — avoid bare `pytest` (conftest imports `responses` which may not be installed in the venv)
-- **CI and release gates:** follow the repository-wide requirements in
-  `AGENTS.md` and `RELEASE.md`; Claude-specific guidance does not redefine them.
-
-## Key Files
-
-
-| File                                                        | Why                                                                                                                                                                                                                                                                                                 |
-| ----------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `docs/spec.md`                                              | Full specification — protocol, UI layouts, phases, dependencies                                                                                                                                                                                                                                     |
-| `docs/decisions.md`                                         | Architecture decisions — framework choice, channel design, auth model                                                                                                                                                                                                                               |
-| `docs/gateway-contract-testing.md`                          | On-demand reusable Gateway scenarios, upstream conformance, Android instrumentation, and ADB certification                                                                                                                                                                                         |
-| `AGENTS.md`                                                 | Universal agent entry point — points here + the non-negotiables (standard-path, commits, writing hygiene)                                                                                                                                                                                           |
-| `docs/mcp-tooling.md`                                       | MCP server setup — android-tools-mcp + mobile-mcp; `android_*` tool usage patterns                                                                                                                                                                                                                  |
-| **App — Core**                                              |                                                                                                                                                                                                                                                                                                     |
-| `ui/RelayApp.kt`                                            | Main scaffold (Scaffold + Compose nav); Chat is home — no mode strip, Manage/Bridge reached via Settings; `bottomBar` is a status pill, not a NavigationBar                                                                                                                                         |
-| `viewmodel/ChatViewModel.kt`                                | Chat orchestration — send, stream, cancel, slash commands                                                                                                                                                                                                                                           |
-| `viewmodel/ConnectionViewModel.kt`                          | Dual connection model (API + relay); `resolveStreamingEndpoint()`; derived `relayUiState` flow + `markPaired` hook stamp the active Connection                                                                                                                                                      |
-| `viewmodel/RelayUiState.kt`                                 | Shared sealed state for the relay row — 5 cases + `asBadgeState()` / `statusText()` extensions; 5s grace window before Stale                                                                                                                                                                        |
-| `network/HermesApiClient.kt`                                | Direct HTTP/SSE — `sendRunStream()`, `sendChatStream()`, `probeCapabilities()`                                                                                                                                                                                                                      |
-| `network/GatewayChatClient.kt`                              | Gateway chat transport — JSON-RPC over dashboard `/api/ws` (tui_gateway); live `reasoning.delta`; fresh ws-ticket per connect; per-turn SSE fallback via `onPreflightFailure`; `prewarm()` (connect+resume off the send path); `setKeepAliveInBackground()` suppresses the 120s idle-close          |
-| `network/GatewayKeepAliveService.kt`                        | Opt-in `specialUse` foreground service (BOTH flavors; declared in main manifest; Play needs a Console FGS declaration) holding the process up so the gateway socket survives background/Doze; driven by ConnectionViewModel from the `KEY_GATEWAY_KEEP_ALIVE` toggle; stops on task-removal         |
-| `data/GatewayKeepAlivePrefs.kt`                             | Shared `KEY_GATEWAY_KEEP_ALIVE` pref key + `Context.setGatewayKeepAlive()` — used by ConnectionViewModel (StateFlow/setter) and the FGS Stop action                                                                                                                                                 |
-| `network/GatewayEventMapper.kt`                             | Pure-JVM gateway event→callback mapping for one turn; unknown event types silently ignored; tui_gateway usage-key translation                                                                                                                                                                       |
-| `network/GatewayModels.kt`                                  | `GatewayAvailability`, `ActiveTurnHandle`, `GatewayTurnCallbacks` (all members REQUIRED — forces dispatchOn main-thread wrap), `GatewayAsk`, `GatewaySubagentEvent`, `resolveStreamingEndpointPreference()`                                                                                         |
-| `ui/components/ChatInputBar.kt`                             | Redesigned input bar — pill field, one trailing slot morphing Send/Voice/Stop/Steer/Queue, no slash button (long-press + opens palette)                                                                                                                                                             |
-| `ui/components/SubagentLane.kt`                             | Per-taskIndex subagent progress lane — guide rail, compact tool rows, auto-collapse                                                                                                                                                                                                                 |
-| `notifications/TurnCompleteNotifier.kt`                     | Turn-complete local notification when backgrounded — channel `chat_turn_complete`, cancel on resume, settings-gated                                                                                                                                                                                 |
-| `network/ConnectionManager.kt`                              | WSS to relay with auto-reconnect; rebuilds OkHttpClient with fresh CertPinner on connect                                                                                                                                                                                                            |
-| `network/ChannelMultiplexer.kt`                             | Envelope routing by channel; `sendNotification()` for notification outbound                                                                                                                                                                                                                         |
-| `network/handlers/ChatHandler.kt`                           | Chat message state, streaming events, tool annotation parser                                                                                                                                                                                                                                        |
-| `network/models/SessionModels.kt`                           | Session, message, SSE event data models                                                                                                                                                                                                                                                             |
-| `data/FeatureFlags.kt`                                      | Feature gating — DEV_MODE + DataStore overrides; `BuildFlavor` (googlePlay/sideload Tier flags)                                                                                                                                                                                                     |
-| **App — Auth**                                              |                                                                                                                                                                                                                                                                                                     |
-| `auth/AuthManager.kt`                                       | Wires SessionTokenStore + CertPinStore; parses auth.ok; `applyServerIssuedCodeAndReset()`                                                                                                                                                                                                           |
-| `auth/SessionTokenStore.kt`                                 | Keystore (StrongBox) + EncryptedSharedPrefs fallback; lossless migration on upgrade                                                                                                                                                                                                                 |
-| `auth/CertPinStore.kt`                                      | TOFU cert pinning — SHA-256 SPKI per host:port in DataStore                                                                                                                                                                                                                                         |
-| `auth/PairedSession.kt`                                     | PairedSession state + PairedDeviceInfo wire model                                                                                                                                                                                                                                                   |
-| `data/Endpoint.kt`                                          | `EndpointCandidate` / `ApiEndpoint` / `RelayEndpoint` — multi-endpoint pairing (ADR 24); `displayLabel()` for LAN/Tailscale/Public/Custom chips                                                                                                                                                     |
-| `network/RelayHttpClient.kt`                                | OkHttp for /media, /sessions (list/revoke/extend), /health                                                                                                                                                                                                                                          |
-| **App — Bridge**                                            |                                                                                                                                                                                                                                                                                                     |
-| `network/handlers/BridgeCommandHandler.kt`                  | Routes `bridge.command` → ActionExecutor; full path inventory + safety-rail integration                                                                                                                                                                                                             |
-| `viewmodel/BridgeViewModel.kt`                              | BridgeScreen VM — masterToggle, bridgeStatus, permissionStatus, activityLog                                                                                                                                                                                                                         |
-| `bridge/BridgeSafetyManager.kt`                             | Connection-scoped capabilities + timed screen expiry + blocklist + destructive confirmation; unknown, denied, and expired commands fail closed                                                                                                                                                     |
-| `bridge/BridgeCapabilities.kt` / `data/BridgeCapabilityPolicyRepository.kt` | Closed method/path registry + no-backup-bound per-Connection Always/Never/Timed policy; global safety vocabulary and timer duration remain in `BridgeSafetyPreferences.kt`                                                                                                                       |
-| `ui/screens/BridgeScreen.kt`                                | Bridge cockpit — master → Agent access posture/setup → single Unattended Access control → capability-scoped Android readiness (expandable full matrix) → Advanced safety/full editor → activity log                                                                                               |
-| `ui/components/BridgeAccessCards.kt`                        | Native access cockpit + first-use preset and screen-lease sheets (renewable idle limits or warned Until-off dedicated-device mode); preserves full permission/safety drilldowns while keeping selected policy/readiness above the fold                                                             |
-| `ui/components/UnattendedAccessRow.kt`                      | Unattended toggle card (sideload); `enabled=masterEnabled`; inline `KeyguardDetectedAlert`                                                                                                                                                                                                          |
-| `ui/components/UnattendedGlobalBanner.kt`                   | 28dp amber strip at scaffold top when master+unattended on (sideload); tap → Bridge tab                                                                                                                                                                                                             |
-| `bridge/BridgeStatusOverlay.kt`                             | WindowManager overlay; `ConfirmationOverlayHost`; requires `SavedStateRegistryOwner` init order (CREATED→restore→RESUMED)                                                                                                                                                                           |
-| `accessibility/HermesAccessibilityService.kt`               | AccessibilityService subclass; `@Volatile instance` singleton for BridgeCommandHandler                                                                                                                                                                                                              |
-| `accessibility/ScreenReader.kt`                             | UI tree → ScreenContent; `findNodeBoundsByText()`, `findFocusedInput()`                                                                                                                                                                                                                             |
-| `accessibility/ActionExecutor.kt`                           | Gesture/text dispatch via GestureDescription + ACTION_SET_TEXT; pressKey maps vocab only                                                                                                                                                                                                            |
-| **App — Voice**                                             |                                                                                                                                                                                                                                                                                                     |
-| `voice/VoiceViewModel.kt`                                   | Voice turn state machine; TTS queue; `ignoreAssistantId`; `errorEvents: SharedFlow`                                                                                                                                                                                                                 |
-| `audio/VoiceRecorder.kt`                                    | MediaRecorder wrapper; perceptual amplitude curve; `.m4a` at 16kHz/64kbps                                                                                                                                                                                                                           |
-| `audio/VoicePlayer.kt`                                      | Media3 ExoPlayer (gapless TTS queue) + Visualizer; amplitude StateFlow; `awaitCompletion()` via coroutine; `audioSessionId` is a thread-safe `@Volatile` cache                                                                                                                                      |
-| `network/RelayVoiceClient.kt`                               | OkHttp for `/voice/transcribe`, `/synthesize`, `/config`                                                                                                                                                                                                                                            |
-| `voice/VoiceBridgeIntentHandler.kt`                         | Interface routing voice utterances to bridge; impls per flavor via factory                                                                                                                                                                                                                          |
-| `voice/VoiceIntentClassifier.kt`                            | Regex phone-control classifier (sideload only); false-negatives preferred over false-positives                                                                                                                                                                                                      |
-| `ui/components/VoiceModeOverlay.kt`                         | Full-screen voice UI — MorphingSphere + VoiceWaveform + mic button                                                                                                                                                                                                                                  |
-| `ui/components/MorphingSphere.kt`                           | Compose renderer for the agent sphere — delegates math to `MorphingSphereCore`                                                                                                                                                                                                                      |
-| `ui/components/MorphingSphereCore.kt`                       | Platform-agnostic sphere algorithm (`kotlin.math` only) — single source of truth; mirrored byte-for-byte in `preview/web/sphere.js`                                                                                                                                                                 |
-| `preview/web/`                                              | Zero-dep browser harness — live `index.html` preview + `parity-check.mjs`; paired with `MorphingSphereCoreParityTest` (JVM) for struct/full checksum diffing                                                                                                                                        |
-| `user-docs/.vitepress/theme/components/SphereMark.vue`      | Docs-site sphere embed — imports `preview/web/sphere.js` directly; autonomous fbm drift + pointer-proximity gaze/state blend; `<ClientOnly>` + `IntersectionObserver` + `prefers-reduced-motion` aware                                                                                              |
-| **App — Media + Notifications**                             |                                                                                                                                                                                                                                                                                                     |
-| `util/MediaCacheWriter.kt`                                  | `cacheDir/hermes-media/` LRU writer; returns FileProvider URIs                                                                                                                                                                                                                                      |
-| `util/MediaSaver.kt`                                        | Save/share/open for chat media — MediaStore scoped-storage save (Pictures/Download `Hermes-Relay`, no perms on API 29+; pre-Q → share sheet); FileProvider share staging; remote-byte fetch; magic-byte image-MIME sniff for correct extensions                                                     |
-| `ui/components/ChatImageViewer.kt`                          | Full-screen image viewer — pinch-zoom/pan (`detectTransformGestures`), double-tap 1×/2.5×, Share/Save/Close; `ChatImageViewerSource` decouples Coil-model/bitmap display from a suspend `bytesProvider` so Save keeps original bytes                                                                |
-| `ui/components/InboundAttachmentCard.kt`                    | Discord-style attachment card for images/video/audio/pdf/text/generic; image tap → ChatImageViewer, file card long-press → Open/Share/Save menu                                                                                                                                                     |
-| `ui/components/ChatImageContent.kt`                         | Parses `![alt](src)` out of assistant content; remote http(s) → Coil (tap → ChatImageViewer), server-local/failed → inline "can't render" notice with the path                                                                                                                                      |
-| `data/HermesCard.kt`                                        | `CARD:{json}` envelope (ADR 26) — type/accent/fields/actions; kotlinx.serialization                                                                                                                                                                                                                 |
-| `ui/components/HermesCardBubble.kt`                         | Rich-card renderer — accent stripe + FlowRow actions + dispatch stamp collapse                                                                                                                                                                                                                      |
-| `viewmodel/CardDispatchSyncBuilder.kt`                      | Twin of VoiceIntentSyncBuilder — synthesizes card dispatches as `hermes_card_action` OpenAI pairs for session memory                                                                                                                                                                                |
-| `notifications/HermesNotificationCompanion.kt`              | NotificationListenerService; cold-start buffer (50); forwards via ChannelMultiplexer                                                                                                                                                                                                                |
-| `util/RelayErrorClassifier.kt`                              | `classifyError(Throwable, context) → HumanError`; used by Voice/Chat/Connection                                                                                                                                                                                                                     |
-| `util/TurnLatencyTracer.kt`                                 | One `TurnLatency` INFO line per chat turn — `warm/cold` + `connect/session/submit/ttfe/ttft/done@…ms`; gateway + 3 SSE paths use it for desktop-comparable latency diagnosis; durations only                                                                                                        |
-| **Relay — Server**                                          |                                                                                                                                                                                                                                                                                                     |
-| `plugin/relay/server.py`                                    | Canonical relay — WSS + HTTP routes; bridge, media, voice, session, pairing handlers. `handle_pairing_mint` mirrors `pair.py:762` — top-level = API server, `relay.{url,code}` nested                                                                                                               |
-| `plugin/relay/auth.py`                                      | PairingManager, SessionManager, RateLimiter; `math.inf` for never-expire                                                                                                                                                                                                                            |
-| `plugin/relay/channels/bridge.py`                           | Bridge handler — `handle_command()` mints request_id, awaits response, 30s timeout                                                                                                                                                                                                                  |
-| `plugin/relay/channels/notifications.py`                    | Bounded deque (100) of notification metadata; in-memory only                                                                                                                                                                                                                                        |
-| `plugin/relay/media.py`                                     | MediaRegistry — LRU token store; `strict_sandbox` off by default for `/media/by-path`                                                                                                                                                                                                               |
-| `plugin/relay/voice.py`                                     | Voice endpoints — transcribe, synthesize, voice_config; lazy tool imports                                                                                                                                                                                                                           |
-| `plugin/relay/qr_sign.py`                                   | HMAC-SHA256 QR signing; secret at `~/.hermes/hermes-relay-qr-secret`; canonical form preserves `endpoints` array order + role strings verbatim (ADR 24)                                                                                                                                             |
-| `plugin/relay/tailscale.py`                                 | First-class Tailscale helper (ADR 25) — `status()` / `enable(port)` / `disable(port)` / `canonical_upstream_present()`; safe-absent via shell-out to `tailscale` CLI                                                                                                                                |
-| `plugin/relay/_env_bootstrap.py`                            | Loads `~/.hermes/.env` before relay imports; called from both entry points                                                                                                                                                                                                                          |
-| **Plugin — Tools + Installer**                              |                                                                                                                                                                                                                                                                                                     |
-| `plugin/tools/android_tool.py`                              | 18 `android_*` tool handlers (14 baseline + send_sms, call, search_contacts, return_to_hermes); `android_screenshot` first consumer of `register_media()`                                                                                                                                           |
-| `plugin/tools/android_navigate.py`                          | Vision-driven navigation loop; up to 20 iterations; `llm_gap` error until vision client wired                                                                                                                                                                                                       |
-| `plugin/pair.py`                                            | QR payload builder + CLI; `build_payload(sign=True)`; `--register-code` fallback                                                                                                                                                                                                                    |
-| `plugin/doctor.py`                                          | `hermes relay doctor`; checks standard upstream API/dashboard reachability, Relay loopback state, plugin layout, and compat hook state                                                                                                                                                              |
-| `plugin/compat.py`                                          | `hermes relay compat status/install/remove`; owns the optional `hermes_relay_bootstrap.pth` lifecycle                                                                                                                                                                                               |
-| `plugin/hermes_relay_bootstrap/`                            | Plugin-owned runtime compatibility patch — compat-only surfaces (session search, memory, skill detail/toggle, config, available-models, slash middleware); sessions + skills-list injection retired (#33134/#33016)                                                                                 |
-| `install.sh`                                                | Canonical installer — 6 steps; idempotent; drops `hermes-relay-update` shim                                                                                                                                                                                                                         |
-| `uninstall.sh`                                              | Canonical uninstaller; reverses install.sh; never touches `.env` or `state.db`                                                                                                                                                                                                                      |
-| `hermes_relay_bootstrap/`                                   | Legacy import shim for old `.pth` files and editable installs                                                                                                                                                                                                                                       |
-| **Plugin — Dashboard**                                      |                                                                                                                                                                                                                                                                                                     |
-| `plugin/dashboard/manifest.json`                            | Declares tab, entry bundle, and FastAPI module for hermes-agent discovery                                                                                                                                                                                                                           |
-| `plugin/dashboard/plugin_api.py`                            | FastAPI router proxying 5 routes to relay over loopback; `/pairing` body = API-server overrides (host/port/tls/api_key), relay URL auto-derived                                                                                                                                                     |
-| `plugin/dashboard/src/index.jsx`                            | React root registering `hermes-relay` plugin with 4-tab shell                                                                                                                                                                                                                                       |
-| `plugin/dashboard/dist/index.js`                            | Committed IIFE bundle loaded verbatim by dashboard                                                                                                                                                                                                                                                  |
-| **Desktop CLI**                                             |                                                                                                                                                                                                                                                                                                     |
-| `desktop/package.json`                                      | `@hermes-relay/cli` package manifest — Node ≥21, one `hermes-relay` bin, pre-built dist                                                                                                                                                                                                             |
-| `desktop/bin/hermes-relay.js`                               | Tiny shim: `import('../dist/cli.js').then(m => m.main())` + error surfacing                                                                                                                                                                                                                         |
-| `desktop/src/chatAttach.ts`                                 | captureClipboardImage / captureScreenshot / readImageFile; ships base64 to server via `image.attach.bytes` RPC before next prompt.submit                                                                                                                                                            |
-| `desktop/src/cli.ts`                                        | argv parser + subcommand dispatcher — bare → `shell` (PTY), positional-only → `chat`; command-scoped `--help` falls through to each command                                                                                                                                                         |
-| `desktop/src/lib/theme.ts`                                  | Shared ANSI palette + `colorEnabled()` + `Theme` (semantic helpers, `statusDot`) — single visual language; `--no-color`/`NO_COLOR`/TTY aware                                                                                                                                                        |
-| `desktop/src/lib/table.ts`                                  | Zero-dep column-aligned table renderer (ANSI-width aware, last column flexes to terminal width) — used by devices/sessions/audit                                                                                                                                                                    |
-| `desktop/src/lib/spinner.ts`                                | Stderr braille spinner for slow ops (pair probe, gateway connect); no-op when piped/quiet/json                                                                                                                                                                                                      |
-| `desktop/src/lib/usage.ts`                                  | `UsageSpec` + `renderUsage`/`printUsage`/`unknownSubcommand` — per-subcommand `--help` + self-documenting sub-verb fallback                                                                                                                                                                         |
-| `desktop/src/lib/hints.ts`                                  | `suggestedFix(err, ctx)` → next-step command (re-pair on auth fail, etc.); `formatError` renders error + hint                                                                                                                                                                                       |
-| `desktop/src/lib/logo.ts`                                   | Slim box-drawing "Hermes Relay" wordmark; shown atop `--help`, first-run welcome, REPL header, and `hermes-relay logo`; theme/no-color aware                                                                                                                                                        |
-| `desktop/src/lib/auditLog.ts`                               | Local desktop-tool audit JSONL (`~/.hermes/desktop-audit.jsonl`); router appends per dispatch; backs `audit` command (relay's ring is loopback-only)                                                                                                                                                |
-| `desktop/src/lib/daemonStatus.ts`                           | Daemon heartbeat file (`~/.hermes/daemon-status.json`) + `isPidAlive` liveness; backs `daemon --status`                                                                                                                                                                                             |
-| `desktop/src/commands/audit.ts`                             | `hermes-relay audit` — tails the local audit log into a table (WHEN/TOOL/STATUS/DETAIL); `--limit`, `--json`                                                                                                                                                                                        |
-| `desktop/src/commands/relay.ts`                             | `hermes-relay relay info/security/context/queue` — relay-server management surface; info/security/queue loopback-only, context works remote with bearer; `queue` lists/cancels the agent→phone outbound buffer (`--clear` / `--cancel <id>`)                                                        |
-| `desktop/src/commands/chat.ts`                              | REPL + one-shot + piped-stdin; `runOneTurn` returns `{promise, cancel}` for safe SIGINT; auto-wires `DesktopToolRouter` when consented                                                                                                                                                              |
-| `desktop/src/commands/shell.ts`                             | Pipes the `terminal` relay channel to raw-mode stdin/stdout; post-attach `exec hermes` 350ms after tmux settles; `Ctrl+A .` detach / `Ctrl+A k` kill / `Ctrl+A Ctrl+A` literal                                                                                                                      |
-| `desktop/src/commands/pair.ts`                              | Either 6-char code + `--remote`, or full v3 QR via `--pair-qr` — probes + picks endpoint, records role; `--grant-tools` (TTY prompt) / `--auto-grant-tools` (silent) stamp `toolsConsented` so `daemon` works without a `shell` round-trip                                                          |
-| `desktop/src/commands/tools.ts`                             | `tools.list` RPC → enabled/available toolsets; `--verbose` lists individual tools                                                                                                                                                                                                                   |
-| `desktop/src/commands/status.ts`                            | Local read of `~/.hermes/remote-sessions.json`; renders `grants:` + `expires:` + `route:`; `--json` redacts tokens, `--reveal-tokens` opts in                                                                                                                                                       |
-| `desktop/src/commands/devices.ts`                           | Server-side session management — `GET/DELETE/PATCH /sessions` via `fetch` over http(s)://host:port; `list` / `revoke <prefix>` / `extend <prefix> --ttl <s>`                                                                                                                                        |
-| `desktop/src/banner.ts`                                     | `buildConnectBanner({url, meta, endpointRole})` → "Connected via LAN (plain) — server 0.6.0"; `humanExpiry()` for TTL formatting                                                                                                                                                                    |
-| `desktop/src/endpoint.ts`                                   | `EndpointCandidate` / `EndpointRole` types + `displayLabel()` — mirrors Android `data/Endpoint.kt`                                                                                                                                                                                                  |
-| `desktop/src/pairingQr.ts`                                  | `decodePairingPayload` (JSON or base64), `payloadToCandidates` (v3 verbatim / v1–v2 synthesized), `probeCandidatesByPriority` (`Promise.any` within tier, `AbortSignal.any`, 4s timeout, 60s cache)                                                                                                 |
-| `desktop/src/certPin.ts`                                    | `extractSpkiSha256(der)` via `crypto.X509Certificate` + `publicKey.export({type:'spki'})`; `pinKey(url)`, `comparePins()`, `isSecureUrl()`                                                                                                                                                          |
-| `desktop/src/tools/router.ts`                               | `DesktopToolRouter.attach(relay)` — `onChannel('desktop')` dispatch under 30s `AbortController`; heartbeat enriched with host/platform/version/uptime_ms + sticky `last_error` for `desktop_health`                                                                                                 |
-| `desktop/src/tools/handlerSet.ts`                           | Single source of truth for the desktop tool map — `DESKTOP_HANDLERS` + `DESKTOP_ADVERTISED_TOOLS`; consumed by `chat.ts` / `shell.ts` / `daemon.ts` so adding a tool is a one-file change                                                                                                           |
-| `desktop/src/tools/consent.ts`                              | `ensureToolsConsent(url)` — stored per-URL in `toolsConsented`; TTY prompt; non-TTY fails closed                                                                                                                                                                                                    |
-| `desktop/src/tools/handlers/fs.ts`                          | `readFileHandler` / `writeFileHandler` / `patchHandler` — strict unified-diff applier, no fuzz                                                                                                                                                                                                      |
-| `desktop/src/tools/handlers/terminal.ts`                    | `bash -lc` / `cmd /c`, SIGKILL on timeout or abort, returns `{stdout, stderr, exit_code, duration_ms}`                                                                                                                                                                                              |
-| `desktop/src/tools/handlers/powershell.ts`                  | Spawns `pwsh`/`powershell` directly with `-Command -`, script piped via stdin — no cmd.exe quote-mangling; auto-picks pwsh &gt; powershell                                                                                                                                                          |
-| `desktop/src/tools/handlers/process.ts`                     | `spawn_detached` (unref'd, returns pid+log_path), `list_processes` (tasklist /FO CSV — no /V to dodge window-title latency), `kill_process`, `find_pid_by_port` (netstat/lsof/ss)                                                                                                                   |
-| `desktop/src/tools/handlers/jobs.ts`                        | Job API — `~/.hermes/desktop-jobs/<id>/{stdout.log, stderr.log, meta.json}` is source of truth across daemon restarts; `taskkill /T` on Windows so build trees die fully                                                                                                                            |
-| `desktop/src/tools/handlers/transfer.ts`                    | `copy_directory` via `fs.cp`, `zip`/`unzip` via tar &gt; zip &gt; PowerShell probe, `checksum` streamed (sha256/sha1/md5)                                                                                                                                                                           |
-| `desktop/src/tools/handlers/search.ts`                      | ripgrep with pure-Node fallback, skips `.git`/`node_modules`/`dist`/`.next`/`.cache`                                                                                                                                                                                                                |
-| `desktop/src/renderer.ts`                                   | Streams `message.delta` → stdout, tool events → decorated lines; NO_COLOR / --json / --quiet aware                                                                                                                                                                                                  |
-| `desktop/src/pairing.ts`                                    | readline-based 6-char prompt (`A-Z0-9`); headless mirror of TUI's Ink prompt; `validatePairingPayloadString` discriminated-union wrapper                                                                                                                                                            |
-| `desktop/src/credentials.ts`                                | Precedence: `--token` → `--pair-qr` (probe+pair) → `--code` → stored → prompt; returns `Credentials{sessionToken?, pairingCode?, resolvedEndpoint?}`                                                                                                                                                |
-| `desktop/src/transport/RelayTransport.ts`                   | Fork of ui-tui's transport + reconnect state machine (`idle/connecting/connected/reconnecting`, exp backoff 1→30s, 5min on 429, gate re-check post-sleep) + pre-WS TLS probe for TOFU                                                                                                               |
-| `desktop/src/remoteSessions.ts`                             | Same file path as TUI (`~/.hermes/remote-sessions.json`, 0600); schema widened with `grants`, `ttlExpiresAt`, `endpointRole`, `toolsConsented`; `saveSession` back-compat overload                                                                                                                  |
-| `desktop/src/commands/daemon.ts`                            | Headless WSS + tool router for always-on access; JSON-line logs; fails closed on missing consent unless `--allow-tools` with explicit `--token`                                                                                                                                                     |
-| `desktop/src/commands/doctor.ts`                            | Local-only diagnostic report — version / binary path / PATH / sessions / daemon detection; `--json` for support-paste; omits tokens entirely                                                                                                                                                        |
-| `desktop/src/relayUrlPrompt.ts`                             | First-run URL fallback — `resolveFirstRunUrl()` auto-picks single stored session, numbered picker for multiple, welcome banner for zero; throws on non-interactive + ambiguous                                                                                                                      |
-| `desktop/src/version.ts`                                    | Build-time-generated constant (`npm run gen:version` before every build) — Bun compiled binaries can't read package.json via `__dirname` so version is embedded at build                                                                                                                            |
-| `desktop/scripts/install.sh` / `install.ps1`                | curl/iwr one-liner installers — download prebuilt Bun binary (no Node required), SHA256-verified, API-resolver for `latest` that includes prereleases, version-aware pre/post-install readback                                                                                                      |
-| `desktop/scripts/uninstall.sh` / `uninstall.ps1`            | 3-tier removal — default (binary + PATH), `--purge` (also wipes `~/.hermes/remote-sessions.json`), `--service` (stub for future service installers); Windows iex-safe env-var fallback                                                                                                              |
-| `desktop/README.md`                                         | User-facing install + usage reference                                                                                                                                                                                                                                                               |
-| **Desktop CLI — dev iteration**                             |                                                                                                                                                                                                                                                                                                     |
-| `npm run smoke` (in `desktop/`)                             | Builds Windows binary + runs `--version` / `--help` / `doctor`, fails loud on zero-output. Local pre-flight before cutting any tag.                                                                                                                                                                 |
-| `npm run gen:version`                                       | Regenerates `src/version.ts` from `package.json`. Runs automatically before every `build` / `build:bin:*`.                                                                                                                                                                                          |
-| `release-cli.yml → Smoke-test Linux binary` step            | CI-side equivalent: runs compiled Linux binary through the same 3-command check before uploading assets. Catches silent-exit-0 + segfault classes.                                                                                                                                                  |
-| **Server — Desktop tool routing (Phase B)**                 |                                                                                                                                                                                                                                                                                                     |
-| `plugin/relay/channels/desktop.py`                          | Mirrors `bridge.py` — `desktop.command`/`desktop.response`/`desktop.status`, UUID-correlated futures, 30s timeout, single-client MVP, per-session advertised-tools set                                                                                                                              |
-| `plugin/tools/desktop_tool.py`                              | 24 `desktop_*` tools (fs/shell/powershell/process/jobs/transfer/health) — registers with `tools.registry` under `desktop` toolset; per-tool `check_fn` pings `/desktop/_ping?tool=<name>`; `desktop_health` is `_RELAY_ONLY` and pings `/desktop/health` so it works even when the client is wedged |
-| **Gradle modules — experimental Quest/XR (in development)** |                                                                                                                                                                                                                                                                                                     |
-| `relay-core/`                                               | [EXPERIMENTAL] Android library (`com.axiomlabs.hermesrelay.core`) — shared pairing/transport/terminal/voice/wire for the Quest port; not yet wired into the shipped `:app`                                                                                                                          |
-| `relay-ui/`                                                 | [EXPERIMENTAL] Android library (`com.axiomlabs.hermesrelay.ui`) — shared Compose UI (sphere, terminal WebView, QR scanner) for the Quest port; carries its own sphere copy                                                                                                                          |
-| `quest/`                                                    | [EXPERIMENTAL] Meta Spatial SDK Quest/XR app — gradle `includeBuild("quest")`; needs further development, not shipped                                                                                                                                                                               |
-| **Tooling — dev iteration (not shipped)**                   |                                                                                                                                                                                                                                                                                                     |
-| `ui-preview/`                                               | Desktop Compose Hot Reload harness — JVM Compose for Desktop; source-shares `MorphingSphereCore` from `:relay-ui`; `Main.kt` gallery; see `ui-preview/README.md`                                                                                                                                    |
-| `app/src/test/.../screenshots/StoreScreenshotTest.kt`       | Roborazzi host-side store/docs screenshot renderer — deterministic, no device, exact 1080×2160; reuses real components+chrome with mock data; `capture(name, themeId){…}` renders any view; see `docs/screenshot-automation.md` §Deterministic rendering (JDK-21 + no-plugin gotchas)               |
-
-
-## What NOT to Do
-
-- **Don't use XML layouts** — Compose only
-- **Don't use Gson** — kotlinx.serialization
-- **Don't use Ktor for networking** — OkHttp for WebSocket
-- **Don't use plaintext WebSocket** — `wss://` only, even in development
-- **Don't put documentation in root** — long-form docs go in `docs/`
-- **Don't forget DEVLOG.md** — update it (record *what happened*)
-- **Don't bury follow-ups** — deferred work / known gaps go in `TODO.md`, never in DEVLOG or one-off code/doc comments
-- **Don't touch production / remote hosts** — automation and orchestrated agents must NEVER SSH into, deploy to, pull/restart/reconfigure, or push code to a live/remote Hermes host. Building, on-device testing, and server deployment are owner-driven (see Server Deployment). Stop at committing on your branch; surface "this needs a deploy/on-device check" rather than doing it.
-
-## MCP Tooling
-
-Two MCP servers are configured for AI-assisted development. See `docs/mcp-tooling.md` for full reference.
-
-
-| Server              | Layer                                                           | Requires                                 |
-| ------------------- | --------------------------------------------------------------- | ---------------------------------------- |
-| `android-tools-mcp` | IDE/Build — Compose previews, Gradle, code search, Android docs | Android Studio running with project open |
-| `mobile-mcp`        | Device/Runtime — tap, swipe, screenshot, app management         | ADB + connected device/emulator          |
-
-
-## Dev Workflow
-
-```bash
-scripts/dev.bat build      # Build debug APK (DEV_MODE=true)
-scripts/dev.bat release    # Build signed release APK (DEV_MODE=false)
-scripts/dev.bat bundle     # Build release AAB for Google Play upload
-scripts/dev.bat run        # Build + install + launch + logcat
-scripts/dev.bat test       # Run unit tests
-scripts/dev.bat version    # Show current version from libs.versions.toml
-scripts/dev.bat relay      # Start relay server (dev mode, no SSL)
-```
-
-### Bridge smoke test (run on hermes-host, not local PC)
-
-```bash
-scripts/bridge-smoke.sh                   # full suite, destructive ON
-scripts/bridge-smoke.sh --no-destructive  # read-only paths only
-scripts/bridge-smoke.sh --filter open_app # re-run a single test
-scripts/bridge-smoke.sh --pair ABCDEF     # register pairing code first
-```
-
-Curls every bridge HTTP route via `localhost:8767`. Catches the silent-drop regression class (Python relay registers a route but Kotlin dispatcher's `when (path)` has no matching branch). Run after every relay restart.
-
-### Typical Dev Loop
-
-1. **Edit locally** — Windows checkout. Both plugin (`plugin/`) and app (`app/`) live here.
-2. **Python syntax check** — `python -m py_compile plugin/<file>.py`. Full tests run on the server.
-3. **Kotlin changes** — do NOT run `gradle build`. Bailey builds via Android Studio's ▶ button. Never `adb install` from Claude.
-4. **Before pushing Kotlin changes** — run `./gradlew lint` locally. It's the exact task CI runs and catches errors Android Studio's live inspections miss — e.g. `UnsafeOptInUsageError` with `kotlin.OptIn` vs `androidx.annotation.OptIn`, `FlowOperatorInvokedInComposition` (mapped flows inside Composables), Media3 `@UnstableApi` propagation. Android CI runs lint alongside build/test for faster feedback, but a local lint run still surfaces issues before the workflow spends runner time compiling and packaging.
-5. **Commit + push** — follow `AGENTS.md` and `RELEASE.md`; normal work PRs to `dev`.
-6. **Pull + restart on server** — see Server Deployment below.
-7. **Test on phone** — Bailey builds from Studio, installs to Samsung device, pairs via `/hermes-relay-pair`.
-
-### Server Deployment
-
-Server is a Linux box running hermes-agent with hermes-relay editable-installed (`pip install -e`). Sensitive details (IP, user, secrets) in `~/SYSTEM.md` on the server — not in this repo.
-
-
-| What               | Where                                                              |
-| ------------------ | ------------------------------------------------------------------ |
-| hermes-agent repo  | `~/.hermes/hermes-agent/`                                          |
-| hermes-relay clone | `~/.hermes/hermes-relay/`                                          |
-| Plugin symlink     | `~/.hermes/plugins/hermes-relay` → `~/.hermes/hermes-relay/plugin` |
-| Config             | `~/.hermes/config.yaml` + `~/.hermes/.env`                         |
-| Relay log          | `journalctl --user -u hermes-relay -f`                             |
-
-
-**Update:** `hermes-relay-update` (idempotent, re-fetches install.sh). Or manually: `git pull --ff-only && systemctl --user restart hermes-relay`.
-
-**Compat hook:** `hermes relay compat status/install/remove` manages only the
-
-optional `hermes_relay_bootstrap.pth` startup hook. New installs load the
-
-plugin-owned bootstrap from `plugin/hermes_relay_bootstrap/`; the repo-root
-
-package is only a legacy import shim. Vanilla Hermes chat, Manage, and dashboard voice
-
-must not depend on this hook.
-
-**Key conventions:**
-
-- Phone pairing **survives** relay restart — `SessionManager` persists sessions to `~/.hermes/hermes-relay-sessions.json` (`server.py:88-90`, `persistence_path` from `RelayConfig.from_env`); a trusted-device refresh token recovers a lost/revoked/reset session without a new QR scan. (Only the in-memory *live-connection presence* clears on restart; the phone reconnects automatically.)
-- Use `python -m unittest` not `pytest` — conftest imports `responses` which may not be installed
-- `_env_bootstrap.py` loads `~/.hermes/.env` on every relay start — no stale API keys
-
-### Where Python vs. Kotlin changes land
-
-
-| Change type                          | Who restarts?            | Command                                            |
-| ------------------------------------ | ------------------------ | -------------------------------------------------- |
-| Plugin tool (`android_tool.py` etc.) | `hermes-gateway.service` | `systemctl --user restart hermes-gateway`          |
-| Relay code (`plugin/relay/*.py`)     | `hermes-relay.service`   | `systemctl --user restart hermes-relay`            |
-| Pair CLI / skill files               | —                        | No restart — fresh process / scanned on invocation |
-| Android app                          | Bailey (Studio)          | Studio run button                                  |
-
-
-### Release Process
-
-See [AGENTS.md](AGENTS.md) for the canonical branch contract and
-[RELEASE.md](RELEASE.md) for version sources, release trains, surface tags,
-hotfixes, secrets, publishing, and verification. Claude-specific automation
-must not infer release authority from feature completion.
-
-## Integration Points
-
-
-| Surface                        | Endpoint                                                                                                            | Notes                                                                                                                                                                                                                                                                                       |
-| ------------------------------ | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Chat (gateway)                 | Dashboard `POST /api/auth/ws-ticket` -&gt; WS `/api/ws`                                                             | Vanilla Hermes dashboard/tui_gateway path; live thinking/reasoning; requires dashboard auth                                                                                                                                                                                                 |
-| Chat streaming                 | `POST /v1/runs` → `GET /v1/runs/{id}/events`                                                                        | Structured tool events; async run-control path                                                                                                                                                                                                                                              |
-| Chat (sessions)                | `POST /api/sessions/{id}/chat/stream`                                                                               | Native upstream session-persisted SSE; preferred when capability probe finds it                                                                                                                                                                                                             |
-| Chat (compat)                  | `POST /v1/chat/completions` (stream=true)                                                                           | Inline tool annotations only                                                                                                                                                                                                                                                                |
-| Session CRUD                   | `GET/POST/PATCH/DELETE /api/sessions`                                                                               | Native upstream (#33134); bootstrap fallback retired                                                                                                                                                                                                                                        |
-| Manage                         | Dashboard `/api/status`, `/api/auth/me`, `/api/config`, `/api/profiles/*`, `/api/env`, `/api/model/*`, `/api/mcp/*` | Vanilla Hermes dashboard surface; do not proxy through Relay                                                                                                                                                                                                                                |
-| Vanilla Hermes voice           | Dashboard `POST /api/audio/transcribe`, `POST /api/audio/speak`                                                     | Vanilla Hermes no-plugin voice; uses dashboard session from Manage                                                                                                                                                                                                                          |
-| Pairing (QR)                   | `POST /pairing/register` (loopback only)                                                                            | Via `/hermes-relay-pair` or `hermes-pair` shim; accepts optional `endpoints` for multi-endpoint QRs                                                                                                                                                                                         |
-| Pairing (multi-endpoint)       | QR `endpoints` array (ADR 24)                                                                                       | `hermes: 3` schema; ordered `lan`/`tailscale`/`public`/... candidates; phone re-probes on network change                                                                                                                                                                                    |
-| Pairing auth                   | WSS `auth.ok` payload                                                                                               | Includes `expires_at`, `grants`, `transport_hint`                                                                                                                                                                                                                                           |
-| Tailscale Serve (ADR 25)       | `hermes-relay-tailscale enable|disable|status` CLI                                                                  | Fronts loopback `:8767` with `tailscale serve --bg --https=<port>`; auto-retires on upstream PR #9295                                                                                                                                                                                       |
-| Inbound media (token)          | `GET /media/{token}`                                                                                                | Bearer auth; 24h TTL                                                                                                                                                                                                                                                                        |
-| Inbound media (path)           | `GET /media/by-path?path=<abs>`                                                                                     | Permissive by default; `RELAY_MEDIA_STRICT_SANDBOX=1` to restrict                                                                                                                                                                                                                           |
-| Session management             | `GET /sessions`, `DELETE /sessions/{prefix}`, `PATCH /sessions/{prefix}`                                            | List/revoke/extend; RelayHttpClient                                                                                                                                                                                                                                                         |
-| Voice transcribe               | `POST /voice/transcribe`                                                                                            | multipart/form-data; bearer auth                                                                                                                                                                                                                                                            |
-| Voice synthesize               | `POST /voice/synthesize`                                                                                            | JSON → audio/mpeg; max 5000 chars                                                                                                                                                                                                                                                           |
-| Voice config                   | `GET /voice/config`                                                                                                 | Returns current tts/stt provider info                                                                                                                                                                                                                                                       |
-| Plugin diagnostics             | `hermes relay doctor --json`                                                                                        | Reports upstream route reachability, Relay loopback state, plugin layout, and legacy bootstrap state                                                                                                                                                                                        |
-| Compat hook lifecycle          | `hermes relay compat status/install/remove`                                                                         | Optional legacy API compatibility hook; not required for the standard path                                                                                                                                                                                                                  |
-| Notifications                  | `GET /notifications/recent?limit=N`                                                                                 | Loopback callers skip bearer                                                                                                                                                                                                                                                                |
-| Relay health                   | `GET /health` on `:8767`                                                                                            | Used by `RelayHttpClient.probeHealth()`                                                                                                                                                                                                                                                     |
-| Capabilities                   | `GET /v1/capabilities` plus targeted `HEAD` probes                                                                  | Prefer capabilities when present; HEAD probes keep mixed-version fallback working                                                                                                                                                                                                           |
-| Desktop CLI (tui channel)      | WSS `tui.attach` / `tui.rpc.request` / `tui.rpc.event`                                                              | Same channel + envelopes as the Ink TUI — the CLI just renders events as plain lines. Zero server changes.                                                                                                                                                                                  |
-| Desktop CLI (terminal channel) | WSS `terminal.attach` / `terminal.input` / `terminal.output` / `terminal.resize` / `terminal.detached`              | Existing channel (shared with Android). CLI `shell` subcommand attaches, injects `clear; exec hermes\n` 350ms after ack, pipes raw bytes. `Ctrl+A .` detaches (tmux preserved), `Ctrl+A k` kills.                                                                                           |
-| Desktop CLI tool visibility    | `tools.list` RPC on the shared tui channel                                                                          | Returns `{toolsets: [{name, description, tool_count, enabled, tools:[]}]}`; surfaced by `hermes-relay tools`                                                                                                                                                                                |
-| Desktop CLI devices            | HTTP `GET/DELETE/PATCH /sessions` on the relay's same port                                                          | Wrapped by `hermes-relay devices list                                                                                                                                                                                                                                                       |
-| Desktop tool routing (Phase B) | WSS `desktop.command` (s→c) + `desktop.response` (c→s) + `desktop.status` (c→s heartbeat)                           | New channel. Hermes calls `desktop_read_file(path)` → Python handler POSTs to `/desktop/desktop_read_file` → relay forwards over `desktop.command` → Node client's `DesktopToolRouter` runs the handler locally → response bubbles back. Mirror of Android's `bridge.command` pattern.      |
-| Desktop tool check_fn          | HTTP `GET /desktop/_ping?tool=<name>`                                                                               | Returns 200 if a client is connected AND advertises this tool; 503 otherwise. Hermes uses this to fail the tool quickly when no desktop client is live, instead of waiting 30s for the dispatch timeout.                                                                                    |
-| Desktop health                 | HTTP `GET /desktop/health`                                                                                          | Returns full status snapshot — connected/host/platform/version/pid/uptime/advertised_tools/last_error/recent_commands. Loopback-only. Backs the `desktop_health` agent tool, which intentionally does NOT round-trip through the client so it remains callable when other tools are wedged. |
-
-
-## Upstream References
-
-
-| Topic                      | Upstream File                                                                 |
-| -------------------------- | ----------------------------------------------------------------------------- |
-| API endpoints              | `gateway/platforms/api_server.py` — all registered HTTP routes                |
-| Platform adapter interface | `gateway/platforms/base.py` — `BasePlatformAdapter` abstract class            |
-| Adding a platform          | `gateway/platforms/ADDING_A_PLATFORM.md` — 16-step checklist                  |
-| Platform registration      | `gateway/run.py` → `_create_adapter()`, `gateway/config.py` → `Platform` enum |
-| Channel directory          | `gateway/channel_directory.py` — how platforms/channels are enumerated        |
-| Send message routing       | `tools/send_message_tool.py` → `platform_map` dict                            |
-| SSE streaming (runs)       | `gateway/platforms/api_server.py` → runs endpoint, `_on_tool_progress`        |
-
-
-## Related Projects
-
-- [**hermes-agent**](https://github.com/NousResearch/hermes-agent) — the agent platform (gateway, WebAPI, plugin system)
-- [**android-tools-mcp**](https://github.com/Codename-11/android-tools-mcp) — our fork of Android Studio MCP bridge (Compose previews, Gradle, docs)
-- [**mobile-mcp**](https://github.com/mobile-next/mobile-mcp) — device control MCP server (ADB, tap/swipe, screenshots)
-
+@AGENTS.md

CLI_RELEASE_NOTES.md

@@ -1,22 +1,18 @@
 # Hermes-Relay CLI+UI v__VERSION__
 
-**Release Date:** 2026-08-30
+**Release Date:** 2026-09-02
 
-This beta preserves complete multi-route pairing while preventing Desktop from dialing Dashboard-ingress Relay routes before Dashboard WebSocket ticket support is available. (Related: #399)
+This beta fixes Windows updates so the installed CLI and management UI advance together. Explicit CLI-only installations keep their standalone update path.
 
 **Beta phase.** Assets remain unsigned, so Windows SmartScreen and macOS Gatekeeper may warn on first launch. Standalone CLI binaries ship for Windows x64, Linux x64/arm64, and macOS x64/arm64; the management UI is Windows-only.
 
 ## What's changed
 
-### Changed
-
-- **Saved hosts retain the full route topology.** Dashboard, Relay, optional API, route priority, transport protection, certificate pins, and the selected host survive LAN, Tailscale, and public-route changes without creating duplicate hosts.
-- **API-less pairing is first-class.** Dashboard plus direct Relay can pair without inventing an optional API server, while secure-first ranking retains plain LAN as the final fallback.
-
 ### Fixed
 
-- **Dashboard-ingress Relay routes fail closed on Desktop.** The daemon, host selector, and Relay transport reject ingress that requires a Dashboard WebSocket ticket and choose a compatible direct Relay fallback instead of attempting an unauthenticated dial.
-- **Pairing accepts the current v3 candidate shape.** Optional API records, same-origin Dashboard/Relay routes, and legacy top-level payloads remain compatible without collapsing route ownership.
+- `hermes-relay update` detects an installed management UI beside the CLI and reports both installed versions.
+- Bundle installations use the checksum-verified Windows installer to update and restart the affected CLI and UI together.
+- Explicit CLI-only installations continue to use the standalone binary updater.
 
 ## Install
 

CONTRIBUTING.md

@@ -61,6 +61,15 @@ configuration between invocations and do not add `--no-daemon` to normal dev
 commands; a different heap or Java home starts a separate daemon and discards
 the warm-process benefit.
 
+On Windows, all repository dev helpers serialize Android build and device work
+through one machine-wide lane shared by every Hermes-Relay worktree. Use
+`scripts/android-lane.ps1` for ad hoc Gradle, connected-test, and APK-install
+commands, and keep Android Studio idle while another owner holds the lane. For
+an exact commit that is already pushed, prefer the `Android On-Demand` workflow
+for heavy verification so concurrent worktrees use isolated GitHub-hosted
+runners. See [Android build execution](docs/android-build-lane.md) for cloud
+presets, the optional full local gate, status, and recovery modes.
+
 Use the narrowest command that proves the change:
 
 1. `scripts/dev.bat compile` for a Kotlin compile check.
@@ -68,7 +77,15 @@ Use the narrowest command that proves the change:
 3. `scripts/dev.bat install-fast` when the result must run on the connected
    arm64 phone. This passes `-Phermes.devAbi=arm64-v8a`, avoiding the x86,
    x86_64, and armeabi-v7a native libraries in the local APK.
-4. `scripts/dev.bat prepush` before pushing Android work.
+4. `Android On-Demand` after an exact commit is pushed for lint, broad checks,
+   assemblies, or release smoke.
+5. `scripts/dev.bat prepush` only when full local verification is explicitly
+   wanted or cloud execution is unavailable.
+
+Android release preparation uses `python scripts/android-prepush.py
+--release-prep` while version notes are changing. It keeps local feedback to
+metadata and release-presentation tests; the exact pushed commit still goes
+through required CI and Play preflight before publication.
 
 `install-fast` is intentionally phone-specific. Use `install` for a universal
 sideload debug APK or when the target ABI is not arm64. Release builds remain
@@ -242,28 +259,36 @@ translations may ship as `ai-translated`; do not claim fluent review unless a
 review reference is recorded. Focused correction PRs from fluent contributors
 are the canonical way to improve wording and can advance a locale to
 `community-reviewed` or `verified` under `docs/translation-playbook.md`.
-Translated READMEs use separate `README.<locale>.md` files; `README.md` remains
-the canonical project description. User docs may be added incrementally under
-`user-docs/<locale>/`, with links back to canonical English reference material.
+Translated README entrypoints live under `docs/readme/` as
+`README.<locale>.md`; root `README.md` remains the canonical project
+description. Keep translated entrypoints concise: summarize onboarding and
+core capabilities, link to localized user docs where available, and link back
+to English for fast-moving architecture, security, and operator detail. User
+docs may be added incrementally under `user-docs/<locale>/`, with links back to
+canonical English reference material.
 
 ## Changelog & writing conventions
 
-This is a **public repo** — `CHANGELOG.md`, `DEVLOG.md`, the README, and everything under `docs/` ship publicly. Keep them clean:
+This is a **public repo** — `CHANGELOG.md`, `docs/project/DEVLOG.md`, the README, and everything under `docs/` ship publicly. Keep them clean:
 
-- **`CHANGELOG.md`** follows [Keep a Changelog](https://keepachangelog.com/) (Added / Changed / Fixed). Append your change to the `## [Unreleased]` block in the PR. Entries can carry detail while they accumulate, but at release-prep the version block is **condensed to crisp public bullets** (1–2 lines each) — the deep "how we debugged it" narrative belongs in commit messages and `DEVLOG.md`, not the public changelog.
-- **`DEVLOG.md`** is a factual engineering log — what changed, why, and how it was verified. Keep it depersonalized and third-person; it's a record, not a diary.
+- **`CHANGELOG.md`** follows [Keep a Changelog](https://keepachangelog.com/) (Added / Changed / Fixed). Append your change to the `## [Unreleased]` block in the PR. Entries can carry detail while they accumulate, but at release-prep the version block is **condensed to crisp public bullets** (1–2 lines each) — the deep "how we debugged it" narrative belongs in commit messages and `docs/project/DEVLOG.md`, not the public changelog.
+- **`docs/project/DEVLOG.md`** is a factual engineering log — what changed, why, and how it was verified. Keep it depersonalized and third-person; it's a record, not a diary.
 - **No non-public wording anywhere committed:** no personal names (attribute impersonally — identity lives in git history), no real server hostnames/IPs or internal deployment names, no AI/assistant process self-narration, no fork/branch plumbing in user-facing notes. Generic example IPs in setup docs are fine.
 
 Release notes (`RELEASE_NOTES.md`, `app/src/main/assets/whats_new.txt`, `docs/play-store-listing.md`) are theme-framed and user-facing; see [RELEASE.md](RELEASE.md) §2 "Scrub for public distribution" for the full checklist.
 
 ## Testing
 
-- **Android pre-push gate:** `scripts\dev.bat prepush` on Windows or
-  `./scripts/dev.sh prepush` on macOS/Linux. This runs the Android repository
-  checks, Google Play debug lint, and the same focused unit-test shard used by
-  CI in one cached Gradle invocation. Run it before pushing Android PR updates
-  to catch common hosted failures without waiting for another full Actions
-  cycle; hosted CI remains the exhaustive all-variant gate.
+- **Android cloud verification (preferred for pushed work):** dispatch the
+  registered `Required checks` workflow with an exact base/head SHA pair and
+  `android_preset` set to `focused`, `lint`, `assemble-debug`, `release-smoke`,
+  or `all-final`. It calls the reusable Android workflow from `dev`. Check for
+  an existing run before dispatching the same SHA/preset again. The four
+  `all-final` compute jobs use isolated runners and may execute concurrently.
+- **Full local Android gate (optional):** `scripts\dev.bat prepush` on Windows
+  or `./scripts/dev.sh prepush` on macOS/Linux. This retains the repository
+  checks, full Android lint, and both focused flavor shards for an explicit local
+  run or cloud outage. On Windows it acquires the machine-wide lane.
 - **Focused Android unit test:** `scripts/dev.bat test-one "<fully-qualified-class-or-pattern>"`
 - **Android unit tests:** `scripts/dev.bat test` (runs the sideload debug JUnit + MockK + Compose suite)
 - **Gateway contract lab:** [`docs/gateway-contract-testing.md`](docs/gateway-contract-testing.md)
@@ -272,7 +297,7 @@ Release notes (`RELEASE_NOTES.md`, `app/src/main/assets/whats_new.txt`, `docs/pl
   device lane is scheduled automatically.
 - **Python tests:** `python -m unittest plugin.tests.test_<name>` from the repo root with the hermes-agent venv active. `pytest` works too but the pre-existing `conftest.py` imports a module that isn't always installed — `unittest` avoids that entirely.
 
-CI is split into path-filtered workflows: `.github/workflows/ci-android.yml` (lint + build + test on app/Gradle changes), `.github/workflows/ci-server.yml` (syntax check + focused server tests on plugin/Python changes), and `.github/workflows/ci-desktop.yml` (desktop type/build/smoke checks). They run on pushes to `main` and `dev` and on PRs targeting either when their paths are touched.
+CI is split into path-filtered workflows: `.github/workflows/ci-android.yml` (lint + build + test on app/Gradle changes), `.github/workflows/ci-server.yml` (syntax check + focused server tests on plugin/Python changes), and `.github/workflows/ci-desktop.yml` (desktop type/build/smoke checks). They run on pushes to `main` and `dev` and on PRs targeting either when their paths are touched. The registered `ci-required.yml` dispatcher calls `android-on-demand.yml` as the trusted manual compute lane for an exact pushed commit; it does not replace required PR checks.
 Superseded Android runs on `dev` and PR refs are canceled automatically; `main`
 runs are never canceled because each release-branch commit must complete its
 independent validation.

PLUGIN_RELEASE_NOTES.md

@@ -1,29 +1,17 @@
 # Hermes-Relay Plugin v__VERSION__
 
-**Release Date:** August 30, 2026
+**Release Date:** September 10, 2026
 
 ## Summary
 
-This release lets one authenticated Hermes Dashboard origin carry Gateway plus optional Relay extensions, adds a bounded Git workspace, and reorganizes the Dashboard plugin around operator tasks. Standard chat, session history, profiles, Manage, and standard voice remain upstream-owned and do not require this plugin.
-
-## Added
-
-- **Dashboard same-origin Relay ingress.** Fixed allowlisted HTTP and WebSocket routes proxy to the local Relay while Dashboard admission and Relay session authentication remain independent. (Related: #399)
-- **Bounded Git workspace.** Configured roots, path containment, line totals, diffs, branches, staging, commits, remotes, grants, and explicit confirmations protect repository operations.
-
-## Changed
-
-- **Task-oriented Dashboard UI.** Overview, Devices, Activity, Remote Access, Git, and Settings now have dedicated surfaces with QR-first pairing, responsive device cards, and honest media diagnostics. (#486)
-- **One explicit route topology.** Dashboard, CLI, and TUI pairing advertise Dashboard, Relay, and optional API surfaces with stable priorities across Tailscale, public HTTPS, and LAN.
-- **Dedicated Tailscale listener.** Recommended setup uses tailnet HTTPS `:10443` to local Dashboard `:9119`, avoiding ownership of a reverse proxy's `:443`. Existing `:443`, `:9119`, and direct `:8767` routes remain migration compatibility.
+This patch makes Android and Desktop tool availability fast and reliable when Relay is unavailable, starts late-created Android bridge sessions without restarting Hermes, and restores compatibility with both current and legacy `android_setup` arguments. Standard Chat, Manage, standard voice, and ordinary inbound files remain upstream-owned.
 
 ## Fixed
 
-- Public and roaming invites no longer synthesize closed direct Relay `:8767` or wrong Dashboard `:9119` routes.
-- Ambiguous, credential-bearing, or plaintext public candidates fail closed before an invite is exposed.
-- Dense pairing QRs use integer-sized modules and a full quiet zone.
-- Inactive optional API routes are omitted; protected Dashboard-ingress `401/403` responses display as authentication-required while direct Relay and API failures remain failures.
-- Default Tailscale disable actions remove only owned listeners, and explicit migration cleanup accepts only the bounded supported ports.
+- **Fast, accurate tool availability.** Android and Desktop tool checks use explicit IPv4 loopback and one bounded health snapshot instead of repeated per-tool connection attempts. Multi-PC capability advertisements remain isolated, and unavailable Relay clients continue to fail closed.
+- **Late Android bridge recovery.** `android_*` calls retry profile-scoped and active bridge-session credentials after a stale token is rejected, so a phone connected after Hermes startup becomes usable without restarting the host.
+- **Compatible Android setup arguments.** `android_setup` accepts the canonical `bridge_session_token` and `pairing_code` fields as well as their legacy aliases, with structured errors when no usable credential is supplied.
+- **Isolated setup tests.** Android tool setup tests use a temporary Hermes home instead of writing bridge settings into the operator environment.
 
 ## Install / update
 
@@ -35,7 +23,7 @@ This release lets one authenticated Hermes Dashboard origin carry Gateway plus o
     # or, if already installed:
     hermes-relay-update
 
-Restart or reload the Hermes Dashboard and Relay after updating so the new manifest, routes, and committed Dashboard bundle are active.
+Restart or reload the Hermes Dashboard and Relay after updating so the new manifest and prompt context are active.
 
 ## Verify
 

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="assets/play-store-feature-1024x500.png" alt="Hermes-Relay — your Hermes agent, in your pocket" width="800">
+  <img src="assets/readme-hero-v2.jpg" alt="Hermes-Relay — Your Hermes agent. Wherever you are. Android, Voice, Desktop." width="1000">
 </p>
 
 <p align="center">
@@ -21,7 +21,13 @@
 </p>
 
 <p align="center">
-  <strong>English</strong> · <a href="README.zh-CN.md">简体中文</a><br>
+  <strong>English</strong> ·
+  <a href="docs/readme/README.de.md">Deutsch</a> ·
+  <a href="docs/readme/README.es.md">Español</a> ·
+  <a href="docs/readme/README.ja.md">日本語</a> ·
+  <a href="docs/readme/README.pt-BR.md">Português (Brasil)</a> ·
+  <a href="docs/readme/README.ru.md">Русский</a> ·
+  <a href="docs/readme/README.zh-CN.md">简体中文</a><br>
   <a href="https://hermes-relay.dev/docs/">Documentation</a> ·
   <a href="https://github.com/Codename-11/hermes-relay/releases">Releases</a> ·
   <a href="https://github.com/Codename-11/hermes-relay/discussions">Discussions</a> ·
@@ -38,10 +44,10 @@ Hermes-Relay puts your [Hermes agent](https://github.com/NousResearch/hermes-age
 - **📱 Android app** — streaming chat, hands-free voice, native plugin pages, and the full Hermes dashboard (models, keys, skills, profiles), rebuilt native. Add a floating Petdex companion or optionally make Hermes your Android assistant; sideload builds can also let the agent read and act on your screen.
 - **⌨️ Hermes-Relay CLI** *(beta)* — a single binary that gives the agent **hands on any machine you pair**: files, terminal, search, screenshots — consent-gated.
 
-A vanilla [hermes-agent](https://github.com/NousResearch/hermes-agent) install is enough for the upstream standard path: chat, management, voice, Petdex, and ordinary installed-plugin pages. The Hermes-Relay plugin is optional for that base but encouraged for the complete current experience: Terminal/TUI, notifications, media, desktop tools, enhanced voice, Relay sessions, page drafts, and optional Device Control. Hermes-Relay prefers compatible upstream surfaces as they become available instead of keeping duplicate extension paths. **Connect Hermes first, then grant Hermes-Relay separately; the same one-time invite contract pairs Android or the Desktop CLI.**
+A vanilla [hermes-agent](https://github.com/NousResearch/hermes-agent) install is enough for the upstream standard path: chat, management, voice, inbound files, Petdex, and ordinary installed-plugin pages. The Hermes-Relay plugin is optional for that base but encouraged for the complete current experience: Terminal/TUI, notifications, desktop tools, enhanced voice, Relay sessions, page drafts, optional Device Control, and media compatibility or metadata. Hermes-Relay prefers compatible upstream surfaces as they become available instead of keeping duplicate extension paths. **Connect Hermes first, then grant Hermes-Relay separately; the same one-time invite contract pairs Android or the Desktop CLI.**
 
 <p align="center">
-  <img src="docs/diagrams/architecture-homepage.png" alt="How Hermes-Relay connects — upstream Hermes owns Chat, Manage, and standard Voice; the encouraged Relay extension fills current gaps for Terminal, notifications, media, enhanced voice, sessions, desktop tools, and optional Device Control." width="900">
+  <img src="assets/readme-connection-map-v2.png" alt="How Hermes-Relay connects — Dashboard and Gateway own the standard Android path for Chat, Manage, Voice, and inbound files; the optional Relay plugin separately adds Android enhancements plus CLI and UI tools; sideload adds Device Control." width="1000">
 </p>
 
 ## Quick Start (Android)
@@ -50,7 +56,7 @@ Install → connect → talk, in about two minutes.
 
 ### 1 · Install the app
 
-- **Google Play** *(easiest — auto-updates)* — [**install from Google Play**](https://play.google.com/store/apps/details?id=com.axiomlabs.hermesrelay). Chat, voice, sessions, and Manage work with standard Hermes; pairing the Hermes-Relay plugin adds Terminal/TUI, media, notifications, and Relay sessions.
+- **Google Play** *(easiest — auto-updates)* — [**install from Google Play**](https://play.google.com/store/apps/details?id=com.axiomlabs.hermesrelay). Chat, voice, sessions, Manage, and inbound files work with standard Hermes; pairing the Hermes-Relay plugin adds Terminal/TUI, notifications, Relay sessions, and media enhancements.
 - **APK** *(full phone-control feature set)* — download the file ending in **`-sideload-release.apk`** from the newest `android-v*` release on [GitHub Releases](https://github.com/Codename-11/hermes-relay/releases) and open it (allow your browser to install unknown apps the first time). Integrity verification, signing fingerprint, and per-build details are in the [Sideload guide](https://hermes-relay.dev/docs/guide/getting-started.html#sideload-apk).
 
 Sideload builds check GitHub for updates and show a one-tap banner when you're behind; Play builds update through the Store. See [Release tracks](https://hermes-relay.dev/docs/guide/release-tracks) for the capability matrix.
@@ -58,7 +64,7 @@ Sideload builds check GitHub for updates and show a one-tap banner when you're b
 ### 2 · Have the Hermes Dashboard running
 
 The normal Android connection uses the upstream Hermes Dashboard/Gateway for
-chat, sign-in, sessions, Manage, and voice. Installing Hermes and choosing a
+chat, sign-in, sessions, Manage, voice, and inbound files. Installing Hermes and choosing a
 provider is vanilla Hermes setup:
 
 ```bash
@@ -77,16 +83,15 @@ the [remote-access guide](https://hermes-relay.dev/docs/guide/remote-access/).
 
 ### 3 · Connect and talk
 
-For a plugin-enabled host, open the Web Dashboard's **Relay** page, click
-**Connect mobile app**, and scan that tokenless QR from Android **Connect → Scan
-Hermes setup QR**. It contains only the Dashboard address and configures the
-upstream Chat, sessions, Manage, sign-in, and standard voice connection.
-
-Without the Dashboard plugin, use **Find Hermes on LAN** or enter the Dashboard
-address manually (conventionally `http://<host>:9119`). Sign in through the
+Use **Find Hermes on LAN** or enter the Dashboard address manually
+(conventionally `http://<host>:9119`). Sign in through the
 Dashboard's configured provider when prompted. The app probes the available
 upstream capabilities and finishes with a connection summary.
 
+If the Relay Dashboard page is already installed, **Connect mobile app** offers
+the same standard connection as a tokenless QR. It contains only the Dashboard
+address and does not install, enable, or pair Relay.
+
 The separate API server can be discovered automatically or added later under
 **Advanced** as a chat fallback or for a headless compatibility setup. Its API
 key is requested only when that optional endpoint is configured. Existing
@@ -99,7 +104,7 @@ The wizard probes everything and finishes with a capability card:
 | **Chat** | Dashboard/Gateway ready — you can talk |
 | **Manage** | Models, keys, skills, and profiles are available from the phone |
 | **Voice** | Speech ready via your server (or one Manage sign-in away) |
-| **API fallback** | Optional API route available/unavailable |
+| **Direct API** | Optional API-only compatibility route available/unavailable |
 | **Relay** | Recommended extensions paired/unpaired; never blocks the upstream path |
 
 One dashboard sign-in unlocks Chat, Manage, sessions, and standard voice. That's
@@ -109,9 +114,9 @@ the whole Vanilla Hermes setup.
 
 ### 4 · Recommended: pair Relay for the complete experience
 
-Install Relay for Terminal/TUI, notifications, media handoff, desktop tools,
-enhanced voice, Relay sessions, approval-gated page drafts, and optional Device
-Control:
+Install Relay for Terminal/TUI, notifications, desktop tools, enhanced voice,
+Relay sessions, approval-gated page drafts, optional Device Control, and media
+compatibility or sensitivity metadata:
 
 ```bash
 hermes plugins install Codename-11/hermes-relay/plugin --enable
@@ -140,7 +145,7 @@ manual fallbacks when QR or clipboard transfer is unavailable.
 [Desktop CLI pairing](https://hermes-relay.dev/docs/desktop/pairing) ·
 [server, TLS, legacy install, and uninstall reference](https://hermes-relay.dev/docs/reference/relay-server)
 
-**Requirements:** Android 8.0+ (SDK 26) · current upstream [hermes-agent](https://github.com/NousResearch/hermes-agent) with the Dashboard/Gateway enabled · Python 3.11+ when installing the Hermes-Relay plugin. The API fallback is optional; the Hermes-Relay plugin is encouraged for the complete experience.
+**Requirements:** Android 8.0+ (SDK 26) · current upstream [hermes-agent](https://github.com/NousResearch/hermes-agent) with the Dashboard/Gateway enabled · Python 3.11+ when installing the Hermes-Relay plugin. Direct API is optional; the Hermes-Relay plugin is encouraged for the complete experience.
 
 ## Screenshots
 
@@ -161,7 +166,7 @@ manual fallbacks when QR or clipboard transfer is unavailable.
 
 <p align="center">
   <img src="assets/screenshots/supplemental/15_git_workspace.png" alt="Native Git workspace showing repository changes, an inline diff, and staging controls" width="260"><br>
-  <sub><b>Native Git workspace</b> — optional Hermes-Relay plugin</sub>
+  <sub><b>Native Git workspace</b> — upstream session context with optional Relay discovery and operations</sub>
 </p>
 
 ### Simplified Chinese
@@ -215,7 +220,7 @@ hermes-relay update                            # self-update via GitHub Releases
 
 It pairs against the **same relay and credential store** as the Android app — pair once from either, both work. Tagged on the `desktop-v*` [release track](https://github.com/Codename-11/hermes-relay/releases?q=desktop), with historical releases still visible under `cli-v*`.
 
-On Windows, the default installer adds the optional compact **Hermes-Relay CLI UI** tray popup for host selection and pairing, connection and daemon state, per-host Ask/Trusted/Full Access, local grant dialogs, authorized-client revocation, activity, settings, and emergency stop. It is a management surface only—chat, TUI, plugins, voice, and agent sessions remain CLI/upstream concerns.
+On Windows, the default installer adds the optional compact **Hermes-Relay CLI UI** tray popup for host selection and pairing, connection and daemon state, per-host Ask/Trusted/Full Access, local grant dialogs, authorized-client revocation, activity, settings, and emergency stop. `hermes-relay update` detects this bundle and updates the CLI and UI together; explicit CLI-only installations stay headless and continue using the standalone binary updater. The UI is a management surface only—chat, TUI, plugins, voice, and agent sessions remain CLI/upstream concerns.
 
 <table>
   <tr>
@@ -239,17 +244,17 @@ remote tool surface. See the [desktop tools guide](https://hermes-relay.dev/docs
 ## How It Works
 
 ```
-Phone        (HTTP/WSS) --> Hermes Dashboard  (:9119)   [chat gateway, manage, vanilla voice]
-Phone        (HTTP/SSE) --> Hermes API Server (:8642)   [chat fallback, sessions, runs]
-Phone        (WSS/HTTP) --> Relay             (:8767)   [terminal, bridge, media, relay voice, sessions]
+Phone        (HTTP/WSS) --> Hermes Dashboard  (:9119)   [chat gateway, manage, vanilla voice, inbound files]
+Phone        (HTTP/SSE) --> Hermes API Server (:8642)   [Direct API chat, sessions, runs]
+Phone        (WSS/HTTP) --> Relay             (:8767)   [terminal, bridge, media enhancements, relay voice, sessions]
 CLI          (WSS)      --> Relay             (:8767)   [machine tools, tui, terminal]
 ```
 
-Chat prefers the Hermes dashboard gateway when Manage auth is ready, then falls
-back to the upstream API server SSE path with the API key. Manage and Vanilla Hermes
+Standard connections keep Chat on the Hermes Dashboard/Gateway. Explicit API-only
+connections use the upstream Direct API SSE path with an API key. Manage and Vanilla Hermes
 voice ride the Hermes dashboard with its own one-time sign-in, so a vanilla
-install needs no plugin for either. The optional relay on `:8767` adds the power
-surfaces: terminal, bridge phone control, media handoff, machine tools, and
+install needs no plugin for those surfaces or ordinary inbound files. The optional relay on `:8767` adds
+terminal, bridge phone control, media compatibility/metadata, machine tools, and
 relay-side voice, which is preferred automatically when paired. One QR can
 configure API, dashboard, and relay routes without merging their auth models.
 

README.zh-CN.md

@@ -1,109 +0,0 @@
-<p align="center">
-  <img src="assets/play-store-feature-1024x500.png" alt="Hermes-Relay — 随身携带您的 Hermes 代理" width="800">
-</p>
-
-<p align="center">
-  <strong>运行在您的电脑上，连接到您的设备。</strong><br>
-  Hermes-Relay 是 <a href="https://github.com/NousResearch/hermes-agent">Hermes Agent</a> 的原生 Android 客户端，提供流式聊天、免手动语音和代理管理；另有单文件 CLI，让代理在已配对的电脑上安全使用终端、文件和截图工具。
-</p>
-
-<p align="center">
-  <strong>简体中文</strong> · <a href="README.md">English</a><br>
-  <a href="https://hermes-relay.dev/docs/zh-CN/">中文文档</a> ·
-  <a href="https://github.com/Codename-11/hermes-relay/releases">版本下载</a> ·
-  <a href="https://github.com/Codename-11/hermes-relay/discussions">社区讨论</a> ·
-  <a href="CHANGELOG.md">更新日志</a>
-</p>
-
-> 英文 [README.md](README.md) 是最新、完整的项目说明。本页维护中文安装入口和核心功能摘要；协议、架构和维护者文档以英文版本为准。
-
-## 功能简介
-
-- **Android 应用**：流式聊天、会话历史、文件附件、Hermes 管理、语音模式、原生插件页面、Petdex 悬浮宠物、多连接和配置文件；也可将 Hermes 设为 Android 助手。
-- **无需插件的标准路径**：聊天、管理和标准语音可直接连接未修改的上游 Hermes Agent。
-- **可选 Relay 插件**：增加终端、手机控制、媒体传输、通知助手、Relay 语音、电脑工具，以及需确认的代理创建插件页面草稿。
-- **安全连接**：二维码配对、Android Keystore、证书固定、按通道授权和可配置会话有效期。
-- **远程使用**：可配置 Tailscale 或 HTTPS 地址，在家庭局域网和远程路由之间自动切换。
-- **两种 Android 发行渠道**：Google Play 版本适合日常使用；sideload 版本包含完整手机控制能力。
-
-## 快速开始
-
-### 1. 安装 Android 应用
-
-- [Google Play](https://play.google.com/store/apps/details?id=com.axiomlabs.hermesrelay)：自动更新，包含聊天、语音、管理、终端、媒体和通知功能。
-- [GitHub Releases](https://github.com/Codename-11/hermes-relay/releases)：下载最新 `android-v*` 版本中以 `-sideload-release.apk` 结尾的文件，获得完整手机控制功能。
-
-### 2. 启动 Hermes API 服务
-
-手机需要能够访问 Hermes API 服务，并使用 API 密钥进行身份验证：
-
-```bash
-hermes setup --portal
-
-mkdir -p ~/.hermes
-API_SERVER_KEY="$(openssl rand -hex 32)"
-cat >> ~/.hermes/.env <<EOF
-API_SERVER_ENABLED=true
-API_SERVER_HOST=0.0.0.0
-API_SERVER_PORT=8642
-API_SERVER_KEY=$API_SERVER_KEY
-EOF
-chmod 600 ~/.hermes/.env
-
-echo "Android API URL: http://<电脑IP>:8642   key: $API_SERVER_KEY"
-hermes gateway
-```
-
-`0.0.0.0` 会让同一网络中的设备访问 API。请保留强密钥；离开可信局域网时，应使用 Tailscale 或 HTTPS 反向代理，不要直接把端口暴露到互联网。
-
-### 3. 在手机上连接
-
-打开应用后，可以：
-
-- 扫描局域网中的 Hermes；
-- 手动输入 `http://<主机>:8642` 和 API 密钥；
-- 扫描包含 API、Dashboard 和可选 Relay 地址的设置二维码。
-
-如需在手机上管理模型、密钥、技能和配置文件，请运行 Hermes Dashboard，并在应用的 **管理** 页面登录一次。同一登录会话也会启用标准语音。
-
-### 4. 可选：安装 Relay
-
-仅在需要终端、手机控制、媒体路由、Relay 会话、实时语音、电脑工具或代理创建插件页面草稿时安装：
-
-```bash
-hermes plugins install Codename-11/hermes-relay/plugin --enable
-hermes relay doctor
-hermes relay start --no-ssl
-hermes pair
-```
-
-已安装的 Hermes 插件可通过已认证的 Dashboard 向 Android 提供由应用安全渲染的原生页面，无需在手机上运行插件代码。Relay 1.5.0 另支持需用户确认的代理创建页面草稿。
-
-完整说明请阅读[中文快速开始](https://hermes-relay.dev/docs/zh-CN/guide/quick-start)；远程访问、协议和高级配置暂时链接到英文参考文档。
-
-安装问题、早期想法、一般交流和作品分享请使用 [GitHub Discussions](https://github.com/Codename-11/hermes-relay/discussions)。可复现的错误和明确、可执行的功能请求请提交到 [Issues](https://github.com/Codename-11/hermes-relay/issues/new)。
-
-## 中文界面
-
-<table>
-  <tr>
-    <td align="center" width="33%"><img src="assets/screenshots/Zh01.jpg" alt="中文设置界面" width="100%"><br><sub><b>设置</b></sub></td>
-    <td align="center" width="33%"><img src="assets/screenshots/Zh02.jpg" alt="中文管理界面" width="100%"><br><sub><b>管理</b></sub></td>
-    <td align="center" width="33%"><img src="assets/screenshots/Zh03.jpg" alt="中文导航界面" width="100%"><br><sub><b>导航</b></sub></td>
-  </tr>
-</table>
-
-## 参与翻译
-
-Android 英文资源是规范来源。新增语言必须保持资源名称、类型和格式参数一致，并通过：
-
-```bash
-python scripts/check-android-locales.py
-./gradlew lint
-```
-
-翻译规范、目录命名、复数和占位符规则见 [docs/localization.md](docs/localization.md)。
-
-## 许可证
-
-[MIT](LICENSE) — Copyright (c) 2026 [Axiom-Labs](https://codename-11.dev)

RELEASE.md

@@ -531,13 +531,14 @@ the new app version and a higher `appVersionCode`.
   `retrace <mapping.txt> <obfuscated-trace.txt>`. Play reports can additionally
   use the mapping bundled into the uploaded AAB through Play Console.
 - `app/src/main/assets/changelog.json` — curated source for the in-app
-  **What's New** dialog and Android release history. Prepend the newest entry
-  with one explicit `highlight` (`title`, plain-language `summary`, and 1–3
-  user-benefit bullets), up to two quieter `improvements`, Android-only
-  `playNotes`, a `toastDigest` with counts and 0–2 short previews for noteworthy
-  items beyond the hero, and the existing technical `sections` used by older clients.
-  Do not derive the highlight mechanically from `CHANGELOG.md`; choosing the
-  release's main reason to care is an editorial release-prep decision.
+  **What's New** dialog and Android release history. Prepend one schema-3 entry
+  with a single descriptive release `title`, a plain-language `summary`, and a
+  complete `changes` inventory. Every user-visible change has a stable `id`, a
+  `kind` (`added`, `improved`, or `fixed`), a short title, a useful explanation,
+  and an optional `highlight: true`; select 1–4 highlights. Add `compatibility`
+  bullets only when users need an availability, migration, flavor, or Plugin
+  boundary, plus Android-only `playNotes`. The app derives toast counts and
+  previews from the same inventory and renders every change exactly once.
 - `app/src/main/assets/whats_new.txt` — legacy in-app fallback generated from
   the newest structured entry. Do not edit it independently.
 - `app/src/googlePlay/play/release-notes/en-US/default.txt` — the Play
@@ -551,8 +552,8 @@ the new app version and a higher `appVersionCode`.
   block and the Gradle Play Publisher note are generated from `playNotes`.
   After editing the newest structured entry, run
   `python scripts/check-android-release-notes.py --write`, then run it again
-  without `--write` to validate the 1–3 / 0–2 editorial limits, current Android
-  version, GitHub-release/changelog headings, derived files, and Play's
+  without `--write` to validate complete unique change records, 1–4 highlights,
+  the current Android version, GitHub-release/changelog headings, derived files, and Play's
   **500-character** limit. Frame Play copy around the release's themes, not a
   feature dump. Compare its **Foreground service
   permissions** section with the merged `googlePlayRelease` manifest and
@@ -570,28 +571,30 @@ authoring contract; do not maintain a separate prompt file.
    boundary that users must understand. Do not generate from commit titles or
    a mixed-surface changelog block alone.
 2. Before editing release files, show a temporary coverage ledger in the task
-   output. Map every selected source change to exactly one placement:
-   `hero`, `secondary`, or `full-only`. Include the change kind (`feature`,
-   `change`, or `fix`) and a short reason. The ledger is review evidence, not a
-   committed public artifact; no selected source item may disappear silently.
-3. Choose exactly one `hero`: the strongest user-facing reason to care about
-   the release. Its summary is one plain-language outcome, and its 1–3 bullets
-   are distinct user benefits rather than implementation steps or filler.
-4. Use `secondary` for other important user-visible features and fixes. The
-   `toastDigest` counts only these items, excluding the hero. Preview the
-   strongest 1–2 secondary items in short phrases. If there are no legitimate
-   secondary items, set both counts to `0` and `preview` to `[]`; the app hides
-   the footer. Never invent an item to satisfy the layout.
-5. Use `full-only` for technically relevant details that belong in
-   `RELEASE_NOTES.md` or `CHANGELOG.md` but would make the collapsed update card
-   noisy. Preserve user-relevant trust and compatibility limits; omit branches,
-   worktrees, CI mechanics, debugging history, and private/operator context.
+   output. Map every selected Android source change to one stable change id and
+   one kind (`added`, `improved`, or `fixed`), and mark whether it is a
+   highlight. The ledger is review evidence, not a committed public artifact;
+   no selected user-visible change may disappear silently or be counted twice.
+3. Write one release title that describes the release as a whole. Do not let a
+   narrow feature name, internal project label, or poetic codename replace the
+   title users see in the toast and history. Follow it with a one- or two-sentence
+   summary that gives the release's overall outcome without becoming a feature dump.
+4. Select 1–4 highlights from the complete change inventory. A highlight is a
+   strong reason to care, not a second copy of the change: the app presents it
+   once in the highlight section and derives the remaining counts and previews
+   from non-highlighted changes.
+5. Include every meaningful user-visible addition, improvement, and fix in
+   `changes`, using plain titles and enough explanation for someone to recognize
+   the affected behavior. Internal refactors, tests, CI mechanics, branch work,
+   and debugging history stay in `RELEASE_NOTES.md`, `CHANGELOG.md`, or engineering
+   records unless they materially change reliability, security, or compatibility.
 6. Write each surface for its audience:
    - `RELEASE_NOTES.md`: concise Summary plus Added/Changed/Fixed; keep the
      deterministic Download and Install/Verify scaffolding intact.
    - `CHANGELOG.md`: complete, crisp public history for the released surface.
-   - `changelog.json`: curated hero, optional improvements, digest, Play copy,
-     and compatibility `sections` for older clients.
+   - `changelog.json`: overall title/summary, complete typed changes, selected
+     highlights, compatibility boundaries, and Play copy. Counts and previews
+     are derived; never author a parallel digest.
    - `playNotes`: Android-only themes within the rendered 500-character limit.
 7. Before presenting the draft, check that wording begins with user outcomes,
    avoids unexplained implementation terminology, uses exact public product
@@ -625,6 +628,21 @@ and the release notes and learn only what the software does.
 
 ### 3. Build and verify locally
 
+During release-note/version iteration, use the narrow release-prep lane:
+
+```powershell
+python scripts/android-prepush.py --release-prep
+```
+
+It runs release metadata checks plus the rendered Changelog/What's New tests in
+the serialized Android lane. Once the exact commit is pushed, current-head CI
+and Play preflight own lint, focused shards, both-flavor assemblies, signing,
+and final package scans. Do not repeat the complete local release build unless
+cloud execution is unavailable or explicit local artifact/device proof is
+needed.
+
+For that explicit full local proof:
+
 ```bat
 scripts\dev.bat bundle
 keytool -printcert -jarfile app\build\outputs\bundle\googlePlayRelease\hermes-relay-*-googlePlay-release.aab
@@ -658,14 +676,17 @@ The preflight workflow:
 3. builds and release-signs the same APK/AAB variants used by the public release;
 4. scans the final minified APK DEX for unsupported collection calls;
 5. uploads the Google Play AAB as a private **Production draft**; and
-6. records a 30-day preflight proof keyed to the version and Git tree hash.
+6. retains the exact signed sideload APK, Play AAB, R8 mappings, manifest, and
+   checksums as one immutable 30-day artifact keyed to version and Git tree.
 
 No sideload APK or GitHub Release is published by preflight. A successful signed
-build, final DEX scan, and Production-draft upload is the automated Play release
-gate. Play Console pre-review and pre-launch reports are informational and
-non-blocking because their detailed results are not exposed through the release
-automation API. If the release source changes after preflight, rerun it—the
-approval workflow matches the complete Git tree, not just the version number.
+build, final package scans, and Production-draft upload is the automated Play
+release gate. The private artifact is immutable and hash-verified again before
+publication; the stable release workflow does not rebuild those bytes. Play
+Console pre-review and pre-launch reports are informational and non-blocking
+because their detailed results are not exposed through the release automation
+API. If the release source changes after preflight, rerun it—the approval
+workflow matches the complete Git tree, not just the version number.
 
 GitHub exposes manual workflows only after their workflow file exists on the
 default branch. For the first release that introduces this process, merge the
@@ -706,12 +727,13 @@ from `main`; every release job explicitly checks out and verifies the immutable
 an existing tag or changing its artifact tree. Manual stable tags are still
 guarded by the same preflight proof in the tag workflow.
 
-The tag-triggered `.github/workflows/release-android.yml` rebuilds and scans the
-artifacts, changes the existing Play Production draft to `completed` (submitting
-it for review), and only after Play accepts that operation creates the public
-GitHub Release with the sideload APK. A missing preflight, changed release tree,
-missing Play credential, or Play submission failure prevents public GitHub
-publication.
+The tag-triggered `.github/workflows/release-android.yml` downloads the exact
+private preflight artifact by ID, verifies its source workflow, manifest, tree,
+version, sizes, and hashes, reruns the package scanners, then changes the
+existing Play Production draft to `completed` (submitting it for review). Only
+after Play accepts that operation does it publish those same APK/AAB bytes on
+GitHub. A missing preflight, changed release tree, artifact mismatch, missing
+Play credential, or Play submission failure prevents public publication.
 
 Plugin/Python version files are intentionally not part of an Android app
 release unless the plugin package itself is also being released.
@@ -740,14 +762,19 @@ git commit -m "release(server): server-v0.6.2"
 git push origin dev
 
 # Open the release PR (dev -> main) and merge with --no-ff.
-# After merge, tag from the new main tip:
-git checkout main
-git pull --ff-only origin main
-git tag server-v0.6.2
-git push origin server-v0.6.2
+# Then run "Hermes-Relay Plugin and CLI+UI Release Approval" from main,
+# select plugin, and enter 0.6.2. The workflow selects and validates main
+# before it creates server-v0.6.2 and starts the immutable-tag release workflow.
 ```
 
-Pushing `server-v*` triggers `.github/workflows/release-plugin.yml`, which
+For a Plugin prerelease, keep the release-prepared commit on `dev` and run the
+same trusted approval workflow from `main`; the version suffix makes it select
+and validate the exact `origin/dev` tip before creating the tag. Stable versions
+select `origin/main` instead.
+Direct `server-v*` tag pushes remain a recovery path and are guarded by the same
+branch-containment and metadata checks.
+
+The approval workflow dispatches `.github/workflows/release-plugin.yml`, which
 validates all plugin-owned version metadata with
 `scripts/check-plugin-version-sync.py`. Run
 `python scripts/check-version-tracks.py` locally before tagging when a change
@@ -778,20 +805,25 @@ git add desktop/package.json desktop/package-lock.json desktop/src/version.ts `
 git commit -m "release(desktop): desktop-v0.4.0-alpha.2"
 git push origin dev
 
-# Open the release PR (dev -> main) and merge with --no-ff.
-# After merge, tag from main:
-git switch main
-git pull --ff-only origin main
-cd desktop
-npm run check:version-sync -- --expect 0.4.0-alpha.2
-cd ..
-git tag desktop-v0.4.0-alpha.2
-git push origin desktop-v0.4.0-alpha.2
+# This is a prerelease: run "Hermes-Relay Plugin and CLI+UI Release Approval"
+# from main, select desktop, and enter 0.4.0-alpha.2. The workflow validates dev
+# before it creates the tag and starts the immutable-tag release workflow.
 ```
 
-The tag workflow rejects version drift and tags whose commit is not in
-`origin/main`, reruns CLI tests, builds all four standalone binaries, tests and
-packages the Windows tray, generates checksums, and publishes the GitHub Release.
+For a stable CLI+UI version, first merge the release PR from `dev` to `main`,
+then run the approval workflow from `main`. The version determines the source:
+prereleases select the exact `origin/dev` tip and stable releases select the
+exact `origin/main` tip before creating any tag. Direct `desktop-v*` tag pushes
+remain a recovery path.
+
+The release workflow rejects version drift and requires prerelease tags to be
+contained in `origin/dev` and stable tags to be contained in `origin/main`. It
+reruns CLI tests, builds all four standalone binaries, tests and packages the
+Windows tray, generates checksums, and publishes the GitHub Release.
+Trusted desktop CI and the release installer job share a Cargo/target cache
+keyed by the lockfile and exact tray sources. A `main` push for the release tree
+warms the exact cache before the immutable tag build; a miss safely performs the
+ordinary Rust/Tauri build.
 
 ### 6. Play review and publishing behavior
 
@@ -892,7 +924,7 @@ gradlew promoteReleaseArtifact --from-track=internal --promote-track=production
   (This step was only needed as a retrofit for v0.1.0 — v0.1.1+ inherit
   the Download section automatically from `RELEASE_NOTES.md`.)
 - Confirm Play Console shows the new versionCode on the target track.
-- Update `DEVLOG.md` with a short entry for the release.
+- Update `docs/project/DEVLOG.md` with a short entry for the release.
 
 ## CI Behavior
 
@@ -900,28 +932,40 @@ Android, Plugin, dashboard, and desktop now have separate CI/release lanes.
 This keeps a dashboard CSS fix from running the full server suite, and keeps
 plugin changes from forcing an Android app `versionCode` bump.
 
+Every successful `Required checks` run records a short-lived proof keyed to the
+checked Git tree. For the canonical `dev` → `main` release PR, CI first proves
+the simulated merge tree is identical to the `dev` tree. If an unexpired proof
+from a successful Required-checks run exists, the PR verifies and reuses it;
+otherwise it automatically falls back to the normal path-aware matrix. Content
+changes can never reuse an older proof because they change the tree hash.
+
 On every push of a tag matching `android-v*`, `.github/workflows/release-android.yml`:
 
 1. Verifies a stable tag resolves to a commit contained in `main`, or a
    prerelease tag resolves to a commit contained in `dev`, and that the tag matches `appVersionName` in
    `gradle/libs.versions.toml` (mismatches fail the workflow).
-2. Runs the Android debug build and the stable sideload pairing/connection
-   regression slice with explicit timeouts.
-3. Decodes `HERMES_KEYSTORE_BASE64` into `$RUNNER_TEMP/release.keystore`
-   and exports `HERMES_KEYSTORE_PATH` (skipped if the secret is unset).
-4. For stable releases, builds all four flavored release artifacts
-   (`./gradlew bundleRelease assembleRelease`); only the sideload APK and
-   googlePlay AAB are attached. For prereleases, builds only the side-by-side
-   `sideloadCandidate` APK.
-5. Generates `SHA256SUMS.txt` covering the two attached files.
-6. For stable releases only, promotes the exact preflighted Production draft to
+2. For stable releases, verifies and downloads the exact immutable Play
+   preflight artifact; prereleases run the focused CI slice and build the
+   side-by-side `sideloadCandidate` APK.
+3. Revalidates stable artifact hashes, DEX collection compatibility, packaged
+   native compatibility, and retained R8 mappings without recompiling.
+4. Generates candidate checksums when applicable; stable checksums come from
+   the verified preflight artifact and cover the two public files.
+5. For stable releases only, promotes the exact preflighted Production draft to
    `completed`; prereleases never upload to Play.
-7. Creates a GitHub Release named `Hermes-Relay Android v<version>` with `RELEASE_NOTES.md` as
+6. Creates a GitHub Release named `Hermes-Relay Android v<version>` with `RELEASE_NOTES.md` as
    the body. Attaches the APK, AAB, and `SHA256SUMS.txt`. Tags any version
    containing a dash (e.g. `android-v0.2.0-beta.1`) as a prerelease automatically.
-8. Prints a `$GITHUB_STEP_SUMMARY` with the release and Play result.
+7. Prints a `$GITHUB_STEP_SUMMARY` with the release and Play result.
 
-On every push of a tag matching `server-v*`,
+For an approved multi-surface train, run **Hermes-Relay Coordinated Release
+Approval** from `main`, select the affected surfaces, and enter their prepared
+versions. It dispatches Android, Plugin, and CLI+UI approval jobs concurrently;
+each surface keeps its independent source, validation, tag, artifact, and
+publication workflow.
+
+On every direct push of a tag matching `server-v*`, or after an approved
+dispatch from `.github/workflows/approve-release-extensions.yml`,
 `.github/workflows/release-plugin.yml`:
 
 1. Verifies a stable tag commit is contained in `main`, or a prerelease tag is
@@ -934,7 +978,8 @@ On every push of a tag matching `server-v*`,
 5. Creates a GitHub Release named `Hermes-Relay Plugin v<version>` with the wheel,
    sdist, and checksum file attached.
 
-On every push of a tag matching `desktop-v*`,
+On every direct push of a tag matching `desktop-v*`, or after an approved
+dispatch from `.github/workflows/approve-release-extensions.yml`,
 `.github/workflows/release-cli.yml` builds and publishes the CLI binaries and
 Windows tray installer. Its GitHub Release body comes from `CLI_RELEASE_NOTES.md`
 (rewritten per release — the CLI counterpart of `RELEASE_NOTES.md`); the workflow

RELEASE_NOTES.md

@@ -1,10 +1,10 @@
-# Hermes-Relay Android v1.14.0
+# Hermes-Relay Android v1.16.1
 
-**Release Date:** August 30, 2026
+**Release Date:** September 12, 2026
 
 ## Download
 
-> Installing on your phone? Download `hermes-relay-1.14.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.16.1-sideload-release.apk` and tap it for the full feature set, or install the conservative build from [Google Play](https://play.google.com/store/apps/details?id=com.axiomlabs.hermesrelay).
 
 The `.aab` file is a Play Console upload bundle and cannot be installed by tapping it on a phone.
 
@@ -12,33 +12,16 @@ Verify the download against `SHA256SUMS.txt`. See the [sideload guide](https://h
 
 ## Summary
 
-This release makes saved Hermes connections reliable across LAN, Tailscale, and public HTTPS while keeping Dashboard authentication bound to its exact trusted origin. It also adds delegated-agent previews and an optional native Git workspace, and improves Voice, Assistant, Threads, profile drafts, and Clarify interactions.
-
-## Added
-
-- **Delegated-agent previews.** Follow bounded lifecycle, progress, tool previews, and available read-only child history without leaving the parent chat. Partial history and reconnect gaps remain explicit. (#447)
-- **Native Git workspace.** Review repository state, diffs, branches, staging, commits, and remotes from Chat or Settings. Git operations require Hermes-Relay Plugin v1.11.0 and retain confirmation and grant boundaries.
-
-## Changed
-
-- **Route-aware connections.** Dashboard, Relay, and optional API health are evaluated independently across LAN, Tailscale, and public HTTPS. Same-origin Relay ingress stays on the Dashboard origin that owns authentication, while direct compatibility routes keep separate credentials. (Related: #399)
-- **Voice Focus controls.** Stop and immediate spoken steering remain accessible while Hermes is Thinking, Transcribing, or Speaking, including TalkBack, Switch Access, keyboard, and sideload overlay surfaces.
+This patch fixes a remaining cold-start path that could leave a Dashboard-only connection waiting for Gateway readiness until the app resumed or its network route changed.
 
 ## Fixed
 
-- Wake-word detection packages one compatible ONNX Runtime for sherpa and Java JNI on every supported ABI. (#444)
-- Continuous voice waits for barge-in microphone teardown before listening again. (#464)
-- Fresh chats retain their selected profile without reopening a previous session or carrying a proactive Thread route across profiles. (#436)
-- Provisional Threads can be removed locally and reconcile with promoted sessions without deleting server history. (#461)
-- Clarify cards expose a reachable Other answer, keyboard Send, and authoritative expiry behavior. (#446)
-- Passive Android browsing no longer claims or interrupts a turn owned by another client. (Related: #365)
-- Assistant sessions show retryable no-speech feedback, recover their active state after recreation, and redact conversation details behind the keyguard. (Related: #424)
-- Protected Relay ingress `401/403` responses are recognized as authentication boundaries rather than outages; malformed, different-origin, and direct unauthorized routes still fail closed.
+- Dashboard-only connections now start the exact profile-scoped session directory before Gateway readiness, so the directory and passive Gateway socket no longer wait on each other during a cold launch.
 
 ## Install / Verify
 
-- App version: **1.14.0** (versionCode **52**).
-- Standard Chat, sessions, profiles, Manage, and standard voice continue to work against unmodified upstream Hermes without the optional Relay plugin.
-- Install Hermes-Relay Plugin v1.11.0 for same-origin Relay extensions, Git workspace actions, Bridge, media, proactive features, and enhanced voice.
-- Granular Device Control and the system Voice Focus overlay remain sideload-only; the Google Play build does not declare their restricted permissions.
-- Existing connections, drafts, sessions, profile ownership, and legacy direct Relay routes remain data-preserving compatibility paths.
+- App version: **1.16.1** (versionCode **56**).
+- Standard Chat, sessions, profiles, Manage, voice, and ordinary media use current upstream Hermes. Speech-to-text still requires a configured provider on the host.
+- Hermes-Relay Plugin **1.11.2** remains the matching optional release for Relay tools; this Gateway startup fix does not require it.
+- Explicit Direct API/API-only connections remain supported and are not used as silent failover for Dashboard-owned chats.
+- Granular Device Control and the system Voice Focus overlay remain sideload-only.

app/build.gradle.kts

@@ -249,6 +249,58 @@ android {
             it.systemProperty("roborazzi.test.record", "true")
             it.maxHeapSize = "2g"
         }
+
+        // On-demand only. Keep each form factor as an individually selected
+        // Gradle-managed device; there is deliberately no aggregate matrix
+        // task or scheduled emulator job. See docs/android-emulator-testing.md.
+        managedDevices {
+            localDevices {
+                create("compactPhoneApi36") {
+                    device = "Pixel 2"
+                    apiLevel = 36
+                    systemImageSource = "aosp"
+                    require64Bit = true
+                    testedAbi = "x86_64"
+                }
+                create("standardPhoneApi36") {
+                    device = "Pixel 6"
+                    apiLevel = 36
+                    systemImageSource = "aosp"
+                    require64Bit = true
+                    testedAbi = "x86_64"
+                }
+                create("largePhoneApi36") {
+                    device = "Pixel 7 Pro"
+                    apiLevel = 36
+                    systemImageSource = "aosp"
+                    require64Bit = true
+                    testedAbi = "x86_64"
+                }
+                create("foldableApi36") {
+                    device = "Pixel Fold"
+                    apiLevel = 36
+                    systemImageSource = "aosp"
+                    require64Bit = true
+                    testedAbi = "x86_64"
+                }
+                create("tabletApi36") {
+                    device = "Pixel Tablet"
+                    apiLevel = 36
+                    systemImageSource = "aosp"
+                    require64Bit = true
+                    testedAbi = "x86_64"
+                }
+                create("futureApi37Ps16k") {
+                    device = "Pixel 7 Pro"
+                    apiLevel = 37
+                    systemImageSource = "google_apis_playstore"
+                    require64Bit = true
+                    testedAbi = "x86_64"
+                    pageAlignment =
+                        com.android.build.api.dsl.ManagedVirtualDevice.PageAlignment.FORCE_16KB_PAGES
+                }
+            }
+        }
     }
 }
 
@@ -315,8 +367,9 @@ dependencies {
     implementation(libs.okhttp)
     implementation(libs.okhttp.sse)
 
-    // Media3 ExoPlayer — gapless TTS queue playback (replaces MediaPlayer in VoicePlayer)
+    // Media3 ExoPlayer + lifecycle-aware Compose video surface.
     implementation(libs.media3.exoplayer)
+    implementation(libs.media3.ui.compose)
 
     // android-vad Silero — on-device VAD for barge-in (B2)
     // Bundled ONNX Silero model (~2.2 MB); pulled from JitPack.
@@ -390,6 +443,12 @@ dependencies {
     // Konsist — enforces the ADR 34 upstream/relay/shared package fence as a JUnit test
     testImplementation(libs.konsist)
     androidTestImplementation(libs.compose.ui.test.junit4)
+    // Compose UI Test still declares Espresso 3.5.0 transitively. API 37
+    // removed the reflected InputManager.getInstance() seam; Espresso 3.7.0
+    // uses Context.getSystemService and is the current stable AndroidX line.
+    androidTestImplementation("androidx.test.espresso:espresso-core:3.7.0")
+    androidTestImplementation("androidx.test:runner:1.7.0")
+    androidTestImplementation("androidx.test.ext:junit:1.3.0")
     // On-device vanilla-Gateway contract tests exercise the production
     // Dashboard ticket + WebSocket stack over real loopback sockets.
     androidTestImplementation(libs.okhttp.mockwebserver)

app/proguard-rules.pro

@@ -55,6 +55,9 @@
 -keep class androidx.camera.** { *; }
 -dontwarn androidx.camera.**
 
+# sherpa-onnx JNI resolves Kotlin configuration classes and fields by name.
+-keep class com.k2fsa.sherpa.onnx.** { *; }
+
 # ── General ──────────────────────────────────────────────────────────
 -keepattributes SourceFile,LineNumberTable
 -renamesourcefileattribute SourceFile

app/src/androidTest/kotlin/com/hermesandroid/relay/network/shared/EndpointResolverConcurrencyInstrumentedTest.kt

@@ -0,0 +1,100 @@
+package com.hermesandroid.relay.network.shared
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.hermesandroid.relay.data.ApiEndpoint
+import com.hermesandroid.relay.data.EndpointCandidate
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import okhttp3.OkHttpClient
+import okhttp3.Protocol
+import okhttp3.Response
+import okhttp3.ResponseBody.Companion.toResponseBody
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.InterruptedIOException
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+
+@RunWith(AndroidJUnit4::class)
+class EndpointResolverConcurrencyInstrumentedTest {
+
+    @Test
+    fun probeCompletionRacingInvalidation_staysCrashFreeOnAndroidCollections() = runBlocking {
+        repeat(25) { iteration ->
+            val candidateCount = 8
+            val requestsStarted = CountDownLatch(candidateCount)
+            val releaseRequests = CountDownLatch(1)
+            val raceGate = CountDownLatch(1)
+            val requestSequence = AtomicInteger(0)
+            val client = OkHttpClient.Builder()
+                .addInterceptor { chain ->
+                    if (requestSequence.incrementAndGet() <= candidateCount) {
+                        requestsStarted.countDown()
+                        releaseRequests.await(5, TimeUnit.SECONDS)
+                        throw InterruptedIOException("instrumented invalidation race")
+                    }
+                    Response.Builder()
+                        .request(chain.request())
+                        .protocol(Protocol.HTTP_1_1)
+                        .code(200)
+                        .message("OK")
+                        .body("{}".toResponseBody())
+                        .build()
+                }
+                .build()
+            val resolver = EndpointResolver(client)
+            val candidates = (1..candidateCount).map { index ->
+                EndpointCandidate(
+                    role = "instrumented-$iteration-$index",
+                    priority = 0,
+                    api = ApiEndpoint(host = "127.0.0.1", port = 1, tls = false),
+                )
+            }
+
+            try {
+                val staleResolve = async(start = CoroutineStart.UNDISPATCHED) {
+                    resolver.resolve(candidates, EndpointSurface.Api)
+                }
+                assertTrue(requestsStarted.await(5, TimeUnit.SECONDS))
+
+                val invalidation = async(Dispatchers.Default) {
+                    raceGate.await(5, TimeUnit.SECONDS)
+                    resolver.clearCache()
+                }
+                val completions = async(Dispatchers.Default) {
+                    raceGate.await(5, TimeUnit.SECONDS)
+                    releaseRequests.countDown()
+                }
+                raceGate.countDown()
+
+                withTimeout(2_000L) {
+                    invalidation.await()
+                    completions.await()
+                    staleResolve.await()
+                }
+                assertTrue(resolver.cacheSnapshot().isEmpty())
+
+                resolver.clearCache()
+                val freshWinner = withTimeout(2_000L) {
+                    resolver.resolve(listOf(candidates.first()), EndpointSurface.Api)
+                }
+                assertEquals(candidates.first(), freshWinner)
+                assertTrue(
+                    resolver.probeOutcomes.value.getValue(
+                        EndpointResolver.cacheKey(candidates.first(), EndpointSurface.Api),
+                    ).reachable,
+                )
+            } finally {
+                raceGate.countDown()
+                releaseRequests.countDown()
+                client.dispatcher.executorService.shutdown()
+            }
+        }
+    }
+}

app/src/androidTest/kotlin/com/hermesandroid/relay/ui/components/AmbientVisualizationVisibilityTest.kt

@@ -6,7 +6,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.junit4.v2.createComposeRule
 import androidx.compose.ui.test.onNodeWithTag
 import androidx.compose.ui.test.onNodeWithText
 import androidx.test.platform.app.InstrumentationRegistry

app/src/androidTest/kotlin/com/hermesandroid/relay/ui/screens/ChatDebugDrawerInstrumentedTest.kt

@@ -0,0 +1,65 @@
+package com.hermesandroid.relay.ui.screens
+
+import androidx.activity.ComponentActivity
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material3.Text
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
+import androidx.compose.ui.test.longClick
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTouchInput
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.network.upstream.GatewayConnectionState
+import com.hermesandroid.relay.ui.components.ChatDebugDrawer
+import com.hermesandroid.relay.ui.components.ChatDebugOverlay
+import com.hermesandroid.relay.ui.components.chatDebugHeaderGesture
+import com.hermesandroid.relay.ui.theme.HermesRelayTheme
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+
+class ChatDebugDrawerInstrumentedTest {
+    @get:Rule val compose = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun longPressOpensDiagnosticsBelowHeaderAndCloseRestoresChat() {
+        compose.setContent {
+            var open by remember { mutableStateOf(false) }
+            HermesRelayTheme(appThemeId = "hermes-relay", themePreference = "dark") {
+                Box(Modifier.fillMaxSize()) {
+                    Text("Hermes", Modifier.fillMaxWidth().height(64.dp).testTag("header")
+                        .chatDebugHeaderGesture(true, onClick = {}, onHold = { open = true }))
+                    ChatDebugOverlay(open, 64.dp, onClose = { open = false }) {
+                        ChatDebugDrawer(
+                            profile = "Server Default", model = "Example", sessionId = "session",
+                            gateway = true, signedIn = true, signInRequired = false,
+                            socketState = GatewayConnectionState.Ready, preparing = false,
+                            streaming = false, loadingHistory = false, directoryUnavailable = false,
+                            failure = null, onClose = { open = false }, onConnections = {},
+                        )
+                    }
+                }
+            }
+        }
+        val header = compose.onNodeWithTag("header")
+        val before = header.fetchSemanticsNode().boundsInRoot
+        header.performTouchInput { longClick() }
+        compose.onNodeWithText("Session diagnostics").assertIsDisplayed()
+        assertEquals(before, header.fetchSemanticsNode().boundsInRoot)
+        compose.onNodeWithContentDescription("Close session diagnostics").performClick()
+        compose.onNodeWithText("Session diagnostics").assertDoesNotExist()
+        header.assertIsDisplayed()
+    }
+}

app/src/androidTest/kotlin/com/hermesandroid/relay/viewmodel/ChatActivityReceiptInstrumentedTest.kt

@@ -0,0 +1,183 @@
+package com.hermesandroid.relay.viewmodel
+
+import android.os.Handler
+import android.os.Looper
+import androidx.activity.ComponentActivity
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.hermesandroid.relay.data.AgentDisplay
+import com.hermesandroid.relay.data.ChatActivityPhase
+import com.hermesandroid.relay.data.InMemoryChatActivityStore
+import com.hermesandroid.relay.data.projectChatActivityReceipts
+import com.hermesandroid.relay.network.upstream.ChatHandler
+import com.hermesandroid.relay.network.upstream.DashboardApiClient
+import com.hermesandroid.relay.network.upstream.GatewayChatClient
+import com.hermesandroid.relay.network.upstream.HermesApiClient
+import com.hermesandroid.relay.ui.components.ChatActivityReceipt
+import com.hermesandroid.relay.ui.components.GatewayBackgroundProcessSheet
+import com.hermesandroid.relay.ui.components.GatewayBackgroundProcessStrip
+import com.hermesandroid.relay.ui.components.SubagentPreviewVisibility
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import okhttp3.OkHttpClient
+import okhttp3.WebSocket
+import org.junit.After
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+/** Real Gateway callbacks drive production activity surfaces through Android lifecycle changes. */
+class ChatActivityReceiptInstrumentedTest {
+    @get:Rule val compose = createAndroidComposeRule<ComponentActivity>()
+
+    private lateinit var fixture: AndroidGatewayContractFixture
+    private lateinit var gatewayScope: CoroutineScope
+    private lateinit var gateway: GatewayChatClient
+    private lateinit var handler: ChatHandler
+    private lateinit var viewModel: ChatViewModel
+    private lateinit var socket: WebSocket
+    private val owner = AgentDisplay.profileContextKey("fixture-connection", "research")
+
+    @Before
+    fun setUp() {
+        fixture = AndroidGatewayContractFixture().also { it.profileName = "research" }
+        gatewayScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+        val http = OkHttpClient()
+        gateway = GatewayChatClient(
+            initialDashboardClient = DashboardApiClient(fixture.server.url("/").toString().trimEnd('/'), okHttpClient = http),
+            okHttpClient = http,
+            callbackDispatcher = { block -> Handler(Looper.getMainLooper()).post(block) },
+            scope = gatewayScope,
+            reconnectJitterUnit = { 0.0 },
+        )
+        handler = ChatHandler().also { it.setSessionId(STORED_SESSION_ID) }
+        viewModel = ChatViewModel().also {
+            it.initialize(HermesApiClient(fixture.server.url("/").toString(), "fixture-key"), handler)
+            it.streamingEndpoint = "gateway"
+            it.setSessionProfileNameProvider { "research" }
+            it.setProfileMessageLoader { Result.success(emptyList()) }
+            it.setChatActivityStore(InMemoryChatActivityStore())
+            it.switchProfileContext(owner, STORED_SESSION_ID)
+            it.updateGatewayClient(gateway)
+            it.setChatVisible(true)
+        }
+        compose.setContent {
+            val messages by viewModel.messages.collectAsStateWithLifecycle()
+            val records by viewModel.activityRecords.collectAsStateWithLifecycle()
+            val children by viewModel.subagentActivities.collectAsStateWithLifecycle()
+            val retained by viewModel.retainedActivityPreview.collectAsStateWithLifecycle()
+            val childPreview by viewModel.subagentChildPreview.collectAsStateWithLifecycle()
+            val session by viewModel.currentSessionId.collectAsStateWithLifecycle()
+            var sheetOpen by remember { mutableStateOf(false) }
+            MaterialTheme {
+                Column {
+                    GatewayBackgroundProcessStrip(
+                        processes = emptyList(), subagentActivities = children,
+                        subagentPreviewVisibility = SubagentPreviewVisibility(), loading = false,
+                        onClick = { viewModel.openCurrentActivityPreview(); sheetOpen = true },
+                        modifier = Modifier.testTag("active-activity"),
+                    )
+                    projectChatActivityReceipts(messages, records, owner, session).forEach { message ->
+                        message.activityRecord?.let { record ->
+                            ChatActivityReceipt(
+                                record = record,
+                                onClick = { sheetOpen = viewModel.openRetainedActivity(record) },
+                                modifier = Modifier.testTag("activity-receipt"),
+                            )
+                        }
+                    }
+                }
+                if (sheetOpen) {
+                    GatewayBackgroundProcessSheet(
+                        processes = retained?.processes.orEmpty(),
+                        subagentActivities = retained?.record?.previewActivities() ?: children,
+                        subagentChildPreview = childPreview,
+                        subagentPreviewVisibility = SubagentPreviewVisibility(),
+                        loading = false, stoppingProcessIds = emptySet(),
+                        onRefresh = viewModel::refreshBackgroundProcesses,
+                        onStop = viewModel::stopBackgroundProcess,
+                        onDismissProcess = viewModel::dismissBackgroundProcess,
+                        onOpenSubagentChild = viewModel::openSubagentChildPreview,
+                        onDismiss = { viewModel.closeActivityPreview(); sheetOpen = false },
+                        readOnlyHistory = retained != null,
+                        historyNotice = "Recorded activity. Available child history is read-only.",
+                    )
+                }
+            }
+        }
+        assertTrue(runBlocking { gateway.prewarmAwait(STORED_SESSION_ID) })
+        socket = fixture.awaitServerSocket()
+        fixture.awaitRpc("session.resume")
+    }
+
+    @After
+    fun tearDown() {
+        viewModel.updateGatewayClient(null)
+        gateway.shutdown()
+        gatewayScope.cancel()
+        fixture.shutdown()
+    }
+
+    @Test
+    fun detachedCompletionLeavesReopenableReceiptAcrossActivityResume() {
+        viewModel.sendMessage("Delegate a background task")
+        fixture.awaitRpc("prompt.submit")
+        socket.send(fixture.event("message.start", null, LIVE_SESSION_ID))
+        socket.send(fixture.event("subagent.start", buildJsonObject {
+            put("subagent_id", "receipt-child")
+            put("delegation_id", "receipt-delegation")
+            put("task_count", 1)
+            put("goal", "Inspect activity lifecycle")
+        }, LIVE_SESSION_ID))
+        compose.waitUntil(5_000) { viewModel.subagentActivities.value.size == 1 }
+        compose.onNodeWithTag("active-activity").assertIsDisplayed()
+        socket.send(fixture.event("message.complete", buildJsonObject { put("text", "Launched") }, LIVE_SESSION_ID))
+        compose.waitUntil(5_000) { !handler.isStreaming.value }
+        compose.onNodeWithTag("active-activity").assertIsDisplayed()
+
+        socket.send(fixture.event("subagent.complete", buildJsonObject {
+            put("subagent_id", "receipt-child")
+            put("delegation_id", "receipt-delegation")
+            put("status", "completed")
+        }, LIVE_SESSION_ID))
+        compose.waitUntil(5_000) { viewModel.activityRecords.value.singleOrNull()?.phase == ChatActivityPhase.COMPLETE }
+        compose.onNodeWithTag("active-activity").assertDoesNotExist()
+        compose.onNodeWithTag("activity-receipt").assertIsDisplayed().performClick()
+        compose.onNodeWithText("Chat activity").assertIsDisplayed()
+        compose.onNodeWithText("Recorded activity. Available child history is read-only.").assertIsDisplayed()
+        compose.onNodeWithText("Stop").assertDoesNotExist()
+        compose.onNodeWithContentDescription("Close activity preview").performClick()
+        compose.onNodeWithTag("activity-receipt").assertIsDisplayed()
+
+        compose.activityRule.scenario.moveToState(Lifecycle.State.STARTED)
+        compose.activityRule.scenario.moveToState(Lifecycle.State.RESUMED)
+        compose.onNodeWithTag("active-activity").assertDoesNotExist()
+        compose.onNodeWithTag("activity-receipt").assertIsDisplayed().performClick()
+        compose.onNodeWithText("Chat activity").assertIsDisplayed()
+    }
+
+    private companion object {
+        const val STORED_SESSION_ID = "20260821_120000_fixture"
+        const val LIVE_SESSION_ID = "fixture-live-1"
+    }
+}

app/src/androidTest/kotlin/com/hermesandroid/relay/viewmodel/GatewayExternalFixtureInstrumentedTest.kt

@@ -15,6 +15,10 @@ import androidx.compose.ui.test.assertTextEquals
 import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
 import androidx.compose.ui.test.onAllNodesWithText
 import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onAllNodesWithContentDescription
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
 import androidx.test.platform.app.InstrumentationRegistry
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.hermesandroid.relay.data.MessageRole
@@ -171,6 +175,81 @@ class GatewayExternalFixtureInstrumentedTest {
         }
     }
 
+    @Test
+    fun queuedStopResume_preservesWorkAcrossLifecycleAndUsesExplicitResume() {
+        val base = InstrumentationRegistry.getArguments().getString(ARG_FIXTURE_BASE_URL)?.trimEnd('/')
+        assumeTrue("Pass a queued_stop_resume fixture URL", !base.isNullOrBlank())
+        requireNotNull(base)
+        val http = OkHttpClient.Builder().callTimeout(10, TimeUnit.SECONDS).build()
+        assertEquals("queued_stop_resume", readFixtureJson(http, "$base/__fixture__/state")["scenario"]?.jsonString())
+        val dashboard = DashboardApiClient(base, http)
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO).also { gatewayScope = it }
+        val gateway = GatewayChatClient(
+            initialDashboardClient = dashboard, okHttpClient = http, scope = scope,
+            callbackDispatcher = { block -> Handler(Looper.getMainLooper()).post(block) },
+            reconnectJitterUnit = { 0.0 },
+        ).also { gatewayClient = it }
+        val handler = ChatHandler().also { it.setSessionId(STORED_SESSION_ID) }
+        val vm = ChatViewModel().also {
+            it.initialize(null, handler)
+            it.streamingEndpoint = "gateway"
+            it.setProfileMessageLoaderWithMode { profile, session, mode -> dashboard.getSessionMessages(session, profile, mode) }
+            it.updateGatewayClient(gateway)
+            it.switchProfileContext(com.hermesandroid.relay.data.AgentDisplay.profileContextKey("fixture-queue", null), STORED_SESSION_ID)
+        }.also { viewModel = it }
+        compose.setContent {
+            val queue by vm.queuedMessages.collectAsStateWithLifecycle()
+            val paused by vm.queuePaused.collectAsStateWithLifecycle()
+            com.hermesandroid.relay.ui.theme.HermesRelayTheme(themePreference = "dark") {
+                androidx.compose.material3.Surface {
+                    Column {
+                        com.hermesandroid.relay.ui.components.ChatBusyActionSelector(
+                            com.hermesandroid.relay.data.BusyMessageAction.QueueNext, {}, onStop = vm::cancelStream,
+                        )
+                        com.hermesandroid.relay.ui.components.ChatMessageQueue(
+                            queue, paused, vm::resumeQueue, vm::clearQueue, {}, vm::removeQueuedAt, canEdit = true,
+                        )
+                    }
+                }
+            }
+        }
+        assertTrue(runBlocking { gateway.prewarmAwait(STORED_SESSION_ID) })
+        compose.runOnIdle { vm.sendMessage("Original work") }
+        compose.waitUntil(10_000) { handler.isStreaming.value && vm.steerableTurn.value }
+        compose.runOnIdle {
+            vm.sendMessage("Remove this follow-up", com.hermesandroid.relay.data.BusyMessageAction.QueueNext)
+            vm.sendMessage("Keep this follow-up", com.hermesandroid.relay.data.BusyMessageAction.QueueNext)
+        }
+        compose.onAllNodesWithContentDescription("Remove queued message")[0].performClick()
+        compose.onNodeWithContentDescription("Stop streaming").performClick()
+        compose.onNodeWithText("Queue paused").assertIsDisplayed()
+        assertEquals(listOf("Keep this follow-up"), vm.queuedMessages.value)
+
+        compose.activityRule.scenario.moveToState(androidx.lifecycle.Lifecycle.State.CREATED)
+        compose.activityRule.scenario.moveToState(androidx.lifecycle.Lifecycle.State.RESUMED)
+        compose.onNodeWithText("Keep this follow-up").assertIsDisplayed()
+        compose.onNodeWithText("Resume").performClick()
+        try {
+            compose.waitUntil(15_000) {
+                vm.queuedMessages.value.isEmpty() && !handler.isStreaming.value &&
+                    handler.messages.value.any { it.content == "Resumed follow-up." }
+            }
+        } catch (error: androidx.compose.ui.test.ComposeTimeoutException) {
+            throw AssertionError(
+                "Synthetic queue fixture did not settle: queued=${vm.queuedMessages.value.size}, " +
+                    "paused=${vm.queuePaused.value}, streaming=${handler.isStreaming.value}, " +
+                    "messages=${handler.messages.value.map { it.role to it.content }}, " +
+                    "error=${handler.error.value}",
+                error,
+            )
+        }
+        val evidence = readFixtureJson(http, "$base/__fixture__/evidence")["entries"] as JsonArray
+        assertEquals(2, evidence.rpcCount("prompt.submit"))
+        assertEquals(1, evidence.rpcCount("session.interrupt"))
+        assertEquals(0, evidence.rpcCount("session.redirect"))
+        assertEquals("gateway", vm.streamingEndpoint)
+    }
+
     private fun JsonArray.rpcCount(method: String): Int = count { element ->
         val entry = element as? JsonObject ?: return@count false
         entry["kind"]?.jsonString() == "rpc" && entry["method"]?.jsonString() == method

app/src/androidTest/kotlin/com/hermesandroid/relay/viewmodel/GatewayForegroundRecoveryInstrumentedTest.kt

@@ -4,11 +4,13 @@ import android.os.Handler
 import android.os.Looper
 import androidx.activity.ComponentActivity
 import androidx.compose.foundation.layout.Column
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.Modifier
+import androidx.compose.material3.Button
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.assertTextEquals
 import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
@@ -16,16 +18,29 @@ import androidx.compose.ui.test.onAllNodesWithTag
 import androidx.compose.ui.test.onNodeWithTag
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.hermesandroid.relay.data.AgentDisplay
+import com.hermesandroid.relay.data.ChatTurnAssistantCheckpoint
+import com.hermesandroid.relay.data.ChatTurnCheckpoint
+import com.hermesandroid.relay.data.ChatTurnCheckpointStore
+import com.hermesandroid.relay.data.ChatTurnUserCheckpoint
 import com.hermesandroid.relay.data.MessageRole
 import com.hermesandroid.relay.network.upstream.ChatHandler
 import com.hermesandroid.relay.network.upstream.DashboardApiClient
+import com.hermesandroid.relay.network.upstream.GatewayAvailability
 import com.hermesandroid.relay.network.upstream.GatewayChatClient
+import com.hermesandroid.relay.network.upstream.GatewayConnectionState
 import com.hermesandroid.relay.network.upstream.HermesApiClient
 import com.hermesandroid.relay.network.upstream.models.MessageItem
+import com.hermesandroid.relay.network.upstream.models.SessionItem
+import com.hermesandroid.relay.ui.components.GatewayBackgroundProcessStrip
+import com.hermesandroid.relay.ui.components.SubagentPreviewVisibility
+import com.hermesandroid.relay.ui.screens.shouldOwnVisibleGateway
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
@@ -44,6 +59,7 @@ import okhttp3.mockwebserver.RecordedRequest
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Rule
@@ -74,10 +90,13 @@ class GatewayForegroundRecoveryInstrumentedTest {
 
     @Volatile
     private var persistedHistory: List<MessageItem> = emptyList()
+    private val historySignInRequired = MutableStateFlow(false)
+    private val coldStartAdmissionEnabled = MutableStateFlow(false)
+    private val coldStartGatewayAvailability = MutableStateFlow(GatewayAvailability.Unknown)
 
     @Before
     fun setUp() {
-        fixture = AndroidGatewayContractFixture()
+        fixture = AndroidGatewayContractFixture().also { it.profileName = PROFILE_NAME }
         gatewayScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
         val okHttp = OkHttpClient()
         gatewayClient = GatewayChatClient(
@@ -97,6 +116,7 @@ class GatewayForegroundRecoveryInstrumentedTest {
                 handler,
             )
             it.streamingEndpoint = "gateway"
+            it.setSessionProfileNameProvider { PROFILE_NAME }
             it.setProfileMessageLoader { Result.success(persistedHistory) }
             it.updateGatewayClient(gatewayClient)
             it.setChatVisible(true)
@@ -105,8 +125,31 @@ class GatewayForegroundRecoveryInstrumentedTest {
         compose.setContent {
             val messages by viewModel.messages.collectAsStateWithLifecycle()
             val streaming by viewModel.isStreaming.collectAsStateWithLifecycle()
+            val children by viewModel.subagentActivities.collectAsStateWithLifecycle()
+            val signInRequired by historySignInRequired.collectAsStateWithLifecycle()
+            val admissionEnabled by coldStartAdmissionEnabled.collectAsStateWithLifecycle()
+            val admissionAvailability by coldStartGatewayAvailability.collectAsStateWithLifecycle()
+            LaunchedEffect(admissionEnabled, admissionAvailability) {
+                if (admissionEnabled) {
+                    viewModel.setChatVisible(
+                        shouldOwnVisibleGateway(
+                            appForeground = true,
+                            isGatewayTransport = true,
+                            gatewayAvailability = admissionAvailability,
+                        ),
+                    )
+                }
+            }
             MaterialTheme {
                 Column(Modifier.testTag("contract-transcript")) {
+                    GatewayBackgroundProcessStrip(
+                        processes = emptyList(),
+                        subagentActivities = children,
+                        subagentPreviewVisibility = SubagentPreviewVisibility(),
+                        loading = false,
+                        onClick = {},
+                        modifier = Modifier.testTag("child-activity"),
+                    )
                     Text(
                         text = if (streaming) "STREAMING" else "IDLE",
                         modifier = Modifier.testTag("stream-state"),
@@ -117,6 +160,14 @@ class GatewayForegroundRecoveryInstrumentedTest {
                             modifier = Modifier.testTag("message-${message.id}"),
                         )
                     }
+                    if (signInRequired) {
+                        Button(
+                            onClick = {},
+                            modifier = Modifier.testTag("dashboard-sign-in-recovery"),
+                        ) {
+                            Text("SIGN IN")
+                        }
+                    }
                 }
             }
         }
@@ -126,6 +177,122 @@ class GatewayForegroundRecoveryInstrumentedTest {
         fixture.awaitRpc("session.resume")
     }
 
+    @Test
+    fun authenticatedUnknownColdLaunch_opensObservationSocketWithoutLifecycleBounce() {
+        viewModel.setChatVisible(false)
+        viewModel.updateGatewayClient(null)
+        gatewayClient.shutdown()
+        gatewayScope.cancel()
+
+        val controlMethods = setOf(
+            "session.resume",
+            "session.activate",
+            "prompt.submit",
+            "session.interrupt",
+        )
+        val baseline = controlMethods.associateWith(fixture::rpcCount)
+        val ticketMintsBefore = fixture.requestsTo("/api/auth/ws-ticket")
+        gatewayScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+        val okHttp = OkHttpClient()
+        gatewayClient = GatewayChatClient(
+            initialDashboardClient = DashboardApiClient(
+                baseUrl = fixture.server.url("/").toString().trimEnd('/'),
+                okHttpClient = okHttp,
+            ),
+            okHttpClient = okHttp,
+            callbackDispatcher = { block -> Handler(Looper.getMainLooper()).post(block) },
+            scope = gatewayScope,
+            reconnectJitterUnit = { 0.0 },
+        )
+        viewModel.setChatTurnCheckpointStore(null)
+        viewModel.updateGatewayClient(gatewayClient)
+
+        coldStartGatewayAvailability.value = GatewayAvailability.Unknown
+        coldStartAdmissionEnabled.value = true
+
+        compose.waitUntil(5_000) {
+            gatewayClient.connectionState.value == GatewayConnectionState.Ready
+        }
+        serverSocket = fixture.awaitServerSocket()
+        assertEquals(ticketMintsBefore + 1, fixture.requestsTo("/api/auth/ws-ticket"))
+        controlMethods.forEach { method ->
+            assertEquals(
+                "cold observation sent $method",
+                baseline.getValue(method),
+                fixture.rpcCount(method),
+            )
+        }
+    }
+
+    @Test
+    fun dashboardOnlyColdLaunch_waitsForExactDirectoryThenOpensObservationSocket() {
+        viewModel.setChatVisible(false)
+        viewModel.updateGatewayClient(null)
+        gatewayClient.shutdown()
+        gatewayScope.cancel()
+
+        val directoryStarted = CompletableDeferred<Unit>()
+        val directoryResult = CompletableDeferred<Result<List<SessionItem>>>()
+        viewModel.setProfileSessionLister { profile ->
+            assertEquals(PROFILE_NAME, profile)
+            directoryStarted.complete(Unit)
+            directoryResult.await()
+        }
+        handler.setSessionId(null)
+        viewModel.switchProfileContext(
+            AgentDisplay.profileContextKey("fixture-connection", PROFILE_NAME),
+            STORED_SESSION_ID,
+        )
+
+        val controlMethods = setOf(
+            "session.resume",
+            "session.activate",
+            "prompt.submit",
+            "session.interrupt",
+        )
+        val baseline = controlMethods.associateWith(fixture::rpcCount)
+        val ticketMintsBefore = fixture.requestsTo("/api/auth/ws-ticket")
+        gatewayScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+        val okHttp = OkHttpClient()
+        gatewayClient = GatewayChatClient(
+            initialDashboardClient = DashboardApiClient(
+                baseUrl = fixture.server.url("/").toString().trimEnd('/'),
+                okHttpClient = okHttp,
+            ),
+            okHttpClient = okHttp,
+            callbackDispatcher = { block -> Handler(Looper.getMainLooper()).post(block) },
+            scope = gatewayScope,
+            reconnectJitterUnit = { 0.0 },
+        )
+        viewModel.setChatTurnCheckpointStore(null)
+        viewModel.updateGatewayClient(gatewayClient)
+        viewModel.setChatVisible(true)
+
+        // This is the production binder's Dashboard/profile hydration edge.
+        // The socket must stay passive and closed until the exact-owner REST
+        // directory publishes, then open without a lifecycle bounce.
+        viewModel.refreshSessions()
+        compose.waitUntil(5_000) { directoryStarted.isCompleted }
+        assertEquals(ticketMintsBefore, fixture.requestsTo("/api/auth/ws-ticket"))
+
+        directoryResult.complete(
+            Result.success(listOf(SessionItem(id = STORED_SESSION_ID, title = "Fixture session"))),
+        )
+
+        compose.waitUntil(5_000) {
+            gatewayClient.connectionState.value == GatewayConnectionState.Ready
+        }
+        serverSocket = fixture.awaitServerSocket()
+        assertEquals(ticketMintsBefore + 1, fixture.requestsTo("/api/auth/ws-ticket"))
+        controlMethods.forEach { method ->
+            assertEquals(
+                "directory-gated cold observation sent $method",
+                baseline.getValue(method),
+                fixture.rpcCount(method),
+            )
+        }
+    }
+
     @After
     fun tearDown() {
         viewModel.updateGatewayClient(null)
@@ -134,6 +301,37 @@ class GatewayForegroundRecoveryInstrumentedTest {
         fixture.shutdown()
     }
 
+    @Test
+    fun detachedChildActivity_survivesParentTerminalAndActivityResume() {
+        viewModel.sendMessage("Delegate a background task")
+        fixture.awaitRpc("prompt.submit")
+        serverSocket.send(fixture.event("message.start", null, LIVE_SESSION_ID))
+        serverSocket.send(fixture.event("subagent.start", buildJsonObject {
+            put("subagent_id", "detached-child")
+            put("goal", "Inspect")
+        }, LIVE_SESSION_ID))
+        compose.waitUntil(5_000) { viewModel.subagentActivities.value.size == 1 }
+        compose.onNodeWithTag("child-activity").assertIsDisplayed()
+        serverSocket.send(fixture.event("message.complete", buildJsonObject { put("text", "Launched") }, LIVE_SESSION_ID))
+        compose.waitUntil(5_000) { !handler.isStreaming.value }
+        compose.activityRule.scenario.moveToState(Lifecycle.State.STARTED)
+        serverSocket.send(fixture.event("subagent.progress", buildJsonObject {
+            put("subagent_id", "detached-child")
+            put("text", "Still working")
+        }, LIVE_SESSION_ID))
+        compose.activityRule.scenario.moveToState(Lifecycle.State.RESUMED)
+        compose.waitUntil(5_000) { viewModel.subagentActivities.value.single().events.last().text == "Still working" }
+        compose.onNodeWithTag("child-activity").assertIsDisplayed()
+        assertFalse(viewModel.subagentActivities.value.single().isTerminal)
+        compose.onNodeWithTag("stream-state").assertTextEquals("IDLE")
+        serverSocket.send(fixture.event("subagent.complete", buildJsonObject {
+            put("subagent_id", "detached-child")
+            put("status", "completed")
+        }, LIVE_SESSION_ID))
+        compose.waitUntil(5_000) { viewModel.subagentActivities.value.single().isTerminal }
+        compose.onNodeWithTag("child-activity").assertDoesNotExist()
+    }
+
     @Test
     fun terminalGapActivate_recoversForegroundTurnWithoutNavigationOrCrossSessionLeak() {
         viewModel.sendMessage("Run a long foreground task")
@@ -239,6 +437,46 @@ class GatewayForegroundRecoveryInstrumentedTest {
         assertEquals(0, fixture.requestsTo("/v1/chat/completions"))
     }
 
+    @Test
+    fun terminalGapActiveList_settlesExactOwnedTurnAndRendersAuthoritativeHistory() {
+        viewModel.sendMessage("Run an Android-owned task")
+        fixture.awaitRpc("prompt.submit")
+        serverSocket.send(fixture.event("message.start", null, LIVE_SESSION_ID))
+        serverSocket.send(
+            fixture.event(
+                "message.delta",
+                buildJsonObject { put("text", PARTIAL_ANSWER) },
+                LIVE_SESSION_ID,
+            ),
+        )
+        compose.waitUntil(5_000) { handler.isStreaming.value }
+        compose.onNodeWithTag("stream-state").assertTextEquals("STREAMING")
+
+        persistedHistory = listOf(
+            MessageItem(
+                id = PERSISTED_ANSWER_ID,
+                sessionId = STORED_SESSION_ID,
+                role = "assistant",
+                content = JsonPrimitive(AUTHORITATIVE_ANSWER),
+            ),
+        )
+        fixture.activeSessionStatus = "idle"
+        runBlocking { gatewayClient.listActiveSessions() }
+
+        compose.waitUntil(5_000) {
+            !handler.isStreaming.value &&
+                !gatewayClient.hasActiveTurn() &&
+                handler.messages.value.singleOrNull()?.id == PERSISTED_ANSWER_ID
+        }
+        compose.onNodeWithTag("stream-state").assertTextEquals("IDLE")
+        compose.onNodeWithTag("message-$PERSISTED_ANSWER_ID")
+            .assertTextEquals("${MessageRole.ASSISTANT.name}:$AUTHORITATIVE_ANSWER")
+        assertEquals(1, fixture.rpcCount("prompt.submit"))
+        assertEquals(0, fixture.rpcCount("session.interrupt"))
+        assertEquals(0, fixture.rpcCount("session.activate"))
+        assertEquals(0, fixture.requestsTo("/v1/chat/completions"))
+    }
+
     @Test
     fun desktopOwnedTurn_remainsReadOnlyAcrossAndroidForegroundLifecycle() {
         viewModel.setChatVisible(false)
@@ -252,9 +490,6 @@ class GatewayForegroundRecoveryInstrumentedTest {
             "session.interrupt",
             "prompt.submit",
         )
-        val baseline = controlMethods.associateWith(fixture::rpcCount)
-        val baselineActiveList = fixture.rpcCount("session.active_list")
-        fixture.activeSessionStatus = "working"
         gatewayScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
         val okHttp = OkHttpClient()
         gatewayClient = GatewayChatClient(
@@ -269,6 +504,17 @@ class GatewayForegroundRecoveryInstrumentedTest {
         )
         viewModel.setChatTurnCheckpointStore(null)
         viewModel.updateGatewayClient(gatewayClient)
+        assertTrue(runBlocking { gatewayClient.observeAwait() })
+        serverSocket = fixture.awaitServerSocket()
+        viewModel.switchProfileContext(
+            AgentDisplay.profileContextKey("fixture-connection", PROFILE_NAME),
+            STORED_SESSION_ID,
+        )
+        viewModel.updateSessionActivityDirectory(listOf(PROFILE_NAME to STORED_SESSION_ID))
+
+        val baseline = controlMethods.associateWith(fixture::rpcCount)
+        val baselineActiveList = fixture.rpcCount("session.active_list")
+        fixture.activeSessionStatus = "working"
 
         viewModel.setChatVisible(true)
         compose.activityRule.scenario.moveToState(Lifecycle.State.STARTED)
@@ -293,6 +539,141 @@ class GatewayForegroundRecoveryInstrumentedTest {
         )
     }
 
+    @Test
+    fun normalCompletion_genericHistory401RetainsTranscriptAndRequiresProfileSignIn() {
+        bindDashboardHistoryFailure(
+            body = "Unauthorized",
+            profileName = PROFILE_NAME,
+        )
+
+        viewModel.sendMessage("Keep this local transcript")
+        fixture.awaitRpc("prompt.submit")
+        serverSocket.send(fixture.event("message.start", null, LIVE_SESSION_ID))
+        serverSocket.send(
+            fixture.event(
+                "message.delta",
+                buildJsonObject { put("text", LOCAL_COMPLETION) },
+                LIVE_SESSION_ID,
+            ),
+        )
+        serverSocket.send(
+            fixture.event(
+                "message.complete",
+                buildJsonObject { put("text", LOCAL_COMPLETION) },
+                LIVE_SESSION_ID,
+            ),
+        )
+
+        compose.waitUntil(15_000) {
+            historySignInRequired.value &&
+                !handler.isStreaming.value &&
+                handler.messages.value.any { it.content == LOCAL_COMPLETION }
+        }
+        compose.activityRule.scenario.moveToState(Lifecycle.State.STARTED)
+        compose.activityRule.scenario.moveToState(Lifecycle.State.RESUMED)
+
+        compose.onNodeWithTag("contract-transcript").assertIsDisplayed()
+        compose.onNodeWithTag("stream-state").assertTextEquals("IDLE")
+        compose.onNodeWithTag("dashboard-sign-in-recovery").assertIsDisplayed()
+        assertFalse(viewModel.isLoadingHistory.value)
+        assertTrue(handler.messages.value.any { it.content == "Keep this local transcript" })
+        assertTrue(handler.messages.value.any { it.content == LOCAL_COMPLETION })
+        assertNull(viewModel.chatFailure.value)
+        assertExactProfileHistoryOnly(PROFILE_NAME)
+    }
+
+    @Test
+    fun recoveredCompletion_sessionExpiredHistoryRetainsSettledTranscript() {
+        bindDashboardHistoryFailure(
+            body = """{"reason":"session_expired"}""",
+            profileName = PROFILE_NAME,
+        )
+        val now = System.currentTimeMillis()
+        val contextKey = AgentDisplay.profileContextKey("fixture-connection", PROFILE_NAME)
+        viewModel.setChatTurnCheckpointStore(
+            MemoryCheckpointStore(
+                ChatTurnCheckpoint(
+                    contextKey = contextKey,
+                    profileKey = PROFILE_NAME,
+                    sessionId = STORED_SESSION_ID,
+                    liveSessionId = LIVE_SESSION_ID,
+                    transport = "gateway",
+                    user = ChatTurnUserCheckpoint("recovered-user", "Resume this turn", now - 2_000L),
+                    assistant = ChatTurnAssistantCheckpoint(
+                        id = "recovered-assistant",
+                        content = "Recovered partial",
+                        timestamp = now - 1_900L,
+                    ),
+                    priorUserMessageCount = 0,
+                    baselineAssistantCount = 0,
+                    startedAt = now - 2_000L,
+                    updatedAt = now,
+                ),
+            ),
+        )
+        fixture.recoveryRunning = true
+        handler.setSessionId(null)
+        viewModel.switchProfileContext(contextKey, STORED_SESSION_ID)
+        fixture.awaitRpc("session.activate")
+
+        serverSocket.send(
+            fixture.event(
+                "message.delta",
+                buildJsonObject { put("text", RECOVERED_COMPLETION) },
+                LIVE_SESSION_ID,
+            ),
+        )
+        serverSocket.send(
+            fixture.event(
+                "message.complete",
+                buildJsonObject { put("text", RECOVERED_COMPLETION) },
+                LIVE_SESSION_ID,
+            ),
+        )
+
+        compose.waitUntil(15_000) {
+            historySignInRequired.value && !handler.isStreaming.value
+        }
+        compose.activityRule.scenario.moveToState(Lifecycle.State.STARTED)
+        compose.activityRule.scenario.moveToState(Lifecycle.State.RESUMED)
+
+        compose.onNodeWithTag("contract-transcript").assertIsDisplayed()
+        compose.onNodeWithTag("stream-state").assertTextEquals("IDLE")
+        compose.onNodeWithTag("dashboard-sign-in-recovery").assertIsDisplayed()
+        assertFalse(viewModel.isLoadingHistory.value)
+        assertTrue(
+            "recovered completion was not retained: ${handler.messages.value}",
+            handler.messages.value.any { it.content.contains(RECOVERED_COMPLETION.trim()) },
+        )
+        assertFalse(handler.messages.value.any { it.isStreaming || it.isThinkingStreaming })
+        assertNull(viewModel.chatFailure.value)
+        assertExactProfileHistoryOnly(PROFILE_NAME)
+    }
+
+    private fun bindDashboardHistoryFailure(body: String, profileName: String) {
+        fixture.profileName = profileName
+        fixture.historyFailureBody = body
+        val dashboard = DashboardApiClient(
+            baseUrl = fixture.server.url("/").toString().trimEnd('/'),
+            okHttpClient = OkHttpClient(),
+        )
+        viewModel.setProfileMessageLoaderWithMode { profile, sessionId, mode ->
+            dashboard.getSessionMessages(sessionId, profile, mode)
+        }
+        viewModel.setDashboardSignInRequiredHandler {
+            historySignInRequired.value = true
+        }
+    }
+
+    private fun assertExactProfileHistoryOnly(profileName: String) {
+        val historyRequests = fixture.historyRequestPaths()
+        assertTrue("no Dashboard history request was observed", historyRequests.isNotEmpty())
+        assertTrue(
+            "history escaped the exact profile: $historyRequests",
+            historyRequests.all { it.contains("profile=$profileName") },
+        )
+    }
+
     private companion object {
         const val STORED_SESSION_ID = "20260821_120000_fixture"
         const val LIVE_SESSION_ID = "fixture-live-1"
@@ -301,6 +682,23 @@ class GatewayForegroundRecoveryInstrumentedTest {
         const val PARTIAL_ANSWER = "Partial foreground answer"
         const val AUTHORITATIVE_ANSWER = "Foreground task finished."
         const val FOREIGN_ANSWER = "Wrong session content"
+        const val PROFILE_NAME = "research"
+        const val LOCAL_COMPLETION = "Completed before Dashboard auth expired."
+        const val RECOVERED_COMPLETION = " and then recovered to completion."
+    }
+}
+
+private class MemoryCheckpointStore(
+    private var checkpoint: ChatTurnCheckpoint?,
+) : ChatTurnCheckpointStore {
+    override suspend fun read(): ChatTurnCheckpoint? = checkpoint
+
+    override suspend fun write(checkpoint: ChatTurnCheckpoint) {
+        this.checkpoint = checkpoint
+    }
+
+    override suspend fun clear() {
+        checkpoint = null
     }
 }
 
@@ -320,6 +718,12 @@ internal class AndroidGatewayContractFixture {
     @Volatile
     var activeSessionStatus: String? = null
 
+    @Volatile
+    var historyFailureBody: String? = null
+
+    @Volatile
+    var profileName: String = "default"
+
     private val listener = object : WebSocketListener() {
         override fun onOpen(webSocket: WebSocket, response: Response) {
             sockets.add(webSocket)
@@ -377,6 +781,11 @@ internal class AndroidGatewayContractFixture {
                             """{"ticket":"device-${ticketCount.incrementAndGet()}","ttl_seconds":30}""",
                         )
                     path.startsWith("/api/ws") -> MockResponse().withWebSocketUpgrade(listener)
+                    path.startsWith("/api/sessions/") && path.contains("/messages") &&
+                        historyFailureBody != null -> MockResponse()
+                        .setResponseCode(401)
+                        .setHeader("Content-Type", "application/json")
+                        .setBody(historyFailureBody.orEmpty())
                     else -> MockResponse().setResponseCode(404)
                 }
             }
@@ -388,7 +797,7 @@ internal class AndroidGatewayContractFixture {
         put("session_id", sessionId)
         put("running", recoveryRunning)
         put("status", if (recoveryRunning) "streaming" else "idle")
-        put("info", buildJsonObject { put("profile_name", "default") })
+        put("info", buildJsonObject { put("profile_name", profileName) })
     }
 
     fun event(type: String, payload: JsonObject?, sessionId: String?): String =
@@ -406,7 +815,7 @@ internal class AndroidGatewayContractFixture {
         sockets.poll(5, TimeUnit.SECONDS) ?: error("Gateway WebSocket did not open")
 
     fun awaitRpc(method: String): JsonObject {
-        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
+        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(15)
         while (System.nanoTime() < deadline) {
             rpcLog.firstOrNull { it.first == method }?.let { return it.second }
             Thread.sleep(20)
@@ -415,7 +824,7 @@ internal class AndroidGatewayContractFixture {
     }
 
     fun awaitRpcCount(method: String, count: Int) {
-        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
+        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(15)
         while (System.nanoTime() < deadline) {
             if (rpcCount(method) >= count) return
             Thread.sleep(20)
@@ -425,6 +834,10 @@ internal class AndroidGatewayContractFixture {
 
     fun requestsTo(path: String): Int = requestPaths.count { it.startsWith(path) }
 
+    fun historyRequestPaths(): List<String> = requestPaths.filter {
+        it.startsWith("/api/sessions/") && it.contains("/messages")
+    }
+
     fun rpcCount(method: String): Int = rpcLog.count { it.first == method }
 
     fun shutdown() {

app/src/googlePlay/play/release-notes/en-US/default.txt

@@ -1,3 +1,3 @@
-v1.14.0 - Connections that follow you
+v1.16.1 - Dashboard-only cold starts recover
 
-Connections now recover independently across LAN, Tailscale, and public HTTPS without mixing Dashboard and Relay authentication. Preview delegated agents, use the optional native Git workspace, and get safer Continuous voice, Voice Focus, Assistant, Threads, profile drafts, and Clarify controls. Wake-word detection also packages a compatible native runtime.
+Dashboard-only connections now prepare the selected profile before Gateway readiness, fixing a remaining cold-start path that could stay on waking or waiting for Gateway until the app resumed or its network route changed.

app/src/main/assets/changelog.json

@@ -1,55 +1,393 @@
 {
- "schema": 2,
+ "schema": 3,
  "versions": [
   {
-   "version": "1.14.0",
-   "title": "Connections that follow you",
-   "date": "2026-08-30",
-   "highlight": {
-    "title": "Reliable routes",
-    "summary": "Move between LAN, Tailscale, and public HTTPS without mixing Dashboard or Relay authentication.",
-    "bullets": [
-     "Keep Chat and sessions on the trusted Dashboard while optional Relay routes recover independently.",
-     "Preview delegated agent work and use the optional native Git workspace.",
-     "Use more reliable Continuous voice, Voice Focus, Assistant, Threads, profiles, and Clarify controls."
-    ]
-   },
-   "improvements": [
-    "Wake-word detection now packages a compatible native runtime for every supported ABI.",
-    "Protected Relay health checks no longer appear as broken routes."
-   ],
-   "toastDigest": {
-    "additionalFeatureCount": 2,
-    "fixCount": 10,
-    "preview": [
-     "delegated-agent previews",
-     "safer voice and sessions"
-    ]
-   },
-   "playNotes": "Connections now recover independently across LAN, Tailscale, and public HTTPS without mixing Dashboard and Relay authentication. Preview delegated agents, use the optional native Git workspace, and get safer Continuous voice, Voice Focus, Assistant, Threads, profile drafts, and Clarify controls. Wake-word detection also packages a compatible native runtime.",
-   "sections": [
+   "version": "1.16.1",
+   "title": "Dashboard-only cold starts recover",
+   "date": "2026-09-12",
+   "summary": "Dashboard-only connections can now prepare the selected profile and open Gateway chat without waiting for a background, resume, or network-route change.",
+   "changes": [
     {
-     "header": "Use the best available route",
-     "bullets": [
-      "Resolve Dashboard, Relay, and optional API health independently across LAN, Tailscale, and public HTTPS.",
-      "Keep same-origin Relay ingress on the exact Dashboard origin that owns authentication."
-     ]
-    },
-    {
-     "header": "Follow active work",
-     "bullets": [
-      "Preview delegated-agent lifecycle, progress, tools, and available read-only child history from the parent chat.",
-      "Review Git status, diffs, branches, staging, commits, and remotes through the optional Relay plugin."
-     ]
-    },
-    {
-     "header": "Keep voice and conversations owned correctly",
-     "bullets": [
-      "Serialize microphone handoff and keep Voice Focus Stop and steering accessible across active phases.",
-      "Preserve fresh profile drafts, provisional Thread ownership, Clarify answers, passive observation, and Assistant privacy through reconnects."
-     ]
+     "id": "gateway-directory-bootstrap",
+     "kind": "fixed",
+     "title": "Open Gateway chat from a Dashboard-only cold start",
+     "summary": "The selected profile's session directory starts before Gateway readiness, so it cannot wait on the same passive socket that depends on its result.",
+     "highlight": true
     }
-   ]
+   ],
+   "compatibility": [
+    "Standard Dashboard and Gateway chat continue to use current upstream Hermes without requiring the optional Hermes-Relay Plugin.",
+    "Hermes-Relay Plugin 1.11.2 remains the matching optional release for Relay tools."
+   ],
+   "playNotes": "Dashboard-only connections now prepare the selected profile before Gateway readiness, fixing a remaining cold-start path that could stay on waking or waiting for Gateway until the app resumed or its network route changed.",
+   "sections": []
+  },
+  {
+   "version": "1.16.0",
+   "title": "Safer startup, connections, and activity",
+   "date": "2026-09-10",
+   "summary": "Gateway chat opens reliably from a cold launch, saved sign-ins stay with the correct connection, and network changes no longer race the route cache. Bot Mode and delegated-work feedback also remain stable across multiple gateways and later review.",
+   "changes": [
+    {
+     "id": "gateway-cold-start",
+     "kind": "fixed",
+     "title": "Open Gateway chat on the first launch",
+     "summary": "An authenticated Gateway wakes and opens from a cold foreground start instead of waiting for the app to background and resume.",
+     "highlight": true
+    },
+    {
+     "id": "connection-owned-signin",
+     "kind": "fixed",
+     "title": "Keep saved sign-ins with their connection",
+     "summary": "Switching gateways cannot reuse an outgoing resolver route to invalidate another connection's saved Dashboard session.",
+     "highlight": true
+    },
+    {
+     "id": "network-change-invalidation",
+     "kind": "fixed",
+     "title": "Recover safely when the network changes",
+     "summary": "Route-probe completion and endpoint-cache invalidation are serialized so Wi-Fi, mobile-data, VPN, or Tailscale changes do not trigger the reported crash.",
+     "highlight": true
+    },
+    {
+     "id": "bot-mode-connection-identity",
+     "kind": "fixed",
+     "title": "Open same-named bots from multiple gateways",
+     "summary": "Bot Mode and Active Now keep connection and profile identity together, avoiding duplicate list keys and opening progress on the selected bot."
+    },
+    {
+     "id": "delegated-activity-receipts",
+     "kind": "improved",
+     "title": "Review delegated work after it finishes",
+     "summary": "Compact, bounded activity receipts survive parent replies and remain available read-only, while the live strip appears only during active work.",
+     "highlight": true
+    },
+    {
+     "id": "chat-feedback-surfaces",
+     "kind": "improved",
+     "title": "Keep feedback with the surface that owns it",
+     "summary": "Themed banners and action cards replace platform popups, global actions stay clear of the composer, and local Developer previews make feedback states inspectable."
+    },
+    {
+     "id": "attachment-error-recovery",
+     "kind": "fixed",
+     "title": "Retry missing attachments in place",
+     "summary": "A missing attachment keeps its error and Retry action in the attachment card without producing repeated global messages."
+    },
+    {
+     "id": "session-preparation-diagnostics",
+     "kind": "improved",
+     "title": "See session preparation and initialization failures",
+     "summary": "Chat distinguishes session preparation from response streaming, retains early initialization errors, and opens session diagnostics from the agent header."
+    },
+    {
+     "id": "pasted-dashboard-credentials",
+     "kind": "fixed",
+     "title": "Paste Dashboard credentials without hidden line breaks",
+     "summary": "Username and password fields remove pasted carriage returns and line feeds while preserving every other credential character."
+    }
+   ],
+   "compatibility": [
+    "Standard Chat, sessions, profiles, Manage, voice, Bot Mode, and delegated activity continue to use current upstream Hermes without requiring the optional Hermes-Relay Plugin.",
+    "Hermes-Relay Plugin 1.11.2 is the matching optional release for Relay tools. Existing erased or revoked Dashboard credentials still require a legitimate sign-in.",
+    "Granular Device Control and the system Voice Focus overlay remain sideload-only."
+   ],
+   "playNotes": "Gateway chat now opens reliably on a cold launch. Saved Dashboard sign-ins stay bound to the correct connection, pasted credentials ignore accidental line breaks, and network changes no longer race the route cache. Bot Mode supports duplicate profile names across gateways, while delegated work, session setup, attachment errors, and feedback remain visible and easier to review.",
+   "sections": []
+  },
+  {
+   "version": "1.15.1",
+   "title": "Steadier chat, media, and voice",
+   "date": "2026-09-02",
+   "summary": "Chats use less memory, attachment previews stay in place, and voice failures are easier to recover from. Follow-up controls make it clear whether a message changes the current response or waits for the next turn.",
+   "changes": [
+    {
+     "id": "follow-up-controls",
+     "kind": "improved",
+     "title": "Choose when follow-up messages are sent",
+     "summary": "A slim tray behind the composer offers Correct now or Queue next. Chat settings sets the default, and a composer choice applies to one message. Stop pauses pending work until Resume; editing or removing an item keeps the remaining queue usable.",
+     "highlight": true
+    },
+    {
+     "id": "tablet-layouts",
+     "kind": "improved",
+     "title": "Make better use of wider screens",
+     "summary": "Chat and Voice keep text and controls on readable centered layouts. Landscape Voice Focus separates identity controls from conversation activity."
+    },
+    {
+     "id": "delivery-labels",
+     "kind": "fixed",
+     "title": "Read message delivery status clearly",
+     "summary": "Correction and delivery labels use contrasting text instead of disappearing into the message bubble."
+    },
+    {
+     "id": "voice-error-dialog",
+     "kind": "fixed",
+     "title": "Read and dismiss voice errors",
+     "summary": "Voice errors open in a contained dialog with scrollable details and separate Retry and Dismiss actions, without overlapping chat controls."
+    },
+    {
+     "id": "attachment-previews",
+     "kind": "fixed",
+     "title": "Keep attachment previews open through rotation",
+     "summary": "Image, video, audio, PDF, text, and file previews stay open as the screen rotates. Videos retain their original proportions.",
+     "highlight": true
+    },
+    {
+     "id": "wake-word-startup",
+     "kind": "fixed",
+     "title": "Fix wake-word startup in release builds",
+     "summary": "Release optimization now preserves the native speech configuration names needed to initialize wake-word detection."
+    },
+    {
+     "id": "attachment-downloads",
+     "kind": "fixed",
+     "title": "Download attachments with less memory",
+     "summary": "Standard Hermes attachments stream into the on-disk cache while download size limits remain enforced."
+    },
+    {
+     "id": "chat-memory-safety",
+     "kind": "fixed",
+     "title": "Keep large chats and media manageable",
+     "summary": "Automatic session refresh no longer loops. Routine history loads, chat rendering, image previews, and media exports use bounded memory instead of allocating entire large responses.",
+     "highlight": true
+    },
+    {
+     "id": "image-progress",
+     "kind": "fixed",
+     "title": "Keep image-generation progress visible",
+     "summary": "The working indicator stays visible between interim replies and the generated image, including gateways that omit tool activity events."
+    },
+    {
+     "id": "first-message-readiness",
+     "kind": "fixed",
+     "title": "Wait for new chats to be ready",
+     "summary": "The first message waits for the Gateway session to initialize. Ownership refusals keep the prompt retryable and show the server's error."
+    }
+   ],
+   "compatibility": [
+    "Standard Chat, sessions, media, and voice continue to use upstream Hermes. Voice transcription still requires a configured speech-to-text provider on the Hermes host.",
+    "Paused text queues can be restored. Attachment bytes are not stored in preferences; an attachment queue that cannot be restored must be reviewed and sent again."
+   ],
+   "playNotes": "More reliable chats and media: fewer memory-heavy refreshes, smoother large histories, and attachment previews that survive rotation. Choose whether follow-ups correct the current response or wait in a queue. Voice errors are easier to read, image-generation progress stays visible, and wake-word startup and first-message readiness are fixed.",
+   "sections": []
+  },
+  {
+   "version": "1.15.0",
+   "title": "Standard Hermes first, with clearer Relay boundaries",
+   "date": "2026-08-31",
+   "summary": "Chat, voice, attachments, inbound files, current-session Git, usage, and Hermes notices now prefer current upstream Dashboard and Gateway support. Relay stays optional for compatibility and the tools it uniquely provides.",
+   "changes": [
+    {
+     "id": "upstream-standard-surfaces",
+     "kind": "improved",
+     "title": "Use standard Hermes without Relay prompts",
+     "summary": "Chat attachments, inbound files, current-session Git, Nous usage, and Hermes notices use upstream routes first.",
+     "highlight": true
+    },
+    {
+     "id": "stable-inbound-media",
+     "kind": "fixed",
+     "title": "Keep returned files loaded",
+     "summary": "Images, audio, video, and documents download through the Dashboard and no longer flash Relay errors or return to Loading.",
+     "highlight": true
+    },
+    {
+     "id": "supervised-parent-access",
+     "kind": "improved",
+     "title": "Use app-specific parent access",
+     "summary": "A parent PIN or password plus recovery phrase protects Supervised Mode without trusting the phone unlock credential.",
+     "highlight": true
+    },
+    {
+     "id": "settings-relay-boundaries",
+     "kind": "improved",
+     "title": "See which features need Relay",
+     "summary": "Media sits with standard Hermes settings while Threads, Terminal, notifications, enhanced voice, and device tools stay under Relay tools."
+    },
+    {
+     "id": "complete-release-history",
+     "kind": "improved",
+     "title": "Read the complete release record",
+     "summary": "What's New shows one release summary, selected highlights, every remaining change, and relevant compatibility notes."
+    },
+    {
+     "id": "relay-removal-voice",
+     "kind": "fixed",
+     "title": "Keep Standard voice after removing Relay",
+     "summary": "Dashboard voice remains ready, temporary outages preserve choices, and shared default-profile settings stay isolated."
+    },
+    {
+     "id": "passive-external-activity",
+     "kind": "fixed",
+     "title": "Observe another client's activity safely",
+     "summary": "A uniquely matched Desktop or TUI turn can show Working or Waiting without Android taking control."
+    },
+    {
+     "id": "chat-transport-ownership",
+     "kind": "fixed",
+     "title": "Keep each chat on its chosen transport",
+     "summary": "Dashboard chats preserve their transcript, draft, profile, and session through sign-out or outages instead of silently changing databases."
+    },
+    {
+     "id": "history-auth-recovery",
+     "kind": "fixed",
+     "title": "Preserve completed replies at sign-in expiry",
+     "summary": "A Dashboard history authentication failure keeps completed text visible and opens the existing sign-in recovery path."
+    },
+    {
+     "id": "compaction-watchdog",
+     "kind": "fixed",
+     "title": "Let long context compaction finish",
+     "summary": "Visible compaction activity refreshes the turn watchdog instead of being interrupted as idle."
+    },
+    {
+     "id": "bot-chat-binding",
+     "kind": "fixed",
+     "title": "Render Bot Chat history immediately",
+     "summary": "Route-owned Bot Chats observe their bound history from first composition."
+    },
+    {
+     "id": "missing-terminal-recovery",
+     "kind": "fixed",
+     "title": "Settle turns after a lost terminal frame",
+     "summary": "An exact idle live-session snapshot reconciles the Android-owned turn and drains its queued follow-up."
+    },
+    {
+     "id": "supervised-gateway-setup",
+     "kind": "fixed",
+     "title": "Keep Gateway setup parent-owned",
+     "summary": "Relock and back navigation cancel the exact pending setup without bypassing parent authority."
+    },
+    {
+     "id": "generated-image-retention",
+     "kind": "fixed",
+     "title": "Keep completed generated images visible",
+     "summary": "Generated media survives marker persistence lag and retains its intended Chat animation."
+    }
+   ],
+   "compatibility": [
+    "Current upstream Hermes provides standard Chat, sessions, Manage, voice, attachments, inbound files, current-session Git reads, usage, and notices without the optional Hermes-Relay Plugin.",
+    "Hermes-Relay Plugin 1.11.1 remains required for Terminal, proactive Threads and offline delivery, Notification Companion, Relay sessions, enhanced voice, Secure Link, and phone or device control.",
+    "Granular Device Control and the system Voice Focus overlay remain sideload-only."
+   ],
+   "playNotes": "Standard Chat, Voice, attachments, returned files, current-session Git, usage, and Hermes notices now prefer upstream Dashboard and Gateway support without requiring Relay. Returned media stays loaded, voice survives Relay removal, and Settings clearly separates standard Hermes from Relay tools. Supervised Mode also gains app-specific parent access and recovery.",
+   "sections": []
+  },
+  {
+   "version": "1.14.0",
+   "title": "Connections, delegated work, Git, and voice",
+   "date": "2026-08-30",
+   "summary": "Connections now recover cleanly across networks. You can also follow delegated agents, work with Git repositories, and rely on steadier voice, sessions, Threads, profiles, Assistant, and Clarify controls.",
+   "changes": [
+    {
+     "id": "route-aware-connections",
+     "kind": "improved",
+     "title": "Connections recover independently",
+     "summary": "Move between LAN, Tailscale, and public HTTPS without mixing Dashboard and Relay authentication.",
+     "highlight": true
+    },
+    {
+     "id": "delegated-agent-previews",
+     "kind": "added",
+     "title": "Follow delegated-agent activity",
+     "summary": "See lifecycle, progress, tool previews, and available read-only child history from the parent chat.",
+     "highlight": true
+    },
+    {
+     "id": "native-git-workspace",
+     "kind": "added",
+     "title": "Work with repositories from Android",
+     "summary": "Review status, diffs, branches, staging, commits, and remotes from Chat or Settings.",
+     "highlight": true
+    },
+    {
+     "id": "voice-focus-controls",
+     "kind": "improved",
+     "title": "Steer voice at any time",
+     "summary": "Stop or redirect Hermes while it is Thinking, Transcribing, or Speaking, including with accessibility controls.",
+     "highlight": true
+    },
+    {
+     "id": "non-blocking-release-notice",
+     "kind": "improved",
+     "title": "Release notes stay out of your way",
+     "summary": "A dismissible post-update notice keeps startup usable and leaves the complete history available from Settings."
+    },
+    {
+     "id": "single-chat-presentation",
+     "kind": "improved",
+     "title": "Chat uses one consistent presentation",
+     "summary": "The overlapping clean-focus mode was removed while the separate Voice Focus experience remains available."
+    },
+    {
+     "id": "wake-word-runtime",
+     "kind": "fixed",
+     "title": "Wake-word detection starts reliably",
+     "summary": "Compatible native voice components are now packaged for every supported phone architecture."
+    },
+    {
+     "id": "sphere-motion",
+     "kind": "fixed",
+     "title": "The visible Sphere keeps moving smoothly",
+     "summary": "Foreground animation no longer falls back to a stepped ambient pulse."
+    },
+    {
+     "id": "continuous-microphone-handoff",
+     "kind": "fixed",
+     "title": "Continuous voice keeps the microphone",
+     "summary": "The next listening turn waits for barge-in recording to release cleanly."
+    },
+    {
+     "id": "fresh-profile-drafts",
+     "kind": "fixed",
+     "title": "New chats keep the selected profile",
+     "summary": "Fresh drafts no longer reopen an older session or carry a Thread route into another profile."
+    },
+    {
+     "id": "provisional-thread-removal",
+     "kind": "fixed",
+     "title": "Provisional Threads can be removed safely",
+     "summary": "Local removal and later session promotion no longer risk duplicate rows or server history."
+    },
+    {
+     "id": "clarify-custom-answers",
+     "kind": "fixed",
+     "title": "Clarify keeps custom answers reachable",
+     "summary": "Other answers, keyboard Send, and expired prompts now behave consistently."
+    },
+    {
+     "id": "passive-session-observation",
+     "kind": "fixed",
+     "title": "Browsing no longer interrupts another client",
+     "summary": "Passive Android observation does not claim a turn owned by Desktop, TUI, or another client."
+    },
+    {
+     "id": "assistant-recovery-privacy",
+     "kind": "fixed",
+     "title": "Assistant sessions recover more clearly",
+     "summary": "No-speech feedback, recreated session state, and keyguard privacy now remain intact."
+    },
+    {
+     "id": "relay-auth-boundaries",
+     "kind": "fixed",
+     "title": "Protected Relay routes report the right problem",
+     "summary": "Authentication challenges are no longer presented as outages, while unsafe routes still fail closed."
+    },
+    {
+     "id": "connection-session-readiness",
+     "kind": "fixed",
+     "title": "Connections and sessions become ready sooner",
+     "summary": "Unavailable optional API and Relay routes no longer delay a healthy Dashboard or authenticated session history."
+    }
+   ],
+   "compatibility": [
+    "Standard Chat, sessions, profiles, Manage, and standard voice continue to work without the optional Hermes-Relay Plugin.",
+    "The Git workspace and same-origin Relay extensions require Hermes-Relay Plugin 1.11.0.",
+    "Granular Device Control and the system Voice Focus overlay remain available only in the sideload build."
+   ],
+   "playNotes": "Connections now recover independently across LAN, Tailscale, and public HTTPS without mixing Dashboard and Relay authentication. Preview delegated agents, use the optional native Git workspace, and get safer Continuous voice, Voice Focus, Assistant, Threads, profile drafts, and Clarify controls. Wake-word detection also packages a compatible native runtime.",
+   "sections": []
   },
   {
    "version": "1.13.2",

app/src/main/assets/whats_new.txt

@@ -1,10 +1,11 @@
-v1.14.0 - Connections that follow you
+v1.16.1 - Dashboard-only cold starts recover
 
-Reliable routes
-* Keep Chat and sessions on the trusted Dashboard while optional Relay routes recover independently.
-* Preview delegated agent work and use the optional native Git workspace.
-* Use more reliable Continuous voice, Voice Focus, Assistant, Threads, profiles, and Clarify controls.
+Summary
+* Dashboard-only connections can now prepare the selected profile and open Gateway chat without waiting for a background, resume, or network-route change.
 
-Also improved
-* Wake-word detection now packages a compatible native runtime for every supported ABI.
-* Protected Relay health checks no longer appear as broken routes.
+Highlights
+* Open Gateway chat from a Dashboard-only cold start — The selected profile's session directory starts before Gateway readiness, so it cannot wait on the same passive socket that depends on its result.
+
+Compatibility
+* Standard Dashboard and Gateway chat continue to use current upstream Hermes without requiring the optional Hermes-Relay Plugin.
+* Hermes-Relay Plugin 1.11.2 remains the matching optional release for Relay tools.

app/src/main/kotlin/com/hermesandroid/relay/data/AgentDisplay.kt

@@ -34,9 +34,7 @@ object AgentDisplay {
         profiles: List<Profile>,
     ): Profile? = selectedProfile
 
-    // 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.
+    // Display resolution never changes selection or persistence identity.
     fun effectiveDisplayProfile(
         selectedProfile: Profile?,
         profiles: List<Profile>,
@@ -44,36 +42,22 @@ object AgentDisplay {
     ): Profile? {
         selectedProfile?.let { return it }
         val resolvedServerDefault = profileRequestName(serverDefaultProfileName)
-        return resolvedServerDefault
-            ?.let { activeName ->
-                profiles.firstOrNull { it.name.equals(activeName, ignoreCase = true) }
-            }
-            ?: profiles.firstOrNull { it.name.equals("default", ignoreCase = true) }
+        // An absent roster row is not authority to substitute the root profile.
+        // Retain the confirmed name while its display metadata is loading.
+        return resolvedServerDefault?.let { activeName ->
+            profiles.firstOrNull { it.name == activeName }
+                ?: Profile(name = activeName, model = "")
+        }
     }
 
-    // The NAME goes in the name slot. Non-default profiles use their profile
-    // name first. The synthetic default profile uses its description only when
-    // that description looks like a concise human agent name ("Victor"), not a
-    // verbose SOUL summary.
+    // Match upstream Desktop: presentation-only display_name, then exact request name.
     fun profileDisplayName(profile: Profile?): String? {
         if (profile == null) return null
-        if (profile.name.equals("default", ignoreCase = true)) {
-            return defaultProfileDisplayName(profile)
-        }
-        return when {
-            profile.name.isNotBlank() -> titleCase(profile.name.trim())
-            profile.description.isNotBlank() -> profile.description.trim()
-            else -> null
-        }
+        return profile.displayName.trim().takeIf(String::isNotEmpty)
+            ?: profile.name.trim().takeIf(String::isNotEmpty)
     }
 
-    fun defaultProfileDisplayName(profile: Profile?): String? =
-        profile
-            ?.description
-            ?.trim()
-            ?.takeIf { it.looksLikeConciseAgentName() }
-            ?.let(::titleCase)
-
+    @Suppress("UNUSED_PARAMETER") // connectionLabel retained for source compatibility.
     fun agentName(
         profile: Profile?,
         selectedPersonality: String,
@@ -86,7 +70,7 @@ object AgentDisplay {
 
         // "none"/"neutral" are the upstream "cleared overlay" aliases — treat
         // them like "default" for identity: fall through to the server default
-        // (or the base connection identity) rather than rendering the literal
+        // identity rather than rendering the literal
         // word as an agent name.
         val personalityName = if (
             isClearedPersonality(selectedPersonality) &&
@@ -102,7 +86,6 @@ object AgentDisplay {
         return when {
             personalityName.isNotBlank() && personalityName != "default" ->
                 titleCase(personalityName.trim())
-            !connectionLabel.isNullOrBlank() -> connectionLabel.trim()
             else -> "Hermes"
         }
     }
@@ -199,16 +182,6 @@ object AgentDisplay {
             ?.replace(Regex("\\s+"), " ")
             ?.takeIf { it.isNotEmpty() }
 
-    private fun String.looksLikeConciseAgentName(): Boolean {
-        if (isBlank() || length > 40 || contains('\n') || contains('\r')) {
-            return false
-        }
-        if (any { it == '.' || it == ':' || it == ';' }) {
-            return false
-        }
-        return trim().split(Regex("\\s+")).size <= 4
-    }
-
     private fun titleCase(value: String): String =
         value.replaceFirstChar { it.uppercase() }
 }

app/src/main/kotlin/com/hermesandroid/relay/data/ChatActivityProjection.kt

@@ -0,0 +1,102 @@
+package com.hermesandroid.relay.data
+
+/** Presentation only: canonical rows retain their wire identity, role and content. */
+internal fun projectChatActivityReceipts(
+    messages: List<ChatMessage>,
+    records: List<ChatActivityRecord>,
+    scopeKey: String?,
+    sessionId: String?,
+): List<ChatMessage> {
+    val originals = messages.filterNot {
+        it.clientOnly && it.id.startsWith("activity:") && it.activityRecord != null
+    }
+    if (scopeKey.isNullOrBlank() || sessionId.isNullOrBlank()) {
+        return originals.map { it.copy(activityRecord = null) }
+    }
+    val owned = records.filter { it.scopeKey == scopeKey && it.sessionId == sessionId }
+        .sortedByDescending { it.updatedAt }
+        .distinctBy { it.id }
+    val represented = mutableSetOf<String>()
+    val canonical = originals.map { message ->
+        val process = message.hermesProcessNotificationOrNull()
+        val delegation = message.activitySourceId?.takeIf { it.startsWith("delegation:") }
+            ?.removePrefix("delegation:")?.takeIf { it.isNotBlank() }
+        val kind = when {
+            message.activitySourceId != null -> ChatActivityKind.SUBAGENTS
+            process != null -> ChatActivityKind.PROCESS
+            else -> return@map message.copy(activityRecord = null)
+        }
+        val sourceId = delegation ?: process?.processId
+        val processTerminal = process?.let { notice ->
+            PROCESS_TERMINAL_HEADLINE.matchEntire(notice.headline)?.let { match ->
+                match.groupValues[2].toIntOrNull()?.let { code ->
+                    val phase = when {
+                        match.groupValues[1].startsWith("terminated by ") -> ChatActivityPhase.CANCELLED
+                        code == 0 -> ChatActivityPhase.COMPLETE
+                        else -> ChatActivityPhase.FAILED
+                    }
+                    phase to code
+                }
+            }
+        }
+        // A process id can be reused after a registry restart. A canonical row has
+        // no start-generation field, so multiple generations must remain unmatched.
+        val matching = if (sourceId == null) emptyList() else owned.filter {
+            it.kind == kind && it.sourceId == sourceId
+        }
+        val record = matching.singleOrNull()?.also { represented += it.id }
+            ?: ChatActivityRecord(
+                id = "canonical:${message.id}",
+                scopeKey = scopeKey,
+                sessionId = sessionId,
+                kind = kind,
+                sourceId = sourceId ?: "unavailable:${message.id}",
+                title = process?.headline ?: message.content,
+                phase = when {
+                    kind == ChatActivityKind.PROCESS -> processTerminal?.first ?: ChatActivityPhase.UNKNOWN
+                    (message.activityFailedCount ?: 0) > 0 ->
+                        if (message.activityFailedCount == message.activityTaskCount) {
+                            ChatActivityPhase.FAILED
+                        } else ChatActivityPhase.UNKNOWN
+                    (message.activityTaskCount ?: 0) > 0 -> ChatActivityPhase.COMPLETE
+                    else -> ChatActivityPhase.UNKNOWN
+                },
+                createdAt = message.timestamp,
+                updatedAt = message.timestamp,
+                taskCount = message.activityTaskCount?.coerceAtLeast(0) ?: 0,
+                processId = process?.processId,
+                exitCode = processTerminal?.second,
+            )
+        // Aggregate completion metadata never rewrites captured child phases.
+        message.copy(activityRecord = record)
+    }
+    val pending = owned.filter { it.phase != ChatActivityPhase.RUNNING && it.id !in represented }
+        .sortedWith(compareBy<ChatActivityRecord> { it.updatedAt }.thenBy { it.id })
+        .map { record ->
+            ChatMessage(
+                id = "activity:${record.id}",
+                role = MessageRole.SYSTEM,
+                content = record.title,
+                timestamp = record.updatedAt,
+                clientOnly = true,
+                activityRecord = record,
+            )
+        }
+    // Stable merge: history order is authoritative even if server timestamps
+    // regress. Only insert local receipts; never sort canonical messages.
+    var next = 0
+    return buildList {
+        canonical.forEach { message ->
+            while (next < pending.size && pending[next].timestamp < message.timestamp) {
+                add(pending[next++])
+            }
+            add(message)
+        }
+        while (next < pending.size) add(pending[next++])
+    }
+}
+
+/** Upstream completion envelope only; never search arbitrary command/output text. */
+private val PROCESS_TERMINAL_HEADLINE = Regex(
+    """Background process \S+ (completed normally|exited|terminated by [^\r\n]+|marked lost because the process backend disappeared|failed to start) \(exit code (-?\d+)(?:, SIGTERM)?\)\.""",
+)

app/src/main/kotlin/com/hermesandroid/relay/data/ChatActivityStore.kt

@@ -0,0 +1,222 @@
+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 java.io.IOException
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.intOrNull
+
+@Serializable
+enum class ChatActivityKind { SUBAGENTS, PROCESS }
+
+@Serializable
+enum class ChatActivityPhase { RUNNING, COMPLETE, FAILED, CANCELLED, UNKNOWN }
+
+@Serializable
+data class ChatActivityChild(
+    val id: String,
+    val childSessionId: String? = null,
+    val goal: String = "",
+    val phase: ChatActivityPhase = ChatActivityPhase.UNKNOWN,
+    val summary: String? = null,
+)
+
+/** Local presentation metadata and exact references, never transcripts or process output. */
+@Serializable
+data class ChatActivityRecord(
+    val id: String,
+    val scopeKey: String,
+    val sessionId: String,
+    val kind: ChatActivityKind,
+    val sourceId: String,
+    val title: String,
+    val phase: ChatActivityPhase,
+    val createdAt: Long,
+    val updatedAt: Long,
+    val children: List<ChatActivityChild> = emptyList(),
+    val taskCount: Int = 0,
+    val processId: String? = null,
+    val processStartedAt: String? = null,
+    val exitCode: Int? = null,
+)
+
+interface ChatActivityStore {
+    /** Recovery is not live evidence: RUNNING becomes UNKNOWN, including child phases. */
+    suspend fun read(scopeKey: String, sessionId: String): List<ChatActivityRecord>
+    suspend fun upsert(record: ChatActivityRecord)
+    suspend fun removeRecord(scopeKey: String, sessionId: String, id: String)
+    suspend fun removeSession(scopeKey: String, sessionId: String)
+}
+
+/**
+ * Bounded app-private history references in the shared settings DataStore.
+ * Retains 30 days, 128 records overall, 32 per exact owner/session, and 32 children
+ * per record. Titles are 160 characters; goals/summaries 512. Identity fields are
+ * rejected above 512 characters (scope 2048), never truncated into another owner.
+ * The complete encoded envelope is capped at 1 MiB, evicting oldest records first.
+ * Five minutes of future skew allows monotonic local revisions within one clock tick.
+ * All read/modify/write operations occur inside DataStore's serialized edit.
+ */
+class DataStoreChatActivityStore(
+    private val dataStore: DataStore<Preferences>,
+    private val now: () -> Long = System::currentTimeMillis,
+) : ChatActivityStore {
+    constructor(context: Context) : this(context.applicationContext.relayDataStore)
+
+    override suspend fun read(scopeKey: String, sessionId: String): List<ChatActivityRecord> {
+        val raw = try {
+            dataStore.data.first()[CHAT_ACTIVITY_KEY]
+        } catch (_: IOException) {
+            return emptyList()
+        }
+        return boundChatActivities(decodeChatActivities(raw), now())
+            .filter { it.scopeKey == scopeKey && it.sessionId == sessionId }
+            .map(ChatActivityRecord::recovered)
+    }
+
+    override suspend fun upsert(record: ChatActivityRecord) {
+        dataStore.edit { preferences ->
+            val records = mergeChatActivity(decodeChatActivities(preferences[CHAT_ACTIVITY_KEY]), record, now())
+            preferences[CHAT_ACTIVITY_KEY] = encodeChatActivities(records)
+        }
+    }
+
+    override suspend fun removeSession(scopeKey: String, sessionId: String) {
+        dataStore.edit { preferences ->
+            val remaining = boundChatActivities(decodeChatActivities(preferences[CHAT_ACTIVITY_KEY]), now())
+                .filterNot { it.scopeKey == scopeKey && it.sessionId == sessionId }
+            if (remaining.isEmpty()) preferences.remove(CHAT_ACTIVITY_KEY)
+            else preferences[CHAT_ACTIVITY_KEY] = encodeChatActivities(remaining)
+        }
+    }
+
+    override suspend fun removeRecord(scopeKey: String, sessionId: String, id: String) {
+        dataStore.edit { preferences ->
+            val remaining = boundChatActivities(decodeChatActivities(preferences[CHAT_ACTIVITY_KEY]), now())
+                .filterNot { it.scopeKey == scopeKey && it.sessionId == sessionId && it.id == id }
+            if (remaining.isEmpty()) preferences.remove(CHAT_ACTIVITY_KEY)
+            else preferences[CHAT_ACTIVITY_KEY] = encodeChatActivities(remaining)
+        }
+    }
+}
+
+/** Test/ephemeral implementation with the same bounds and recovery semantics. */
+class InMemoryChatActivityStore(
+    private val now: () -> Long = System::currentTimeMillis,
+) : ChatActivityStore {
+    private val mutex = Mutex()
+    private var records = emptyList<ChatActivityRecord>()
+
+    override suspend fun read(scopeKey: String, sessionId: String): List<ChatActivityRecord> = mutex.withLock {
+        records = boundChatActivities(records, now())
+        records.filter { it.scopeKey == scopeKey && it.sessionId == sessionId }
+            .map(ChatActivityRecord::recovered)
+    }
+
+    override suspend fun upsert(record: ChatActivityRecord) = mutex.withLock {
+        records = mergeChatActivity(records, record, now())
+    }
+
+    override suspend fun removeSession(scopeKey: String, sessionId: String) = mutex.withLock {
+        records = boundChatActivities(records, now())
+            .filterNot { it.scopeKey == scopeKey && it.sessionId == sessionId }
+    }
+
+    override suspend fun removeRecord(scopeKey: String, sessionId: String, id: String) = mutex.withLock {
+        records = boundChatActivities(records, now())
+            .filterNot { it.scopeKey == scopeKey && it.sessionId == sessionId && it.id == id }
+    }
+}
+
+internal const val CHAT_ACTIVITY_MAX_AGE_MS = 30L * 24L * 60L * 60L * 1_000L
+private const val MAX_RECORDS = 128
+private const val MAX_SESSION_RECORDS = 32
+private const val MAX_PAYLOAD_BYTES = 1_048_576
+private val CHAT_ACTIVITY_KEY = stringPreferencesKey("chat_activity_records_v1")
+private val activityJson = Json { ignoreUnknownKeys = true; encodeDefaults = true }
+
+@Serializable
+private data class ChatActivityEnvelope(val version: Int = 1, val records: List<ChatActivityRecord>)
+
+private fun encodeChatActivities(records: List<ChatActivityRecord>): String =
+    activityJson.encodeToString(ChatActivityEnvelope(records = records))
+
+internal fun decodeChatActivities(raw: String?): List<ChatActivityRecord> {
+    if (raw == null || raw.length > MAX_PAYLOAD_BYTES || raw.toByteArray().size > MAX_PAYLOAD_BYTES) {
+        return emptyList()
+    }
+    val envelope = runCatching { activityJson.parseToJsonElement(raw) as? JsonObject }.getOrNull()
+        ?: return emptyList()
+    val version = runCatching { envelope["version"]?.jsonPrimitive?.intOrNull }.getOrNull()
+    if (version != 1) return emptyList()
+    val rows = envelope["records"] as? JsonArray ?: return emptyList()
+    // One corrupt or newer row must not hide independently valid records.
+    return rows.mapNotNull { row ->
+        runCatching { activityJson.decodeFromJsonElement(ChatActivityRecord.serializer(), row) }.getOrNull()
+    }
+}
+
+private fun ChatActivityRecord.identity() = Triple(scopeKey, sessionId, id)
+
+private fun mergeChatActivity(
+    existing: List<ChatActivityRecord>,
+    record: ChatActivityRecord,
+    now: Long,
+): List<ChatActivityRecord> {
+    // Sorting first also rejects a late write for an older generation of the same record.
+    return boundChatActivities(listOf(record) + existing, now)
+}
+
+internal fun boundChatActivities(records: List<ChatActivityRecord>, now: Long): List<ChatActivityRecord> {
+    val counts = mutableMapOf<Pair<String, String>, Int>()
+    val bounded = records.mapNotNull { it.bounded(now) }
+        .sortedByDescending(ChatActivityRecord::updatedAt)
+        .distinctBy { it.identity() }
+        .filter {
+            val owner = it.scopeKey to it.sessionId
+            val count = counts.getOrDefault(owner, 0)
+            counts[owner] = count + 1
+            count < MAX_SESSION_RECORDS
+        }.take(MAX_RECORDS).toMutableList()
+    while (bounded.isNotEmpty() && encodeChatActivities(bounded).toByteArray().size > MAX_PAYLOAD_BYTES) {
+        bounded.removeAt(bounded.lastIndex)
+    }
+    return bounded
+}
+
+private fun validIdentity(value: String, max: Int = 512) = value.isNotBlank() && value.length <= max
+
+private fun ChatActivityRecord.bounded(now: Long): ChatActivityRecord? {
+    if (!validIdentity(scopeKey, 2048) || !validIdentity(sessionId) || !validIdentity(id) ||
+        !validIdentity(sourceId) || (processId != null && !validIdentity(processId)) ||
+        (processStartedAt != null && !validIdentity(processStartedAt)) ||
+        createdAt < 0 || updatedAt < createdAt || updatedAt > now + 300_000L ||
+        now - updatedAt > CHAT_ACTIVITY_MAX_AGE_MS
+    ) return null
+    return copy(
+        title = title.take(160),
+        taskCount = taskCount.coerceIn(0, 10_000),
+        children = children.asSequence().filter {
+            validIdentity(it.id) && (it.childSessionId == null || validIdentity(it.childSessionId))
+        }.distinctBy(ChatActivityChild::id).take(32)
+            .map { it.copy(goal = it.goal.take(512), summary = it.summary?.take(512)) }.toList(),
+    )
+}
+
+private fun ChatActivityRecord.recovered() = copy(
+    phase = if (phase == ChatActivityPhase.RUNNING) ChatActivityPhase.UNKNOWN else phase,
+    children = children.map {
+        if (it.phase == ChatActivityPhase.RUNNING) it.copy(phase = ChatActivityPhase.UNKNOWN) else it
+    },
+)

app/src/main/kotlin/com/hermesandroid/relay/data/ChatInputPreferences.kt

@@ -22,6 +22,26 @@ enum class PhysicalKeyboardEnterBehavior(val storedValue: String) {
     }
 }
 
+/** Default intent for a message submitted while an agent is responding. */
+enum class BusyMessageAction(val storedValue: String) {
+    CorrectNow("correct_now"),
+    QueueNext("queue_next");
+
+    companion object {
+        fun fromStoredValue(value: String?): BusyMessageAction =
+            entries.firstOrNull { it.storedValue == value } ?: CorrectNow
+    }
+}
+
+fun canCorrectBusyMessage(
+    steerable: Boolean,
+    hasAttachments: Boolean,
+    hasPendingInput: Boolean,
+    status: String?,
+    text: String,
+): Boolean = steerable && !hasAttachments && !hasPendingInput &&
+    status?.contains("compact", ignoreCase = true) != true && !text.trimStart().startsWith("/")
+
 /** Device-level chat input preferences shared by every Hermes profile. */
 class ChatInputPreferencesRepository(
     private val dataStore: DataStore<Preferences>,
@@ -29,6 +49,7 @@ class ChatInputPreferencesRepository(
     constructor(context: Context) : this(context.relayDataStore)
 
     companion object {
+        internal val KEY_BUSY_MESSAGE_ACTION = stringPreferencesKey("busy_message_action")
         internal val KEY_PHYSICAL_KEYBOARD_ENTER =
             stringPreferencesKey("physical_keyboard_enter_behavior")
         internal val KEY_CONVERT_LARGE_PASTES =
@@ -45,6 +66,14 @@ class ChatInputPreferencesRepository(
         }
         .distinctUntilChanged()
 
+    val busyMessageAction: Flow<BusyMessageAction> = dataStore.data
+        .map { BusyMessageAction.fromStoredValue(it[KEY_BUSY_MESSAGE_ACTION]) }
+        .distinctUntilChanged()
+
+    suspend fun setBusyMessageAction(action: BusyMessageAction) {
+        dataStore.edit { it[KEY_BUSY_MESSAGE_ACTION] = action.storedValue }
+    }
+
     val convertLargePastesToAttachments: Flow<Boolean> = dataStore.data
         .map { preferences -> preferences[KEY_CONVERT_LARGE_PASTES] ?: true }
         .distinctUntilChanged()

app/src/main/kotlin/com/hermesandroid/relay/data/ChatMessage.kt

@@ -10,6 +10,16 @@ package com.hermesandroid.relay.data
  */
 enum class AttachmentState { LOADING, LOADED, FAILED }
 
+/**
+ * Gateway tool events do not yet expose an output kind before completion.
+ * Recognize the upstream built-in plus the profile-tool naming convention used
+ * for image generators without guessing from generic prompt arguments.
+ */
+internal fun isImageGenerationToolName(name: String): Boolean {
+    val normalized = name.trim().lowercase()
+    return normalized == "image_generate" || normalized.endsWith("_create_image")
+}
+
 /**
  * How the UI should render a loaded attachment. Derived from the MIME type.
  * - [IMAGE]  inline image (decode bytes / load URI).
@@ -160,6 +170,12 @@ data class ChatMessage(
      * but server history never owns these presentation blocks.
      */
     val moaReferences: List<MoaReference> = emptyList(),
+    /** Exact upstream identity on a persisted activity-completion marker. */
+    val activitySourceId: String? = null,
+    val activityTaskCount: Int? = null,
+    val activityFailedCount: Int? = null,
+    /** Read-only UI projection; never sent as model history or voice input. */
+    val activityRecord: ChatActivityRecord? = null,
 )
 
 data class MessageReaction(

app/src/main/kotlin/com/hermesandroid/relay/data/ChatTurnCheckpointStore.kt

@@ -35,6 +35,9 @@ data class ChatTurnCheckpoint(
     val baselineAssistantCount: Int,
     val pendingAsk: ChatTurnAskCheckpoint? = null,
     val queuedMessages: List<ChatQueuedMessageCheckpoint> = emptyList(),
+    val queuePaused: Boolean = false,
+    /** Only pending local work remains; never reattach the completed/stopped turn. */
+    val queueOnly: Boolean = false,
     val startedAt: Long,
     val updatedAt: Long,
 ) {

app/src/main/kotlin/com/hermesandroid/relay/data/ConnectionCapabilities.kt

@@ -29,3 +29,24 @@ val Connection.capabilities: ConnectionCapabilities
         apiServerConfigured = apiServerUrl.isNotBlank(),
         relayConfigured = relayUrl.isNotBlank(),
     )
+
+/**
+ * Stable owner for an Auto chat before a conversation is opened.
+ *
+ * A legacy API-only record has no persisted Dashboard route; the conventional
+ * same-host `:9119` derivation remains useful for an explicit upgrade, but it
+ * must not silently turn that compatibility record into a Gateway-owned chat.
+ * Once a Dashboard route (or authenticated Dashboard origin) is persisted,
+ * standard Chat belongs to Gateway even while that route is signed out or
+ * temporarily unreachable.
+ */
+val Connection.automaticChatTransport: SessionTransport
+    get() {
+        val dashboardPersisted = !dashboardUrl.isNullOrBlank() ||
+            !authenticatedDashboardOrigin.isNullOrBlank()
+        return if (dashboardPersisted) SessionTransport.GATEWAY else SessionTransport.SSE
+    }
+
+fun Connection.chatTransportForPreference(preference: String): SessionTransport =
+    if (preference == "auto") automaticChatTransport
+    else SessionTransport.forEndpoint(preference)

app/src/main/kotlin/com/hermesandroid/relay/data/ConnectionSecurity.kt

@@ -124,7 +124,7 @@ private fun EndpointCandidate?.secureLinkProtects(label: String, url: String): B
     val normalized = url.trim().trimEnd('/')
     val service = when (label) {
         "Chat & Manage", "Dashboard & Gateway" -> "dashboard"
-        "API / sessions", "API fallback" -> "api"
+        "API / sessions", "API fallback", "Direct API" -> "api"
         "Relay tools" -> "relay"
         else -> return false
     }
@@ -170,7 +170,7 @@ fun computeConnectionSecurity(
         apiUrl.trim().takeIf { it.isNotBlank() }?.let {
             add(
                 classifySurfaceSecurity(
-                    label = "API fallback",
+                    label = "Direct API",
                     url = it,
                     activeEndpoint = apiEndpoint,
                     isTailscaleDetected = isTailscaleDetected,

app/src/main/kotlin/com/hermesandroid/relay/data/GitStateApiClient.kt

@@ -1,7 +1,13 @@
 package com.hermesandroid.relay.data
 
 import com.hermesandroid.relay.network.upstream.DashboardApiClient
+import com.hermesandroid.relay.network.upstream.DashboardHttpException
 import com.hermesandroid.relay.plugins.runtime.ScopedPluginApiClient
+import java.io.IOException
+import java.net.URLEncoder
+import java.util.Locale
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.buildJsonArray
@@ -9,113 +15,178 @@ import kotlinx.serialization.json.buildJsonObject
 import kotlinx.serialization.json.decodeFromJsonElement
 import kotlinx.serialization.json.put
 
-// Read + write client for the Hermes-Relay Git State endpoints.
-// All requests are confined to the ``hermes-relay`` plugin namespace and the
-// ``git/*`` sub-path via ScopedPluginApiClient, which rejects traversal and
-// encodes query values.
-
 private fun pathsArray(paths: List<String>) = buildJsonArray { paths.forEach { add(JsonPrimitive(it)) } }
 
+/**
+ * Uses official Dashboard `/api/git/…` reads for the active session repository.
+ * Relay remains the discovery source and owns stronger write/preview extensions.
+ * Operational upstream failures are never hidden by a Relay retry; only a 404
+ * can fall back to a matching Relay-discovered repository.
+ */
 class GitStateApiClient(
-    dashboard: DashboardApiClient,
+    private val dashboard: DashboardApiClient,
 ) {
     private val scoped = ScopedPluginApiClient("hermes-relay", dashboard)
     private val json = Json { ignoreUnknownKeys = true }
+    private val reposById = linkedMapOf<String, GitRepo>()
+    private val relayRepoIdsByRoot = linkedMapOf<String, String>()
 
-    suspend fun repos(): Result<List<GitRepo>> = scoped
-        .get("git/repos")
-        .mapCatching { element ->
-            json.decodeFromJsonElement<ReposResponse>(element).repos
+    suspend fun repos(
+        sessionRepoPath: String? = null,
+        includeRelayDiscovery: Boolean = true,
+    ): Result<List<GitRepo>> {
+        reposById.clear()
+        relayRepoIdsByRoot.clear()
+        val path = sessionRepoPath?.trim().orEmpty()
+        if (path.isBlank()) {
+            return if (includeRelayDiscovery) relayRepos().onSuccess(::rememberRepos)
+            else Result.success(emptyList())
         }
 
-    suspend fun status(repo: String): Result<GitStatus> = scoped
-        .get("git/status", mapOf("repo" to repo))
-        .mapCatching { element -> json.decodeFromJsonElement<GitStatus>(element) }
-
-    suspend fun branches(repo: String): Result<List<GitBranch>> = scoped
-        .get("git/branches", mapOf("repo" to repo))
-        .mapCatching { element ->
-            json.decodeFromJsonElement<BranchesResponse>(element).branches
+        val upstream = upstreamStatus(path)
+        if (upstream.isFailure) {
+            val error = upstream.exceptionOrNull()!!
+            if (!error.isUnsupportedGitRoute()) return Result.failure(error)
+            return if (includeRelayDiscovery) relayRepos().onSuccess(::rememberRepos)
+            else Result.failure(error)
+        }
+        val status = upstream.getOrNull()
+        if (status == null) {
+            return if (includeRelayDiscovery) relayRepos().onSuccess(::rememberRepos)
+            else Result.success(emptyList())
         }
 
-    suspend fun diff(repo: String, path: String, kind: String): Result<GitDiff> = scoped
-        .get("git/diff", mapOf("repo" to repo, "path" to path, "kind" to kind))
-        .mapCatching { element -> json.decodeFromJsonElement<GitDiff>(element) }
+        val standardRepo = GitRepo(
+            id = UPSTREAM_SESSION_REPO_ID,
+            name = path.replace('\\', '/').trimEnd('/').substringAfterLast('/').ifBlank { path },
+            root = path,
+            currentBranch = status.branch,
+            dirty = status.changed > 0,
+            route = GitRepositoryRoute.UPSTREAM,
+        )
 
-    suspend fun file(repo: String, path: String): Result<GitFile> = scoped
-        .get("git/file", mapOf("repo" to repo, "path" to path))
-        .mapCatching { element -> json.decodeFromJsonElement<GitFile>(element) }
+        // Plugin discovery is an enhancement. Once upstream answered, plugin
+        // absence or breakage cannot take the standard session repository down.
+        val relay = if (includeRelayDiscovery) relayRepos().getOrDefault(emptyList()) else emptyList()
+        val merged = buildList {
+            add(standardRepo)
+            addAll(relay.filterNot { sameRoot(it.root, standardRepo.root) })
+        }
+        rememberRepos(merged)
+        rememberRelayRepos(relay)
+        return Result.success(merged)
+    }
 
-    // ── Write operations ───────────────────────────────────────────────────
-    // Every write requires the plugin.api.write grant, which the app enforces
-    // (see GitStateViewModel: a POST is never sent without the grant). The
-    // server additionally enforces per-use confirmation strings for destructive
-    // ops (discard/push/dirty-checkout) — the caller passes the echoed token.
+    suspend fun status(repo: String): Result<GitStatus> {
+        val target = reposById[repo]
+        if (target?.route != GitRepositoryRoute.UPSTREAM) return relayStatus(repo)
+        return fallbackOnUnsupported(target, upstreamStatusWithFiles(target.root), ::relayStatus)
+    }
+
+    suspend fun branches(repo: String): Result<List<GitBranch>> {
+        val target = reposById[repo]
+        if (target?.route != GitRepositoryRoute.UPSTREAM) return relayBranches(repo)
+        return fallbackOnUnsupported(target, upstreamBranches(target.root), ::relayBranches)
+    }
+
+    suspend fun diff(repo: String, path: String, kind: String): Result<GitDiff> {
+        val target = reposById[repo]
+        if (target?.route != GitRepositoryRoute.UPSTREAM) return relayDiff(repo, path, kind)
+        val upstream = dashboard.getJsonElement(
+            upstreamPath(
+                "/api/git/review/diff",
+                mapOf(
+                    "path" to target.root,
+                    "file" to path,
+                    "scope" to "uncommitted",
+                    "staged" to (kind == "staged").toString(),
+                ),
+            ),
+        ).mapCatching { element ->
+            GitDiff(
+                path = path,
+                kind = kind,
+                diff = json.decodeFromJsonElement<UpstreamDiffResponse>(element).diff,
+            )
+        }
+        return fallbackOnUnsupported(target, upstream) { relay -> relayDiff(relay, path, kind) }
+    }
+
+    /** Clean tracked-file preview is a Relay enhancement; file-diff is not equivalent. */
+    suspend fun file(repo: String, path: String): Result<GitFile> {
+        val relay = relayRepoId(repo)
+            ?: return Result.failure(IOException("Tracked-file preview requires the Relay plugin"))
+        return relayFile(relay, path)
+    }
+
+    // Writes intentionally stay on Relay. The upstream Desktop mutation shape
+    // does not carry plugin.api.write or the server-enforced confirmation echoes
+    // used by this mobile surface, so it is not an equivalent safety contract.
 
     suspend fun stage(repo: String, paths: List<String>): Result<GitMutationResult> =
-        scoped.post("git/stage", buildJsonObject {
-            put("repo", repo)
+        relayWrite(repo) { relay -> scoped.post("git/stage", buildJsonObject {
+            put("repo", relay)
             put("paths", pathsArray(paths))
-        }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+        }).decodeMutation() }
 
     suspend fun unstage(repo: String, paths: List<String>): Result<GitMutationResult> =
-        scoped.post("git/unstage", buildJsonObject {
-            put("repo", repo)
+        relayWrite(repo) { relay -> scoped.post("git/unstage", buildJsonObject {
+            put("repo", relay)
             put("paths", pathsArray(paths))
-        }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+        }).decodeMutation() }
 
     suspend fun discard(
         repo: String,
         paths: List<String>,
         confirmation: String,
         deleteUntracked: Boolean = false,
-    ): Result<GitMutationResult> = scoped.post("git/discard", buildJsonObject {
-        put("repo", repo)
+    ): Result<GitMutationResult> = relayWrite(repo) { relay -> scoped.post("git/discard", buildJsonObject {
+        put("repo", relay)
         put("paths", pathsArray(paths))
         put("confirmation", confirmation)
         put("delete_untracked", deleteUntracked)
-    }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+    }).decodeMutation() }
 
     suspend fun commit(repo: String, message: String): Result<GitMutationResult> =
-        scoped.post("git/commit", buildJsonObject {
-            put("repo", repo)
+        relayWrite(repo) { relay -> scoped.post("git/commit", buildJsonObject {
+            put("repo", relay)
             put("message", message)
-        }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+        }).decodeMutation() }
 
     suspend fun commitSelected(
         repo: String,
         message: String,
         paths: List<String>,
-    ): Result<GitMutationResult> = scoped.post("git/commit_selected", buildJsonObject {
-        put("repo", repo)
+    ): Result<GitMutationResult> = relayWrite(repo) { relay -> scoped.post("git/commit_selected", buildJsonObject {
+        put("repo", relay)
         put("message", message)
         put("paths", pathsArray(paths))
-    }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+    }).decodeMutation() }
 
     suspend fun fetch(repo: String, remote: String = "origin"): Result<GitMutationResult> =
-        scoped.post("git/fetch", buildJsonObject {
-            put("repo", repo)
+        relayWrite(repo) { relay -> scoped.post("git/fetch", buildJsonObject {
+            put("repo", relay)
             put("remote", remote)
-        }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+        }).decodeMutation() }
 
     suspend fun pull(repo: String, remote: String = "origin", branch: String = ""): Result<GitMutationResult> =
-        scoped.post("git/pull", buildJsonObject {
-            put("repo", repo)
+        relayWrite(repo) { relay -> scoped.post("git/pull", buildJsonObject {
+            put("repo", relay)
             put("remote", remote)
             put("branch", branch)
-        }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+        }).decodeMutation() }
 
     suspend fun push(
         repo: String,
         confirmation: String,
         remote: String = "origin",
         branch: String = "",
-    ): Result<GitMutationResult> = scoped.post("git/push", buildJsonObject {
-        put("repo", repo)
+    ): Result<GitMutationResult> = relayWrite(repo) { relay -> scoped.post("git/push", buildJsonObject {
+        put("repo", relay)
         put("remote", remote)
         put("branch", branch)
         put("confirmation", confirmation)
-    }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+    }).decodeMutation() }
 
     suspend fun checkout(
         repo: String,
@@ -123,41 +194,217 @@ class GitStateApiClient(
         confirmation: String? = null,
         newBranch: String = "",
         track: Boolean = false,
-    ): Result<GitMutationResult> = scoped.post("git/checkout", buildJsonObject {
-        put("repo", repo)
+    ): Result<GitMutationResult> = relayWrite(repo) { relay -> scoped.post("git/checkout", buildJsonObject {
+        put("repo", relay)
         put("ref", ref)
         if (confirmation != null) put("confirmation", confirmation)
         if (newBranch.isNotEmpty()) put("new_branch", newBranch)
         put("track", track)
-    }).mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+    }).decodeMutation() }
 
-    // ── Phase 3 extras ─────────────────────────────────────────────────────
+    suspend fun commitMessage(repo: String): Result<GitCommitMessage> = relayWrite(repo) { relay ->
+        scoped.post("git/commit_message", buildJsonObject { put("repo", relay) })
+            .mapCatching { json.decodeFromJsonElement<GitCommitMessage>(it) }
+    }
 
-    /** Generate a commit-message suggestion from the staged diff. */
-    suspend fun commitMessage(repo: String): Result<GitCommitMessage> =
-        scoped.post("git/commit_message", buildJsonObject {
-            put("repo", repo)
-        }).mapCatching { json.decodeFromJsonElement<GitCommitMessage>(it) }
+    suspend fun commitMessageSelected(repo: String, paths: List<String>): Result<GitCommitMessage> =
+        relayWrite(repo) { relay -> scoped.post("git/commit_message_selected", buildJsonObject {
+            put("repo", relay)
+            put("paths", pathsArray(paths))
+        }).mapCatching { json.decodeFromJsonElement<GitCommitMessage>(it) } }
 
-    /** Generate a commit-message suggestion from the given paths' staged diff. */
-    suspend fun commitMessageSelected(
-        repo: String,
-        paths: List<String>,
-    ): Result<GitCommitMessage> = scoped.post("git/commit_message_selected", buildJsonObject {
-        put("repo", repo)
-        put("paths", pathsArray(paths))
-    }).mapCatching { json.decodeFromJsonElement<GitCommitMessage>(it) }
-
-    /** Checkout that auto-stashes a dirty tree first. */
     suspend fun stashCheckout(
         repo: String,
         ref: String,
         newBranch: String = "",
         track: Boolean = false,
-    ): Result<GitStashCheckoutResult> = scoped.post("git/stash_checkout", buildJsonObject {
-        put("repo", repo)
+    ): Result<GitStashCheckoutResult> = relayWrite(repo) { relay -> scoped.post("git/stash_checkout", buildJsonObject {
+        put("repo", relay)
         put("ref", ref)
         if (newBranch.isNotEmpty()) put("new_branch", newBranch)
         put("track", track)
-    }).mapCatching { json.decodeFromJsonElement<GitStashCheckoutResult>(it) }
+    }).mapCatching { json.decodeFromJsonElement<GitStashCheckoutResult>(it) } }
+
+    private suspend fun relayRepos(): Result<List<GitRepo>> = scoped.get("git/repos").mapCatching {
+        json.decodeFromJsonElement<ReposResponse>(it).repos
+    }
+
+    private suspend fun relayStatus(repo: String): Result<GitStatus> = scoped
+        .get("git/status", mapOf("repo" to repo))
+        .mapCatching { json.decodeFromJsonElement<GitStatus>(it) }
+
+    private suspend fun relayBranches(repo: String): Result<List<GitBranch>> = scoped
+        .get("git/branches", mapOf("repo" to repo))
+        .mapCatching { json.decodeFromJsonElement<BranchesResponse>(it).branches }
+
+    private suspend fun relayDiff(repo: String, path: String, kind: String): Result<GitDiff> = scoped
+        .get("git/diff", mapOf("repo" to repo, "path" to path, "kind" to kind))
+        .mapCatching { json.decodeFromJsonElement<GitDiff>(it) }
+
+    private suspend fun relayFile(repo: String, path: String): Result<GitFile> = scoped
+        .get("git/file", mapOf("repo" to repo, "path" to path))
+        .mapCatching { json.decodeFromJsonElement<GitFile>(it) }
+
+    private suspend fun upstreamStatus(path: String): Result<UpstreamStatus?> = dashboard
+        .getJsonElement(upstreamPath("/api/git/status", mapOf("path" to path)))
+        .mapCatching { json.decodeFromJsonElement<UpstreamStatus?>(it) }
+
+    private suspend fun upstreamStatusWithFiles(path: String): Result<GitStatus> {
+        val status = upstreamStatus(path).mapCatching {
+            it ?: throw IOException("The active session path is not a Git repository")
+        }.getOrElse { return Result.failure(it) }
+        val review = dashboard.getJsonElement(
+            upstreamPath("/api/git/review/list", mapOf("path" to path, "scope" to "uncommitted")),
+        ).mapCatching { json.decodeFromJsonElement<UpstreamReviewList>(it) }
+            .getOrElse { return Result.failure(it) }
+        val statusByPath = status.files.associateBy { it.path }
+        val staged = mutableListOf<GitStatusEntry>()
+        val modified = mutableListOf<GitStatusEntry>()
+        val untracked = mutableListOf<GitStatusEntry>()
+        review.files.forEach { file ->
+            val entry = GitStatusEntry(file.path, file.added, file.removed)
+            val fileStatus = statusByPath[file.path]
+            if (fileStatus?.untracked == true) {
+                untracked += entry
+            } else {
+                if (file.staged || fileStatus?.staged == true) staged += entry
+                if (fileStatus?.unstaged == true || (!file.staged && fileStatus == null)) {
+                    modified += entry
+                }
+            }
+        }
+        return Result.success(
+            GitStatus(
+                counts = GitStatusCounts(
+                    staged = status.staged,
+                    modified = status.unstaged,
+                    untracked = status.untracked,
+                    changes = status.changed,
+                    additions = status.added,
+                    deletions = status.removed,
+                ),
+                staged = staged,
+                modified = modified,
+                untracked = untracked,
+            ),
+        )
+    }
+
+    private suspend fun upstreamBranches(path: String): Result<List<GitBranch>> = dashboard
+        .getJsonElement(upstreamPath("/api/git/branches", mapOf("path" to path)))
+        .mapCatching { element ->
+            json.decodeFromJsonElement<UpstreamBranches>(element).branches.map {
+                GitBranch(name = it.name, isCurrent = it.checkedOut)
+            }
+        }
+
+    private suspend fun <T> fallbackOnUnsupported(
+        target: GitRepo,
+        upstream: Result<T>,
+        relayCall: suspend (String) -> Result<T>,
+    ): Result<T> {
+        if (upstream.isSuccess) return upstream
+        val error = upstream.exceptionOrNull()!!
+        if (!error.isUnsupportedGitRoute()) return Result.failure(error)
+        val relay = relayRepoIdsByRoot[normalizedRoot(target.root)] ?: return Result.failure(error)
+        return relayCall(relay)
+    }
+
+    private suspend fun <T> relayWrite(repo: String, block: suspend (String) -> Result<T>): Result<T> {
+        val relay = relayRepoId(repo)
+            ?: return Result.failure(IOException("This Git action requires the Relay plugin enhancement"))
+        return block(relay)
+    }
+
+    private fun relayRepoId(repo: String): String? {
+        val target = reposById[repo] ?: return repo.takeUnless { it == UPSTREAM_SESSION_REPO_ID }
+        return if (target.route == GitRepositoryRoute.RELAY) target.id
+        else relayRepoIdsByRoot[normalizedRoot(target.root)]
+    }
+
+    private fun rememberRepos(repos: List<GitRepo>) {
+        repos.forEach { reposById[it.id] = it }
+        rememberRelayRepos(repos.filter { it.route == GitRepositoryRoute.RELAY })
+    }
+
+    private fun rememberRelayRepos(repos: List<GitRepo>) {
+        repos.forEach { relayRepoIdsByRoot[normalizedRoot(it.root)] = it.id }
+    }
+
+    private fun upstreamPath(path: String, query: Map<String, String>): String = buildString {
+        append(path)
+        if (query.isNotEmpty()) {
+            append('?')
+            append(query.entries.joinToString("&") { (key, value) -> "${encode(key)}=${encode(value)}" })
+        }
+    }
+
+    private fun encode(value: String): String =
+        URLEncoder.encode(value, Charsets.UTF_8.name()).replace("+", "%20")
+
+    private fun normalizedRoot(path: String): String {
+        val normalized = path.trim().replace('\\', '/').trimEnd('/')
+        return if (WINDOWS_ROOT.containsMatchIn(normalized) || normalized.startsWith("//")) {
+            normalized.lowercase(Locale.ROOT)
+        } else {
+            normalized
+        }
+    }
+
+    private fun sameRoot(first: String, second: String): Boolean =
+        normalizedRoot(first) == normalizedRoot(second)
+
+    private fun Result<kotlinx.serialization.json.JsonObject>.decodeMutation(): Result<GitMutationResult> =
+        mapCatching { json.decodeFromJsonElement<GitMutationResult>(it) }
+
+    private fun Throwable.isUnsupportedGitRoute(): Boolean =
+        this is DashboardHttpException && statusCode == 404
+
+    private companion object {
+        const val UPSTREAM_SESSION_REPO_ID = "__upstream_session__"
+        val WINDOWS_ROOT = Regex("^[A-Za-z]:/")
+    }
 }
+
+@Serializable
+private data class UpstreamStatus(
+    val branch: String? = null,
+    val staged: Int = 0,
+    val unstaged: Int = 0,
+    val untracked: Int = 0,
+    val changed: Int = 0,
+    val added: Int = 0,
+    val removed: Int = 0,
+    val files: List<UpstreamStatusFile> = emptyList(),
+)
+
+@Serializable
+private data class UpstreamStatusFile(
+    val path: String,
+    val staged: Boolean = false,
+    val unstaged: Boolean = false,
+    val untracked: Boolean = false,
+)
+
+@Serializable
+private data class UpstreamReviewList(val files: List<UpstreamReviewFile> = emptyList())
+
+@Serializable
+private data class UpstreamReviewFile(
+    val path: String,
+    val added: Int = 0,
+    val removed: Int = 0,
+    val staged: Boolean = false,
+)
+
+@Serializable
+private data class UpstreamBranches(val branches: List<UpstreamBranch> = emptyList())
+
+@Serializable
+private data class UpstreamBranch(
+    val name: String,
+    @SerialName("checkedOut") val checkedOut: Boolean = false,
+)
+
+@Serializable
+private data class UpstreamDiffResponse(val diff: String = "")

app/src/main/kotlin/com/hermesandroid/relay/data/GitStateModels.kt

@@ -3,7 +3,7 @@ package com.hermesandroid.relay.data
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
-/** A repository discovered by the plugin's /git/repos endpoint. */
+/** A current-session upstream repository or a Relay-discovered repository. */
 @Serializable
 data class GitRepo(
     val id: String,
@@ -11,9 +11,19 @@ data class GitRepo(
     val root: String,
     @SerialName("current_branch") val currentBranch: String? = null,
     val dirty: Boolean = false,
+    val route: GitRepositoryRoute = GitRepositoryRoute.RELAY,
 )
 
-/** Working-tree status from /git/status. */
+@Serializable
+enum class GitRepositoryRoute {
+    @SerialName("relay")
+    RELAY,
+
+    @SerialName("upstream")
+    UPSTREAM,
+}
+
+/** Normalized working-tree status from upstream or Relay Git routes. */
 @Serializable
 data class GitStatus(
     val counts: GitStatusCounts = GitStatusCounts(),

app/src/main/kotlin/com/hermesandroid/relay/data/ProfileData.kt

@@ -111,6 +111,8 @@ data class Profile(
     val hasAvatar: Boolean = false,
     @SerialName("ui_meta")
     val uiMeta: JsonObject = JsonObject(emptyMap()),
+    @SerialName("display_name")
+    val displayName: String = "",
 ) {
     val hasIsolatedApi: Boolean
         get() = !apiServerUrl.isNullOrBlank()

app/src/main/kotlin/com/hermesandroid/relay/data/SupervisedModeStore.kt

@@ -81,6 +81,24 @@ class SupervisedModeStore private constructor(
         dataStore.edit { preferences -> preferences.remove(KEY_POLICIES) }
     }
 
+    /** Disable every policy while preserving its configured controls and remove the parent credential atomically. */
+    internal suspend fun disableAllAndRemoveCredential(
+        parentCredentialKey: Preferences.Key<String>,
+    ) {
+        dataStore.edit { preferences ->
+            val decoded = decode(preferences[KEY_POLICIES])
+            if (decoded.corrupt || decoded.policies.isEmpty()) {
+                preferences.remove(KEY_POLICIES)
+            } else {
+                val disabled = decoded.policies.mapValues { (_, policy) ->
+                    policy.copy(enabled = false).normalized()
+                }
+                preferences[KEY_POLICIES] = json.encodeToString(serializer, disabled)
+            }
+            preferences.remove(parentCredentialKey)
+        }
+    }
+
     private fun decode(raw: String?): DecodeResult {
         if (raw.isNullOrBlank()) return DecodeResult(emptyMap(), corrupt = false)
         return try {

app/src/main/kotlin/com/hermesandroid/relay/data/SupervisedParentAuthStore.kt

@@ -0,0 +1,461 @@
+package com.hermesandroid.relay.data
+
+import android.content.Context
+import android.util.Log
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import java.security.MessageDigest
+import java.security.SecureRandom
+import java.util.Base64
+import javax.crypto.SecretKeyFactory
+import javax.crypto.spec.PBEKeySpec
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+
+/** Availability of the app-specific parent credential. */
+enum class SupervisedParentAuthStatus {
+    Missing,
+    Configured,
+    Corrupt,
+}
+
+/** Input method selected for the app-specific parent credential. */
+@Serializable
+enum class SupervisedParentCredentialType {
+    Legacy,
+    Pin,
+    Password,
+}
+
+@Serializable
+private enum class SupervisedRecoveryFormat {
+    LegacyCode,
+    WordPhrase,
+}
+
+/** Result of a parent-secret or recovery-phrase verification attempt. */
+sealed interface SupervisedParentAuthResult {
+    data object Success : SupervisedParentAuthResult
+    data class Invalid(val attemptsBeforeDelay: Int) : SupervisedParentAuthResult
+    data class Throttled(val retryAfterMillis: Long) : SupervisedParentAuthResult
+    data object Missing : SupervisedParentAuthResult
+    data object Corrupt : SupervisedParentAuthResult
+}
+
+/** Successful enrollment returns a recovery phrase which is shown once and never persisted. */
+data class SupervisedParentEnrollment(val recoveryPhrase: String)
+
+/** Validation result for a new parent PIN or password. */
+data class SupervisedParentSecretValidation(
+    val valid: Boolean,
+    val message: String? = null,
+)
+
+/** Narrow authentication surface consumed by Compose dialogs and test fakes. */
+interface SupervisedParentAuthenticator {
+    val credentialTypeFlow: Flow<SupervisedParentCredentialType?>
+    suspend fun enroll(
+        newSecret: CharArray,
+        credentialType: SupervisedParentCredentialType,
+    ): Result<SupervisedParentEnrollment>
+    suspend fun verify(secret: CharArray): SupervisedParentAuthResult
+    suspend fun change(
+        currentSecret: CharArray,
+        newSecret: CharArray,
+        credentialType: SupervisedParentCredentialType,
+    ): Result<SupervisedParentEnrollment>
+    suspend fun resetWithRecoveryPhrase(
+        recoveryPhrase: CharArray,
+        newSecret: CharArray,
+        credentialType: SupervisedParentCredentialType,
+    ): Result<SupervisedParentEnrollment>
+}
+
+/**
+ * App-specific parent authentication for Supervised Mode.
+ *
+ * This store deliberately does not delegate to Android's device credential: a
+ * child can legitimately own the PIN or biometrics on their Android profile.
+ * Only salted PBKDF2 verifiers and bounded failure state are stored. The parent
+ * secret and recovery phrase are never persisted.
+ */
+class SupervisedParentAuthStore private constructor(
+    private val dataStore: DataStore<Preferences>,
+    private val iterations: Int,
+    private val minimumAcceptedIterations: Int,
+    private val random: SecureRandom,
+    private val nowMillis: () -> Long,
+) : SupervisedParentAuthenticator {
+    constructor(context: Context) : this(
+        dataStore = context.applicationContext.relayDataStore,
+        iterations = DEFAULT_PBKDF2_ITERATIONS,
+        minimumAcceptedIterations = MIN_ACCEPTED_ITERATIONS,
+        random = SecureRandom(),
+        nowMillis = System::currentTimeMillis,
+    )
+
+    private val json = Json { encodeDefaults = true; ignoreUnknownKeys = false }
+    val statusFlow: Flow<SupervisedParentAuthStatus> = dataStore.data.map { preferences ->
+        decode(preferences[KEY_RECORD]).status
+    }
+    override val credentialTypeFlow: Flow<SupervisedParentCredentialType?> = dataStore.data.map { preferences ->
+        decode(preferences[KEY_RECORD]).record?.credentialType
+    }
+
+    override suspend fun enroll(
+        newSecret: CharArray,
+        credentialType: SupervisedParentCredentialType,
+    ): Result<SupervisedParentEnrollment> = processMutex.withLock {
+        val validation = validateNewSecret(newSecret, credentialType)
+        if (!validation.valid) {
+            return Result.failure(IllegalArgumentException(validation.message))
+        }
+        if (decode(dataStore.data.first()[KEY_RECORD]).status != SupervisedParentAuthStatus.Missing) {
+            return Result.failure(IllegalStateException("Parent access is already configured or unavailable."))
+        }
+        runCatching { enrollLocked(newSecret, credentialType) }
+    }
+
+    override suspend fun verify(secret: CharArray): SupervisedParentAuthResult = processMutex.withLock {
+        verifyLocked(secret, AuthTarget.ParentSecret)
+    }
+
+    override suspend fun change(
+        currentSecret: CharArray,
+        newSecret: CharArray,
+        credentialType: SupervisedParentCredentialType,
+    ): Result<SupervisedParentEnrollment> = processMutex.withLock {
+        val validation = validateNewSecret(newSecret, credentialType)
+        if (!validation.valid) {
+            return Result.failure(IllegalArgumentException(validation.message))
+        }
+        when (val verified = verifyLocked(currentSecret, AuthTarget.ParentSecret)) {
+            SupervisedParentAuthResult.Success -> runCatching { enrollLocked(newSecret, credentialType) }
+            else -> Result.failure(ParentAuthenticationException(verified))
+        }
+    }
+
+    override suspend fun resetWithRecoveryPhrase(
+        recoveryPhrase: CharArray,
+        newSecret: CharArray,
+        credentialType: SupervisedParentCredentialType,
+    ): Result<SupervisedParentEnrollment> = processMutex.withLock {
+        val validation = validateNewSecret(newSecret, credentialType)
+        if (!validation.valid) {
+            return Result.failure(IllegalArgumentException(validation.message))
+        }
+        val record = decode(dataStore.data.first()[KEY_RECORD]).record
+            ?: return Result.failure(ParentAuthenticationException(SupervisedParentAuthResult.Missing))
+        val normalizedRecovery = normalizeRecoveryPhrase(recoveryPhrase, record.recoveryFormat)
+        try {
+            when (val verified = verifyLocked(normalizedRecovery, AuthTarget.RecoveryCode)) {
+                SupervisedParentAuthResult.Success -> runCatching { enrollLocked(newSecret, credentialType) }
+                else -> Result.failure(ParentAuthenticationException(verified))
+            }
+        } finally {
+            normalizedRecovery.fill('\u0000')
+        }
+    }
+
+    /**
+     * Authenticated escape hatch used by the parent controls.
+     *
+     * The app-global credential cannot be removed while leaving any supervised
+     * policy enabled. Every policy is disabled, but its configuration is retained,
+     * in the same transaction that removes the credential.
+     */
+    suspend fun clearCredentialAndDisablePolicies(): Result<Unit> = processMutex.withLock {
+        runCatching {
+            SupervisedModeStore.forTesting(dataStore).disableAllAndRemoveCredential(KEY_RECORD)
+            Unit
+        }
+    }
+
+    private suspend fun enrollLocked(
+        secret: CharArray,
+        credentialType: SupervisedParentCredentialType,
+    ): SupervisedParentEnrollment {
+        require(credentialType != SupervisedParentCredentialType.Legacy)
+        val recoveryChars = generateRecoveryPhrase().toCharArray()
+        val parentSalt = ByteArray(SALT_BYTES).also(random::nextBytes)
+        val recoverySalt = ByteArray(SALT_BYTES).also(random::nextBytes)
+        var parentVerifier = ByteArray(0)
+        var recoveryVerifier = ByteArray(0)
+        try {
+            parentVerifier = derive(secret, parentSalt, iterations)
+            recoveryVerifier = derive(recoveryChars, recoverySalt, iterations)
+            val record = PersistedParentAuth(
+                iterations = iterations,
+                parentSalt = encode(parentSalt),
+                parentVerifier = encode(parentVerifier),
+                recoverySalt = encode(recoverySalt),
+                recoveryVerifier = encode(recoveryVerifier),
+                credentialType = credentialType,
+                recoveryFormat = SupervisedRecoveryFormat.WordPhrase,
+            )
+            dataStore.edit { it[KEY_RECORD] = json.encodeToString(record) }
+            return SupervisedParentEnrollment(recoveryChars.concatToString())
+        } finally {
+            recoveryChars.fill('\u0000')
+            parentSalt.fill(0)
+            recoverySalt.fill(0)
+            parentVerifier.fill(0)
+            recoveryVerifier.fill(0)
+        }
+    }
+
+    private suspend fun verifyLocked(
+        candidate: CharArray,
+        target: AuthTarget,
+    ): SupervisedParentAuthResult {
+        val decoded = decode(dataStore.data.first()[KEY_RECORD])
+        val record = decoded.record ?: return when (decoded.status) {
+            SupervisedParentAuthStatus.Missing -> SupervisedParentAuthResult.Missing
+            else -> SupervisedParentAuthResult.Corrupt
+        }
+        val now = nowMillis()
+        if (record.blockedUntilEpochMillis > now) {
+            return SupervisedParentAuthResult.Throttled(record.blockedUntilEpochMillis - now)
+        }
+
+        val saltText = when (target) {
+            AuthTarget.ParentSecret -> record.parentSalt
+            AuthTarget.RecoveryCode -> record.recoverySalt
+        }
+        val verifierText = when (target) {
+            AuthTarget.ParentSecret -> record.parentVerifier
+            AuthTarget.RecoveryCode -> record.recoveryVerifier
+        }
+        val salt = decodeBytes(saltText) ?: return SupervisedParentAuthResult.Corrupt
+        val expected = decodeBytes(verifierText) ?: return SupervisedParentAuthResult.Corrupt
+        val actual = try {
+            derive(candidate, salt, record.iterations)
+        } catch (error: Exception) {
+            Log.w(TAG, "Unable to derive supervised parent verifier", error)
+            return SupervisedParentAuthResult.Corrupt
+        } finally {
+            salt.fill(0)
+        }
+        val matches = try {
+            MessageDigest.isEqual(expected, actual)
+        } finally {
+            expected.fill(0)
+            actual.fill(0)
+        }
+
+        if (matches) {
+            if (record.failedAttempts != 0 || record.blockedUntilEpochMillis != 0L) {
+                save(record.copy(failedAttempts = 0, blockedUntilEpochMillis = 0L))
+            }
+            return SupervisedParentAuthResult.Success
+        }
+
+        val failures = (record.failedAttempts + 1).coerceAtMost(MAX_TRACKED_FAILURES)
+        val delayMillis = backoffMillis(failures)
+        save(
+            record.copy(
+                failedAttempts = failures,
+                blockedUntilEpochMillis = if (delayMillis == 0L) 0L else now + delayMillis,
+            ),
+        )
+        return if (delayMillis == 0L) {
+            SupervisedParentAuthResult.Invalid(
+                attemptsBeforeDelay = (FAILURES_BEFORE_BACKOFF - failures).coerceAtLeast(0),
+            )
+        } else {
+            SupervisedParentAuthResult.Throttled(delayMillis)
+        }
+    }
+
+    private suspend fun save(record: PersistedParentAuth) {
+        dataStore.edit { it[KEY_RECORD] = json.encodeToString(record) }
+    }
+
+    private suspend fun derive(secret: CharArray, salt: ByteArray, rounds: Int): ByteArray =
+        withContext(Dispatchers.Default) {
+            val spec = PBEKeySpec(secret, salt, rounds, KEY_BITS)
+            try {
+                SecretKeyFactory.getInstance(KDF_ALGORITHM).generateSecret(spec).encoded
+            } finally {
+                spec.clearPassword()
+            }
+        }
+
+    private fun decode(raw: String?): DecodedRecord {
+        if (raw.isNullOrBlank()) {
+            return DecodedRecord(SupervisedParentAuthStatus.Missing, null)
+        }
+        val record = runCatching { json.decodeFromString<PersistedParentAuth>(raw) }
+            .getOrElse {
+                Log.w(TAG, "Unable to decode supervised parent authentication; failing closed", it)
+                return DecodedRecord(SupervisedParentAuthStatus.Corrupt, null)
+            }
+        val valid = record.version == RECORD_VERSION &&
+            record.algorithm == KDF_ALGORITHM &&
+            record.iterations in minimumAcceptedIterations..MAX_ACCEPTED_ITERATIONS &&
+            decodeBytes(record.parentSalt)?.size == SALT_BYTES &&
+            decodeBytes(record.parentVerifier)?.size == KEY_BITS / 8 &&
+            decodeBytes(record.recoverySalt)?.size == SALT_BYTES &&
+            decodeBytes(record.recoveryVerifier)?.size == KEY_BITS / 8 &&
+            record.failedAttempts in 0..MAX_TRACKED_FAILURES &&
+            record.blockedUntilEpochMillis >= 0
+        return if (valid) {
+            DecodedRecord(SupervisedParentAuthStatus.Configured, record)
+        } else {
+            DecodedRecord(SupervisedParentAuthStatus.Corrupt, null)
+        }
+    }
+
+    private fun generateRecoveryPhrase(): String {
+        val available = RECOVERY_WORDS.toMutableList()
+        val selected = buildList(RECOVERY_WORD_COUNT) {
+            repeat(RECOVERY_WORD_COUNT) {
+                add(available.removeAt(random.nextInt(available.size)))
+            }
+        }
+        return selected.joinToString("-")
+    }
+
+    private fun encode(bytes: ByteArray): String = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes)
+
+    private fun decodeBytes(value: String): ByteArray? =
+        runCatching { Base64.getUrlDecoder().decode(value) }.getOrNull()
+
+    private fun backoffMillis(failures: Int): Long = when (failures) {
+        in 0 until FAILURES_BEFORE_BACKOFF -> 0L
+        FAILURES_BEFORE_BACKOFF -> 30_000L
+        FAILURES_BEFORE_BACKOFF + 1 -> 60_000L
+        FAILURES_BEFORE_BACKOFF + 2 -> 120_000L
+        FAILURES_BEFORE_BACKOFF + 3 -> 300_000L
+        else -> MAX_BACKOFF_MILLIS
+    }
+
+    @Serializable
+    private data class PersistedParentAuth(
+        val version: Int = RECORD_VERSION,
+        val algorithm: String = KDF_ALGORITHM,
+        val iterations: Int,
+        val parentSalt: String,
+        val parentVerifier: String,
+        val recoverySalt: String,
+        val recoveryVerifier: String,
+        val credentialType: SupervisedParentCredentialType = SupervisedParentCredentialType.Legacy,
+        val recoveryFormat: SupervisedRecoveryFormat = SupervisedRecoveryFormat.LegacyCode,
+        val failedAttempts: Int = 0,
+        val blockedUntilEpochMillis: Long = 0L,
+    )
+
+    private data class DecodedRecord(
+        val status: SupervisedParentAuthStatus,
+        val record: PersistedParentAuth?,
+    )
+
+    private enum class AuthTarget { ParentSecret, RecoveryCode }
+
+    class ParentAuthenticationException(
+        val authResult: SupervisedParentAuthResult,
+    ) : IllegalStateException("Parent authentication failed: $authResult")
+
+    companion object {
+        private const val TAG = "SupervisedParentAuth"
+        private const val RECORD_VERSION = 1
+        private const val KDF_ALGORITHM = "PBKDF2WithHmacSHA256"
+        private const val DEFAULT_PBKDF2_ITERATIONS = 310_000
+        private const val MIN_ACCEPTED_ITERATIONS = 100_000
+        private const val MAX_ACCEPTED_ITERATIONS = 1_000_000
+        private const val SALT_BYTES = 16
+        private const val KEY_BITS = 256
+        private const val FAILURES_BEFORE_BACKOFF = 5
+        private const val MAX_TRACKED_FAILURES = 9
+        private const val MAX_BACKOFF_MILLIS = 15 * 60_000L
+        private const val RECOVERY_WORD_COUNT = 6
+        private val KEY_RECORD = stringPreferencesKey("supervised_parent_auth_v1")
+        private val processMutex = Mutex()
+
+        fun validateNewSecret(
+            secret: CharArray,
+            credentialType: SupervisedParentCredentialType,
+        ): SupervisedParentSecretValidation {
+            if (secret.size > 64) {
+                return SupervisedParentSecretValidation(false, "Use at most 64 characters.")
+            }
+            if (credentialType == SupervisedParentCredentialType.Pin) {
+                return if (secret.size == 6 && secret.all(Char::isDigit)) {
+                    SupervisedParentSecretValidation(true)
+                } else {
+                    SupervisedParentSecretValidation(false, "Use exactly 6 digits.")
+                }
+            }
+            return if (
+                credentialType == SupervisedParentCredentialType.Password &&
+                secret.size >= 8 && secret.any { !it.isWhitespace() }
+            ) {
+                SupervisedParentSecretValidation(true)
+            } else {
+                SupervisedParentSecretValidation(false, "Use a password with at least 8 characters.")
+            }
+        }
+
+        private fun normalizeRecoveryPhrase(
+            value: CharArray,
+            format: SupervisedRecoveryFormat,
+        ): CharArray = when (format) {
+            SupervisedRecoveryFormat.LegacyCode -> value
+                .filterNot { it == '-' || it.isWhitespace() }
+                .joinToString("")
+                .uppercase()
+                .toCharArray()
+            SupervisedRecoveryFormat.WordPhrase -> value.concatToString()
+                .trim()
+                .lowercase()
+                .split(Regex("[-\\s]+"))
+                .filter(String::isNotBlank)
+                .joinToString("-")
+                .toCharArray()
+        }
+
+        private val RECOVERY_WORDS = listOf(
+            "acorn", "amber", "apple", "april", "arrow", "beach", "berry", "birch",
+            "blue", "breeze", "brook", "button", "cabin", "cactus", "candle", "cedar",
+            "cherry", "cloud", "clover", "cobalt", "comet", "coral", "cotton", "cove",
+            "daisy", "dawn", "delta", "drift", "eagle", "earth", "ember", "fern",
+            "field", "finch", "forest", "frost", "garden", "ginger", "glade", "gold",
+            "grape", "green", "harbor", "hazel", "heron", "honey", "island", "ivory",
+            "jade", "juniper", "kite", "lagoon", "lake", "lantern", "lark", "leaf",
+            "lemon", "lilac", "lotus", "maple", "meadow", "mint", "moon", "morning",
+            "moss", "oasis", "ocean", "olive", "orchid", "otter", "peach", "pearl",
+            "pebble", "pine", "plum", "pond", "poppy", "quartz", "rain", "reed",
+            "river", "robin", "rose", "saffron", "sage", "sand", "shell", "silver",
+            "sky", "snow", "sparrow", "spring", "spruce", "star", "stone", "summer",
+            "sun", "sunset", "teal", "thistle", "tide", "tulip", "valley", "violet",
+            "willow", "wind", "winter", "wood", "wren", "yellow", "zephyr", "zinnia",
+            "anchor", "bamboo", "copper", "cricket", "feather", "harvest", "marble", "ribbon",
+            "rocket", "shadow", "timber", "whistle", "yarrow", "almond", "badger", "canvas",
+        )
+
+        internal fun forTesting(
+            dataStore: DataStore<Preferences>,
+            iterations: Int = MIN_ACCEPTED_ITERATIONS,
+            minimumAcceptedIterations: Int = MIN_ACCEPTED_ITERATIONS,
+            random: SecureRandom = SecureRandom(),
+            nowMillis: () -> Long = System::currentTimeMillis,
+        ): SupervisedParentAuthStore = SupervisedParentAuthStore(
+            dataStore = dataStore,
+            iterations = iterations,
+            minimumAcceptedIterations = minimumAcceptedIterations,
+            random = random,
+            nowMillis = nowMillis,
+        )
+
+        internal val recordKeyForTesting: Preferences.Key<String> = KEY_RECORD
+    }
+}

app/src/main/kotlin/com/hermesandroid/relay/data/VoicePreferences.kt

@@ -344,6 +344,46 @@ class VoicePreferencesRepository(private val dataStore: DataStore<Preferences>)
         dataStore.edit { it[key] = route.storageValue }
     }
 
+    /**
+     * Clear Relay-only selections after Relay has been explicitly removed from
+     * the active connection. A temporarily unreachable configured Relay must
+     * not call this: preserving the selection lets the richer route resume
+     * when connectivity returns.
+     *
+     * [expectedScope] fences profile/connection changes that can race the
+     * DataStore edit. Values are re-read inside the transaction instead of
+     * trusting an earlier settings snapshot, so a newer user choice wins.
+     * The legacy default-profile keys are global (their storage names predate
+     * connection scoping), so they are never rewritten here: runtime fallback
+     * handles an unpaired default profile without changing another
+     * connection's selection.
+     */
+    suspend fun reconcileRelayRemoval(expectedScope: VoiceProfileScope): Boolean {
+        if (_scope.value != expectedScope || expectedScope.profileName == null) return false
+        var changed = false
+        dataStore.edit { prefs ->
+            if (_scope.value != expectedScope) return@edit
+
+            val engine = VoiceEngineMode.fromStorage(
+                resolveString(prefs, KEY_ENGINE_MODE, expectedScope, DEFAULT_ENGINE_MODE),
+            )
+            val route = VoiceAudioRoute.fromStorage(
+                resolveString(prefs, KEY_AUDIO_ROUTE, expectedScope, DEFAULT_AUDIO_ROUTE),
+            )
+            if (engine == VoiceEngineMode.RealtimeAgent) {
+                prefs[stringPreferencesKey(scopedName(KEY_ENGINE_MODE, expectedScope))] =
+                    VoiceEngineMode.HermesVoiceOutput.storageValue
+                changed = true
+            }
+            if (route == VoiceAudioRoute.Relay) {
+                prefs[stringPreferencesKey(scopedName(KEY_AUDIO_ROUTE, expectedScope))] =
+                    VoiceAudioRoute.Auto.storageValue
+                changed = true
+            }
+        }
+        return changed
+    }
+
     /** "" clears the override (relay falls back to the server's saved voice). */
     suspend fun setEnhancedVoice(voice: String) {
         val key = stringPreferencesKey(scopedName(KEY_ENH_VOICE, _scope.value))

app/src/main/kotlin/com/hermesandroid/relay/network/relay/BridgeCommandHandler.kt

@@ -348,7 +348,7 @@ class BridgeCommandHandler(
      * the multiplexer. The two paths are fully independent.
      *
      * Caught by Bailey's on-device test 2026-04-14 — see the v0.4.1
-     * "voice intent local dispatch loop" entry in ROADMAP.md.
+     * "voice intent local dispatch loop" entry in docs/project/ROADMAP.md.
      */
     suspend fun handleLocalCommand(envelope: Envelope): LocalDispatchResult {
         if (envelope.type != "bridge.command") {

app/src/main/kotlin/com/hermesandroid/relay/network/relay/RelayHttpClient.kt

@@ -28,6 +28,7 @@ import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.RequestBody.Companion.toRequestBody
 import java.io.IOException
+import java.io.ByteArrayOutputStream
 
 internal const val RELAY_SESSION_HEADER: String = "X-Hermes-Relay-Session"
 
@@ -88,6 +89,7 @@ class RelayHttpClient(
 
     companion object {
         private const val TAG = "RelayHttpClient"
+        private const val DEFAULT_MEDIA_DOWNLOAD_LIMIT_BYTES = 100L * 1024L * 1024L
         const val MAX_MODEL_CAPABILITY_ROWS = 64
         private const val MAX_MODEL_CAPABILITY_PROVIDER_CHARS = 128
         private const val MAX_MODEL_CAPABILITY_MODEL_CHARS = 512
@@ -257,7 +259,10 @@ class RelayHttpClient(
      * underlying exception with a human-readable message suitable for
      * surfacing in the attachment's `errorMessage` field.
      */
-    suspend fun fetchMedia(token: String): Result<FetchedMedia> = withContext(Dispatchers.IO) {
+    suspend fun fetchMedia(
+        token: String,
+        maxBytes: Long = DEFAULT_MEDIA_DOWNLOAD_LIMIT_BYTES,
+    ): Result<FetchedMedia> = withContext(Dispatchers.IO) {
         val relayUrl = relayUrlProvider()?.trim().orEmpty()
         if (relayUrl.isEmpty()) {
             return@withContext Result.failure(
@@ -318,7 +323,7 @@ class RelayHttpClient(
                 if (body == null) {
                     return@withContext Result.failure(IOException("Empty response body"))
                 }
-                val bytes = body.bytes()
+                val bytes = body.readBytesBounded(maxBytes)
                 Result.success(FetchedMedia(contentType, bytes, fileName, sensitive))
             }
         } catch (e: IOException) {
@@ -352,6 +357,7 @@ class RelayHttpClient(
     suspend fun fetchMediaByPath(
         path: String,
         contentTypeHint: String? = null,
+        maxBytes: Long = DEFAULT_MEDIA_DOWNLOAD_LIMIT_BYTES,
     ): Result<FetchedMedia> = withContext(Dispatchers.IO) {
         val relayUrl = relayUrlProvider()?.trim().orEmpty()
         if (relayUrl.isEmpty()) {
@@ -427,12 +433,16 @@ class RelayHttpClient(
                 if (body == null) {
                     return@withContext Result.failure(IOException("Empty response body"))
                 }
-                val bytes = body.bytes()
+                val bytes = body.readBytesBounded(maxBytes)
                 Result.success(FetchedMedia(contentType, bytes, fileName, sensitive))
             }
         } catch (e: IOException) {
             Log.w(TAG, "fetchMediaByPath failed for $path: ${e.message}")
-            Result.failure(IOException("Relay unreachable: ${e.message ?: "IO error"}"))
+            if (e is RelayMediaLimitException) {
+                Result.failure(e)
+            } else {
+                Result.failure(IOException("Relay unreachable: ${e.message ?: "IO error"}"))
+            }
         } catch (e: Exception) {
             Log.w(TAG, "fetchMediaByPath unexpected error for $path: ${e.message}")
             Result.failure(e)
@@ -1456,6 +1466,33 @@ class RelayHttpClient(
         return match?.groupValues?.get(1)?.trim()?.ifBlank { null }
     }
 
+    private fun okhttp3.ResponseBody.readBytesBounded(maxBytes: Long): ByteArray {
+        if (maxBytes <= 0L) throw RelayMediaLimitException()
+        val declared = contentLength().takeIf { it >= 0L }
+        if (declared != null && declared > maxBytes) throw RelayMediaLimitException()
+        val output = ByteArrayOutputStream(
+            declared?.coerceAtMost(Int.MAX_VALUE.toLong())?.toInt() ?: DEFAULT_BUFFER_SIZE,
+        )
+        byteStream().use { input ->
+            val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+            var total = 0L
+            while (true) {
+                val count = input.read(buffer)
+                if (count < 0) break
+                total += count
+                if (total > maxBytes) throw RelayMediaLimitException()
+                output.write(buffer, 0, count)
+            }
+            if (declared != null && total != declared) {
+                throw IOException("Media file changed while it was being downloaded")
+            }
+        }
+        return output.toByteArray()
+    }
+
+    private class RelayMediaLimitException :
+        IOException("File exceeds the configured download limit")
+
     /**
      * Parse the relay's `X-Media-Sensitive` response header into a bool.
      *
@@ -1468,7 +1505,7 @@ class RelayHttpClient(
         return value == "1" || value == "true"
     }
 
-    /** Provider-neutral compatibility fetch for gateways without `account.usage`. */
+    /** Provider-neutral enhancement for pools and providers upstream does not expose. */
     suspend fun fetchProviderUsage(
         profile: String? = null,
         sessionId: String? = null,

app/src/main/kotlin/com/hermesandroid/relay/network/shared/EndpointResolver.kt

@@ -149,7 +149,10 @@ class EndpointResolver(
     )
 
     private val probeCache = ConcurrentHashMap<String, CacheEntry>()
-    private val inFlightProbes = ConcurrentHashMap<String, Deferred<Boolean>>()
+    // Every access is owned by [probeStateLock]. This must not be a
+    // concurrently-mutated collection: clearCache() takes a stable snapshot
+    // while completion callbacks remove finished probes.
+    private val inFlightProbes = mutableMapOf<String, Deferred<Boolean>>()
     private val probeScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
     private val probeStateLock = Any()
     private var probeGeneration = 0L
@@ -486,7 +489,13 @@ class EndpointResolver(
                     probe(candidate, surface, generation)
                 }.also { deferred ->
                     inFlightProbes[key] = deferred
-                    deferred.invokeOnCompletion { inFlightProbes.remove(key, deferred) }
+                    deferred.invokeOnCompletion {
+                        synchronized(probeStateLock) {
+                            // Identity-aware removal prevents an invalidated
+                            // probe from removing its fresh replacement.
+                            inFlightProbes.remove(key, deferred)
+                        }
+                    }
                     deferred.start()
                 }
             }

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/ChatHandler.kt

@@ -13,6 +13,7 @@ import com.hermesandroid.relay.data.MessageRole
 import com.hermesandroid.relay.data.MoaReference
 import com.hermesandroid.relay.data.RealtimeTurnTrace
 import com.hermesandroid.relay.data.ToolCall
+import com.hermesandroid.relay.data.isImageGenerationToolName
 import com.hermesandroid.relay.data.VoiceIntentTrace
 import com.hermesandroid.relay.network.shared.LocalDispatchResult
 import com.hermesandroid.relay.network.upstream.models.MessageItem
@@ -1450,6 +1451,12 @@ class ChatHandler {
         val loaded = renderedItems.mapNotNull { item ->
             val displayKind = item.displayKind?.trim()?.lowercase()
             if (displayKind == "hidden") return@mapNotNull null
+            val activitySourceId = if (displayKind == "async_delegation_complete") {
+                item.displayMetadata.stringField("delegation_id")?.let { "delegation:$it" }
+                    ?: "unavailable:${item.id}"
+            } else null
+            val activityTaskCount = if (activitySourceId != null) item.displayMetadata.intField("task_count") else null
+            val activityFailedCount = if (activitySourceId != null) item.displayMetadata.intField("failed_count") else null
             val role = when {
                 displayKind == "model_switch" ||
                     displayKind == "async_delegation_complete" ||
@@ -1499,11 +1506,13 @@ class ChatHandler {
 
             // Run the media marker parser on assistant content; strip matched
             // lines and queue hits for post-assignment dispatch.
+            val messageMediaHits = mutableListOf<Pair<String, MediaMarkerHit>>()
             val afterMedia = if (role == MessageRole.ASSISTANT && persistedImages.cleanedText.isNotEmpty()) {
-                extractMediaMarkersFromContent(messageId, persistedImages.cleanedText, pendingMediaHits)
+                extractMediaMarkersFromContent(messageId, persistedImages.cleanedText, messageMediaHits)
             } else {
                 persistedImages.cleanedText
             }
+            pendingMediaHits += messageMediaHits
 
             // Cards are synchronous (no async fetch) so we attach them
             // straight onto the reconstructed ChatMessage and strip their
@@ -1537,15 +1546,34 @@ class ChatHandler {
             val prior = priorById[messageId]
             // Outbound attachments: prefer an id-match (covers any future
             // user-message id reconciliation), else fall back to the
-            // content-keyed queue. Inbound attachments are intentionally
-            // excluded — they come back via the marker re-dispatch.
+            // content-keyed queue. Exact inbound marker attachments are also
+            // carried by id: a history refresh must not replace a successfully
+            // loaded image/file with a fresh LOADING placeholder. A process
+            // restart has no prior attachment, so the marker still dispatches
+            // normally and rehydrates it. One additional narrow exception
+            // retains a completed image_generate result when the immediate
+            // post-turn history read still lacks its MEDIA marker.
             val carriedAttachments = run {
                 val persistedImagePaths = persistedImages.paths.toHashSet()
+                val persistedMediaKeys = messageMediaHits.mapTo(HashSet()) { (_, hit) ->
+                    when (hit) {
+                        is MediaMarkerHit.RelayToken -> hit.token
+                        is MediaMarkerHit.BarePath -> hit.path
+                    }
+                }
+                val priorGeneratedImage = prior?.toolCalls.orEmpty().any { tool ->
+                    isImageGenerationToolName(tool.name) &&
+                        tool.isComplete && tool.success != false
+                }
                 val byId = prior?.attachments.orEmpty().filter { attachment ->
                     attachment.relayToken == null ||
+                        attachment.relayToken in persistedMediaKeys ||
+                        (role == MessageRole.USER && attachment.relayToken in persistedImagePaths) ||
                         (
-                            role == MessageRole.USER &&
-                                attachment.relayToken in persistedImagePaths
+                            role == MessageRole.ASSISTANT &&
+                                priorGeneratedImage &&
+                                attachment.isImage &&
+                                messageMediaHits.isEmpty()
                             )
                 }
                 when {
@@ -1589,6 +1617,9 @@ class ChatHandler {
                 // this as the same visible row across the post-turn reload.
                 prior.copy(
                     id = messageId,
+                    activitySourceId = activitySourceId,
+                    activityTaskCount = activityTaskCount,
+                    activityFailedCount = activityFailedCount,
                     rowId = item.resolvedRowId,
                     reactions = item.reactions,
                     role = role,
@@ -1621,6 +1652,9 @@ class ChatHandler {
                 // nothing local to carry).
                 ChatMessage(
                     id = messageId,
+                    activitySourceId = activitySourceId,
+                    activityTaskCount = activityTaskCount,
+                    activityFailedCount = activityFailedCount,
                     rowId = item.resolvedRowId,
                     reactions = item.reactions,
                     role = role,
@@ -1695,15 +1729,27 @@ class ChatHandler {
                 is MediaMarkerHit.RelayToken -> {
                     val dedupeKey = "$messageId:relay:${hit.token}"
                     if (dispatchedMediaMarkers.add(dedupeKey)) {
-                        Log.d(TAG, "Media marker accepted from reloaded Relay history")
-                        onMediaAttachmentRequested(messageId, hit.token)
+                        val alreadyHydrated = _messages.value
+                            .firstOrNull { it.matchesIdentity(messageId) }
+                            ?.attachments
+                            ?.any { it.relayToken == hit.token } == true
+                        if (!alreadyHydrated) {
+                            Log.d(TAG, "Media marker accepted from reloaded Relay history")
+                            onMediaAttachmentRequested(messageId, hit.token)
+                        }
                     }
                 }
                 is MediaMarkerHit.BarePath -> {
                     val dedupeKey = "$messageId:bare:${hit.path}"
                     if (dispatchedMediaMarkers.add(dedupeKey)) {
-                        Log.d(TAG, "Media marker (bare-path, reload): ${hit.path}")
-                        onMediaBarePathRequested(messageId, hit.path)
+                        val alreadyHydrated = _messages.value
+                            .firstOrNull { it.matchesIdentity(messageId) }
+                            ?.attachments
+                            ?.any { it.relayToken == hit.path } == true
+                        if (!alreadyHydrated) {
+                            Log.d(TAG, "Media marker (bare-path, reload): ${hit.path}")
+                            onMediaBarePathRequested(messageId, hit.path)
+                        }
                     }
                 }
             }

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/DashboardApiClient.kt

@@ -29,6 +29,7 @@ import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonNull
 import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.booleanOrNull
 import kotlinx.serialization.json.buildJsonObject
@@ -49,6 +50,7 @@ import okhttp3.Request
 import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
+import java.io.ByteArrayOutputStream
 import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
@@ -293,6 +295,34 @@ internal fun copyBounded(
     return written
 }
 
+internal fun copyMediaBounded(
+    input: InputStream,
+    output: OutputStream,
+    declaredLength: Long?,
+    limitBytes: Long,
+): Long {
+    require(limitBytes > 0)
+    require(declaredLength == null || declaredLength >= 0)
+    if (declaredLength != null && declaredLength > limitBytes) {
+        throw IOException("File exceeds the configured download limit")
+    }
+    val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+    var written = 0L
+    while (true) {
+        val read = input.read(buffer)
+        if (read < 0) break
+        written += read
+        if (written > limitBytes) {
+            throw IOException("File exceeds the configured download limit")
+        }
+        output.write(buffer, 0, read)
+    }
+    if (declaredLength != null && written != declaredLength) {
+        throw IOException("Media file changed while it was being downloaded")
+    }
+    return written
+}
+
 /** One entry from `GET /api/audio/elevenlabs/voices` — non-secret voice metadata. */
 data class ElevenLabsVoice(
     val voiceId: String,
@@ -310,6 +340,19 @@ data class ElevenLabsVoices(
     val voices: List<ElevenLabsVoice>,
 )
 
+/**
+ * Metadata for a file streamed from upstream's authenticated managed-files surface.
+ *
+ * The Dashboard applies its own managed-root, sensitive-file, and maximum-size
+ * policy before the file leaves the Hermes host. Android applies the user's
+ * stricter inbound-media cap while reading the response as a second boundary.
+ */
+data class DashboardFetchedFile(
+    val sizeBytes: Long,
+    val contentType: String,
+    val fileName: String?,
+)
+
 /**
  * Native client for the Hermes dashboard/admin server (:9119).
  *
@@ -381,6 +424,58 @@ class DashboardApiClient(
         executeJsonElement(request, normalized)
     }
 
+    /**
+     * Download a server-local artifact through current upstream Hermes.
+     *
+     * This is the same authenticated `/api/files/download` route official
+     * Desktop uses for remote gateway files. The caller supplies its display
+     * cap so a malicious or stale Content-Length cannot cause an unbounded
+     * allocation. The supplied output is normally Android's on-disk media cache;
+     * local playback supplies seeking, so `/api/files/stream` is unnecessary
+     * on this path.
+     */
+    suspend fun downloadManagedFile(
+        serverPath: String,
+        maxBytes: Long,
+        output: OutputStream,
+    ): Result<DashboardFetchedFile> = withContext(Dispatchers.IO) {
+        if (serverPath.isBlank()) {
+            return@withContext Result.failure(IOException("Media path is empty"))
+        }
+        if (maxBytes <= 0L) {
+            return@withContext Result.failure(IOException("Media download limit is invalid"))
+        }
+        val httpUrl = resolveUrl("/api/files/download")
+            ?.newBuilder()
+            ?.addQueryParameter("path", serverPath)
+            ?.build()
+            ?: return@withContext Result.failure(invalidUrlException())
+        val request = Request.Builder().url(httpUrl).get().build()
+
+        executeCancellable(request, "Dashboard media download") { response ->
+            val body = response.body
+            val declaredLength = body.contentLength().takeIf { it >= 0L }
+            if (declaredLength != null && declaredLength > maxBytes) {
+                throw IOException("File exceeds the configured download limit")
+            }
+            val readTotal = body.byteStream().use { input ->
+                copyMediaBounded(input, output, declaredLength, maxBytes)
+            }
+            DashboardFetchedFile(
+                sizeBytes = readTotal,
+                contentType = response.header("Content-Type")
+                    ?.substringBefore(';')
+                    ?.trim()
+                    ?.takeIf(String::isNotEmpty)
+                    ?: "application/octet-stream",
+                fileName = response.header("Content-Disposition")
+                    ?.let(::contentDispositionFileName)
+                    ?: serverPath.substringAfterLast('/').substringAfterLast('\\')
+                        .takeIf(String::isNotBlank),
+            )
+        }
+    }
+
     suspend fun postJsonObject(
         path: String,
         payload: JsonObject = JsonObject(emptyMap()),
@@ -1262,7 +1357,7 @@ class DashboardApiClient(
     suspend fun getSessionMessages(
         sessionId: String,
         profile: String? = null,
-        mode: SessionMessageLoadMode = SessionMessageLoadMode.COMPLETE,
+        mode: SessionMessageLoadMode = SessionMessageLoadMode.LATEST,
     ): Result<List<MessageItem>> = withContext(Dispatchers.IO) {
         val name = profile?.trim().orEmpty()
         loadSessionMessages(mode) { page ->
@@ -1412,7 +1507,7 @@ class DashboardApiClient(
             val patched = buildJsonObject {
                 obj.forEach { (k, v) -> put(k, v) }
                 if (obj["name"] == null && !nameOverride.isNullOrBlank()) put("name", nameOverride)
-                if (obj["model"] == null) put("model", "")
+                if (obj["model"] == null || obj["model"] == JsonNull) put("model", "")
             }
             json.decodeFromJsonElement(Profile.serializer(), patched)
         }.getOrNull()
@@ -1431,10 +1526,14 @@ class DashboardApiClient(
         password: String,
         next: String = "/",
     ): Result<DashboardLoginResponse> = withContext(Dispatchers.IO) {
+        // Match the Dashboard's single-line HTML username/password controls:
+        // remove only forbidden line breaks and preserve every other code point.
+        val normalizedUsername = username.replace("\r", "").replace("\n", "")
+        val normalizedPassword = password.replace("\r", "").replace("\n", "")
         val payload = buildJsonObject {
             put("provider", provider)
-            put("username", username)
-            put("password", password)
+            put("username", normalizedUsername)
+            put("password", normalizedPassword)
             put("next", next)
         }
         val httpUrl = resolveUrl("/auth/password-login")
@@ -1666,6 +1765,7 @@ class DashboardApiClient(
         // Mirrors current upstream `_MANAGED_FILE_MAX_BYTES`; enforcing it
         // client-side avoids uploading a body the Dashboard will reject.
         internal const val MAX_BACKUP_TRANSFER_BYTES = 100L * 1024L * 1024L
+        internal const val MAX_JSON_RESPONSE_BYTES = 8L * 1024L * 1024L
 
         fun pathSegment(value: String): String =
             URLEncoder.encode(value, "UTF-8").replace("+", "%20")
@@ -2394,17 +2494,61 @@ data class StoredDashboardCookie(
 }
 
 private fun Response.readJsonObject(json: Json): JsonObject {
-    val raw = body.string()
+    val raw = body.readUtf8Bounded(DashboardApiClient.MAX_JSON_RESPONSE_BYTES)
     if (raw.isBlank()) return JsonObject(emptyMap())
     return json.parseToJsonElement(raw).jsonObject
 }
 
 private fun Response.readJsonElement(json: Json): JsonElement {
-    val raw = body.string()
+    val raw = body.readUtf8Bounded(DashboardApiClient.MAX_JSON_RESPONSE_BYTES)
     if (raw.isBlank()) return JsonObject(emptyMap())
     return json.parseToJsonElement(raw)
 }
 
+internal fun okhttp3.ResponseBody.readUtf8Bounded(maxBytes: Long): String {
+    require(maxBytes in 1..Int.MAX_VALUE.toLong()) { "Invalid response byte limit" }
+    val declaredLength = contentLength()
+    if (declaredLength > maxBytes) {
+        throw IOException("Dashboard response exceeds Android's bounded JSON limit")
+    }
+    val initialSize = when {
+        declaredLength in 1..maxBytes -> declaredLength.toInt()
+        else -> minOf(maxBytes, DEFAULT_BUFFER_SIZE.toLong()).toInt()
+    }
+    val output = ByteArrayOutputStream(initialSize)
+    byteStream().use { input ->
+        val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+        var total = 0L
+        while (true) {
+            val read = input.read(buffer)
+            if (read < 0) break
+            total += read
+            if (total > maxBytes) {
+                throw IOException("Dashboard response exceeds Android's bounded JSON limit")
+            }
+            output.write(buffer, 0, read)
+        }
+    }
+    return output.toString(Charsets.UTF_8.name())
+}
+
+private fun contentDispositionFileName(header: String): String? {
+    val encoded = Regex("""filename\*=UTF-8''([^;]+)""", RegexOption.IGNORE_CASE)
+        .find(header)
+        ?.groupValues
+        ?.getOrNull(1)
+        ?.let { runCatching { java.net.URLDecoder.decode(it, "UTF-8") }.getOrNull() }
+    val plain = Regex("""filename=\"([^\"]+)\"|filename=([^;]+)""", RegexOption.IGNORE_CASE)
+        .find(header)
+        ?.let { it.groupValues[1].ifBlank { it.groupValues[2] } }
+        ?.trim()
+        ?.trim('"')
+    return (encoded ?: plain)
+        ?.substringAfterLast('/')
+        ?.substringAfterLast('\\')
+        ?.takeIf(String::isNotBlank)
+}
+
 internal class DashboardHttpException(
     val statusCode: Int,
     message: String,
@@ -2436,14 +2580,11 @@ internal fun Throwable.isDashboardSignInRequiredFailure(): Boolean {
         java.util.IdentityHashMap<Throwable, Boolean>(),
     )
     while (current != null && seen.add(current)) {
-        if (
-            current is DashboardHttpException &&
-            current.statusCode == 401 &&
-            (
-                current.message.orEmpty().contains("no_cookie", ignoreCase = true) ||
-                    current.message.orEmpty().contains("unauthenticated", ignoreCase = true)
-                )
-        ) {
+        // Every 401 from an authenticated Dashboard route means the saved
+        // browser/native session can no longer authorize this request. Older
+        // gateways used `no_cookie`/`unauthenticated`; current builds may return
+        // reason codes such as `session_expired`, or no structured body at all.
+        if (current is DashboardHttpException && current.statusCode == 401) {
             return true
         }
         current = current.cause
@@ -2451,8 +2592,39 @@ internal fun Throwable.isDashboardSignInRequiredFailure(): Boolean {
     return false
 }
 
+/** True only when the managed-file route itself is absent on this Hermes build. */
+internal fun Throwable.isDashboardManagedFilesUnsupported(): Boolean {
+    var current: Throwable? = this
+    val seen = java.util.Collections.newSetFromMap(
+        java.util.IdentityHashMap<Throwable, Boolean>(),
+    )
+    while (current != null && seen.add(current)) {
+        if (current is DashboardHttpException) {
+            if (current.statusCode in setOf(405, 501)) return true
+            if (current.statusCode == 404) {
+                val detail = current.message.orEmpty()
+                // FastAPI's missing-route response is the generic "Not Found".
+                // A real managed-file miss says "File not found" and must not
+                // silently escape to Relay's broader path policy.
+                val isManagedFileMiss = detail.contains("File not found", ignoreCase = true) ||
+                    detail.contains("Path not found", ignoreCase = true)
+                val isGenericRouteMiss = detail.trim().endsWith(": not found", ignoreCase = true) ||
+                    detail.contains("\"detail\":\"Not Found\"", ignoreCase = true) ||
+                    detail.contains("\"detail\": \"Not Found\"", ignoreCase = true)
+                if (!isManagedFileMiss && isGenericRouteMiss) return true
+            }
+        }
+        current = current.cause
+    }
+    return false
+}
+
 private fun apiFailure(response: Response, operation: String): IOException {
-    val bodyDetail = runCatching { response.body.string() }.getOrDefault("")
+    val bodyDetail = try {
+        response.body.readUtf8Bounded(4L * 1024L)
+    } catch (_: Exception) {
+        ""
+    }
     val detail = bodyDetail.take(240).ifBlank { response.message }
     return DashboardHttpException(
         statusCode = response.code,

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/GatewayChatClient.kt

@@ -119,6 +119,10 @@ class GatewayChatClient(
     private val promptSubmitTimeoutMs: Long = PROMPT_SUBMIT_REQUEST_TIMEOUT_MS,
     /** Test seam — idle-progress watchdog base. Production keeps [TURN_TIMEOUT_MS]. */
     private val turnIdleTimeoutMs: Long = TURN_TIMEOUT_MS,
+    /** Test seam — lazy session.create/resume readiness barrier. */
+    private val sessionReadyTimeoutMs: Long = SESSION_READY_TIMEOUT_MS,
+    /** Test seam — compaction idle lease. Production keeps [COMPACTING_TIMEOUT_MS]. */
+    private val compactingTimeoutMs: Long = COMPACTING_TIMEOUT_MS,
     /** Random source for ordinary reconnect full-jitter. */
     private val reconnectJitterUnit: () -> Double = { kotlin.random.Random.nextDouble() },
 ) : GatewayProfileEditorClient {
@@ -159,6 +163,19 @@ class GatewayChatClient(
         private const val ASK_SUDO_TIMEOUT_MS = 150_000L
         private const val ASK_UNBOUNDED_TIMEOUT_MS = 600_000L
 
+        /**
+         * Server-side context compaction summarizes the transcript through a
+         * (possibly slow) model with NO deltas or tool events flowing until it
+         * finishes — near the context ceiling that silence routinely exceeds
+         * [TURN_TIMEOUT_MS], so the idle watchdog would `session.interrupt` a
+         * healthy compression, roll back its work, and retrigger on the next
+         * prompt forever. A `status.update` event with kind `compacting`
+         * (emitted at compaction start, and periodically by newer gateways)
+         * arms this longer leash instead; any regular event rearms
+         * [TURN_TIMEOUT_MS].
+         */
+        private const val COMPACTING_TIMEOUT_MS = 600_000L
+
         private const val RPC_TIMEOUT_MS = 15_000L
         const val PROFILE_AVATAR_MAX_BYTES = 2_000_000
 
@@ -176,6 +193,7 @@ class GatewayChatClient(
          * would have been abandoned server-side anyway.
          */
         private const val PROMPT_SUBMIT_REQUEST_TIMEOUT_MS = 1_800_000L
+        private const val SESSION_READY_TIMEOUT_MS = 300_000L
         private const val CONNECT_TIMEOUT_MS = 20_000L
 
         /**
@@ -263,7 +281,7 @@ class GatewayChatClient(
         .newBuilder()
         // The 10s default connectTimeout is LAN-tuned; a remote dashboard
         // reached over Tailscale (DERP cold start) can take longer to complete
-        // the WS upgrade. A failed connect drops chat to the SSE fallback and a
+        // the WS upgrade. A failed connect leaves Android on its Gateway owner and a
         // 5s cooldown, so give the first remote handshake room.
         .connectTimeout(20, TimeUnit.SECONDS)
         .pingInterval(30, TimeUnit.SECONDS)
@@ -384,12 +402,24 @@ class GatewayChatClient(
     private val _serverProject = MutableStateFlow<GatewaySessionProject?>(null)
     val serverProject: StateFlow<GatewaySessionProject?> = _serverProject.asStateFlow()
 
+    /**
+     * Exact model-callable tool names from upstream `session.info.tools` for
+     * the selected live session/profile. Null means the gateway has not
+     * supplied a catalog; an empty set means it authoritatively supplied none.
+     */
+    private val _serverTools = MutableStateFlow<Set<String>?>(null)
+    val serverTools: StateFlow<Set<String>?> = _serverTools.asStateFlow()
+
     /** Serializes connect / session-establish so concurrent sends share one socket. */
     private val connectMutex = Mutex()
 
     @Volatile
     private var webSocket: WebSocket? = null
 
+    /** Profile explicitly routed by the Dashboard `/api/ws?profile=` handshake. */
+    @Volatile
+    private var connectedSocketProfile: String? = null
+
     /** Completed when the server's `gateway.ready` event arrives for the current socket. */
     @Volatile
     private var readySignal: CompletableDeferred<Unit>? = null
@@ -398,6 +428,12 @@ class GatewayChatClient(
     /** Invalidates an older async prewarm when a newer session selection wins. */
     private val prewarmRequestGeneration = AtomicLong(0)
     private val pendingRpcs = ConcurrentHashMap<Long, CompletableDeferred<JsonObject>>()
+    private val lazyLiveSessions = ConcurrentHashMap.newKeySet<String>()
+    private val readyLiveSessions = ConcurrentHashMap.newKeySet<String>()
+    private val sessionReadyWaiters = ConcurrentHashMap<String, CompletableDeferred<Unit>>()
+    private val sessionReadyFailures = ConcurrentHashMap<String, String>()
+    private val _preparingSessionId = MutableStateFlow<String?>(null)
+    val preparingSessionId: StateFlow<String?> = _preparingSessionId.asStateFlow()
 
     /** Monotonic client-local fence for lazy child watch open/close races. */
     private val childWatchGeneration = AtomicLong(0)
@@ -548,6 +584,28 @@ class GatewayChatClient(
         val terminalRequired: Boolean,
     )
 
+    /**
+     * One exact turn settled from authoritative session state may still receive
+     * the terminal frame that was already in flight. Consume only that terminal
+     * so it cannot be reported as a second unmatched completion. A subsequent
+     * message.start clears the drain because it establishes the next turn on
+     * the same live runtime.
+     */
+    @Volatile
+    private var settledTurnDrain: SettledTurnDrain? = null
+
+    private data class SettledTurnDrain(
+        val storedSessionId: String,
+        val liveSessionId: String,
+    )
+
+    private data class ActiveTurnLivenessProbe(
+        val turn: GatewayTurn,
+        val storedSessionId: String,
+        val liveSessionId: String,
+        val progressGeneration: Long,
+    )
+
     /**
      * Creates UI callbacks when the server starts a turn that has no matching
      * [sendTurn] call (for example a background-process completion). The
@@ -578,6 +636,13 @@ class GatewayChatClient(
     @Volatile
     private var processEventListener: ((GatewayProcessEvent) -> Unit)? = null
 
+    @Volatile
+    private var subagentEventListener: ((String, String?, GatewaySubagentEvent) -> Unit)? = null
+
+    fun setSubagentEventListener(listener: ((String, String?, GatewaySubagentEvent) -> Unit)?) {
+        subagentEventListener = listener
+    }
+
     /** Process-wide durable-session invalidation/liveness edge. */
     @Volatile
     private var sessionDirectoryInvalidationListener: (() -> Unit)? = null
@@ -677,6 +742,7 @@ class GatewayChatClient(
     ): ActiveTurnHandle {
         val turn = GatewayTurn(
             callbacks = dispatchOn(callbacks),
+            androidOwned = true,
             onTransportAccepted = onTransportAccepted,
         )
         // Warm = the connection-establish phases are skipped this turn (socket
@@ -724,6 +790,10 @@ class GatewayChatClient(
                     cleanupStagedAttachments(stagedImagePaths)
                     return@launch
                 }
+                // A newly accepted Android send is a distinct generation on
+                // this runtime. Its terminal must never be consumed by the
+                // prior turn's optional late-terminal drain.
+                settledTurnDrain = null
                 activeTurn = turn
                 turn.armWatchdog()
                 // Generic `file.attach` uploads are staged artifacts, not
@@ -758,7 +828,7 @@ class GatewayChatClient(
                     // Once this turn's own events are flowing (or it already
                     // finished), the prompt provably reached the server — a
                     // slow, lost, or socket-severed ack must NOT preflight-fail
-                    // into the SSE fallback, which would resubmit the same
+                    // into a second transport, which would resubmit the same
                     // prompt as a duplicate turn. Recovery belongs to the
                     // stream: the watchdog and mid-turn rejoin own it.
                     if (turn.started || turn.ended || turn.transportRecoveryStarted) {
@@ -782,7 +852,7 @@ class GatewayChatClient(
                         // through the normal failed-turn callback instead.
                         cleanupStagedAttachments(stagedImagePaths)
                         turn.tracer.done("submit-rejected")
-                        turn.callbacks.onError(
+                        turn.callbacks.onSubmitRejected(
                             submitError?.message ?: "Hermes rejected the new session",
                         )
                         return@launch
@@ -849,7 +919,11 @@ class GatewayChatClient(
         liveSessionId = null
         storedSessionId = null
         liveSessionProfile = null
+        failSessionReadyWaiters("gateway session cleared")
+        lazyLiveSessions.clear()
+        readyLiveSessions.clear()
         cancelledTurnDrain = null
+        _serverTools.value = null
     }
 
     /**
@@ -1363,6 +1437,7 @@ class GatewayChatClient(
                     callbacks = dispatchOn(callbacks),
                     dedupeAdjacentMessageStarts = true,
                     deferEvents = true,
+                    androidOwned = true,
                 ).also { turn ->
                     turn.markRecoveredStarted()
                     activeTurn = turn
@@ -1486,6 +1561,7 @@ class GatewayChatClient(
                     boundTurn = GatewayTurn(
                         callbacks = dispatchOn(callbacks),
                         dedupeAdjacentMessageStarts = true,
+                        androidOwned = true,
                     ).also { turn ->
                         turn.markRecoveredStarted()
                         activeTurn = turn
@@ -1497,7 +1573,10 @@ class GatewayChatClient(
                         .orEmpty()
                         .also { recoveryEvents = null }
                 }
-                buffered.forEach { event -> boundTurn?.onEvent(event.type, event.payload) }
+                buffered.forEach { event ->
+                    dispatchSubagentEvent(event.type, event.payload, event.sessionId)
+                    boundTurn.onEvent(event.type, event.payload)
+                }
                 queued?.let { queuedTurn ->
                     queuedTurnProvider?.invoke(queuedTurn)?.let { registration ->
                         boundTurn.installQueuedSuccessor(registration)
@@ -1519,6 +1598,7 @@ class GatewayChatClient(
                     val queuedTurn = GatewayTurn(
                         callbacks = dispatchOn(registration.callbacks),
                         dedupeAdjacentMessageStarts = true,
+                        androidOwned = true,
                     )
                     // recoverTurn is resumed on its caller's coroutine context;
                     // ChatViewModel calls it from Main, so this admission runs
@@ -1765,18 +1845,17 @@ class GatewayChatClient(
     }
 
     /**
-     * Provider-neutral account limits owned by upstream Hermes. Current hosts
-     * may not expose this additive method yet; callers should treat JSON-RPC
-     * method-not-found as capability absence and use the optional Relay
-     * compatibility surface when paired.
+     * Official upstream Nous usage bars. Current hosts may not expose this
+     * additive method yet; callers should treat JSON-RPC method-not-found as
+     * capability absence and use the optional Relay enhancement when paired.
      */
-    suspend fun providerUsage(): Result<JsonObject> {
+    suspend fun usageBars(): Result<JsonObject> {
         try {
             connectMutex.withLock { ensureConnected() }
         } catch (e: Exception) {
             return Result.failure(e)
         }
-        return rpc("account.usage", JsonObject(emptyMap()))
+        return rpc("usage.bars", JsonObject(emptyMap()))
     }
 
     /**
@@ -1834,6 +1913,7 @@ class GatewayChatClient(
                     model = row.stringField("model").orEmpty(),
                     provider = row.stringField("provider").orEmpty(),
                     description = row.stringField("description").orEmpty(),
+                    displayName = row.stringField("display_name").orEmpty(),
                     skillCount = (row["skill_count"] as? JsonPrimitive)?.intOrNull ?: 0,
                     isDefault = (row["is_default"] as? JsonPrimitive)?.booleanOrNull ?: false,
                     hasAvatar = (row["has_avatar"] as? JsonPrimitive)?.booleanOrNull ?: false,
@@ -2414,6 +2494,7 @@ class GatewayChatClient(
         } catch (error: Exception) {
             return GatewayActiveSessionsResult.TransientFailure(error)
         }
+        val livenessProbe = captureActiveTurnLivenessProbe()
         val result = rpc(
             "session.active_list",
             buildJsonObject {
@@ -2433,12 +2514,58 @@ class GatewayChatClient(
             val payload = result.getOrThrow()
             val rows = payload["sessions"] as? JsonArray
                 ?: throw GatewayRpcException("session.active_list returned no sessions array")
-            GatewayActiveSessionsResult.Success(rows.map(::parseGatewayActiveSession))
+            val sessions = rows.map(::parseGatewayActiveSession)
+            reconcileActiveTurnFromSnapshot(livenessProbe, sessions)
+            GatewayActiveSessionsResult.Success(sessions)
         } catch (parseError: Exception) {
             GatewayActiveSessionsResult.TransientFailure(parseError)
         }
     }
 
+    /**
+     * Capture only a locally submitted/recovered turn. Merely observing an
+     * exact session through the shared Gateway socket never grants Android
+     * authority to settle Desktop/TUI work.
+     */
+    private fun captureActiveTurnLivenessProbe(): ActiveTurnLivenessProbe? {
+        val turn = activeTurn ?: return null
+        val generation = turn.captureLivenessGeneration() ?: return null
+        val storedId = storedSessionId ?: return null
+        val liveId = liveSessionId ?: return null
+        return ActiveTurnLivenessProbe(turn, storedId, liveId, generation)
+    }
+
+    /**
+     * `session.active_list` is process-wide, but a row naming both identifiers
+     * already owned by this client is authoritative for that exact runtime.
+     * Fence the delayed snapshot by turn identity and progress generation so an
+     * old idle result cannot settle a newer turn or race newer live events.
+     */
+    private fun reconcileActiveTurnFromSnapshot(
+        probe: ActiveTurnLivenessProbe?,
+        sessions: List<GatewayActiveSession>,
+    ) {
+        probe ?: return
+        if (activeTurn !== probe.turn ||
+            storedSessionId != probe.storedSessionId ||
+            liveSessionId != probe.liveSessionId
+        ) return
+        val exact = sessions.singleOrNull { row ->
+            row.runtimeSessionId == probe.liveSessionId &&
+                row.storedSessionId == probe.storedSessionId
+        } ?: return
+        if (exact.status != GatewayActiveSessionStatus.Idle) return
+        if (probe.turn.settleFromAuthoritativeSessionState(
+                running = false,
+                source = "session.active_list",
+                expectedProgressGeneration = probe.progressGeneration,
+            )
+        ) {
+            if (activeTurn === probe.turn) activeTurn = null
+            if (!AppForegroundTracker.isForeground.value) scheduleBackgroundClose()
+        }
+    }
+
     /** Stop one process owned by the current live gateway session. */
     suspend fun killProcess(processId: String): Result<Unit> {
         if (processId.isBlank()) {
@@ -2831,11 +2958,13 @@ class GatewayChatClient(
         activeTurn = null
         backgroundTurns.clear()
         cancelledTurnDrain = null
+        settledTurnDrain = null
         unsolicitedTurnProvider = null
         coldPrewarmSessionReadyListener = null
         unmatchedTurnCompleteListener = null
         backgroundInteractionListener = null
         processEventListener = null
+        subagentEventListener = null
         sessionDirectoryInvalidationListener = null
         closeSocket("client shutdown")
         backgroundCloseJob?.cancel()
@@ -2956,9 +3085,10 @@ class GatewayChatClient(
             )
         }
         val ticketMs = (System.nanoTime() - connectStart) / 1_000_000
+        val socketProfile = currentSessionProfile()
         val url = dashboardClient.gatewayWebSocketUrl(
             ticket = ticket.ticket,
-            profile = currentSessionProfile(),
+            profile = socketProfile,
         )
             ?: throw GatewayConnectAttemptException(
                 "could not build /api/ws URL",
@@ -2992,6 +3122,7 @@ class GatewayChatClient(
         if (readyFailure != null) {
             socket.cancel()
             webSocket = null
+            connectedSocketProfile = null
             throw (readyFailure as? GatewayConnectAttemptException
                 ?: GatewayConnectAttemptException(
                     "gateway connection failed: ${readyFailure.message}",
@@ -3004,6 +3135,7 @@ class GatewayChatClient(
         val wsMs = (System.nanoTime() - connectStart) / 1_000_000 - ticketMs
         Log.i(TAG, "Gateway connected (/api/ws ready) — ticket=${ticketMs}ms ws=${wsMs}ms")
         hasEverReachedReady = true
+        connectedSocketProfile = socketProfile
         coldStartFailureEpisodes = 0
         _reconnectDisposition.value = GatewayReconnectDisposition.None
         _connectionState.value = GatewayConnectionState.Ready
@@ -3134,6 +3266,18 @@ class GatewayChatClient(
                     )
                 }
         }
+        if (info.containsKey("tools")) {
+            val groups = info["tools"] as? JsonObject
+            _serverTools.value = groups
+                ?.values
+                ?.asSequence()
+                ?.mapNotNull { it as? JsonArray }
+                ?.flatMap { it.asSequence() }
+                ?.mapNotNull { (it as? JsonPrimitive)?.contentOrNull }
+                ?.filter { it.isNotBlank() }
+                ?.toSet()
+                ?: emptySet()
+        }
         // Context usage: require used > 0 — a COLD resume resets counters and
         // reports 0 until the first turn rebuilds the prompt; painting 0 would
         // mislead on a session that actually has history.
@@ -3149,6 +3293,7 @@ class GatewayChatClient(
     /** Apply a session create/resume result without leaking metadata from the prior session. */
     private fun applySessionResultInfo(result: JsonObject) {
         _serverProject.value = null
+        _serverTools.value = null
         (result["info"] as? JsonObject)?.let { applySessionInfo(it) }
     }
 
@@ -3165,7 +3310,8 @@ class GatewayChatClient(
             ?.stringField("profile_name")
             ?.trim()
             ?.takeIf { it.isNotEmpty() }
-        if (actual != expected) {
+        val socketConfirmed = actual == null && connectedSocketProfile == expected
+        if (actual != expected && !socketConfirmed) {
             val detail = actual?.let { "Hermes returned profile '$it'" }
                 ?: "Hermes did not confirm profile ownership"
             throw GatewayPreflightException(
@@ -3267,6 +3413,7 @@ class GatewayChatClient(
         val requestedProfile = currentSessionProfile()
         if (requestedStoredId != null && requestedStoredId != storedSessionId) {
             cancelledTurnDrain = null
+            settledTurnDrain = null
         }
         if (
             liveSessionId != null &&
@@ -3274,6 +3421,7 @@ class GatewayChatClient(
             requestedStoredId != null &&
             liveSessionProfile == requestedProfile
         ) {
+            awaitSessionReadyIfRequired(liveSessionId!!)
             return
         }
 
@@ -3303,6 +3451,7 @@ class GatewayChatClient(
                 liveSessionProfile = requestedProfile
                 updateCancelledDrainLiveSession(requestedStoredId, live)
                 applySessionResultInfo(result)
+                awaitSessionReadyIfRequired(live, result)
                 return
             }
             throw GatewayAuthoritativeResumeException(
@@ -3336,7 +3485,54 @@ class GatewayChatClient(
         storedSessionId = stored
         liveSessionProfile = requestedProfile
         if (cancelledTurnDrain?.storedSessionId != stored) cancelledTurnDrain = null
+        if (settledTurnDrain?.storedSessionId != stored) settledTurnDrain = null
         turn.callbacks.onSessionId(stored)
+        awaitSessionReadyIfRequired(live, created)
+    }
+
+    /**
+     * Wait for current upstream's authoritative deferred-build edge instead of
+     * racing a lazy session into compute-host turn isolation. Without this
+     * barrier, the parent runtime can claim the durable lease before the child
+     * rechecks it, causing the child to reject itself as a second live owner.
+     */
+    private suspend fun awaitSessionReadyIfRequired(
+        liveId: String,
+        sessionResult: JsonObject? = null,
+    ) {
+        sessionReadyFailures[liveId]?.let { throw GatewayPreflightException(it) }
+        val lazy = (sessionResult?.get("info") as? JsonObject)?.booleanField("lazy") == true
+        if (lazy) lazyLiveSessions += liveId
+        if (liveId !in lazyLiveSessions) return
+        if (readyLiveSessions.remove(liveId)) {
+            lazyLiveSessions.remove(liveId)
+            return
+        }
+        val waiter = sessionReadyWaiters.computeIfAbsent(liveId) { CompletableDeferred() }
+        if (readyLiveSessions.remove(liveId)) waiter.complete(Unit)
+        sessionReadyFailures[liveId]?.let { waiter.completeExceptionally(GatewayRpcException(it)) }
+        val preparingStoredId = storedSessionId
+        _preparingSessionId.value = preparingStoredId
+        try {
+            withTimeout(sessionReadyTimeoutMs) { waiter.await() }
+            lazyLiveSessions.remove(liveId)
+        } catch (error: Exception) {
+            throw GatewayPreflightException(
+                error.message ?: "Hermes session initialization timed out",
+            )
+        } finally {
+            if (_preparingSessionId.value == preparingStoredId) _preparingSessionId.value = null
+            sessionReadyWaiters.remove(liveId, waiter)
+        }
+    }
+
+    private fun failSessionReadyWaiters(message: String) {
+        _preparingSessionId.value = null
+        sessionReadyFailures.clear()
+        sessionReadyWaiters.values.forEach {
+            it.completeExceptionally(GatewayRpcException(message))
+        }
+        sessionReadyWaiters.clear()
     }
 
     private fun createListener(ready: CompletableDeferred<Unit>) = object : WebSocketListener() {
@@ -3515,6 +3711,40 @@ class GatewayChatClient(
             return
         }
 
+        // Lazy create/resume returns before its AIAgent exists. The deferred
+        // build publishes exact-session session.info when it is ready. Record
+        // that edge before live-session routing so a fast build cannot race
+        // the RPC response and strand the first submit.
+        if (type == "session.info" && !eventSessionId.isNullOrBlank() &&
+            payload?.booleanField("lazy") != true
+        ) {
+            sessionReadyFailures.remove(eventSessionId)
+            readyLiveSessions += eventSessionId
+            sessionReadyWaiters.remove(eventSessionId)?.complete(Unit)
+        }
+
+        // Deferred agent construction can fail after lazy session.create/
+        // resume returns but before prompt.submit. Fail the readiness barrier
+        // immediately so the optimistic prompt remains retryable/Not sent
+        // instead of waiting for the five-minute readiness timeout.
+        if (type == "error" && !eventSessionId.isNullOrBlank() &&
+            (eventSessionId in lazyLiveSessions || sessionReadyWaiters.containsKey(eventSessionId) ||
+                payload?.stringField("message")?.startsWith("agent init failed:") == true)
+        ) {
+            val message = payload?.stringField("message")
+                ?: "Hermes session initialization failed"
+            // A fast deferred build can fail before the lazy RPC acknowledgement.
+            // Retain the exact runtime failure so the subsequent readiness wait
+            // cannot lose that edge and hang until its deadline.
+            if (sessionReadyFailures.size >= 64) sessionReadyFailures.keys.firstOrNull()?.let(sessionReadyFailures::remove)
+            sessionReadyFailures[eventSessionId] = message.take(2_000)
+            lazyLiveSessions.remove(eventSessionId)
+            readyLiveSessions.remove(eventSessionId)
+            sessionReadyWaiters.remove(eventSessionId)
+                ?.completeExceptionally(GatewayRpcException(message))
+            return
+        }
+
         // Upstream emits session.reclaimed process-wide, so it is identified
         // by payload rather than params.session_id. Retire only an exact live
         // runtime we own; preserve the durable id so the next send resumes it.
@@ -3713,6 +3943,8 @@ class GatewayChatClient(
         }
         dispatchProcessEvent(type, payload, eventSessionId)
         if (consumeCancelledTurnEvent(type, eventSessionId)) return
+        if (consumeSettledTurnTerminal(type, eventSessionId)) return
+        dispatchSubagentEvent(type, payload, eventSessionId)
         var turn = activeTurn
         if (turn == null && type == "message.start") {
             // Unsolicited turns are accepted only with an explicit exact live-
@@ -3774,10 +4006,25 @@ class GatewayChatClient(
     }
 
     /**
-     * Deliver session-scoped process events before the active-turn gate. The
-     * gateway socket is process-wide, so an exact non-blank live id match is
-     * required; missing/foreign ids must never leak another window's process.
+     * Detached child updates belong to the session even between parent turns.
+     * Recheck socket, session, profile and listener ownership on UI dispatch.
      */
+    private fun dispatchSubagentEvent(type: String, payload: JsonObject?, eventSessionId: String?) {
+        val liveId = liveSessionId ?: return
+        val storedId = storedSessionId ?: return
+        if (eventSessionId.isNullOrBlank() || eventSessionId != liveId) return
+        val event = GatewayEventMapper.parseSubagentEvent(type, payload) ?: return
+        val profile = liveSessionProfile
+        val socket = webSocket
+        val listener = subagentEventListener ?: return
+        callbackDispatcher {
+            if (webSocket === socket && liveSessionId == liveId && storedSessionId == storedId &&
+                liveSessionProfile == profile && subagentEventListener === listener
+            ) listener(storedId, profile, event)
+        }
+    }
+
+    /** Process updates likewise require an exact live-session match before turn admission. */
     private fun dispatchProcessEvent(type: String, payload: JsonObject?, eventSessionId: String?) {
         val liveId = liveSessionId ?: return
         if (eventSessionId.isNullOrBlank() || eventSessionId != liveId) return
@@ -3828,6 +4075,7 @@ class GatewayChatClient(
         // id on the shared gateway stream) keeps matching after reconnect.
         val preservedLiveId = liveSessionId
         webSocket = null
+        connectedSocketProfile = null
         readySignal = null
         liveSessionId = null
         attachMethodForSocket = null
@@ -3841,6 +4089,9 @@ class GatewayChatClient(
             it.completeExceptionally(GatewayRpcException("gateway connection lost"))
         }
         pendingRpcs.clear()
+        failSessionReadyWaiters("gateway connection lost")
+        lazyLiveSessions.clear()
+        readyLiveSessions.clear()
         failChildWatches("Child watch disconnected from the gateway")
         val turn = activeTurn
         if (turn == null) {
@@ -4016,8 +4267,12 @@ class GatewayChatClient(
     private fun closeSocket(reason: String) {
         webSocket?.close(1000, reason)
         webSocket = null
+        connectedSocketProfile = null
         readySignal = null
         liveSessionId = null
+        failSessionReadyWaiters("gateway socket closed")
+        lazyLiveSessions.clear()
+        readyLiveSessions.clear()
         attachMethodForSocket = null
         commandsCatalogCache = null
         _processCapability.value = GatewayProcessCapability.Unknown
@@ -4226,10 +4481,12 @@ class GatewayChatClient(
     // ------------------------------------------------------------------
 
     /** Per-event idle-watchdog duration — asks block server-side with no events, so they arm longer. */
-    private fun watchdogTimeoutFor(eventType: String): Long = when (eventType) {
-        "clarify.request", "secret.request" -> ASK_CLARIFY_SECRET_TIMEOUT_MS
-        "sudo.request" -> ASK_SUDO_TIMEOUT_MS
-        "approval.request" -> ASK_UNBOUNDED_TIMEOUT_MS
+    private fun watchdogTimeoutFor(eventType: String, payload: JsonObject? = null): Long = when {
+        eventType == "clarify.request" || eventType == "secret.request" -> ASK_CLARIFY_SECRET_TIMEOUT_MS
+        eventType == "sudo.request" -> ASK_SUDO_TIMEOUT_MS
+        eventType == "approval.request" -> ASK_UNBOUNDED_TIMEOUT_MS
+        eventType == "status.update" &&
+            payload?.stringField("kind") == "compacting" -> compactingTimeoutMs
         else -> turnIdleTimeoutMs
     }
 
@@ -4237,6 +4494,7 @@ class GatewayChatClient(
         val callbacks: GatewayTurnCallbacks,
         dedupeAdjacentMessageStarts: Boolean = false,
         deferEvents: Boolean = false,
+        private val androidOwned: Boolean = false,
         private val onTransportAccepted: () -> Unit = { },
     ) : ActiveTurnHandle {
         private val mapper = GatewayEventMapper(callbacks, dedupeAdjacentMessageStarts)
@@ -4263,6 +4521,7 @@ class GatewayChatClient(
 
         private val rejoinAttempts = java.util.concurrent.atomic.AtomicInteger(0)
         private val transportAccepted = AtomicBoolean(false)
+        private val progressGeneration = java.util.concurrent.atomic.AtomicLong(0L)
 
         fun markTransportAccepted() {
             if (transportAccepted.compareAndSet(false, true)) {
@@ -4339,6 +4598,7 @@ class GatewayChatClient(
             if (settledWithoutTerminalFrame) return
             if (type != "session.info") {
                 started = true
+                progressGeneration.incrementAndGet()
                 markTransportAccepted()
             }
             tracer.mark("ttfe")
@@ -4348,7 +4608,7 @@ class GatewayChatClient(
             // Reset on every event — long tool runs keep the turn alive.
             // Ask requests block with no further events, so they arm with
             // their own (longer) duration via watchdogTimeoutFor.
-            armWatchdog(watchdogTimeoutFor(type))
+            armWatchdog(watchdogTimeoutFor(type, payload))
             // Queue this immediately before the terminal callbacks. Both are
             // marshalled through the same dispatcher, preserving callback order
             // even when the WebSocket reader and reconnect coroutine differ.
@@ -4368,10 +4628,20 @@ class GatewayChatClient(
          * exact turn has proved it went live. A pre-start `running=false`
          * heartbeat can race `prompt.submit` and is not a completion boundary.
          */
-        fun settleFromAuthoritativeSessionState(running: Boolean?, source: String): Boolean {
+        fun captureLivenessGeneration(): Long? =
+            if (androidOwned && started && !ended) progressGeneration.get() else null
+
+        fun settleFromAuthoritativeSessionState(
+            running: Boolean?,
+            source: String,
+            expectedProgressGeneration: Long? = null,
+        ): Boolean {
             if (running != false || !started) return false
             val settled = synchronized(deferredEventLock) {
-                if (ended) {
+                if (ended ||
+                    (expectedProgressGeneration != null &&
+                        progressGeneration.get() != expectedProgressGeneration)
+                ) {
                     false
                 } else {
                     settledWithoutTerminalFrame = true
@@ -4382,6 +4652,7 @@ class GatewayChatClient(
             if (!settled) return false
 
             disarmWatchdog()
+            armSettledTurnDrain()
             Log.i(TAG, "Gateway turn settled from $source after missing terminal frame")
             callbacks.onReconcileRequired()
             callbacks.onComplete()
@@ -4402,6 +4673,7 @@ class GatewayChatClient(
                         callbacks = dispatchOn(registration.callbacks),
                         dedupeAdjacentMessageStarts = true,
                         deferEvents = true,
+                        androidOwned = true,
                     )
                 }
             }
@@ -4529,6 +4801,26 @@ class GatewayChatClient(
         )
     }
 
+    private fun armSettledTurnDrain() {
+        val storedId = storedSessionId ?: return
+        val liveId = liveSessionId ?: return
+        settledTurnDrain = SettledTurnDrain(storedId, liveId)
+    }
+
+    /** Consume one late terminal from a turn already settled by session state. */
+    private fun consumeSettledTurnTerminal(type: String, eventSessionId: String?): Boolean {
+        val drain = settledTurnDrain ?: return false
+        if (eventSessionId != drain.liveSessionId) return false
+        if (type == "message.start") {
+            if (settledTurnDrain === drain) settledTurnDrain = null
+            return false
+        }
+        if (type != "message.complete" && type != "error") return false
+        if (settledTurnDrain === drain) settledTurnDrain = null
+        Log.d(TAG, "Ignored late terminal for gateway turn settled from session state")
+        return true
+    }
+
     private fun updateCancelledDrainLiveSession(storedId: String, liveId: String) {
         val drain = cancelledTurnDrain ?: return
         if (drain.storedSessionId == storedId) {
@@ -4655,6 +4947,11 @@ class GatewayChatClient(
             dispatchIfCurrent(stillCurrent) { callbacks.onStatusUpdate(kind, text) }
         },
         onStatusClear = { kind -> dispatchIfCurrent(stillCurrent) { callbacks.onStatusClear(kind) } },
+        onNoticeShow = { notice -> dispatchIfCurrent(stillCurrent) { callbacks.onNoticeShow(notice) } },
+        onNoticeClear = { key -> dispatchIfCurrent(stillCurrent) { callbacks.onNoticeClear(key) } },
+        onSubmitRejected = { message ->
+            dispatchIfCurrent(stillCurrent) { callbacks.onSubmitRejected(message) }
+        },
     )
 
     private fun dispatchIfCurrent(stillCurrent: () -> Boolean, callback: () -> Unit) {
@@ -4707,7 +5004,7 @@ data class GatewayAttachment(
     val sizeBytes: Long? = null,
 )
 
-/** Connect/auth/submit failed before the turn started — safe to fall back to SSE. */
+/** Connect/auth/submit failed before the turn started; the caller retains transport ownership. */
 internal class GatewayPreflightException(message: String) : Exception(message)
 
 /** Attachment bytes were not safely bound to a Gateway turn; never silently fall through to SSE. */
@@ -4972,6 +5269,7 @@ private fun parseBotRosterEntry(row: JsonObject): BotRosterEntry? {
             model = row.stringField("model").orEmpty(),
             provider = row.stringField("provider").orEmpty(),
             description = row.stringField("description")?.take(512).orEmpty(),
+            displayName = row.stringField("display_name").orEmpty(),
             skillCount = (row["skill_count"] as? JsonPrimitive)?.intOrNull ?: 0,
             isDefault = (row["is_default"] as? JsonPrimitive)?.booleanOrNull ?: false,
             hasAvatar = (row["has_avatar"] as? JsonPrimitive)?.booleanOrNull ?: false,

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/GatewayEventMapper.kt

@@ -7,6 +7,7 @@ import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.contentOrNull
 import kotlinx.serialization.json.doubleOrNull
 import kotlinx.serialization.json.intOrNull
+import kotlinx.serialization.json.longOrNull
 import kotlinx.serialization.json.booleanOrNull
 
 /**
@@ -195,7 +196,8 @@ class GatewayEventMapper(
 
             "tool.start" -> {
                 clearActivityStatuses()
-                val name = payload.string("name") ?: "unknown"
+                val identity = payload.effectiveToolIdentity()
+                val name = identity.name
                 // A pending generating placeholder for this name is adopted
                 // (consumed FIFO) whether or not the server sent a real id.
                 val adopted = generatingIdsByName[name]?.removeFirstOrNull()
@@ -207,7 +209,7 @@ class GatewayEventMapper(
                     }
                     else -> syntheticToolId(name)
                 }
-                val argsPreview = payload?.get("args")
+                val argsPreview = identity.argsPreview ?: payload?.get("args")
                     ?.takeUnless { it is JsonPrimitive && it.contentOrNull.isNullOrBlank() }
                     ?.toString()
                     ?.takeIf { it.isNotBlank() && it != "null" }
@@ -219,7 +221,7 @@ class GatewayEventMapper(
 
             "tool.complete" -> {
                 clearActivityStatuses()
-                val name = payload.string("name") ?: "unknown"
+                val name = payload.effectiveToolIdentity().name
                 val toolId = payload.string("tool_id")
                     ?: openSyntheticIdsByName[name]?.removeFirstOrNull()
                     ?: return
@@ -278,41 +280,19 @@ class GatewayEventMapper(
 
             "error" -> {
                 turnEnded = true
-                callbacks.onError(payload.string("message") ?: "Gateway error")
+                val message = payload.string("message") ?: "Gateway error"
+                if (isSessionOwnershipRejection(message)) {
+                    callbacks.onSubmitRejected(message)
+                } else {
+                    callbacks.onError(message)
+                }
             }
 
             "subagent.spawn_requested", "subagent.start", "subagent.thinking", "subagent.tool",
             "subagent.progress", "subagent.complete",
             -> {
                 clearActivityStatuses()
-                val phase = when (type) {
-                    "subagent.spawn_requested" -> GatewaySubagentEvent.Phase.SPAWN_REQUESTED
-                    "subagent.start" -> GatewaySubagentEvent.Phase.START
-                    "subagent.thinking" -> GatewaySubagentEvent.Phase.THINKING
-                    "subagent.tool" -> GatewaySubagentEvent.Phase.TOOL
-                    "subagent.progress" -> GatewaySubagentEvent.Phase.PROGRESS
-                    else -> GatewaySubagentEvent.Phase.COMPLETE
-                }
-                callbacks.onSubagentEvent(
-                    GatewaySubagentEvent(
-                        phase = phase,
-                        taskIndex = payload.int("task_index") ?: 0,
-                        taskCount = payload.int("task_count") ?: 1,
-                        goal = payload.string("goal") ?: "",
-                        status = payload.string("status"),
-                        summary = payload.string("summary"),
-                        toolName = payload.string("tool_name"),
-                        // subagent.tool sets tool_preview AND mirrors it into
-                        // text; thinking/progress carry text only.
-                        preview = payload.string("tool_preview") ?: payload.string("text"),
-                        durationSeconds = payload.double("duration_seconds"),
-                        subagentId = payload.string("subagent_id"),
-                        childSessionId = payload.string("child_session_id"),
-                        parentId = payload.string("parent_id"),
-                        depth = payload.int("depth"),
-                        model = payload.string("model"),
-                    ),
-                )
+                parseSubagentEvent(type, payload)?.let(callbacks.onSubagentEvent)
             }
 
             "tool.output_risk" -> {
@@ -397,8 +377,26 @@ class GatewayEventMapper(
                 }
             }
 
-            // Known-but-unrendered (notification.show, …) and unknown types
-            // alike: ignore.
+            "notification.show" -> {
+                val text = payload.string("text")?.trim().orEmpty()
+                if (text.isNotEmpty()) {
+                    callbacks.onNoticeShow(
+                        GatewayAgentNotice(
+                            text = text,
+                            level = payload.string("level"),
+                            kind = payload.string("kind"),
+                            ttlMs = payload.long("ttl_ms"),
+                            key = payload.string("key"),
+                            id = payload.string("id"),
+                        ),
+                    )
+                }
+            }
+
+            "notification.clear" ->
+                payload.string("key")?.trim()?.takeIf(String::isNotEmpty)?.let(callbacks.onNoticeClear)
+
+            // Unknown event types remain forward-compatible no-ops.
             else -> Unit
         }
         previousEventType = type
@@ -442,6 +440,42 @@ class GatewayEventMapper(
     }
 
     companion object {
+        /** Shared by turn transcripts and the session-owned activity stream. */
+        fun parseSubagentEvent(type: String, payload: JsonObject?): GatewaySubagentEvent? {
+            if (type !in setOf(
+                    "subagent.spawn_requested", "subagent.start", "subagent.thinking",
+                    "subagent.tool", "subagent.progress", "subagent.complete",
+                )) return null
+            val phase = when (type) {
+                "subagent.spawn_requested" -> GatewaySubagentEvent.Phase.SPAWN_REQUESTED
+                "subagent.start" -> GatewaySubagentEvent.Phase.START
+                "subagent.thinking" -> GatewaySubagentEvent.Phase.THINKING
+                "subagent.tool" -> GatewaySubagentEvent.Phase.TOOL
+                "subagent.progress" -> GatewaySubagentEvent.Phase.PROGRESS
+                else -> GatewaySubagentEvent.Phase.COMPLETE
+            }
+
+            return GatewaySubagentEvent(
+                phase = phase,
+                taskIndex = payload.int("task_index") ?: 0,
+                taskCount = payload.int("task_count") ?: 1,
+                goal = payload.string("goal") ?: "",
+                status = payload.string("status"),
+                summary = payload.string("summary"),
+                toolName = payload.string("tool_name"),
+                // subagent.tool sets tool_preview AND mirrors it into
+                // text; thinking/progress carry text only.
+                preview = payload.string("tool_preview") ?: payload.string("text"),
+                durationSeconds = payload.double("duration_seconds"),
+                subagentId = payload.string("subagent_id"),
+                childSessionId = payload.string("child_session_id"),
+                parentId = payload.string("parent_id"),
+                depth = payload.int("depth"),
+                model = payload.string("model"),
+                delegationId = payload.string("delegation_id"),
+            )
+        }
+
         const val PROVIDER_WAIT_STATUS_KIND = "provider_wait"
         const val COMPACTION_STATUS_KIND = "compacting"
         const val ERROR_STATUS_KIND = "error"
@@ -450,6 +484,19 @@ class GatewayEventMapper(
         private const val MAX_MOA_REFERENCE_CHARS = 16_000
         private val OUTPUT_RISK_LEVELS = setOf("low", "medium", "high", "critical")
         private val TERMINAL_EVENTS = setOf("message.complete", "error")
+
+        /**
+         * Isolated-turn paths can acknowledge `prompt.submit` and then emit
+         * the ownership refusal as a plain terminal `error` event. That event
+         * has no JSON-RPC code or structured reason, so match both stable
+         * clauses from upstream's canonical message.
+         */
+        internal fun isSessionOwnershipRejection(message: String): Boolean {
+            val normalized = message.lowercase()
+            return "already has a live owner (" in normalized &&
+                "only one surface at a time may run a session" in normalized
+        }
+
         internal fun isFailedMoaReference(text: String): Boolean {
             val normalized = text.trimStart().lowercase()
             return normalized.startsWith("[failed:") || normalized.startsWith("[skipped:")
@@ -590,12 +637,43 @@ private const val MAX_CLARIFY_CHOICES = 4
 private const val SUDO_TIMEOUT_SECONDS = 120
 private const val SECRET_TIMEOUT_SECONDS = 300
 
+private data class GatewayToolIdentity(
+    val name: String,
+    val argsPreview: String?,
+)
+
+/**
+ * Older Tool Search gateways can expose the model-visible `tool_call` bridge
+ * instead of the effective tool identity that current upstream callbacks use.
+ * Unwrap only the bridge's explicit structured `{name, arguments}` envelope;
+ * never infer a tool from prompt text or result content.
+ */
+private fun JsonObject?.effectiveToolIdentity(): GatewayToolIdentity {
+    val outerName = string("name") ?: "unknown"
+    val outerArgs = this?.get("args") as? JsonObject
+    if (outerName != "tool_call" || outerArgs == null) {
+        return GatewayToolIdentity(outerName, null)
+    }
+    val effectiveName = outerArgs.string("name")
+        ?.trim()
+        ?.takeIf { it.isNotEmpty() }
+        ?: return GatewayToolIdentity(outerName, null)
+    val effectiveArgs = outerArgs["arguments"]
+        ?.takeUnless { it is JsonPrimitive && it.contentOrNull.isNullOrBlank() }
+        ?.toString()
+        ?.takeIf { it.isNotBlank() && it != "null" }
+    return GatewayToolIdentity(effectiveName, effectiveArgs)
+}
+
 private fun JsonObject?.string(key: String): String? =
     (this?.get(key) as? JsonPrimitive)?.contentOrNull
 
 private fun JsonObject?.int(key: String): Int? =
     (this?.get(key) as? JsonPrimitive)?.intOrNull
 
+private fun JsonObject?.long(key: String): Long? =
+    (this?.get(key) as? JsonPrimitive)?.longOrNull
+
 private fun JsonObject?.double(key: String): Double? =
     (this?.get(key) as? JsonPrimitive)?.doubleOrNull
 

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/GatewayModels.kt

@@ -91,26 +91,19 @@ enum class GatewayApprovalModeCapability {
  * is unit-testable without an AndroidViewModel. ConnectionViewModel
  * delegates here with its live state.
  *
- * Manual picks pass through untouched (ChatViewModel handles per-turn
- * fallback when a "gateway" pick can't serve a send); "auto" prefers the
- * gateway while the dashboard probe is unresolved or ready. A capability-
- * preferred SSE fallback is selected only after a definitive unavailable,
- * unsupported, or sign-in-required verdict.
+ * Manual picks pass through untouched. "auto" follows the saved connection's
+ * stable owner: Dashboard/Gateway for a standard connection, or the
+ * capability-preferred SSE surface for a true API-only compatibility record.
+ * Live reachability and sign-in state never change the owner of an open chat.
  */
 fun resolveStreamingEndpointPreference(
     preference: String,
     gateway: GatewayAvailability,
     capabilities: ServerCapabilities,
+    gatewayOwned: Boolean = true,
 ): String = when (preference) {
     "sessions", "completions", "runs", "gateway" -> preference
-    else -> if (
-        gateway == GatewayAvailability.Ready ||
-        gateway == GatewayAvailability.Unknown
-    ) {
-        "gateway"
-    } else {
-        capabilities.preferredChatEndpoint()
-    }
+    else -> if (gatewayOwned) "gateway" else capabilities.preferredChatEndpoint()
 }
 
 /**
@@ -263,6 +256,16 @@ data class GatewayToolOutputRisk(
     val redacted: Boolean,
 )
 
+/** Official upstream `notification.show` AgentNotice payload. */
+data class GatewayAgentNotice(
+    val text: String,
+    val level: String? = null,
+    val kind: String? = null,
+    val ttlMs: Long? = null,
+    val key: String? = null,
+    val id: String? = null,
+)
+
 /**
  * One `subagent.*` lifecycle event, emitted on the PARENT session. Lifecycle
  * per task: SPAWN_REQUESTED → START → (THINKING | TOOL | PROGRESS)* →
@@ -290,6 +293,8 @@ data class GatewaySubagentEvent(
     val depth: Int? = null,
     /** Effective child model, when the emitter exposes it. */
     val model: String? = null,
+    /** Exact delegation group id shared with persisted async completion metadata. */
+    val delegationId: String? = null,
 ) {
     enum class Phase { SPAWN_REQUESTED, START, THINKING, TOOL, PROGRESS, COMPLETE }
 }
@@ -734,6 +739,16 @@ class GatewayTurnCallbacks(
     val onStatusUpdate: (kind: String?, text: String) -> Unit = { _, _ -> },
     /** Clear a transient status only when [kind] still owns the visible status slot. */
     val onStatusClear: (kind: String) -> Unit = { _ -> },
+    /** Official upstream account/agent notice; distinct from Relay proactive messages. */
+    val onNoticeShow: (GatewayAgentNotice) -> Unit = { _ -> },
+    /** Exact-key dismissal for an upstream notice. */
+    val onNoticeClear: (key: String) -> Unit = { _ -> },
+    /**
+     * The Gateway authoritatively refused `prompt.submit` before a model turn
+     * began. The composed user row remains local and retryable; callers must
+     * not treat this as a dropped stream or reconcile it from history.
+     */
+    val onSubmitRejected: (String) -> Unit = onError,
 )
 
 /**

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/HermesApiClient.kt

@@ -726,10 +726,10 @@ class HermesApiClient(
 
     suspend fun getMessages(
         sessionId: String,
-        mode: SessionMessageLoadMode = SessionMessageLoadMode.COMPLETE,
+        mode: SessionMessageLoadMode = SessionMessageLoadMode.LATEST,
     ): List<MessageItem> = withContext(Dispatchers.IO) {
         loadSessionMessages(mode) { page ->
-            runCatching {
+            try {
                 val url = "$baseUrl/api/sessions/$sessionId/messages".toHttpUrlOrNull()
                     ?.newBuilder()
                     ?.addQueryParameter("limit", page.limit.toString())
@@ -740,14 +740,20 @@ class HermesApiClient(
                 val request = authRequest(url.toString()).get().build()
                 client.newCall(request).execute().use { response ->
                     if (!response.isSuccessful) error("HTTP ${response.code}")
-                    val body = response.body?.string() ?: error("empty response body")
+                    val body = response.body.readUtf8Bounded(
+                        DashboardApiClient.MAX_JSON_RESPONSE_BYTES,
+                    )
                     val parsed = json.decodeFromString<MessageListResponse>(body)
                     SessionMessagePage(
                         messages = parsed.data ?: parsed.items ?: parsed.messages ?: emptyList(),
                         pagination = parsed.pagination,
                         payloadChars = body.length,
                     )
-                }
+                }.let { Result.success(it) }
+            } catch (error: CancellationException) {
+                throw error
+            } catch (error: Exception) {
+                Result.failure(error)
             }
         }.getOrElse { error ->
             if (error is CancellationException) throw error

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/SessionMessagePagination.kt

@@ -72,7 +72,7 @@ internal suspend fun loadSessionMessages(
         Result.success(collected)
     } catch (error: CancellationException) {
         throw error
-    } catch (error: Throwable) {
+    } catch (error: Exception) {
         Result.failure(error)
     }
 }

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/StandardHermesVoiceClient.kt

@@ -195,7 +195,7 @@ class StandardHermesVoiceClient(
                 .let { Result.success<VoiceSpeechStream?>(it) }
         } catch (cancelled: CancellationException) {
             throw cancelled
-        } catch (error: Throwable) {
+        } catch (error: Exception) {
             Result.failure(error)
         }
     }
@@ -222,7 +222,9 @@ class StandardHermesVoiceClient(
                 if (!response.isSuccessful) {
                     return Result.failure(apiFailure(response, operation))
                 }
-                val body = response.body.string()
+                val body = response.body.readUtf8Bounded(
+                    DashboardApiClient.MAX_JSON_RESPONSE_BYTES,
+                )
                 if (body.isBlank()) {
                     return Result.failure(IOException("$operation returned an empty response"))
                 }
@@ -245,7 +247,11 @@ class StandardHermesVoiceClient(
     }
 
     private fun apiFailure(response: Response, operation: String): IOException {
-        val body = runCatching { response.body.string() }.getOrDefault("")
+        val body = try {
+            response.body.readUtf8Bounded(4L * 1024L)
+        } catch (_: Exception) {
+            ""
+        }
         val detail = body.takeIf { it.isNotBlank() } ?: response.message
         val message = when (response.code) {
             400 -> "$operation rejected that input - ${detail.ifBlank { "bad request" }}"

app/src/main/kotlin/com/hermesandroid/relay/network/usage/ProviderUsageRepository.kt

@@ -3,10 +3,12 @@ package com.hermesandroid.relay.network.usage
 import com.hermesandroid.relay.network.relay.RelayHttpClient
 import com.hermesandroid.relay.network.upstream.GatewayChatClient
 import com.hermesandroid.relay.network.upstream.DashboardApiClient
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.decodeFromJsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.doubleOrNull
 
-/** Relay-enhanced usage with an upstream fallback for hosts without Relay support. */
+/** Upstream usage enriched by the optional Relay provider/pool surface. */
 class ProviderUsageRepository(
     private val gatewayClientProvider: () -> GatewayChatClient?,
     private val dashboardClientProvider: () -> DashboardApiClient? = { null },
@@ -14,33 +16,142 @@ class ProviderUsageRepository(
     private val profileProvider: () -> String? = { null },
     private val sessionProvider: () -> String? = { null },
 ) {
-    private val json = Json {
-        ignoreUnknownKeys = true
-        coerceInputValues = true
-        explicitNulls = false
-    }
-
     suspend fun fetch(): Result<ProviderUsageResponse?> {
         val profile = profileProvider()
         val session = sessionProvider()
+        val upstream: Result<ProviderUsageResponse?> = gatewayClientProvider()
+            ?.usageBars()
+            ?.mapCatching(::providerUsageFromUpstreamBars)
+            ?: Result.success(null)
+
         val dashboard = dashboardClientProvider()
+        var enhancement: Result<ProviderUsageResponse?>? = null
         if (dashboard != null) {
-            val enhanced = dashboard.getProviderUsage(profile, session)
-            if (enhanced.isSuccess && enhanced.getOrNull() != null) return enhanced
+            enhancement = dashboard.getProviderUsage(profile, session)
         }
 
-        val relay = relayHttpClient.fetchProviderUsage(
-            profile = profile,
-            sessionId = session,
+        if (enhancement?.getOrNull() == null) {
+            enhancement = relayHttpClient.fetchProviderUsage(
+                profile = profile,
+                sessionId = session,
+            )
+        }
+
+        val merged = mergeProviderUsage(
+            upstream = upstream.getOrNull(),
+            enhancement = enhancement?.getOrNull(),
         )
-        if (relay.isSuccess && relay.getOrNull() != null) return relay
+        if (merged != null) return Result.success(merged)
 
-        val gateway = gatewayClientProvider()
-        if (gateway != null) {
-            val upstream = gateway.providerUsage()
-                .mapCatching { json.decodeFromJsonElement<ProviderUsageResponse>(it) }
-            if (upstream.isSuccess) return upstream
+        return when {
+            upstream.isFailure && enhancement?.isFailure == true ->
+                Result.failure(enhancement?.exceptionOrNull()!!)
+            enhancement?.isFailure == true -> Result.failure(enhancement?.exceptionOrNull()!!)
+            else -> Result.success(null)
         }
-        return relay
     }
 }
+
+internal fun providerUsageFromUpstreamBars(root: JsonObject): ProviderUsageResponse? {
+    if (root.boolean("available") != true) return null
+
+    val renewsAt = root.string("renews_at")
+    val windows = listOfNotNull(
+        root.usageWindow("plan", "Plan", renewsAt),
+        root.usageWindow("topup", "Top-up", null),
+    )
+    val details = listOfNotNull(
+        root.string("subscription_remaining_display")?.let { "Subscription remaining: $it" },
+        root.string("topup_remaining_display")?.let { "Top-up remaining: $it" },
+        root.string("total_spendable_display")?.let { "Total spendable: $it" },
+    )
+
+    return ProviderUsageResponse(
+        providers = listOf(
+            ProviderUsageProvider(
+                id = "nous",
+                displayName = "Nous",
+                status = ProviderUsageProvider.STATUS_AVAILABLE,
+                source = "upstream:usage.bars",
+                plan = root.string("plan_name"),
+                windows = windows,
+                details = details,
+                renewsAt = renewsAt,
+            ),
+        ),
+    )
+}
+
+internal fun mergeProviderUsage(
+    upstream: ProviderUsageResponse?,
+    enhancement: ProviderUsageResponse?,
+): ProviderUsageResponse? {
+    if (upstream == null) return enhancement
+    if (enhancement == null) return upstream
+
+    val providers = linkedMapOf<String, ProviderUsageProvider>()
+    upstream.providers.forEach { providers[it.id] = it }
+    enhancement.providers.forEach { enhanced ->
+        val standard = providers[enhanced.id]
+        providers[enhanced.id] = when {
+            standard == null -> enhanced
+            standard.available -> standard.copy(
+                // Official usage.bars stays authoritative for every field it
+                // supplies. Relay enriches the row with pool/balance metadata
+                // and fills only gaps that upstream left absent.
+                fetchedAt = standard.fetchedAt ?: enhanced.fetchedAt,
+                plan = standard.plan ?: enhanced.plan,
+                windows = standard.windows.ifEmpty { enhanced.windows },
+                details = (standard.details + enhanced.details).distinct(),
+                balances = enhanced.balances,
+                renewsAt = standard.renewsAt ?: enhanced.renewsAt,
+                actionUrl = standard.actionUrl ?: enhanced.actionUrl,
+                credentials = enhanced.credentials,
+                activeCredentialId = enhanced.activeCredentialId,
+                activeCredentialState = enhanced.activeCredentialState,
+                activeObservedAt = enhanced.activeObservedAt,
+                message = standard.message ?: enhanced.message,
+            )
+            enhanced.available -> enhanced
+            else -> enhanced
+        }
+    }
+    return ProviderUsageResponse(
+        schemaVersion = maxOf(upstream.schemaVersion, enhancement.schemaVersion),
+        fetchedAt = enhancement.fetchedAt ?: upstream.fetchedAt,
+        capabilities = upstream.capabilities + enhancement.capabilities,
+        providers = providers.values.toList(),
+    )
+}
+
+private fun JsonObject.usageWindow(
+    id: String,
+    label: String,
+    resetAt: String?,
+): ProviderUsageWindow? {
+    val bar = this["${id}_bar"] as? JsonObject ?: return null
+    val remaining = bar.string("remaining_display")
+    val total = bar.string("total_display")
+    val detail = when {
+        remaining != null && total != null -> "$remaining remaining of $total"
+        remaining != null -> "$remaining remaining"
+        total != null -> "$total total"
+        else -> null
+    }
+    return ProviderUsageWindow(
+        id = id,
+        label = label,
+        usedPercent = bar.double("pct_used"),
+        resetAt = resetAt,
+        detail = detail,
+    )
+}
+
+private fun JsonObject.string(key: String): String? =
+    (this[key] as? JsonPrimitive)?.content?.trim()?.takeIf(String::isNotEmpty)
+
+private fun JsonObject.boolean(key: String): Boolean? =
+    (this[key] as? JsonPrimitive)?.booleanOrNull
+
+private fun JsonObject.double(key: String): Double? =
+    (this[key] as? JsonPrimitive)?.doubleOrNull

app/src/main/kotlin/com/hermesandroid/relay/runtime/HermesRuntimeBinder.kt

@@ -21,6 +21,7 @@ import com.hermesandroid.relay.data.EnhancedVoiceOverrides
 import com.hermesandroid.relay.data.VoiceAudioRoute
 import com.hermesandroid.relay.data.VoiceEngineMode
 import com.hermesandroid.relay.data.VoicePreferencesRepository
+import com.hermesandroid.relay.data.VoiceProfileScope
 import com.hermesandroid.relay.data.VoiceSettings
 import com.hermesandroid.relay.network.relay.RelayVoiceAudioClientAdapter
 import com.hermesandroid.relay.network.relay.RelayVoiceClient
@@ -170,6 +171,9 @@ internal class HermesRuntimeBinder(
             relayHttpClient = connection.relayHttpClient,
             mediaSettingsRepo = connection.mediaSettingsRepo,
             mediaCacheWriter = connection.mediaCacheWriter,
+            dashboardMediaClientProvider = {
+                connection.activeDashboardUrl()?.let(connection::dashboardClientForActive)
+            },
         )
         chat.setSelectedProfileProvider { connection.selectedProfile.value }
         chat.setIsolatedProfileApiProvider { connection.selectedProfileUsesIsolatedApiRoute() }
@@ -209,6 +213,7 @@ internal class HermesRuntimeBinder(
         chat.setProfileMessageLoaderWithMode { profileName, sessionId, mode ->
             connection.loadProfileScopedMessages(profileName, sessionId, mode)
         }
+        chat.setDashboardSignInRequiredHandler(connection::probeNow)
         chat.setDashboardConfigLoader { connection.loadActiveDashboardConfig() }
         chat.profileSessionDeleter = connection::deleteSession
         chat.profileSessionRenamer = connection::renameSession
@@ -261,6 +266,11 @@ internal class HermesRuntimeBinder(
         jobs += runtime.coroutineScope.launch {
             chat.isStreaming.collect(connection::setChatStreaming)
         }
+        jobs += runtime.coroutineScope.launch {
+            chat.conversationBinding.collect { binding ->
+                connection.setActiveConversationTransport(binding.transport)
+            }
+        }
         jobs += runtime.coroutineScope.launch {
             combine(
                 connection.activeConnectionId,
@@ -281,6 +291,36 @@ internal class HermesRuntimeBinder(
                 }
             }
         }
+        jobs += runtime.coroutineScope.launch {
+            combine(
+                connection.connectionsHydrated,
+                connection.activeConnectionId,
+                connection.relayConfigured,
+                voiceSettingsHydrated,
+                voicePreferencesRepository.activeScope,
+            ) { connectionsReady, connectionId, relayConfigured, settingsReady, scope ->
+                VoiceRelayReconciliationInputs(
+                    connectionsReady = connectionsReady,
+                    connectionId = connectionId,
+                    relayConfigured = relayConfigured,
+                    settingsReady = settingsReady,
+                    scope = scope,
+                )
+            }.collectLatest { inputs ->
+                if (
+                    inputs.connectionsReady &&
+                    inputs.settingsReady &&
+                    inputs.connectionId != null &&
+                    !inputs.relayConfigured &&
+                    // Default-profile storage is a legacy global layer shared
+                    // across connections. Keep its fallback runtime-only.
+                    inputs.scope.profileName != null &&
+                    inputs.scope.connectionId == inputs.connectionId
+                ) {
+                    voicePreferencesRepository.reconcileRelayRemoval(inputs.scope)
+                }
+            }
+        }
         jobs += runtime.coroutineScope.launch {
             combine(
                 connection.streamingEndpoint,
@@ -311,14 +351,18 @@ internal class HermesRuntimeBinder(
                 connection.activeConnectionId,
                 connection.effectiveSessionProfileName,
                 connection.lastSessionId,
-                connection.activeEndpoint,
-            ) { ready, connectionId, profileName, sessionId, activeEndpoint ->
+                // The session directory belongs to the standard Dashboard
+                // route. connection.activeEndpoint is the optional Relay
+                // socket's selected candidate and stays null on a valid
+                // Dashboard-only LAN connection.
+                connection.effectiveDashboardUrl,
+            ) { ready, connectionId, profileName, sessionId, dashboardUrl ->
                 ProfileContextInputs(
                     ready,
                     connectionId,
                     profileName,
                     sessionId,
-                    dashboardRouteResolved = activeEndpoint != null,
+                    dashboardUrl = dashboardUrl,
                 )
             }
             combine(
@@ -334,7 +378,7 @@ internal class HermesRuntimeBinder(
                 )
             }.collectLatest { inputs ->
                 profileContextReady.value = false
-                if (!shouldRefreshSessionDirectory(inputs.chatReady, inputs.dashboardRouteResolved)) {
+                if (!shouldRefreshSessionDirectory(inputs.chatReady, inputs.dashboardUrl)) {
                     return@collectLatest
                 }
                 if (!inputs.profileSelectionSettled) {
@@ -397,13 +441,22 @@ internal class HermesRuntimeBinder(
                 connection.chatReady,
                 connection.standardVoiceAvailability,
                 connection.relayVoiceReady,
-                connection.profileSelectionSettled,
-            ) { settings, chatReady, standard, relayReady, profileSettled ->
+                connection.relayConfigured,
+            ) { settings, chatReady, standard, relayReady, relayConfigured ->
+                VoiceReadinessInputs(
+                    settings = settings,
+                    chatReady = chatReady,
+                    standardAvailability = standard,
+                    relayReady = relayReady,
+                    relayConfigured = relayConfigured,
+                )
+            }.combine(connection.profileSelectionSettled) { inputs, profileSettled ->
                 resolveVoiceActivationReadiness(
-                    settings,
-                    chatReady,
-                    standard,
-                    relayReady,
+                    inputs.settings,
+                    inputs.chatReady,
+                    inputs.standardAvailability,
+                    inputs.relayReady,
+                    inputs.relayConfigured,
                     profileSettled,
                 )
             }
@@ -551,12 +604,28 @@ internal class HermesRuntimeBinder(
         val connectionId: String?,
         val profileName: String?,
         val sessionId: String?,
-        val dashboardRouteResolved: Boolean,
+        val dashboardUrl: String,
         val profileSelectionSettled: Boolean = false,
         val profileLocked: Boolean = false,
         val hiddenSources: Set<String> = emptySet(),
     )
 
+    private data class VoiceRelayReconciliationInputs(
+        val connectionsReady: Boolean,
+        val connectionId: String?,
+        val relayConfigured: Boolean,
+        val settingsReady: Boolean,
+        val scope: VoiceProfileScope,
+    )
+
+    private data class VoiceReadinessInputs(
+        val settings: VoiceSettings,
+        val chatReady: Boolean,
+        val standardAvailability: StandardVoiceAvailability,
+        val relayReady: Boolean,
+        val relayConfigured: Boolean,
+    )
+
     private companion object {
         const val PROFILE_SETTLE_BACKSTOP_MS = 2_500L
         const val PROFILE_CONTEXT_COALESCE_MS = 160L
@@ -567,12 +636,13 @@ internal class HermesRuntimeBinder(
 /**
  * Session browsing is Dashboard HTTP state, not Gateway-socket state. API-only
  * connections still use chat readiness; Dashboard connections can refresh once
- * the resolver has selected a live route, after the profile-settle fence.
+ * their persisted/resolved Dashboard origin publishes, after the profile-settle
+ * fence. The optional Relay endpoint is deliberately not part of this decision.
  */
 internal fun shouldRefreshSessionDirectory(
     chatReady: Boolean,
-    dashboardRouteResolved: Boolean,
-): Boolean = chatReady || dashboardRouteResolved
+    dashboardUrl: String,
+): Boolean = chatReady || dashboardUrl.isNotBlank()
 
 internal fun assistantCanTransmitScreenContext(engineMode: VoiceEngineMode): Boolean =
     engineMode == VoiceEngineMode.HermesVoiceOutput
@@ -595,12 +665,14 @@ internal fun resolveVoiceActivationReadiness(
     chatReady: Boolean,
     standardAvailability: StandardVoiceAvailability,
     relayReady: Boolean,
+    relayConfigured: Boolean,
     profileSettled: Boolean,
 ): HermesVoiceActivationReadiness {
     if (!profileSettled) {
         return HermesVoiceActivationReadiness.Waiting("Loading the selected Hermes profile")
     }
-    return when (VoiceEngineMode.fromStorage(settings.engineMode)) {
+    val effectiveSettings = voiceSettingsForRelayConfiguration(settings, relayConfigured)
+    return when (VoiceEngineMode.fromStorage(effectiveSettings.engineMode)) {
         VoiceEngineMode.RealtimeAgent -> {
             if (relayReady) {
                 HermesVoiceActivationReadiness.Ready(HermesVoiceActivationRoute.Realtime)
@@ -612,7 +684,7 @@ internal fun resolveVoiceActivationReadiness(
             if (!chatReady) {
                 return HermesVoiceActivationReadiness.Waiting("Waiting for Hermes chat")
             }
-            when (VoiceAudioRoute.fromStorage(settings.audioRoute)) {
+            when (VoiceAudioRoute.fromStorage(effectiveSettings.audioRoute)) {
                 VoiceAudioRoute.Relay -> if (relayReady) {
                     HermesVoiceActivationReadiness.Ready(
                         HermesVoiceActivationRoute.RelayAudio
@@ -636,6 +708,24 @@ internal fun resolveVoiceActivationReadiness(
     }
 }
 
+/**
+ * Relay absence is a topology decision, unlike a transient route outage. Only
+ * the former may fall back from Relay-only persisted selections.
+ */
+internal fun voiceSettingsForRelayConfiguration(
+    settings: VoiceSettings,
+    relayConfigured: Boolean,
+): VoiceSettings {
+    if (relayConfigured) return settings
+    return settings.copy(
+        engineMode = VoiceEngineMode.HermesVoiceOutput.storageValue,
+        audioRoute = when (VoiceAudioRoute.fromStorage(settings.audioRoute)) {
+            VoiceAudioRoute.Relay -> VoiceAudioRoute.Auto.storageValue
+            else -> settings.audioRoute
+        },
+    )
+}
+
 private fun standardVoiceReadiness(
     availability: StandardVoiceAvailability,
 ): HermesVoiceActivationReadiness = when (availability) {

app/src/main/kotlin/com/hermesandroid/relay/ui/ChatResponsiveLayout.kt

@@ -0,0 +1,40 @@
+package com.hermesandroid.relay.ui
+
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+/** Width policy shared by Chat's content and persistent status surfaces. */
+internal data class ChatResponsiveLayout(
+    val introMaxWidth: Dp?,
+    val avatarSize: Dp?,
+    val chromeMaxWidth: Dp?,
+    val transcriptMaxWidth: Dp?,
+    val focusVoiceMaxWidth: Dp?,
+)
+
+internal fun chatResponsiveLayout(screenWidthDp: Int): ChatResponsiveLayout = when {
+    screenWidthDp >= 840 -> ChatResponsiveLayout(
+        introMaxWidth = 720.dp,
+        avatarSize = 360.dp,
+        chromeMaxWidth = 960.dp,
+        transcriptMaxWidth = 960.dp,
+        focusVoiceMaxWidth = 1120.dp,
+    )
+    screenWidthDp >= 600 -> ChatResponsiveLayout(
+        introMaxWidth = 600.dp,
+        avatarSize = 300.dp,
+        chromeMaxWidth = 760.dp,
+        transcriptMaxWidth = 760.dp,
+        focusVoiceMaxWidth = 760.dp,
+    )
+    else -> ChatResponsiveLayout(
+        introMaxWidth = null,
+        avatarSize = null,
+        chromeMaxWidth = null,
+        transcriptMaxWidth = null,
+        focusVoiceMaxWidth = null,
+    )
+}
+
+internal fun useSplitVoiceLayout(screenWidthDp: Int, screenHeightDp: Int): Boolean =
+    screenWidthDp >= 840 && screenWidthDp > screenHeightDp

app/src/main/kotlin/com/hermesandroid/relay/ui/RelayApp.kt

@@ -36,7 +36,7 @@ import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarDuration
-import androidx.compose.material3.SnackbarHost
+import com.hermesandroid.relay.ui.components.ThemedMessageHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.SnackbarResult
 import androidx.compose.material3.Surface
@@ -117,6 +117,7 @@ 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.ChatMediaViewerHost
 import com.hermesandroid.relay.ui.components.ChatTransportStatusBadge
 import com.hermesandroid.relay.ui.components.ChatTransportTier
 import com.hermesandroid.relay.ui.components.ConnectionSecurityGlyph
@@ -136,6 +137,8 @@ import com.hermesandroid.relay.data.BridgeSafetyPreferencesRepository
 import com.hermesandroid.relay.data.BuildFlavor
 import com.hermesandroid.relay.data.CandidateBuild
 import com.hermesandroid.relay.data.Connection
+import com.hermesandroid.relay.data.SessionTransport
+import com.hermesandroid.relay.data.chatTransportForPreference
 import com.hermesandroid.relay.data.EndpointCandidate
 import com.hermesandroid.relay.data.FeatureFlags
 import com.hermesandroid.relay.data.SupervisedModePolicy
@@ -144,6 +147,7 @@ import com.hermesandroid.relay.data.VoicePresentationMode
 import com.hermesandroid.relay.data.capabilities
 import com.hermesandroid.relay.data.displayLabel
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -226,11 +230,7 @@ val LocalSnackbarHost = staticCompositionLocalOf<SnackbarHostState> {
 // Short-lived snackbar by default; retryable errors get Long so users have
 // time to tap the action before it auto-dismisses.
 suspend fun SnackbarHostState.showHumanError(err: HumanError): SnackbarResult {
-    return showSnackbar(
-        message = err.body,
-        actionLabel = err.actionLabel,
-        duration = if (err.retryable) SnackbarDuration.Long else SnackbarDuration.Short,
-    )
+    return showSnackbar(com.hermesandroid.relay.ui.components.HumanErrorVisuals(err))
 }
 
 /** Startup chrome should wait for either standard chat surface, not Relay. */
@@ -282,6 +282,8 @@ internal fun resolveAppChatRuntimeStatus(
     connection: Connection?,
     gatewayAvailability: GatewayAvailability,
     apiHealth: ConnectionViewModel.HealthStatus,
+    streamingEndpoint: String = "auto",
+    conversationOwner: SessionTransport? = null,
 ): ChatRuntimeStatus {
     val capabilities = connection?.capabilities
     val gateway = when {
@@ -297,7 +299,11 @@ internal fun resolveAppChatRuntimeStatus(
             apiHealth == ConnectionViewModel.HealthStatus.Probing -> ChatTransportReadiness.Connecting
         else -> ChatTransportReadiness.Unavailable
     }
-    return resolveChatRuntimeStatus(gateway = gateway, apiSse = api)
+    val owner = when (conversationOwner ?: connection?.chatTransportForPreference(streamingEndpoint)) {
+        SessionTransport.SSE -> ChatTransportPath.ApiSse
+        else -> ChatTransportPath.Gateway
+    }
+    return resolveChatRuntimeStatus(gateway = gateway, apiSse = api, owner = owner)
 }
 
 internal fun shouldSettleStartupUnreachable(
@@ -359,7 +365,7 @@ internal fun resolveFooterRouteCandidate(
  *
  * Endpoint roles are operator and wire metadata, so an internal role such as
  * `authenticated_dashboard` must never leak into this constrained surface.
- * Gateway labels describe how the Dashboard is reached; API fallback keeps
+ * Gateway labels describe how the Dashboard is reached; Direct API keeps
  * the route's ordinary transport label.
  */
 internal fun resolveFooterRouteLabel(
@@ -738,6 +744,10 @@ fun RelayApp() {
     val pendingAddConnectionJobs = remember {
         mutableMapOf<String, kotlinx.coroutines.Job>()
     }
+    var pendingAddConnectionTargetId by rememberSaveable { mutableStateOf<String?>(null) }
+    val pendingAddConnectionAbortJobs = remember {
+        mutableMapOf<String, kotlinx.coroutines.Job>()
+    }
     val prepareAddConnection: (String, Boolean) -> Unit = { id, retryRequested ->
         val existingJob = pendingAddConnectionJobs[id]
         if (shouldStartPairPreparation(existingJob?.isActive == true, retryRequested)) {
@@ -758,6 +768,25 @@ fun RelayApp() {
             job.start()
         }
     }
+    val abortAddConnection: (String) -> kotlinx.coroutines.Job = { id ->
+        pendingAddConnectionAbortJobs[id] ?: connectionSwitchScope.launch {
+            try {
+                pendingAddConnectionJobs.remove(id)?.cancelAndJoin()
+                connectionViewModel.discardPlaceholderConnection(id)
+            } finally {
+                if (pendingAddConnectionTargetId == id) {
+                    pendingAddConnectionTargetId = null
+                }
+            }
+        }.also { job ->
+            pendingAddConnectionAbortJobs[id] = job
+            job.invokeOnCompletion {
+                if (pendingAddConnectionAbortJobs[id] === job) {
+                    pendingAddConnectionAbortJobs.remove(id)
+                }
+            }
+        }
+    }
 
     // One-time init: the terminal channel ViewModel registers with the shared
     // multiplexer and observes the relay connection state so it can attach/
@@ -983,6 +1012,17 @@ fun RelayApp() {
         chatSessions.firstOrNull { it.sessionId == currentChatSessionId }
     }
 
+    LaunchedEffect(
+        gitOwnerKey,
+        activeChatSession?.gitRepoRoot,
+        activeChatSession?.workingDirectory,
+    ) {
+        gitStateViewModel.setSessionWorkspace(
+            repoRoot = activeChatSession?.gitRepoRoot,
+            workingDirectory = activeChatSession?.workingDirectory,
+        )
+    }
+
     // Bind Git to the active coding session when upstream supplies its exact
     // workspace metadata. CWD fallback only matches a path-segment descendant;
     // an ambiguous multi-repo catalog stays unselected until the user chooses.
@@ -999,7 +1039,7 @@ fun RelayApp() {
         }
     }
 
-    val gitWorkspaceAvailable = gitRepoScanningEnabled &&
+    val gitWorkspaceAvailable =
         (gitReposState as? GitStateUiState.Ready)?.repos?.isNotEmpty() == true
     val gitWorkspaceSummary = remember(
         gitReposState,
@@ -1351,6 +1391,9 @@ fun RelayApp() {
                 currentRoute = currentRoute,
             )
             if (redirect) {
+                pendingAddConnectionTargetId?.let { targetId ->
+                    abortAddConnection(targetId).join()
+                }
                 navController.navigate(Screen.Chat.route(openAgentSheet = false)) {
                     popUpTo(navController.graph.findStartDestination().id) { inclusive = false }
                     launchSingleTop = true
@@ -1566,6 +1609,7 @@ fun RelayApp() {
         // evidence alone left a window where the reveal showed the CTA for
         // the few hundred ms until the client-based health verdict landed.
         val chatReady by connectionViewModel.chatReady.collectAsState()
+        val conversationOwner by connectionViewModel.activeConversationTransport.collectAsState()
         var startupGateMinElapsed by remember { mutableStateOf(false) }
         var startupGateTimedOut by remember { mutableStateOf(false) }
         var startupGateReleased by remember { mutableStateOf(false) }
@@ -1592,6 +1636,8 @@ fun RelayApp() {
             connection = activeConnection,
             gatewayAvailability = gatewayAvailability,
             apiHealth = apiHealth,
+            streamingEndpoint = streamingEndpoint,
+            conversationOwner = conversationOwner,
         )
         // A Dashboard/Gateway-only connection is a complete standard Hermes
         // connection. Startup readiness follows the same transport-neutral
@@ -1902,6 +1948,8 @@ fun RelayApp() {
         // child TopAppBar doesn't double-pad when this banner owns the top edge.
         val activeMessageCount by UiMessageBus.activeCount.collectAsState()
         val showMessageBanner = activeMessageCount > 0
+        val modalMessageHostActive by UiMessageBus.modalHostActive.collectAsState()
+        val showActionMessage = snackbarHostState.currentSnackbarData != null && !modalMessageHostActive
         // Update availability (unified): googlePlay = Play In-App Update FLEXIBLE,
         // sideload = GitHub releases. The handle filters dismissed versions +
         // throttles checks internally, exposing a surfaceable status for the
@@ -2027,6 +2075,14 @@ fun RelayApp() {
             includeStatusBarPadding =
                 !showUnattendedBanner && !showDemoBanner && !showHostResourcePressure,
         )
+        // Action feedback owns layout space at the top, never the composer's
+        // touch area. Modal windows keep their own scoped host.
+        ThemedMessageHost(
+            snackbarHostState,
+            modifier = if (showActionMessage && !showMessageBanner &&
+                !showUnattendedBanner && !showDemoBanner && !showHostResourcePressure
+            ) Modifier.windowInsetsPadding(WindowInsets.statusBars) else Modifier,
+        )
 
         // The update banner AND the connection-status indicator now render as
         // floating overlay TOASTS in the Box below (see the top-overlay Column
@@ -2067,7 +2123,7 @@ fun RelayApp() {
                     // participates in the top-inset accounting.
                     if (showUnattendedBanner || showDemoBanner || showHostResourcePressure ||
                         connectionChipVisible ||
-                        showMessageBanner
+                        showMessageBanner || showActionMessage
                     ) {
                         Modifier.consumeWindowInsets(WindowInsets.statusBars)
                     } else {
@@ -2075,7 +2131,6 @@ fun RelayApp() {
                     }
                 ),
             contentWindowInsets = WindowInsets(0),
-            snackbarHost = { SnackbarHost(snackbarHostState) },
             bottomBar = {
                 if (
                     !suppressGlobalChrome &&
@@ -2098,7 +2153,9 @@ fun RelayApp() {
                             ?: stringResource(R.string.status_no_route),
                     )
                     val transportStatus = resolveChatTransportStatus(
-                        streamingEndpoint = streamingEndpoint,
+                        streamingEndpoint = connectionViewModel.resolveActiveStreamingEndpoint(
+                            streamingEndpoint,
+                        ),
                         gatewayAvailability = gatewayAvailability,
                         serverCapabilities = serverCapabilities,
                     )
@@ -2113,10 +2170,20 @@ fun RelayApp() {
                         ?: AgentDisplay.displayModelName(serverModelName)
                         ?: stringResource(R.string.status_model_pending)
                     val footerModelLabel = compactFooterModelLabel(modelLabel)
-                    val openConnections = {
-                        navController.navigate(Screen.ConnectionsSettings.route) {
-                            launchSingleTop = true
+                    val openConnections: (() -> Unit)? = if (
+                        isSupervisedRouteContentAllowed(
+                            supervisedEnabled = supervisedPolicy.enabled,
+                            parentAccessUnlocked = parentAccessForCurrentRoute,
+                            currentRoute = Screen.ConnectionsSettings.route,
+                        )
+                    ) {
+                        {
+                            navController.navigate(Screen.ConnectionsSettings.route) {
+                                launchSingleTop = true
+                            }
                         }
+                    } else {
+                        null
                     }
                     RelayStatusStrip(
                         leadingBadge = {
@@ -2139,6 +2206,9 @@ fun RelayApp() {
                         // Routine in-progress reconnect surfaces here (amber cue)
                         // instead of a take-space banner or a floating toast.
                         reconnecting = connectionReconnecting,
+                        maxContentWidth = chatResponsiveLayout(
+                            LocalConfiguration.current.screenWidthDp,
+                        ).chromeMaxWidth,
                         modifier = Modifier.petPerchSurface(
                             key = APP_STATUS_PET_WALK_REGION,
                             routes = APP_STATUS_PET_ROUTES,
@@ -2147,7 +2217,10 @@ fun RelayApp() {
                 }
             }
         ) { innerPadding ->
-            CompositionLocalProvider(LocalSnackbarHost provides snackbarHostState) {
+            CompositionLocalProvider(
+                LocalSnackbarHost provides snackbarHostState,
+                com.hermesandroid.relay.ui.components.LocalMessageActionHost provides snackbarHostState,
+            ) {
             Column(
                 modifier = Modifier
                     .fillMaxSize()
@@ -2411,103 +2484,110 @@ fun RelayApp() {
 
                     val screenChatLabel = stringResource(R.string.screen_chat_label)
 
-                    ChatScreen(
-                        chatViewModel = chatViewModel,
-                        connectionViewModel = connectionViewModel,
-                        voiceViewModel = voiceViewModel,
-                        voiceClient = voiceClient,
-                        maxBubbleWidth = maxBubbleWidth,
-                        voicePresentationMode = voicePresentationMode,
-                        onVoicePresentationModeChange = { mode ->
-                            connectionSwitchScope.launch {
-                                voicePreferences.setPresentationMode(mode)
-                            }
-                        },
-                        openAgentSheetOnEntry = openAgentSheetArg,
-                        onAgentSheetArgConsumed = {
-                            backStackEntry.arguments?.putBoolean(
-                                Screen.Chat.ARG_OPEN_AGENT_SHEET, false,
-                            )
-                        },
-                        // AgentInfoSheet footer jumps straight into the full
-                        // Connections CRUD screen — saves a detour through
-                        // Settings → Gateways.
-                        onNavigateToConnections = {
-                            navController.navigate(Screen.ConnectionsSettings.route)
-                        },
-                        onNavigateToConnect = {
-                            navController.navigate(Screen.Pair.route()) {
-                                launchSingleTop = true
-                            }
-                        },
-                        onRepairConnection = {
-                            navController.navigate(
-                                Screen.Pair.route(
-                                    connectionId = activeConnectionId,
-                                    autoStart = "relay",
-                                ),
-                            ) {
-                                launchSingleTop = true
-                            }
-                        },
-                        // Empty-chat "needs connection" card also offers the offline
-                        // demo, so a skipped / never-connected first run can explore
-                        // without leaving Chat. Safe here — this state only shows when
-                        // nothing is configured, so there's no placeholder in flight.
-                        onTryDemo = enterDemo,
-                        onNavigateToDashboardSignIn = {
-                            navController.navigate(Screen.DashboardSignIn.route()) {
-                                launchSingleTop = true
-                            }
-                        },
-                        onNavigateToBridge = {
-                            rememberBridgeReturn(
-                                route = Screen.Chat.route(openAgentSheet = false),
-                                label = screenChatLabel,
-                            )
-                            navController.navigate(Screen.Bridge.route) {
-                                popUpTo(navController.graph.findStartDestination().id) {
-                                    saveState = true
+                    ChatMediaViewerHost(
+                        activeConnectionId,
+                        effectiveSessionProfileName,
+                        currentChatSessionId,
+                        chatSupervisedPolicy,
+                    ) {
+                        ChatScreen(
+                            chatViewModel = chatViewModel,
+                            connectionViewModel = connectionViewModel,
+                            voiceViewModel = voiceViewModel,
+                            voiceClient = voiceClient,
+                            maxBubbleWidth = maxBubbleWidth,
+                            voicePresentationMode = voicePresentationMode,
+                            onVoicePresentationModeChange = { mode ->
+                                connectionSwitchScope.launch {
+                                    voicePreferences.setPresentationMode(mode)
                                 }
-                                launchSingleTop = true
-                                restoreState = true
-                            }
-                        },
-                        onNavigateToTerminal = {
-                            navController.navigate(Screen.Terminal.route) {
-                                launchSingleTop = true
-                            }
-                        },
-                        onNavigateToSettings = {
-                            navController.navigate(Screen.Settings.route) {
-                                launchSingleTop = true
-                            }
-                        },
-                        onNavigateToAppearanceSettings = {
-                            navController.navigate(Screen.AppearanceSettings.route) {
-                                launchSingleTop = true
-                            }
-                        },
-                        onNavigateToVoiceSettings = {
-                            navController.navigate(Screen.VoiceSettings.route) {
-                                launchSingleTop = true
-                            }
-                        },
-                        onNavigateToProfileInspector = { profileName ->
-                            navController.navigate(Screen.ProfileInspector.route(profileName)) {
-                                launchSingleTop = true
-                            }
-                        },
-                        supervisedPolicy = chatSupervisedPolicy,
-                        onNavigateToBotMode = {
-                            navController.navigate(Screen.BotMode.route) { launchSingleTop = true }
-                        },
-                        gitWorkspaceAvailable = gitWorkspaceAvailable,
-                        gitWorkspaceSummary = gitWorkspaceSummary,
-                        onNavigateToGitWorkspace = {
-                            navController.navigate(Screen.GitState.route) { launchSingleTop = true }
-                        },
-                    )
+                            },
+                            openAgentSheetOnEntry = openAgentSheetArg,
+                            onAgentSheetArgConsumed = {
+                                backStackEntry.arguments?.putBoolean(
+                                    Screen.Chat.ARG_OPEN_AGENT_SHEET, false,
+                                )
+                            },
+                            // AgentInfoSheet footer jumps straight into the full
+                            // Connections CRUD screen — saves a detour through
+                            // Settings → Gateways.
+                            onNavigateToConnections = {
+                                navController.navigate(Screen.ConnectionsSettings.route)
+                            },
+                            onNavigateToConnect = {
+                                navController.navigate(Screen.Pair.route()) {
+                                    launchSingleTop = true
+                                }
+                            },
+                            onRepairConnection = {
+                                navController.navigate(
+                                    Screen.Pair.route(
+                                        connectionId = activeConnectionId,
+                                        autoStart = "relay",
+                                    ),
+                                ) {
+                                    launchSingleTop = true
+                                }
+                            },
+                            // Empty-chat "needs connection" card also offers the offline
+                            // demo, so a skipped / never-connected first run can explore
+                            // without leaving Chat. Safe here — this state only shows when
+                            // nothing is configured, so there's no placeholder in flight.
+                            onTryDemo = enterDemo,
+                            onNavigateToDashboardSignIn = {
+                                navController.navigate(Screen.DashboardSignIn.route()) {
+                                    launchSingleTop = true
+                                }
+                            },
+                            onNavigateToBridge = {
+                                rememberBridgeReturn(
+                                    route = Screen.Chat.route(openAgentSheet = false),
+                                    label = screenChatLabel,
+                                )
+                                navController.navigate(Screen.Bridge.route) {
+                                    popUpTo(navController.graph.findStartDestination().id) {
+                                        saveState = true
+                                    }
+                                    launchSingleTop = true
+                                    restoreState = true
+                                }
+                            },
+                            onNavigateToTerminal = {
+                                navController.navigate(Screen.Terminal.route) {
+                                    launchSingleTop = true
+                                }
+                            },
+                            onNavigateToSettings = {
+                                navController.navigate(Screen.Settings.route) {
+                                    launchSingleTop = true
+                                }
+                            },
+                            onNavigateToAppearanceSettings = {
+                                navController.navigate(Screen.AppearanceSettings.route) {
+                                    launchSingleTop = true
+                                }
+                            },
+                            onNavigateToVoiceSettings = {
+                                navController.navigate(Screen.VoiceSettings.route) {
+                                    launchSingleTop = true
+                                }
+                            },
+                            onNavigateToProfileInspector = { profileName ->
+                                navController.navigate(Screen.ProfileInspector.route(profileName)) {
+                                    launchSingleTop = true
+                                }
+                            },
+                            supervisedPolicy = chatSupervisedPolicy,
+                            onNavigateToBotMode = {
+                                navController.navigate(Screen.BotMode.route) { launchSingleTop = true }
+                            },
+                            gitWorkspaceAvailable = gitWorkspaceAvailable,
+                            gitWorkspaceSummary = gitWorkspaceSummary,
+                            onNavigateToGitWorkspace = {
+                                navController.navigate(Screen.GitState.route) { launchSingleTop = true }
+                            },
+                        )
+                    }
                 }
                 composable(Screen.BotMode.route) {
                     BotModeScreen(
@@ -2930,7 +3010,12 @@ fun RelayApp() {
                 }
                 composable(Screen.AdvancedSettings.route) {
                     if (!parentAccessForCurrentRoute && supervisedPolicy.enabled) {
-                        LaunchedEffect(Unit) { navController.popBackStack() }
+                        LaunchedEffect(Unit) {
+                            navController.navigate(Screen.Chat.route(openAgentSheet = false)) {
+                                popUpTo(navController.graph.findStartDestination().id) { inclusive = false }
+                                launchSingleTop = true
+                            }
+                        }
                     } else {
                         AdvancedSettingsScreen(
                             supervisedPolicy = supervisedPolicy,
@@ -2961,7 +3046,12 @@ fun RelayApp() {
                 }
                 composable(Screen.SupervisedControls.route) {
                     if (!parentAccessForCurrentRoute && supervisedPolicy.enabled) {
-                        LaunchedEffect(Unit) { navController.popBackStack() }
+                        LaunchedEffect(Unit) {
+                            navController.navigate(Screen.Chat.route(openAgentSheet = false)) {
+                                popUpTo(navController.graph.findStartDestination().id) { inclusive = false }
+                                launchSingleTop = true
+                            }
+                        }
                     } else {
                         SupervisedControlsScreen(
                             connectionViewModel = connectionViewModel,
@@ -3203,16 +3293,34 @@ fun RelayApp() {
                         addConnectionEnabled = mayStartAddConnection(
                             supervisedEnabled = supervisedPolicy.enabled,
                             parentAccessUnlocked = parentAccessForCurrentRoute,
+                            activeTargetId = pendingAddConnectionTargetId,
                         ),
-                        onAddConnection = {
-                            val id = java.util.UUID.randomUUID().toString()
+                        onAddConnection = addConnection@{
+                            val liveConnectionId = connectionViewModel.activeConnectionId.value
+                            val livePolicyState = supervisedPolicyState.value
+                                ?.takeIf { (ownerId, _) -> ownerId == liveConnectionId }
+                            val livePolicy = when {
+                                liveConnectionId == null -> SupervisedModePolicy()
+                                livePolicyState != null -> livePolicyState.second
+                                else -> return@addConnection
+                            }
+                            val liveRoute = navController.currentDestination?.route
+                            val liveParentAccess = parentAccessUnlocked &&
+                                !shouldRelockParentAccess(
+                                    supervisedEnabled = livePolicy.enabled,
+                                    parentAccessUnlocked = parentAccessUnlocked,
+                                    route = liveRoute,
+                                )
                             runAddConnectionAction(
-                                supervisedEnabled = supervisedPolicy.enabled,
-                                parentAccessUnlocked = parentAccessForCurrentRoute,
-                                navigateToPair = {
+                                supervisedEnabled = livePolicy.enabled,
+                                parentAccessUnlocked = liveParentAccess,
+                                activeTargetId = pendingAddConnectionTargetId,
+                                allocateTarget = { java.util.UUID.randomUUID().toString() },
+                                recordTarget = { id -> pendingAddConnectionTargetId = id },
+                                navigateToPair = { id ->
                                     navController.navigate(Screen.Pair.route(connectionId = id))
                                 },
-                                prepareConnection = { prepareAddConnection(id, false) },
+                                prepareConnection = { id -> prepareAddConnection(id, false) },
                             )
                         },
                         onBack = { navController.popBackStack() },
@@ -3356,9 +3464,15 @@ fun RelayApp() {
                             if (connectionIdArg != null && pairDraftId == connectionIdArg) {
                                 connectionSwitchScope.launch {
                                     connectionViewModel.commitConnectionDraft(connectionIdArg)
+                                    if (pendingAddConnectionTargetId == connectionIdArg) {
+                                        pendingAddConnectionTargetId = null
+                                    }
                                     navController.popBackStack()
                                 }
                             } else {
+                                if (pendingAddConnectionTargetId == connectionIdArg) {
+                                    pendingAddConnectionTargetId = null
+                                }
                                 navController.popBackStack()
                             }
                         },
@@ -3378,6 +3492,9 @@ fun RelayApp() {
                                     runCatching {
                                         connectionViewModel.commitConnectionDraft(targetId)
                                     }.onSuccess {
+                                        if (pendingAddConnectionTargetId == targetId) {
+                                            pendingAddConnectionTargetId = null
+                                        }
                                         android.util.Log.i(
                                             "GatewayPairFlow",
                                             "Opening Dashboard sign-in for staged gateway",
@@ -3414,14 +3531,12 @@ fun RelayApp() {
                             // never got a pairedAt stamp.
                             if (connectionIdArg != null) {
                                 connectionSwitchScope.launch {
-                                    // If Back wins the race with background
-                                    // preparation, wait until the placeholder
-                                    // exists before attempting to discard it.
-                                    pendingAddConnectionJobs.remove(connectionIdArg)?.join()
-                                    connectionViewModel.discardPlaceholderConnection(connectionIdArg)
+                                    abortAddConnection(connectionIdArg).join()
+                                    navController.popBackStack()
                                 }
+                            } else {
+                                navController.popBackStack()
                             }
-                            navController.popBackStack()
                         },
                     )
                 }

app/src/main/kotlin/com/hermesandroid/relay/ui/SupervisedNavigationPolicy.kt

@@ -15,18 +15,24 @@ internal fun isSupervisedRouteAllowed(route: String?, parentAccessUnlocked: Bool
 internal fun mayStartAddConnection(
     supervisedEnabled: Boolean,
     parentAccessUnlocked: Boolean,
-): Boolean = !supervisedEnabled || parentAccessUnlocked
+    activeTargetId: String? = null,
+): Boolean = activeTargetId == null && (!supervisedEnabled || parentAccessUnlocked)
 
 internal inline fun runAddConnectionAction(
     supervisedEnabled: Boolean,
     parentAccessUnlocked: Boolean,
-    navigateToPair: () -> Unit,
-    prepareConnection: () -> Unit,
-): Boolean {
-    if (!mayStartAddConnection(supervisedEnabled, parentAccessUnlocked)) return false
-    navigateToPair()
-    prepareConnection()
-    return true
+    activeTargetId: String?,
+    allocateTarget: () -> String,
+    recordTarget: (String) -> Unit,
+    navigateToPair: (String) -> Unit,
+    prepareConnection: (String) -> Unit,
+): String? {
+    if (!mayStartAddConnection(supervisedEnabled, parentAccessUnlocked, activeTargetId)) return null
+    val targetId = allocateTarget()
+    recordTarget(targetId)
+    navigateToPair(targetId)
+    prepareConnection(targetId)
+    return targetId
 }
 
 /** Do not inspect or mutate a NavController until its first destination exists. */
@@ -132,12 +138,10 @@ internal fun sanitizeSupervisedChatRouteArgs(
     }
 }
 
-/** A disabled policy may become active only after an enrolled credential succeeds. */
+/** A disabled policy may become active only after the app-specific parent credential succeeds. */
 internal fun mayEnableSupervisedMode(
     policy: SupervisedModePolicy,
-    deviceSecure: Boolean,
-    deviceCredentialConfirmed: Boolean,
+    parentCredentialConfirmed: Boolean,
 ): Boolean = !policy.enabled &&
     policy.isConfigured &&
-    deviceSecure &&
-    deviceCredentialConfirmed
+    parentCredentialConfirmed

app/src/main/kotlin/com/hermesandroid/relay/ui/UiMessageBus.kt

@@ -8,26 +8,50 @@ import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import java.util.concurrent.atomic.AtomicLong
 
-/** Visual tone of a transient banner message. Errors are NOT modelled here —
- * they stay on the snackbar (see [LocalSnackbarHost]); this bus is info-only. */
-enum class UiMessageSeverity { Info, Success, Status }
+/** Visual tone of a transient banner message. */
+enum class UiMessageSeverity { Info, Success, Status, Warning, Error }
 
 data class UiMessage(
     val id: Long,
     val text: String,
     val severity: UiMessageSeverity,
     val ttlMillis: Long,
+    /** Stable upstream key for replace-in-place and exact dismissal. */
+    val key: String? = null,
 )
 
+sealed interface UiMessageEvent {
+    data class Show(val message: UiMessage) : UiMessageEvent
+    data class Clear(val key: String) : UiMessageEvent
+    data object ClearAll : UiMessageEvent
+}
+
+internal fun reduceUiMessages(
+    current: List<UiMessage>,
+    event: UiMessageEvent,
+    maxRetained: Int,
+): List<UiMessage> = when (event) {
+    UiMessageEvent.ClearAll -> emptyList()
+    is UiMessageEvent.Clear -> current.filterNot { it.key == event.key }
+    is UiMessageEvent.Show -> {
+        val incoming = event.message
+        val withoutDuplicate = current.filterNot { existing ->
+            if (incoming.key != null) existing.key == incoming.key else existing.text == incoming.text
+        }
+        (withoutDuplicate + incoming).takeLast(maxRetained)
+    }
+}
+
 /**
- * App-wide bus for transient, non-error status/confirmation messages that
+ * App-wide bus for transient status, confirmation, and error messages that
  * surface in the top [com.hermesandroid.relay.ui.components.MessageBannerHost]
  * — a thin banner that takes its own space (content slides down, no overlay),
  * shows the newest line collapsed, expands to a few recent lines, auto-dismisses
  * and coalesces duplicates.
  *
- * Deliberately info-only: errors and persistent/actionable messages keep going
- * to the snackbar so they demand acknowledgement. Migrate frequent
+ * Messages requiring Retry or Undo use ThemedMessageHost and retain their
+ * action-result contract. Upstream keyed AgentNotices own their sticky/clear lifecycle.
+ * Migrate frequent
  * `snackbarHostState.showSnackbar("…")` confirmations/status to [info] /
  * [success] / [status] here.
  *
@@ -39,8 +63,25 @@ object UiMessageBus {
     const val STATUS_TTL_MS = 6_000L
 
     private val counter = AtomicLong(0L)
-    private val _events = MutableSharedFlow<UiMessage>(extraBufferCapacity = 24)
-    val events: SharedFlow<UiMessage> = _events.asSharedFlow()
+    private val hosts = linkedMapOf<Long, Boolean>()
+    private val _activeHost = MutableStateFlow<Long?>(null)
+    internal val activeHost = _activeHost.asStateFlow()
+    private val _modalHostActive = MutableStateFlow(false)
+    internal val modalHostActive = _modalHostActive.asStateFlow()
+    internal fun registerHost(primary: Boolean): Long = synchronized(hosts) {
+        counter.incrementAndGet().also {
+            hosts[it] = primary
+            _activeHost.value = hosts.keys.lastOrNull()
+            _modalHostActive.value = hosts.values.any { primaryHost -> !primaryHost }
+        }
+    }
+    internal fun unregisterHost(id: Long) { synchronized(hosts) {
+        hosts.remove(id)
+        _activeHost.value = hosts.keys.lastOrNull()
+        _modalHostActive.value = hosts.values.any { !it }
+    } }
+    private val _events = MutableSharedFlow<UiMessageEvent>(extraBufferCapacity = 24)
+    val events: SharedFlow<UiMessageEvent> = _events.asSharedFlow()
 
     // Number of messages currently shown by the host. Lifted here so the app
     // scaffold can fold banner visibility into its status-bar inset accounting
@@ -52,12 +93,33 @@ object UiMessageBus {
         text: String,
         severity: UiMessageSeverity = UiMessageSeverity.Info,
         ttlMillis: Long = DEFAULT_TTL_MS,
+        key: String? = null,
     ) {
         val trimmed = text.trim()
         if (trimmed.isEmpty()) return
-        _events.tryEmit(UiMessage(counter.incrementAndGet(), trimmed, severity, ttlMillis))
+        _events.tryEmit(
+            UiMessageEvent.Show(
+                UiMessage(
+                    id = counter.incrementAndGet(),
+                    text = trimmed,
+                    severity = severity,
+                    ttlMillis = ttlMillis.coerceAtLeast(0L),
+                    key = key?.trim()?.takeIf(String::isNotEmpty),
+                ),
+            ),
+        )
     }
 
+    /** Dismiss only the keyed message owned by the matching upstream notice. */
+    fun clear(key: String) {
+        key.trim().takeIf(String::isNotEmpty)?.let { _events.tryEmit(UiMessageEvent.Clear(it)) }
+    }
+
+    fun clearAll() { _events.tryEmit(UiMessageEvent.ClearAll) }
+
+    fun warning(text: String, ttlMillis: Long = STATUS_TTL_MS) = post(text, UiMessageSeverity.Warning, ttlMillis)
+    fun error(text: String, ttlMillis: Long = 10_000L) = post(text, UiMessageSeverity.Error, ttlMillis)
+
     /** Neutral confirmation/info (e.g. "Pairing code copied"). */
     fun info(text: String, ttlMillis: Long = DEFAULT_TTL_MS) =
         post(text, UiMessageSeverity.Info, ttlMillis)

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ActiveConnectionSections.kt

@@ -1,6 +1,6 @@
 package com.hermesandroid.relay.ui.components
 
-import android.widget.Toast
+import com.hermesandroid.relay.ui.UiMessageBus
 import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
@@ -209,7 +209,7 @@ fun ActiveCardRelayStatusSection(
     val relayUiState by connectionViewModel.relayUiState.collectAsState()
     val relayRowState by connectionViewModel.relayRowState.collectAsState()
 
-    // Pre-resolve strings for Toast (non-composable context)
+    // Pre-resolve strings for action callbacks (non-composable context).
     val reconnectingRelayToast = stringResource(R.string.active_section_reconnecting_relay)
     val relayStatusText = when (relayRowState.phase) {
         RelayUiState.NotConfigured -> stringResource(R.string.relay_state_optional)
@@ -250,11 +250,7 @@ fun ActiveCardRelayStatusSection(
         onClick = {
             if (relayUiState == RelayUiState.Stale) {
                 connectionViewModel.reconnectIfStale()
-                Toast.makeText(
-                    context,
-                    reconnectingRelayToast,
-                    Toast.LENGTH_SHORT,
-                ).show()
+                UiMessageBus.status(reconnectingRelayToast)
             } else {
                 onOpenRelayInfo()
             }
@@ -613,7 +609,7 @@ private fun CapabilityRow(
 
 /**
  * Advanced compatibility and override content:
- *  - optional direct API fallback URL/key
+ *  - optional Direct API URL/key
  *  - explicit direct Relay endpoint override/test
  *  - allow-insecure-connections development toggle
  *
@@ -817,7 +813,7 @@ private fun ManualUrlSubsection(
     }
     val autoRelayUrl = RelayUrlDeriver.deriveFromApiUrl(apiUrlInput)
 
-    // Pre-resolve strings for Toast (non-composable context)
+    // Pre-resolve strings for action callbacks (non-composable context).
     val apiHermesVoiceReachableToast = stringResource(R.string.active_section_api_hermes_voice_reachable)
     val apiRelayVoiceReachableToast = stringResource(R.string.active_section_api_relay_voice_reachable)
     val apiReachableVoiceReviewToast = stringResource(R.string.active_section_api_reachable_voice_review)
@@ -926,21 +922,21 @@ private fun ManualUrlSubsection(
                         relayOverrideVisible = true
                         result.relayUrl?.let { relayUrlInput = it }
                     }
-                    Toast.makeText(
-                        context,
-                        when {
-                            result.apiReachable && result.voiceConfigReachable ->
-                                if (result.voiceRoute == "standard") {
-                                    apiHermesVoiceReachableToast
-                                } else {
-                                    apiRelayVoiceReachableToast
-                                }
-                            result.apiReachable ->
-                                apiReachableVoiceReviewToast
-                            else -> cannotReachApiToast
-                        },
-                        Toast.LENGTH_SHORT,
-                    ).show()
+                    val feedback = when {
+                        result.apiReachable && result.voiceConfigReachable ->
+                            if (result.voiceRoute == "standard") {
+                                apiHermesVoiceReachableToast
+                            } else {
+                                apiRelayVoiceReachableToast
+                            }
+                        result.apiReachable -> apiReachableVoiceReviewToast
+                        else -> cannotReachApiToast
+                    }
+                    when {
+                        result.apiReachable && result.voiceConfigReachable -> UiMessageBus.success(feedback)
+                        result.apiReachable -> UiMessageBus.warning(feedback)
+                        else -> UiMessageBus.error(feedback)
+                    }
                 }
             },
             enabled = apiUrlInput.isNotBlank() && !isTestingApi && inputApiKeyError == null,

app/src/main/kotlin/com/hermesandroid/relay/ui/components/AttachmentGallery.kt

@@ -31,6 +31,7 @@ import androidx.compose.runtime.mutableStateMapOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -128,10 +129,11 @@ fun AttachmentGallery(
     val exportAllowed = LocalImageExportAllowed.current
     val scope = rememberCoroutineScope()
     val blurMode = LocalMediaBlurMode.current
+    val viewerController = LocalChatMediaViewerController.current
     val revealed = remember { mutableStateMapOf<String, Boolean>() }
-    var viewerStartIndex by remember { mutableStateOf<Int?>(null) }
+    var viewerStartIndex by rememberSaveable { mutableStateOf<Int?>(null) }
 
-    viewerStartIndex?.let { startIndex ->
+    viewerStartIndex?.takeIf { viewerController == null }?.let { startIndex ->
         AttachmentGalleryViewer(
             attachments = attachments,
             initialIndex = startIndex.coerceIn(attachments.indices),
@@ -184,7 +186,21 @@ fun AttachmentGallery(
                                     .testTag("attachment-gallery-tile-$galleryIndex")
                                     .clip(RoundedCornerShape(GALLERY_CORNER))
                                     .combinedClickable(
-                                        onClick = { viewerStartIndex = galleryIndex },
+                                        onClick = {
+                                            if (viewerController != null) {
+                                                viewerController.openGallery(
+                                                    attachments = attachments,
+                                                    initialIndex = galleryIndex,
+                                                    initiallyRevealedKeys = revealed
+                                                        .filterValues { it }
+                                                        .keys,
+                                                    blurMode = blurMode,
+                                                    exportAllowed = exportAllowed,
+                                                )
+                                            } else {
+                                                viewerStartIndex = galleryIndex
+                                            }
+                                        },
                                         onLongClick = { menuExpanded = true },
                                     ),
                             )

app/src/main/kotlin/com/hermesandroid/relay/ui/components/AttachmentViewer.kt

@@ -9,8 +9,7 @@ import android.media.audiofx.Visualizer
 import android.net.Uri
 import android.os.Build
 import android.os.ParcelFileDescriptor
-import android.view.SurfaceView
-import android.widget.Toast
+import com.hermesandroid.relay.ui.UiMessageBus
 import androidx.annotation.OptIn
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
@@ -63,10 +62,12 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
 import androidx.compose.runtime.mutableStateMapOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Alignment
@@ -86,13 +87,13 @@ import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.IntSize
-import androidx.compose.ui.viewinterop.AndroidView
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
 import androidx.media3.common.MediaItem
 import androidx.media3.common.Player
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.ui.compose.ContentFrame
 import coil3.compose.AsyncImage
 import com.hermesandroid.relay.data.Attachment
 import com.hermesandroid.relay.data.AttachmentRenderMode
@@ -290,7 +291,7 @@ fun Modifier.zoomable(maxScale: Float = 6f): Modifier {
  * Dispatches on [Attachment.renderMode]:
  *  - IMAGE → zoomable image (Coil from the cached URI, or a decoded bitmap),
  *            honoring the sensitive blur gate.
- *  - VIDEO → ExoPlayer on a hand-wired [SurfaceView] with transport controls.
+ *  - VIDEO → ExoPlayer through Media3's lifecycle-aware Compose content frame.
  *  - AUDIO → ExoPlayer mini-player with scrubber + a Visualizer amplitude meter.
  *  - PDF   → [PdfRenderer] paginated pages in a LazyColumn.
  *  - TEXT  → in-app monospace text viewer.
@@ -311,109 +312,112 @@ fun AttachmentViewer(
         onDismissRequest = onDismiss,
         properties = DialogProperties(usePlatformDefaultWidth = false),
     ) {
-        val context = LocalContext.current
-        val exportAllowed = LocalImageExportAllowed.current ||
-            attachment.renderMode != AttachmentRenderMode.IMAGE
-        AllowDeviceRotation()
-        val scope = rememberCoroutineScope()
-        var busy by remember { mutableStateOf(false) }
+        MessageOverlayScope {
+            val context = LocalContext.current
+            val exportAllowed = LocalImageExportAllowed.current ||
+                attachment.renderMode != AttachmentRenderMode.IMAGE
+            AllowDeviceRotation()
+            val scope = rememberCoroutineScope()
+            var busy by remember { mutableStateOf(false) }
 
-        val blurMode = LocalMediaBlurMode.current
-        var revealed by remember(attachment.cachedUri, attachment.relayToken) {
-            mutableStateOf(initiallyRevealed)
-        }
-        val blurred = !revealed &&
-            attachment.renderMode == AttachmentRenderMode.IMAGE &&
-            shouldBlurImage(blurMode, attachment.sensitive)
-
-        val title = attachment.fileName
-            ?: attachment.contentType.substringBefore(';').ifBlank { stringResource(R.string.attachment_title) }
-
-        // --- One shared Share / Save / Open-externally action set ----------
-        fun runWithBytes(action: suspend (ByteArray) -> Unit) {
-            scope.launch {
-                busy = true
-                val bytes = attachmentBytes(context, attachment)
-                if (bytes == null) {
-                    busy = false
-                    viewerToast(context, context.getString(R.string.inbound_attach_share_failed))
-                    return@launch
-                }
-                action(bytes)
-                busy = false
+            val blurMode = LocalMediaBlurMode.current
+            var revealed by remember(attachment.cachedUri, attachment.relayToken) {
+                mutableStateOf(initiallyRevealed)
             }
-        }
+            val blurred = !revealed &&
+                attachment.renderMode == AttachmentRenderMode.IMAGE &&
+                shouldBlurImage(blurMode, attachment.sensitive)
 
-        val onShare = {
-            runWithBytes { bytes ->
-                val uri = MediaSaver.stageForShare(context, bytes, attachment.fileName, attachment.contentType)
-                MediaSaver.share(context, uri, attachment.contentType)
-            }
-        }
-        val onSave = {
-            runWithBytes { bytes ->
-                val result = if (attachment.renderMode == AttachmentRenderMode.IMAGE) {
-                    MediaSaver.saveImage(context, bytes, attachment.fileName, attachment.contentType)
-                } else {
-                    MediaSaver.saveFile(context, bytes, attachment.fileName, attachment.contentType)
-                }
-                when (result) {
-                    is MediaSaver.SaveResult.Saved ->
-                        viewerToast(context, context.getString(R.string.inbound_attach_saved, result.location))
-                    MediaSaver.SaveResult.UseShareInstead -> {
-                        val uri = MediaSaver.stageForShare(context, bytes, attachment.fileName, attachment.contentType)
-                        MediaSaver.share(context, uri, attachment.contentType)
+            val title = attachment.fileName
+                ?: attachment.contentType.substringBefore(';').ifBlank { stringResource(R.string.attachment_title) }
+
+            // --- One shared Share / Save / Open-externally action set ----------
+            fun runWithBytes(action: suspend (ByteArray) -> Unit) {
+                scope.launch {
+                    busy = true
+                    val bytes = attachmentBytes(context, attachment)
+                    if (bytes == null) {
+                        busy = false
+                        UiMessageBus.error(context.getString(R.string.inbound_attach_share_failed))
+                        return@launch
                     }
-                    is MediaSaver.SaveResult.Failed ->
-                        viewerToast(context, context.getString(R.string.inbound_attach_save_failed, result.message))
+                    action(bytes)
+                    busy = false
                 }
             }
-        }
-        val onOpenExternal = {
-            val cached = attachment.cachedUri
-            if (!cached.isNullOrBlank()) {
-                MediaSaver.open(context, Uri.parse(cached), attachment.contentType)
-            } else {
+
+            val onShare = {
                 runWithBytes { bytes ->
                     val uri = MediaSaver.stageForShare(context, bytes, attachment.fileName, attachment.contentType)
-                    MediaSaver.open(context, uri, attachment.contentType)
+                    MediaSaver.share(context, uri, attachment.contentType)
                 }
             }
-        }
-
-        Box(
-            modifier = modifier
-                .fillMaxSize()
-                .background(Color.Black.copy(alpha = 0.96f)),
-        ) {
-            // Body fills; toolbar floats on top. PDF/TEXT add their own top
-            // inset so the first line clears the toolbar.
-            Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
-                when (attachment.renderMode) {
-                    AttachmentRenderMode.IMAGE -> ImageBody(
-                        attachment = attachment,
-                        blurred = blurred,
-                        onReveal = { revealed = true },
-                    )
-                    AttachmentRenderMode.VIDEO -> VideoBody(attachment)
-                    AttachmentRenderMode.AUDIO -> AudioBody(attachment)
-                    AttachmentRenderMode.PDF -> PdfBody(attachment)
-                    AttachmentRenderMode.TEXT -> TextBody(attachment)
-                    AttachmentRenderMode.GENERIC -> GenericBody(attachment, onOpenExternal)
+            val onSave = {
+                runWithBytes { bytes ->
+                    val result = if (attachment.renderMode == AttachmentRenderMode.IMAGE) {
+                        MediaSaver.saveImage(context, bytes, attachment.fileName, attachment.contentType)
+                    } else {
+                        MediaSaver.saveFile(context, bytes, attachment.fileName, attachment.contentType)
+                    }
+                    when (result) {
+                        is MediaSaver.SaveResult.Saved ->
+                            UiMessageBus.success(context.getString(R.string.inbound_attach_saved, result.location))
+                        MediaSaver.SaveResult.UseShareInstead -> {
+                            val uri = MediaSaver.stageForShare(context, bytes, attachment.fileName, attachment.contentType)
+                            MediaSaver.share(context, uri, attachment.contentType)
+                        }
+                        is MediaSaver.SaveResult.Failed ->
+                            UiMessageBus.error(context.getString(R.string.inbound_attach_save_failed, result.message))
+                    }
+                }
+            }
+            val onOpenExternal = {
+                val cached = attachment.cachedUri
+                if (!cached.isNullOrBlank()) {
+                    MediaSaver.open(context, Uri.parse(cached), attachment.contentType)
+                } else {
+                    runWithBytes { bytes ->
+                        val uri = MediaSaver.stageForShare(context, bytes, attachment.fileName, attachment.contentType)
+                        MediaSaver.open(context, uri, attachment.contentType)
+                    }
                 }
             }
 
-            MediaViewerToolbar(
-                title = title,
-                busy = busy,
-                actionsEnabled = !blurred,
-                exportAllowed = exportAllowed,
-                onShare = onShare,
-                onSave = onSave,
-                onOpenExternal = onOpenExternal,
-                onClose = onDismiss,
-                modifier = Modifier.align(Alignment.TopCenter),
-            )
+            Box(
+                modifier = modifier
+                    .fillMaxSize()
+                    .background(Color.Black.copy(alpha = 0.96f))
+                    .testTag("attachment-viewer"),
+            ) {
+                // Body fills; toolbar floats on top. PDF/TEXT add their own top
+                // inset so the first line clears the toolbar.
+                Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                    when (attachment.renderMode) {
+                        AttachmentRenderMode.IMAGE -> ImageBody(
+                            attachment = attachment,
+                            blurred = blurred,
+                            onReveal = { revealed = true },
+                        )
+                        AttachmentRenderMode.VIDEO -> VideoBody(attachment)
+                        AttachmentRenderMode.AUDIO -> AudioBody(attachment)
+                        AttachmentRenderMode.PDF -> PdfBody(attachment)
+                        AttachmentRenderMode.TEXT -> TextBody(attachment)
+                        AttachmentRenderMode.GENERIC -> GenericBody(attachment, onOpenExternal)
+                    }
+                }
+
+                MediaViewerToolbar(
+                    title = title,
+                    busy = busy,
+                    actionsEnabled = !blurred,
+                    exportAllowed = exportAllowed,
+                    onShare = onShare,
+                    onSave = onSave,
+                    onOpenExternal = onOpenExternal,
+                    onClose = onDismiss,
+                    modifier = Modifier.align(Alignment.TopCenter),
+                )
+            }
         }
     }
 }
@@ -450,164 +454,165 @@ internal fun AttachmentGalleryViewer(
         onDismissRequest = onDismiss,
         properties = DialogProperties(usePlatformDefaultWidth = false),
     ) {
-        val context = LocalContext.current
-        val exportAllowed = LocalImageExportAllowed.current
-        AllowDeviceRotation()
-        val scope = rememberCoroutineScope()
-        var busy by remember { mutableStateOf(false) }
-        val revealed = remember { mutableStateMapOf<String, Boolean>() }
-        LaunchedEffect(initiallyRevealedKeys) {
-            initiallyRevealedKeys.forEach { revealed[it] = true }
-        }
-        val pagerState = rememberPagerState(
-            initialPage = initialIndex.coerceIn(attachments.indices),
-            pageCount = { attachments.size },
-        )
-
-        val currentIndex = pagerState.currentPage.coerceIn(attachments.indices)
-        val attachment = attachments[currentIndex]
-        val currentKey = galleryAttachmentKey(attachment, currentIndex)
-        val blurMode = LocalMediaBlurMode.current
-        val currentBlurred = revealed[currentKey] != true &&
-            shouldBlurImage(blurMode, attachment.sensitive)
-        val title = attachment.fileName
-            ?: attachment.contentType.substringBefore(';').ifBlank { "Image" }
-        val toolbarTitle = "$title · ${currentIndex + 1} of ${attachments.size}"
-
-        // Capture the currently visible attachment in each click lambda. A
-        // swipe while IO is running must not redirect Save/Share to a new page.
-        fun runWithBytes(action: suspend (Attachment, ByteArray) -> Unit) {
-            if (currentBlurred || busy) return
-            val target = attachment
-            scope.launch {
-                busy = true
-                try {
-                    val bytes = attachmentBytes(context, target)
-                    if (bytes == null) {
-                        viewerToast(context, "Couldn't read this image")
-                        return@launch
-                    }
-                    action(target, bytes)
-                } catch (error: Exception) {
-                    viewerToast(
-                        context,
-                        error.message?.takeIf { it.isNotBlank() }
-                            ?: "Couldn't complete that image action",
-                    )
-                } finally {
-                    busy = false
-                }
+        MessageOverlayScope {
+            val context = LocalContext.current
+            val exportAllowed = LocalImageExportAllowed.current
+            AllowDeviceRotation()
+            val scope = rememberCoroutineScope()
+            var busy by remember { mutableStateOf(false) }
+            val revealed = remember { mutableStateMapOf<String, Boolean>() }
+            LaunchedEffect(initiallyRevealedKeys) {
+                initiallyRevealedKeys.forEach { revealed[it] = true }
             }
-        }
+            val pagerState = rememberPagerState(
+                initialPage = initialIndex.coerceIn(attachments.indices),
+                pageCount = { attachments.size },
+            )
 
-        val onShare = {
-            runWithBytes { target, bytes ->
-                val uri = MediaSaver.stageForShare(
-                    context,
-                    bytes,
-                    target.fileName,
-                    target.contentType,
-                )
-                MediaSaver.share(context, uri, target.contentType)
-            }
-        }
-        val onSave = {
-            runWithBytes { target, bytes ->
-                when (val result = MediaSaver.saveImage(
-                    context,
-                    bytes,
-                    target.fileName,
-                    target.contentType,
-                )) {
-                    is MediaSaver.SaveResult.Saved ->
-                        viewerToast(context, "Saved to ${result.location}")
-                    MediaSaver.SaveResult.UseShareInstead -> {
-                        val uri = MediaSaver.stageForShare(
-                            context,
-                            bytes,
-                            target.fileName,
-                            target.contentType,
+            val currentIndex = pagerState.currentPage.coerceIn(attachments.indices)
+            val attachment = attachments[currentIndex]
+            val currentKey = galleryAttachmentKey(attachment, currentIndex)
+            val blurMode = LocalMediaBlurMode.current
+            val currentBlurred = revealed[currentKey] != true &&
+                shouldBlurImage(blurMode, attachment.sensitive)
+            val title = attachment.fileName
+                ?: attachment.contentType.substringBefore(';').ifBlank { "Image" }
+            val toolbarTitle = "$title · ${currentIndex + 1} of ${attachments.size}"
+
+            // Capture the currently visible attachment in each click lambda. A
+            // swipe while IO is running must not redirect Save/Share to a new page.
+            fun runWithBytes(action: suspend (Attachment, ByteArray) -> Unit) {
+                if (currentBlurred || busy) return
+                val target = attachment
+                scope.launch {
+                    busy = true
+                    try {
+                        val bytes = attachmentBytes(context, target)
+                        if (bytes == null) {
+                            UiMessageBus.error("Couldn't read this image")
+                            return@launch
+                        }
+                        action(target, bytes)
+                    } catch (error: Exception) {
+                        UiMessageBus.error(
+                            error.message?.takeIf { it.isNotBlank() }
+                                ?: "Couldn't complete that image action",
                         )
-                        MediaSaver.share(context, uri, target.contentType)
+                    } finally {
+                        busy = false
                     }
-                    is MediaSaver.SaveResult.Failed ->
-                        viewerToast(context, "Save failed: ${result.message}")
                 }
             }
-        }
-        val onOpenExternal: () -> Unit = openExternal@{
-            if (currentBlurred || busy) return@openExternal
-            val target = attachment
-            val cached = target.cachedUri
-            if (!cached.isNullOrBlank()) {
-                runCatching {
-                    MediaSaver.open(context, Uri.parse(cached), target.contentType)
-                }.onFailure {
-                    viewerToast(context, "Couldn't open this image")
-                }
-            } else {
-                runWithBytes { item, bytes ->
+
+            val onShare = {
+                runWithBytes { target, bytes ->
                     val uri = MediaSaver.stageForShare(
                         context,
                         bytes,
-                        item.fileName,
-                        item.contentType,
+                        target.fileName,
+                        target.contentType,
                     )
-                    MediaSaver.open(context, uri, item.contentType)
+                    MediaSaver.share(context, uri, target.contentType)
                 }
             }
-        }
-
-        Box(
-            modifier = modifier
-                .fillMaxSize()
-                .background(Color.Black.copy(alpha = 0.96f)),
-        ) {
-            HorizontalPager(
-                state = pagerState,
-                beyondViewportPageCount = 0,
-                pageSpacing = 12.dp,
-                modifier = Modifier
-                    .fillMaxSize()
-                    .testTag("attachment-gallery-pager"),
-            ) { page ->
-                val pageAttachment = attachments[page]
-                val pageKey = galleryAttachmentKey(pageAttachment, page)
-                val blurred = revealed[pageKey] != true && shouldBlurImage(
-                    blurMode,
-                    pageAttachment.sensitive,
-                )
-                ImageBody(
-                    attachment = pageAttachment,
-                    blurred = blurred,
-                    onReveal = { revealed[pageKey] = true },
-                )
+            val onSave = {
+                runWithBytes { target, bytes ->
+                    when (val result = MediaSaver.saveImage(
+                        context,
+                        bytes,
+                        target.fileName,
+                        target.contentType,
+                    )) {
+                        is MediaSaver.SaveResult.Saved ->
+                            UiMessageBus.success("Saved to ${result.location}")
+                        MediaSaver.SaveResult.UseShareInstead -> {
+                            val uri = MediaSaver.stageForShare(
+                                context,
+                                bytes,
+                                target.fileName,
+                                target.contentType,
+                            )
+                            MediaSaver.share(context, uri, target.contentType)
+                        }
+                        is MediaSaver.SaveResult.Failed ->
+                            UiMessageBus.error("Save failed: ${result.message}")
+                    }
+                }
+            }
+            val onOpenExternal: () -> Unit = openExternal@{
+                if (currentBlurred || busy) return@openExternal
+                val target = attachment
+                val cached = target.cachedUri
+                if (!cached.isNullOrBlank()) {
+                    runCatching {
+                        MediaSaver.open(context, Uri.parse(cached), target.contentType)
+                    }.onFailure {
+                        UiMessageBus.error("Couldn't open this image")
+                    }
+                } else {
+                    runWithBytes { item, bytes ->
+                        val uri = MediaSaver.stageForShare(
+                            context,
+                            bytes,
+                            item.fileName,
+                            item.contentType,
+                        )
+                        MediaSaver.open(context, uri, item.contentType)
+                    }
+                }
             }
 
-            MediaViewerToolbar(
-                title = toolbarTitle,
-                busy = busy,
-                actionsEnabled = !currentBlurred,
-                exportAllowed = exportAllowed,
-                onShare = onShare,
-                onSave = onSave,
-                onOpenExternal = onOpenExternal,
-                onClose = onDismiss,
-                modifier = Modifier.align(Alignment.TopCenter),
-            )
+            Box(
+                modifier = modifier
+                    .fillMaxSize()
+                    .background(Color.Black.copy(alpha = 0.96f)),
+            ) {
+                HorizontalPager(
+                    state = pagerState,
+                    beyondViewportPageCount = 0,
+                    pageSpacing = 12.dp,
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .testTag("attachment-gallery-pager"),
+                ) { page ->
+                    val pageAttachment = attachments[page]
+                    val pageKey = galleryAttachmentKey(pageAttachment, page)
+                    val blurred = revealed[pageKey] != true && shouldBlurImage(
+                        blurMode,
+                        pageAttachment.sensitive,
+                    )
+                    ImageBody(
+                        attachment = pageAttachment,
+                        blurred = blurred,
+                        onReveal = { revealed[pageKey] = true },
+                    )
+                }
 
-            Text(
-                text = "${currentIndex + 1} / ${attachments.size}",
-                style = MaterialTheme.typography.labelMedium,
-                color = Color.White,
-                modifier = Modifier
-                    .align(Alignment.BottomCenter)
-                    .windowInsetsPadding(WindowInsets.safeDrawing)
-                    .padding(bottom = 12.dp)
-                    .clip(RoundedCornerShape(50))
-                    .background(Color.Black.copy(alpha = 0.55f))
-                    .padding(horizontal = 12.dp, vertical = 6.dp),
-            )
+                MediaViewerToolbar(
+                    title = toolbarTitle,
+                    busy = busy,
+                    actionsEnabled = !currentBlurred,
+                    exportAllowed = exportAllowed,
+                    onShare = onShare,
+                    onSave = onSave,
+                    onOpenExternal = onOpenExternal,
+                    onClose = onDismiss,
+                    modifier = Modifier.align(Alignment.TopCenter),
+                )
+
+                Text(
+                    text = "${currentIndex + 1} / ${attachments.size}",
+                    style = MaterialTheme.typography.labelMedium,
+                    color = Color.White,
+                    modifier = Modifier
+                        .align(Alignment.BottomCenter)
+                        .windowInsetsPadding(WindowInsets.safeDrawing)
+                        .padding(bottom = 12.dp)
+                        .clip(RoundedCornerShape(50))
+                        .background(Color.Black.copy(alpha = 0.55f))
+                        .padding(horizontal = 12.dp, vertical = 6.dp),
+                )
+            }
         }
     }
 }
@@ -737,17 +742,27 @@ private fun VideoBody(attachment: Attachment) {
         return
     }
 
+    var savedPosition by rememberSaveable(uri.toString()) { mutableLongStateOf(0L) }
+    var wantsToPlay by rememberSaveable(uri.toString()) { mutableStateOf(true) }
+    var muted by rememberSaveable(uri.toString()) { mutableStateOf(false) }
     val player = remember(uri) {
         ExoPlayer.Builder(context).build().apply {
             setMediaItem(MediaItem.fromUri(uri))
+            if (savedPosition > 0L) seekTo(savedPosition)
+            playWhenReady = wantsToPlay
+            volume = if (muted) 0f else 1f
             prepare()
-            playWhenReady = true
         }
     }
-    DisposableEffect(player) { onDispose { player.release() } }
+    DisposableEffect(player) {
+        onDispose {
+            savedPosition = player.currentPosition.coerceAtLeast(0L)
+            wantsToPlay = player.playWhenReady
+            player.release()
+        }
+    }
 
-    var isPlaying by remember { mutableStateOf(true) }
-    var muted by remember { mutableStateOf(false) }
+    var isPlaying by remember { mutableStateOf(player.isPlaying) }
     var position by remember { mutableStateOf(0L) }
     var duration by remember { mutableStateOf(0L) }
 
@@ -761,24 +776,30 @@ private fun VideoBody(attachment: Attachment) {
     LaunchedEffect(player) {
         while (true) {
             position = player.currentPosition.coerceAtLeast(0L)
+            savedPosition = position
             duration = player.duration.takeIf { it > 0L } ?: 0L
             delay(250)
         }
     }
 
     Column(modifier = Modifier.fillMaxSize(), verticalArrangement = Arrangement.Center) {
-        AndroidView(
-            factory = { ctx ->
-                SurfaceView(ctx).also { player.setVideoSurfaceView(it) }
-            },
-            modifier = Modifier.fillMaxWidth().weight(1f, fill = false).aspectRatio(16f / 9f),
-        )
+        Box(
+            modifier = Modifier.fillMaxWidth().weight(1f),
+            contentAlignment = Alignment.Center,
+        ) {
+            ContentFrame(
+                player = player,
+                modifier = Modifier.fillMaxSize().testTag("attachment-video-content"),
+                contentScale = ContentScale.Fit,
+            )
+        }
         PlaybackControls(
             isPlaying = isPlaying,
             position = position,
             duration = duration,
             onPlayPause = {
-                if (player.isPlaying) player.pause() else player.play()
+                wantsToPlay = !player.playWhenReady
+                player.playWhenReady = wantsToPlay
             },
             onSeek = { player.seekTo(it) },
             trailing = {
@@ -1173,10 +1194,6 @@ private fun rememberPlayableUri(attachment: Attachment): Uri? {
     return uri
 }
 
-private fun viewerToast(context: Context, message: String) {
-    Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
-}
-
 private const val MAX_TEXT_BYTES = 2 * 1024 * 1024
 
 // --- Non-composable IO helpers ---------------------------------------------

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatActivityReceipt.kt

@@ -0,0 +1,118 @@
+package com.hermesandroid.relay.ui.components
+
+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.heightIn
+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.AccountTree
+import androidx.compose.material.icons.filled.ChevronRight
+import androidx.compose.material.icons.filled.Terminal
+import androidx.compose.material3.Icon
+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.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.stateDescription
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.R
+import com.hermesandroid.relay.data.ChatActivityKind
+import com.hermesandroid.relay.data.ChatActivityPhase
+import com.hermesandroid.relay.data.ChatActivityRecord
+
+/** Stable transcript entry into the same read-only preview used by active work. */
+@Composable
+internal fun ChatActivityReceipt(
+    record: ChatActivityRecord,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val subagents = record.kind == ChatActivityKind.SUBAGENTS
+    val title = stringResource(
+        if (subagents) R.string.chat_activity_receipt_subagents else R.string.chat_activity_receipt_process,
+    )
+    val action = stringResource(
+        if (subagents) R.string.chat_activity_receipt_view_activity else R.string.chat_activity_receipt_view_output,
+    )
+    val status = if (subagents && record.children.isNotEmpty()) {
+        val groups = record.children.groupingBy { it.phase }.eachCount().toMutableMap()
+        val missing = (record.taskCount - record.children.size).coerceAtLeast(0)
+        if (missing > 0) groups[ChatActivityPhase.UNKNOWN] = (groups[ChatActivityPhase.UNKNOWN] ?: 0) + missing
+        val labels = groups.map { (phase, count) ->
+            stringResource(R.string.chat_activity_receipt_count_phase, count, activityPhaseLabel(phase))
+        }
+        labels.joinToString(" · ")
+    } else if (subagents && record.taskCount > 0) {
+        stringResource(R.string.chat_activity_receipt_count_phase, record.taskCount, activityPhaseLabel(record.phase))
+    } else {
+        activityPhaseLabel(record.phase)
+    }
+    Surface(
+        modifier = modifier
+            .fillMaxWidth()
+            .heightIn(min = 48.dp)
+            .semantics(mergeDescendants = true) { stateDescription = status }
+            .clickable(role = Role.Button, onClickLabel = action, onClick = onClick),
+        shape = MaterialTheme.shapes.medium,
+        color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.58f),
+    ) {
+        Row(
+            modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Icon(
+                imageVector = if (subagents) Icons.Filled.AccountTree else Icons.Filled.Terminal,
+                contentDescription = null,
+                tint = if (record.phase == ChatActivityPhase.FAILED) {
+                    MaterialTheme.colorScheme.error
+                } else {
+                    MaterialTheme.colorScheme.onSurfaceVariant
+                },
+                modifier = Modifier.size(16.dp),
+            )
+            Spacer(Modifier.width(8.dp))
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = "$title · $status",
+                    style = MaterialTheme.typography.labelMedium,
+                    maxLines = 2,
+                    overflow = TextOverflow.Ellipsis,
+                )
+                Text(
+                    text = action,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            Spacer(Modifier.width(8.dp))
+            Icon(
+                imageVector = Icons.Filled.ChevronRight,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.size(18.dp),
+            )
+        }
+    }
+}
+
+@Composable
+private fun activityPhaseLabel(phase: ChatActivityPhase): String = stringResource(
+    when (phase) {
+        ChatActivityPhase.RUNNING -> R.string.bg_processes_running
+        ChatActivityPhase.COMPLETE -> R.string.agent_activity_status_completed
+        ChatActivityPhase.FAILED -> R.string.agent_activity_status_failed
+        ChatActivityPhase.CANCELLED -> R.string.task_status_cancelled
+        ChatActivityPhase.UNKNOWN -> R.string.agent_activity_status_unavailable
+    },
+)

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatBusyControls.kt

@@ -0,0 +1,215 @@
+package com.hermesandroid.relay.ui.components
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Stop
+import androidx.compose.material.icons.filled.ExpandLess
+import androidx.compose.material.icons.filled.ExpandMore
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.zIndex
+import com.hermesandroid.relay.ui.theme.appearanceTopRoundedCornerShape
+import com.hermesandroid.relay.R
+import com.hermesandroid.relay.data.BusyMessageAction
+
+private val COMPOSER_TRAY_UNDERLAP = 12.dp
+
+/** A separate rear surface tucked beneath the composer's foreground edge. */
+@Composable
+fun ChatComposerLayers(
+    action: BusyMessageAction?,
+    onActionChange: (BusyMessageAction) -> Unit,
+    correctionAvailable: Boolean,
+    onStop: (() -> Unit)?,
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    Column(
+        modifier = modifier.fillMaxWidth(),
+        verticalArrangement = Arrangement.spacedBy(-COMPOSER_TRAY_UNDERLAP),
+    ) {
+        if (action != null) {
+            ChatBusyActionSelector(
+                action, onActionChange,
+                correctionAvailable = correctionAvailable,
+                onStop = onStop,
+                bottomUnderlap = COMPOSER_TRAY_UNDERLAP,
+                modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp).zIndex(0f),
+            )
+        }
+        Box(Modifier.fillMaxWidth().zIndex(1f).testTag("chatComposerForeground")) { content() }
+    }
+}
+
+/** Compact current intent; optional plain-text choices slide out from behind it. */
+@Composable
+fun ChatBusyActionSelector(
+    action: BusyMessageAction,
+    onActionChange: (BusyMessageAction) -> Unit,
+    modifier: Modifier = Modifier,
+    correctionAvailable: Boolean = true,
+    onStop: (() -> Unit)? = null,
+    bottomUnderlap: Dp = 0.dp,
+) {
+    var expanded by remember { mutableStateOf(false) }
+    BackHandler(enabled = expanded) { expanded = false }
+    Surface(
+        modifier = modifier.testTag("chatBusyActionTray"),
+        color = MaterialTheme.colorScheme.surfaceContainerLow.copy(alpha = 0.82f),
+        shape = appearanceTopRoundedCornerShape(12.dp),
+        tonalElevation = 0.dp,
+    ) {
+        Column(Modifier.padding(bottom = bottomUnderlap)) {
+            AnimatedVisibility(
+                visible = expanded,
+                enter = expandVertically(tween(220), expandFrom = Alignment.Bottom) +
+                    slideInVertically(tween(220)) { it } + fadeIn(tween(160)),
+                exit = shrinkVertically(tween(180), shrinkTowards = Alignment.Bottom) +
+                    slideOutVertically(tween(180)) { it } + fadeOut(tween(120)),
+            ) {
+                Row(
+                    Modifier.fillMaxWidth().testTag("chatBusyActionDrawer").padding(horizontal = 8.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    BusyMessageAction.entries.forEach { option ->
+                        val available = option == BusyMessageAction.QueueNext || correctionAvailable
+                        Row(
+                            Modifier.weight(1f).heightIn(min = 48.dp)
+                                .testTag("chatBusyAction-${option.storedValue}")
+                                .selectable(selected = option == action, enabled = available, role = Role.RadioButton) {
+                                    onActionChange(option)
+                                    expanded = false
+                                }.padding(horizontal = 8.dp),
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.spacedBy(6.dp),
+                        ) {
+                            if (option == action) {
+                                Icon(Icons.Default.Check, null, Modifier.size(14.dp),
+                                    tint = MaterialTheme.colorScheme.onSurface)
+                            } else Spacer(Modifier.size(14.dp))
+                            Text(
+                                stringResource(if (option == BusyMessageAction.CorrectNow) R.string.chat_correct_now else R.string.chat_queue_next),
+                                style = MaterialTheme.typography.labelMedium,
+                                color = MaterialTheme.colorScheme.onSurface.copy(alpha = if (available) 1f else 0.38f),
+                            )
+                        }
+                    }
+                }
+            }
+            Row(
+                Modifier.fillMaxWidth().padding(horizontal = 12.dp),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Row(
+                    Modifier.weight(1f).heightIn(min = 40.dp)
+                        .testTag("chatBusyActionTrigger")
+                        .clickable(role = Role.Button) { expanded = !expanded },
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(4.dp),
+                ) {
+                    Text(
+                        stringResource(if (action == BusyMessageAction.CorrectNow) R.string.chat_correct_now else R.string.chat_queue_next),
+                        style = MaterialTheme.typography.labelSmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                    Icon(
+                        if (expanded) Icons.Default.ExpandMore else Icons.Default.ExpandLess,
+                        null, Modifier.size(14.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+                if (onStop != null) {
+                    IconButton(onClick = onStop) {
+                        Icon(Icons.Default.Stop, stringResource(R.string.chat_input_stop_streaming), Modifier.size(18.dp))
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun ChatMessageQueue(
+    messages: List<String>,
+    paused: Boolean,
+    onResume: () -> Unit,
+    onClear: () -> Unit,
+    onEdit: (Int) -> Unit,
+    onRemove: (Int) -> Unit,
+    canEdit: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    if (messages.isEmpty()) return
+    Column(modifier) {
+        Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+            Text(
+                if (paused) stringResource(R.string.chat_queue_paused)
+                else pluralStringResource(R.plurals.chat_queue_count, messages.size, messages.size),
+                style = MaterialTheme.typography.labelMedium,
+                modifier = Modifier.weight(1f),
+            )
+            if (paused) TextButton(onClick = onResume) { Text(stringResource(R.string.chat_queue_resume)) }
+            TextButton(onClick = onClear) { Text(stringResource(R.string.chat_clear)) }
+        }
+        Column(
+            Modifier.heightIn(max = 144.dp).verticalScroll(rememberScrollState()),
+            verticalArrangement = Arrangement.spacedBy(2.dp),
+        ) {
+            messages.forEachIndexed { index, text ->
+                Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+                    Text(
+                        text = text,
+                        maxLines = 2,
+                        overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis,
+                        style = MaterialTheme.typography.bodySmall,
+                        modifier = Modifier.weight(1f)
+                            .clickable(enabled = canEdit, role = Role.Button) { onEdit(index) }
+                            .padding(vertical = 12.dp),
+                    )
+                    IconButton(onClick = { onRemove(index) }) {
+                        Icon(Icons.Default.Close, stringResource(R.string.chat_queue_remove))
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatDebugDrawer.kt

@@ -0,0 +1,197 @@
+package com.hermesandroid.relay.ui.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.activity.compose.BackHandler
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.unit.Dp
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+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.filled.Close
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.paneTitle
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.R
+import com.hermesandroid.relay.diagnostics.DiagnosticsLog
+import com.hermesandroid.relay.network.upstream.GatewayConnectionState
+import com.hermesandroid.relay.viewmodel.ConnectionStepState
+
+@Composable
+internal fun Modifier.chatDebugHeaderGesture(enabled: Boolean, onClick: () -> Unit, onHold: () -> Unit): Modifier =
+    combinedClickable(enabled = enabled, onClick = onClick, onLongClick = onHold,
+        onLongClickLabel = stringResource(R.string.chat_debug_open))
+
+@Composable
+internal fun BoxScope.ChatDebugOverlay(
+    visible: Boolean,
+    headerHeight: Dp,
+    onClose: () -> Unit,
+    content: @Composable () -> Unit,
+) {
+    BackHandler(enabled = visible, onBack = onClose)
+    if (visible) {
+        Box(Modifier.fillMaxSize().padding(top = headerHeight)
+            .background(MaterialTheme.colorScheme.scrim.copy(alpha = 0.28f))
+            .clickable(onClick = onClose))
+    }
+    AnimatedVisibility(
+        visible = visible,
+        enter = slideInVertically { -it } + fadeIn(),
+        exit = slideOutVertically { -it } + fadeOut(),
+        modifier = Modifier.align(Alignment.TopCenter).padding(top = headerHeight).fillMaxWidth().clipToBounds(),
+    ) { content() }
+}
+
+/** Read-only snapshot of the visible conversation; opening it sends no RPCs. */
+@Composable
+internal fun ChatDebugDrawer(
+    profile: String,
+    model: String,
+    sessionId: String?,
+    gateway: Boolean,
+    signedIn: Boolean,
+    signInRequired: Boolean,
+    socketState: GatewayConnectionState,
+    preparing: Boolean,
+    streaming: Boolean,
+    loadingHistory: Boolean,
+    directoryUnavailable: Boolean,
+    failure: String?,
+    onClose: () -> Unit,
+    onConnections: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val title = stringResource(R.string.chat_debug_title)
+    val safeFailure = DiagnosticsLog.redactReportText(failure)?.take(600)
+    val ready = socketState == GatewayConnectionState.Ready
+    val steps = buildList {
+        if (gateway) {
+            add(ConnectionSetupTimelineStep(
+                stringResource(R.string.chat_debug_sign_in),
+                stringResource(when {
+                    signInRequired -> R.string.chat_debug_sign_in_needed
+                    signedIn -> R.string.chat_debug_authenticated
+                    else -> R.string.chat_debug_auth_unknown
+                }),
+                when {
+                    signInRequired -> ConnectionStepState.Failed
+                    signedIn -> ConnectionStepState.Done
+                    else -> ConnectionStepState.Pending
+                },
+            ))
+            add(ConnectionSetupTimelineStep(
+                stringResource(R.string.chat_debug_gateway),
+                stringResource(when (socketState) {
+                    GatewayConnectionState.Ready -> R.string.chat_debug_socket_ready
+                    GatewayConnectionState.MintingTicket -> R.string.chat_debug_ticket
+                    GatewayConnectionState.Connecting -> R.string.chat_debug_socket_connecting
+                    GatewayConnectionState.AwaitingReady -> R.string.chat_debug_socket_waiting
+                    GatewayConnectionState.Idle -> R.string.chat_debug_socket_idle
+                }),
+                when {
+                    ready -> ConnectionStepState.Done
+                    signInRequired -> ConnectionStepState.Failed
+                    socketState != GatewayConnectionState.Idle -> ConnectionStepState.Active
+                    else -> ConnectionStepState.Pending
+                },
+            ))
+        }
+        add(ConnectionSetupTimelineStep(
+            stringResource(R.string.chat_debug_session),
+            stringResource(when {
+                preparing -> R.string.chat_debug_preparing_detail
+                loadingHistory -> R.string.chat_debug_history_loading
+                directoryUnavailable -> R.string.chat_debug_history_failed
+                sessionId != null -> R.string.chat_debug_session_selected
+                else -> R.string.chat_debug_session_new
+            }),
+            when {
+                preparing || loadingHistory -> ConnectionStepState.Active
+                directoryUnavailable -> ConnectionStepState.Failed
+                sessionId != null -> ConnectionStepState.Done
+                else -> ConnectionStepState.Pending
+            },
+        ))
+        add(ConnectionSetupTimelineStep(
+            stringResource(R.string.chat_debug_response),
+            stringResource(when {
+                safeFailure != null -> R.string.chat_debug_response_failed
+                preparing -> R.string.chat_debug_response_waiting
+                streaming -> R.string.chat_debug_response_active
+                else -> R.string.chat_debug_response_idle
+            }),
+            when {
+                safeFailure != null -> ConnectionStepState.Failed
+                preparing -> ConnectionStepState.Pending
+                streaming -> ConnectionStepState.Active
+                else -> ConnectionStepState.Pending
+            },
+        ))
+    }
+    Surface(
+        modifier = modifier.fillMaxWidth().semantics { paneTitle = title },
+        shape = RoundedCornerShape(bottomStart = 24.dp, bottomEnd = 24.dp),
+        color = MaterialTheme.colorScheme.surface,
+        shadowElevation = 8.dp,
+    ) {
+        Column(Modifier.heightIn(max = 560.dp).verticalScroll(rememberScrollState()).padding(20.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp)) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Column(Modifier.weight(1f)) {
+                    Text(title, style = MaterialTheme.typography.titleLarge)
+                    Text(listOf(if (gateway) "Gateway" else "Direct API", profile, model)
+                        .filter(String::isNotBlank).joinToString(" · "), style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant)
+                }
+                IconButton(onClick = onClose) {
+                    Icon(Icons.Filled.Close, stringResource(R.string.chat_debug_close))
+                }
+            }
+            ConnectionSetupTimeline(steps)
+            if (safeFailure != null) {
+                Surface(color = MaterialTheme.colorScheme.errorContainer, shape = RoundedCornerShape(12.dp)) {
+                    Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                        Text(safeFailure, style = MaterialTheme.typography.bodySmall)
+                        if (safeFailure.contains("agent init failed", ignoreCase = true)) {
+                            Text(stringResource(R.string.chat_debug_init_recovery), style = MaterialTheme.typography.bodySmall)
+                        }
+                    }
+                }
+            }
+            HorizontalDivider()
+            Text(stringResource(R.string.chat_debug_session_id, sessionId ?: "—"),
+                style = MaterialTheme.typography.labelSmall, fontFamily = FontFamily.Monospace,
+                color = MaterialTheme.colorScheme.onSurfaceVariant)
+            TextButton(onClick = onConnections) { Text(stringResource(R.string.chat_debug_connections)) }
+        }
+    }
+}

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatFailurePanel.kt

@@ -53,7 +53,13 @@ fun ChatFailurePanel(
                 Spacer(Modifier.width(10.dp))
                 Column(modifier = Modifier.weight(1f)) {
                     Text(
-                        text = stringResource(R.string.chat_failure_title),
+                        text = stringResource(
+                            if (isInferenceUnavailableFailure(failure.rawError)) {
+                                R.string.chat_failure_inference_unavailable
+                            } else {
+                                R.string.chat_failure_title
+                            },
+                        ),
                         style = MaterialTheme.typography.bodyMedium,
                         fontWeight = FontWeight.SemiBold,
                     )
@@ -148,3 +154,10 @@ internal fun failureIdentity(route: String, model: String?, provider: String?):
         provider?.trim()?.takeIf { it.isNotEmpty() },
         model?.trim()?.takeIf { it.isNotEmpty() },
     ).distinct().joinToString(" · ")
+
+internal fun isInferenceUnavailableFailure(rawError: String): Boolean {
+    val message = rawError.lowercase()
+    return "agent init failed" in message ||
+        "no codex credentials stored" in message ||
+        "runtime resolution still failed" in message
+}

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatImageContent.kt

@@ -2,6 +2,7 @@ package com.hermesandroid.relay.ui.components
 
 import android.content.Intent
 import android.graphics.BitmapFactory
+import android.net.Uri
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
@@ -29,6 +30,7 @@ import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Alignment
@@ -97,9 +99,9 @@ private fun isSensitiveAltText(alt: String): Boolean {
 
 /**
  * Resolves a server-local image path — an absolute path the agent put in a
- * markdown image `![alt](/abs/path)` — to raw bytes, via the relay's
- * `/media/by-path` route when a relay session is paired. Returns null when no
- * relay is available or the fetch fails, so the renderer falls back to the
+ * markdown image `![alt](/abs/path)` — to an on-disk cache URI, via the relay's
+ * authenticated Dashboard route (or Relay compatibility route). Returns a
+ * failure when no route is available or the fetch fails, so the renderer falls back to the
  * "this image is on the server" notice. Provided by ChatScreen from
  * [com.hermesandroid.relay.viewmodel.ChatViewModel.resolveServerImage]; the
  * default is null, which preserves the standard (no-plugin) behavior where a
@@ -113,12 +115,12 @@ private fun isSensitiveAltText(alt: String): Boolean {
  * `RelayServerImage` on app open with a server-local image in history).
  */
 sealed interface ServerImageResult {
-    class Success(val bytes: ByteArray, val sensitive: Boolean = false) : ServerImageResult
+    class Success(val cachedUri: String, val sensitive: Boolean = false) : ServerImageResult
     class Failure(val reason: String) : ServerImageResult
 }
 
 fun interface RelayServerImageResolver {
-    /** Fetch the server-local file's bytes over the relay, or a
+    /** Fetch the server-local file into the media cache, or a
      *  [ServerImageResult.Failure] whose reason explains why (unpaired /
      *  sandboxed / missing / decode) so the UI can surface it instead of a
      *  generic placeholder. */
@@ -293,8 +295,10 @@ private sealed interface DataUrlImagePhase {
 @Composable
 private fun DataUrlChatImage(image: ChatInlineImage, maxWidth: Dp) {
     var phase by remember(image.src) { mutableStateOf<DataUrlImagePhase>(DataUrlImagePhase.Loading) }
-    var viewerOpen by remember(image.src) { mutableStateOf(false) }
+    var viewerOpen by rememberSaveable(image.src) { mutableStateOf(false) }
     val blurMode = LocalMediaBlurMode.current
+    val exportAllowed = LocalImageExportAllowed.current
+    val viewerController = LocalChatMediaViewerController.current
     var revealed by remember(image.src) { mutableStateOf(false) }
     LaunchedEffect(image.src) {
         phase = withInlineImageDecodeLock {
@@ -329,17 +333,17 @@ private fun DataUrlChatImage(image: ChatInlineImage, maxWidth: Dp) {
             reason = "Unsupported or oversized inline image.",
         )
         is DataUrlImagePhase.Loaded -> {
-            if (viewerOpen) {
+            val viewerSource = ChatImageViewerSource.Bitmap(
+                bitmap = current.bitmap,
+                displayName = image.alt.ifBlank { "image" },
+                mime = current.mime,
+                // Decode the already-retained data URL only when the user
+                // requests Save/Share; don't retain a second byte array.
+                bytesProvider = { decodeInlineImageDataUrlOffMain(image.src)?.bytes },
+            )
+            if (viewerController == null && viewerOpen) {
                 ChatImageViewer(
-                    source = ChatImageViewerSource.Bitmap(
-                        bitmap = current.bitmap,
-                        displayName = image.alt.ifBlank { "image" },
-                        mime = current.mime,
-                        // Decode the already-retained data URL only when the
-                        // user requests Save/Share; don't keep a second 5 MiB
-                        // byte array beside every thumbnail.
-                        bytesProvider = { decodeInlineImageDataUrlOffMain(image.src)?.bytes },
-                    ),
+                    source = viewerSource,
                     onDismiss = { viewerOpen = false },
                     sensitive = image.sensitive,
                     initiallyRevealed = revealed,
@@ -358,7 +362,19 @@ private fun DataUrlChatImage(image: ChatInlineImage, maxWidth: Dp) {
                             .widthIn(max = maxWidth)
                             .heightIn(max = 360.dp)
                             .clip(RoundedCornerShape(12.dp))
-                            .clickable { viewerOpen = true },
+                            .clickable {
+                                if (viewerController != null) {
+                                    viewerController.openImage(
+                                        source = viewerSource,
+                                        sensitive = image.sensitive,
+                                        initiallyRevealed = revealed,
+                                        blurMode = blurMode,
+                                        exportAllowed = exportAllowed,
+                                    )
+                                } else {
+                                    viewerOpen = true
+                                }
+                            },
                     )
                 }
             }
@@ -368,18 +384,21 @@ private fun DataUrlChatImage(image: ChatInlineImage, maxWidth: Dp) {
 
 @Composable
 private fun RemoteChatImage(image: ChatInlineImage, maxWidth: Dp) {
-    var viewerOpen by remember { mutableStateOf(false) }
+    var viewerOpen by rememberSaveable(image.src) { mutableStateOf(false) }
     val blurMode = LocalMediaBlurMode.current
+    val exportAllowed = LocalImageExportAllowed.current
+    val viewerController = LocalChatMediaViewerController.current
     var revealed by remember(image.src) { mutableStateOf(false) }
     val blurred = !revealed && shouldBlurImage(blurMode, image.sensitive)
-    if (viewerOpen) {
+    val viewerSource = ChatImageViewerSource.Coil(
+        model = image.src,
+        displayName = image.alt.ifBlank { "image" },
+        mime = "image/*",
+        bytesProvider = { MediaSaver.fetchRemoteBytes(image.src).first },
+    )
+    if (viewerController == null && viewerOpen) {
         ChatImageViewer(
-            source = ChatImageViewerSource.Coil(
-                model = image.src,
-                displayName = image.alt.ifBlank { "image" },
-                mime = "image/*",
-                bytesProvider = { MediaSaver.fetchRemoteBytes(image.src).first },
-            ),
+            source = viewerSource,
             onDismiss = { viewerOpen = false },
             sensitive = image.sensitive,
             initiallyRevealed = revealed,
@@ -395,7 +414,19 @@ private fun RemoteChatImage(image: ChatInlineImage, maxWidth: Dp) {
                     .widthIn(max = maxWidth)
                     .heightIn(max = 360.dp)
                     .clip(RoundedCornerShape(12.dp))
-                    .clickable { viewerOpen = true },
+                    .clickable {
+                        if (viewerController != null) {
+                            viewerController.openImage(
+                                source = viewerSource,
+                                sensitive = image.sensitive,
+                                initiallyRevealed = revealed,
+                                blurMode = blurMode,
+                                exportAllowed = exportAllowed,
+                            )
+                        } else {
+                            viewerOpen = true
+                        }
+                    },
             ) {
                 val state by painter.state.collectAsState()
                 when (state) {
@@ -461,6 +492,7 @@ private fun RelayServerImage(
     maxWidth: Dp,
     resolver: RelayServerImageResolver,
 ) {
+    val context = LocalContext.current
     var phase by remember(image.src) {
         mutableStateOf<RelayImagePhase>(
             cachedInlineImage(image.src)
@@ -473,20 +505,22 @@ private fun RelayServerImage(
         phase = withContext(Dispatchers.IO) {
             val result = try {
                 resolver.fetch(image.src)
-            } catch (t: Throwable) {
-                ServerImageResult.Failure(t.message ?: "relay fetch failed")
+            } catch (error: Exception) {
+                ServerImageResult.Failure(error.message ?: "relay fetch failed")
             }
             when (result) {
                 is ServerImageResult.Success -> {
-                    val bytes = result.bytes
-                    val bmp = runCatching {
-                        decodeOrientedBitmap(bytes)
-                    }.getOrNull()?.asImageBitmap()
+                    val cachedUri = Uri.parse(result.cachedUri)
+                    val bmp = try {
+                        decodeBoundedOrientedBitmap(context, cachedUri)
+                    } catch (_: Exception) {
+                        null
+                    }?.asImageBitmap()
                     if (bmp != null) {
                         putInlineImage(image.src, bmp, result.sensitive)
                         RelayImagePhase.Loaded(bmp, result.sensitive)
                     } else {
-                        RelayImagePhase.Failed("fetched ${bytes.size} B but couldn't decode the image")
+                        RelayImagePhase.Failed("fetched file could not be decoded as an image")
                     }
                 }
                 is ServerImageResult.Failure -> RelayImagePhase.Failed(result.reason)
@@ -527,23 +561,32 @@ private fun RelayServerImageContent(
     maxWidth: Dp,
     resolver: RelayServerImageResolver,
 ) {
-    var viewerOpen by remember { mutableStateOf(false) }
+    val context = LocalContext.current
+    var viewerOpen by rememberSaveable(image.src) { mutableStateOf(false) }
     val blurMode = LocalMediaBlurMode.current
+    val exportAllowed = LocalImageExportAllowed.current
+    val viewerController = LocalChatMediaViewerController.current
     var revealed by remember(image.src) { mutableStateOf(false) }
     val sensitive = image.sensitive || fetchedSensitive
     val blurred = !revealed && shouldBlurImage(blurMode, sensitive)
-    if (viewerOpen) {
+    val viewerSource = ChatImageViewerSource.Bitmap(
+        bitmap = bitmap,
+        displayName = image.alt.ifBlank {
+            image.src.substringAfterLast('/').ifBlank { "image" }
+        },
+        mime = "image/*",
+        // Save/Share re-fetch the original bytes on demand so we don't hold
+        // them in memory next to the decoded bitmap.
+        bytesProvider = {
+            (resolver.fetch(image.src) as? ServerImageResult.Success)?.let { fetched ->
+                context.contentResolver.openInputStream(Uri.parse(fetched.cachedUri))
+                    ?.use { it.readBytes() }
+            }
+        },
+    )
+    if (viewerController == null && viewerOpen) {
         ChatImageViewer(
-            source = ChatImageViewerSource.Bitmap(
-                bitmap = bitmap,
-                displayName = image.alt.ifBlank {
-                    image.src.substringAfterLast('/').ifBlank { "image" }
-                },
-                mime = "image/*",
-                // Save/Share re-fetch the original bytes on demand so we don't
-                // hold them in memory next to the decoded bitmap.
-                bytesProvider = { (resolver.fetch(image.src) as? ServerImageResult.Success)?.bytes },
-            ),
+            source = viewerSource,
             onDismiss = { viewerOpen = false },
             sensitive = sensitive,
             initiallyRevealed = revealed,
@@ -559,7 +602,19 @@ private fun RelayServerImageContent(
                     .widthIn(max = maxWidth)
                     .heightIn(max = 360.dp)
                     .clip(RoundedCornerShape(12.dp))
-                    .clickable { viewerOpen = true },
+                    .clickable {
+                        if (viewerController != null) {
+                            viewerController.openImage(
+                                source = viewerSource,
+                                sensitive = sensitive,
+                                initiallyRevealed = revealed,
+                                blurMode = blurMode,
+                                exportAllowed = exportAllowed,
+                            )
+                        } else {
+                            viewerOpen = true
+                        }
+                    },
             )
         }
     }

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatImageViewer.kt

@@ -2,7 +2,7 @@
 
 package com.hermesandroid.relay.ui.components
 
-import android.widget.Toast
+import com.hermesandroid.relay.ui.UiMessageBus
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
@@ -107,135 +107,141 @@ fun ChatImageViewer(
         onDismissRequest = onDismiss,
         properties = DialogProperties(usePlatformDefaultWidth = false),
     ) {
-        val context = LocalContext.current
-        val exportAllowed = LocalImageExportAllowed.current
-        AllowDeviceRotation()
-        val scope = rememberCoroutineScope()
+        MessageOverlayScope {
+            val context = LocalContext.current
+            val exportAllowed = LocalImageExportAllowed.current
+            AllowDeviceRotation()
+            val scope = rememberCoroutineScope()
 
-        var busy by remember { mutableStateOf(false) }
+            var busy by remember { mutableStateOf(false) }
 
-        val blurMode = LocalMediaBlurMode.current
-        var revealed by remember(source) { mutableStateOf(initiallyRevealed) }
-        val blurred = !revealed && shouldBlurImage(blurMode, sensitive)
+            val blurMode = LocalMediaBlurMode.current
+            var revealed by remember(source) { mutableStateOf(initiallyRevealed) }
+            val blurred = !revealed && shouldBlurImage(blurMode, sensitive)
 
-        val gestureModifier = Modifier.fillMaxSize().zoomable()
+            val gestureModifier = Modifier.fillMaxSize().zoomable()
 
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .background(Color.Black.copy(alpha = 0.94f)),
-            contentAlignment = Alignment.Center,
-        ) {
-            BlurredMedia(
-                blurred = blurred,
-                onReveal = { revealed = true },
-                modifier = Modifier.fillMaxSize(),
-            ) {
-                when (source) {
-                    is ChatImageViewerSource.Coil -> AsyncImage(
-                        model = source.model,
-                        contentDescription = source.displayName,
-                        contentScale = ContentScale.Fit,
-                        modifier = gestureModifier,
-                    )
-
-                    is ChatImageViewerSource.Bitmap -> Image(
-                        bitmap = source.bitmap,
-                        contentDescription = source.displayName,
-                        contentScale = ContentScale.Fit,
-                        modifier = gestureModifier,
-                    )
-                }
-            }
-
-            if (busy) {
-                CircularProgressIndicator(color = Color.White)
-            }
-
-            // Control bar — top-right, inset past the status bar / notch.
-            Row(
+            Box(
                 modifier = Modifier
-                    .align(Alignment.TopEnd)
-                    .windowInsetsPadding(WindowInsets.safeDrawing)
-                    .padding(8.dp),
-                horizontalArrangement = Arrangement.spacedBy(4.dp),
+                    .fillMaxSize()
+                    .background(Color.Black.copy(alpha = 0.94f)),
+                contentAlignment = Alignment.Center,
             ) {
-                val tint = IconButtonDefaults.iconButtonColors(contentColor = Color.White)
-                val cdClose = stringResource(R.string.cd_close_viewer)
-                val errorMsg = context.getString(R.string.image_viewer_error)
-                if (exportAllowed) {
-                    val cdShare = stringResource(R.string.cd_share)
-                    val cdSave = stringResource(R.string.cd_save)
-                    IconButton(
-                        onClick = {
-                            scope.launch {
-                                busy = true
-                                val bytes = runCatching { source.bytesProvider() }.getOrNull()
-                                busy = false
-                                if (bytes == null) {
-                                    toast(context, errorMsg)
-                                    return@launch
-                                }
-                                val uri = MediaSaver.stageForShare(
-                                    context,
-                                    bytes,
-                                    source.displayName,
-                                    source.mime,
-                                )
-                                MediaSaver.share(context, uri, source.mime)
-                            }
-                        },
-                        colors = tint,
-                    ) {
-                        Icon(Icons.Filled.Share, contentDescription = cdShare)
-                    }
-                    val savedFmt = context.getString(R.string.image_viewer_saved)
-                    val failedFmt = context.getString(R.string.image_viewer_failed)
-                    IconButton(
-                        onClick = {
-                            scope.launch {
-                                busy = true
-                                val bytes = runCatching { source.bytesProvider() }.getOrNull()
-                                if (bytes == null) {
-                                    busy = false
-                                    toast(context, errorMsg)
-                                    return@launch
-                                }
-                                when (val result = MediaSaver.saveImage(context, bytes, source.displayName, source.mime)) {
-                                    is MediaSaver.SaveResult.Saved -> {
-                                        busy = false
-                                        toast(context, savedFmt.format(result.location))
-                                    }
-                                    MediaSaver.SaveResult.UseShareInstead -> {
-                                        busy = false
-                                        val uri = MediaSaver.stageForShare(
-                                            context,
-                                            bytes,
-                                            source.displayName,
-                                            source.mime,
-                                        )
-                                        MediaSaver.share(context, uri, source.mime)
-                                    }
-                                    is MediaSaver.SaveResult.Failed -> {
-                                        busy = false
-                                        toast(context, failedFmt.format(result.message))
-                                    }
-                                }
-                            }
-                        },
-                        colors = tint,
-                    ) {
-                        Icon(Icons.Filled.Download, contentDescription = cdSave)
+                BlurredMedia(
+                    blurred = blurred,
+                    onReveal = { revealed = true },
+                    modifier = Modifier.fillMaxSize(),
+                ) {
+                    when (source) {
+                        is ChatImageViewerSource.Coil -> AsyncImage(
+                            model = source.model,
+                            contentDescription = source.displayName,
+                            contentScale = ContentScale.Fit,
+                            modifier = gestureModifier,
+                        )
+
+                        is ChatImageViewerSource.Bitmap -> Image(
+                            bitmap = source.bitmap,
+                            contentDescription = source.displayName,
+                            contentScale = ContentScale.Fit,
+                            modifier = gestureModifier,
+                        )
                     }
                 }
-                IconButton(onClick = onDismiss, colors = tint) {
-                    Icon(Icons.Filled.Close, contentDescription = cdClose)
+
+                if (busy) {
+                    CircularProgressIndicator(color = Color.White)
+                }
+
+                // Control bar — top-right, inset past the status bar / notch.
+                Row(
+                    modifier = Modifier
+                        .align(Alignment.TopEnd)
+                        .windowInsetsPadding(WindowInsets.safeDrawing)
+                        .padding(8.dp),
+                    horizontalArrangement = Arrangement.spacedBy(4.dp),
+                ) {
+                    val tint = IconButtonDefaults.iconButtonColors(contentColor = Color.White)
+                    val cdClose = stringResource(R.string.cd_close_viewer)
+                    val errorMsg = context.getString(R.string.image_viewer_error)
+                    if (exportAllowed) {
+                        val cdShare = stringResource(R.string.cd_share)
+                        val cdSave = stringResource(R.string.cd_save)
+                        IconButton(
+                            onClick = {
+                                scope.launch {
+                                    busy = true
+                                    val bytes = try {
+                                        source.bytesProvider()
+                                    } catch (_: Exception) {
+                                        null
+                                    }
+                                    busy = false
+                                    if (bytes == null) {
+                                        UiMessageBus.error(errorMsg)
+                                        return@launch
+                                    }
+                                    val uri = MediaSaver.stageForShare(
+                                        context,
+                                        bytes,
+                                        source.displayName,
+                                        source.mime,
+                                    )
+                                    MediaSaver.share(context, uri, source.mime)
+                                }
+                            },
+                            colors = tint,
+                        ) {
+                            Icon(Icons.Filled.Share, contentDescription = cdShare)
+                        }
+                        val savedFmt = context.getString(R.string.image_viewer_saved)
+                        val failedFmt = context.getString(R.string.image_viewer_failed)
+                        IconButton(
+                            onClick = {
+                                scope.launch {
+                                    busy = true
+                                    val bytes = try {
+                                        source.bytesProvider()
+                                    } catch (_: Exception) {
+                                        null
+                                    }
+                                    if (bytes == null) {
+                                        busy = false
+                                        UiMessageBus.error(errorMsg)
+                                        return@launch
+                                    }
+                                    when (val result = MediaSaver.saveImage(context, bytes, source.displayName, source.mime)) {
+                                        is MediaSaver.SaveResult.Saved -> {
+                                            busy = false
+                                            UiMessageBus.success(savedFmt.format(result.location))
+                                        }
+                                        MediaSaver.SaveResult.UseShareInstead -> {
+                                            busy = false
+                                            val uri = MediaSaver.stageForShare(
+                                                context,
+                                                bytes,
+                                                source.displayName,
+                                                source.mime,
+                                            )
+                                            MediaSaver.share(context, uri, source.mime)
+                                        }
+                                        is MediaSaver.SaveResult.Failed -> {
+                                            busy = false
+                                            UiMessageBus.error(failedFmt.format(result.message))
+                                        }
+                                    }
+                                }
+                            },
+                            colors = tint,
+                        ) {
+                            Icon(Icons.Filled.Download, contentDescription = cdSave)
+                        }
+                    }
+                    IconButton(onClick = onDismiss, colors = tint) {
+                        Icon(Icons.Filled.Close, contentDescription = cdClose)
+                    }
                 }
             }
         }
     }
 }
-
-private fun toast(context: android.content.Context, message: String) {
-    Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
-}

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatInputBar.kt

@@ -1,5 +1,6 @@
 package com.hermesandroid.relay.ui.components
 
+import com.hermesandroid.relay.data.BusyMessageAction
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.core.tween
@@ -191,6 +192,9 @@ fun ChatInputBar(
     physicalEnterSends: Boolean = true,
     largePasteThreshold: Int? = null,
     onLargePaste: (String) -> Unit = {},
+    busyAction: BusyMessageAction? = null,
+    correctionAvailable: Boolean = true,
+    onBusyActionChange: (BusyMessageAction) -> Unit = {},
 ) {
     val canSubmit = enabled && submitEnabled && trailing in setOf(
         ChatInputTrailing.SEND,
@@ -236,7 +240,7 @@ fun ChatInputBar(
         // 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) {
+        AnimatedVisibility(visible = caption != null && busyAction == null) {
             val detail = caption ?: lastCaption.orEmpty()
             val actionLabel = when (trailing) {
                 ChatInputTrailing.STEER -> stringResource(R.string.chat_input_steer_response)
@@ -319,6 +323,12 @@ fun ChatInputBar(
             )
         }
 
+        ChatComposerLayers(
+            action = busyAction,
+            onActionChange = onBusyActionChange,
+            correctionAvailable = correctionAvailable,
+            onStop = onStop.takeUnless { trailing == ChatInputTrailing.STOP },
+        ) {
         Surface(
             shape = appearanceComposerShape(),
             color = MaterialTheme.colorScheme.surfaceContainerHigh,
@@ -646,6 +656,7 @@ fun ChatInputBar(
     }
 }
 }
+}
 
 internal data class LargeTextInsertion(
     val insertedText: String,

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatMediaViewerHost.kt

@@ -0,0 +1,146 @@
+package com.hermesandroid.relay.ui.components
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.staticCompositionLocalOf
+import com.hermesandroid.relay.data.Attachment
+import com.hermesandroid.relay.data.BlurMode
+
+private sealed interface ChatMediaViewerRequest {
+    val blurMode: BlurMode
+    val exportAllowed: Boolean
+
+    data class SingleAttachment(
+        val attachment: Attachment,
+        val initiallyRevealed: Boolean,
+        override val blurMode: BlurMode,
+        override val exportAllowed: Boolean,
+    ) : ChatMediaViewerRequest
+
+    data class AttachmentGallery(
+        val attachments: List<Attachment>,
+        val initialIndex: Int,
+        val initiallyRevealedKeys: Set<String>,
+        override val blurMode: BlurMode,
+        override val exportAllowed: Boolean,
+    ) : ChatMediaViewerRequest
+
+    data class InlineImage(
+        val source: ChatImageViewerSource,
+        val sensitive: Boolean,
+        val initiallyRevealed: Boolean,
+        override val blurMode: BlurMode,
+        override val exportAllowed: Boolean,
+    ) : ChatMediaViewerRequest
+}
+
+@Stable
+internal class ChatMediaViewerController {
+    private var activeRequest by mutableStateOf<ChatMediaViewerRequest?>(null)
+
+    internal fun openAttachment(
+        attachment: Attachment,
+        initiallyRevealed: Boolean,
+        blurMode: BlurMode,
+        exportAllowed: Boolean,
+    ) {
+        activeRequest = ChatMediaViewerRequest.SingleAttachment(
+            attachment = attachment,
+            initiallyRevealed = initiallyRevealed,
+            blurMode = blurMode,
+            exportAllowed = exportAllowed,
+        )
+    }
+
+    internal fun openGallery(
+        attachments: List<Attachment>,
+        initialIndex: Int,
+        initiallyRevealedKeys: Set<String>,
+        blurMode: BlurMode,
+        exportAllowed: Boolean,
+    ) {
+        activeRequest = ChatMediaViewerRequest.AttachmentGallery(
+            attachments = attachments,
+            initialIndex = initialIndex,
+            initiallyRevealedKeys = initiallyRevealedKeys,
+            blurMode = blurMode,
+            exportAllowed = exportAllowed,
+        )
+    }
+
+    internal fun openImage(
+        source: ChatImageViewerSource,
+        sensitive: Boolean,
+        initiallyRevealed: Boolean,
+        blurMode: BlurMode,
+        exportAllowed: Boolean,
+    ) {
+        activeRequest = ChatMediaViewerRequest.InlineImage(
+            source = source,
+            sensitive = sensitive,
+            initiallyRevealed = initiallyRevealed,
+            blurMode = blurMode,
+            exportAllowed = exportAllowed,
+        )
+    }
+
+    internal fun dismiss() {
+        activeRequest = null
+    }
+
+    @Composable
+    internal fun RenderActiveViewer() {
+        val request = activeRequest ?: return
+        CompositionLocalProvider(
+            LocalMediaBlurMode provides request.blurMode,
+            LocalImageExportAllowed provides request.exportAllowed,
+        ) {
+            when (request) {
+                is ChatMediaViewerRequest.SingleAttachment -> AttachmentViewer(
+                    attachment = request.attachment,
+                    onDismiss = ::dismiss,
+                    initiallyRevealed = request.initiallyRevealed,
+                )
+                is ChatMediaViewerRequest.AttachmentGallery -> AttachmentGalleryViewer(
+                    attachments = request.attachments,
+                    initialIndex = request.initialIndex,
+                    onDismiss = ::dismiss,
+                    initiallyRevealedKeys = request.initiallyRevealedKeys,
+                )
+                is ChatMediaViewerRequest.InlineImage -> ChatImageViewer(
+                    source = request.source,
+                    onDismiss = ::dismiss,
+                    sensitive = request.sensitive,
+                    initiallyRevealed = request.initiallyRevealed,
+                )
+            }
+        }
+    }
+}
+
+internal val LocalChatMediaViewerController =
+    staticCompositionLocalOf<ChatMediaViewerController?> { null }
+
+/**
+ * Owns the active full-screen preview above transcript rows so responsive
+ * portrait/landscape reflow cannot dispose the viewer with its source bubble.
+ */
+@Composable
+internal fun ChatMediaViewerHost(
+    vararg ownerKeys: Any?,
+    content: @Composable () -> Unit,
+) {
+    // A preview never follows a connection/session/policy owner change. Aside
+    // from avoiding stale media, this makes export permission fail closed when
+    // supervised policy changes while a viewer is open.
+    val controller = remember(*ownerKeys) { ChatMediaViewerController() }
+    CompositionLocalProvider(LocalChatMediaViewerController provides controller) {
+        content()
+        controller.RenderActiveViewer()
+    }
+}

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ChatTransportStatusBadge.kt

@@ -1,6 +1,6 @@
 package com.hermesandroid.relay.ui.components
 
-import android.widget.Toast
+import com.hermesandroid.relay.ui.UiMessageBus
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.padding
@@ -12,7 +12,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import com.hermesandroid.relay.network.upstream.GatewayAvailability
@@ -21,9 +20,9 @@ import com.hermesandroid.relay.ui.theme.RelayRefresh
 
 enum class ChatTransportTier(val endpointId: String, val label: String) {
     Gateway("gateway", "⚡ Gateway"),
-    Sessions("sessions", "📡 Sessions"),
-    Completions("completions", "Completions"),
-    Runs("runs", "Runs"),
+    Sessions("sessions", "Direct API"),
+    Completions("completions", "Direct API"),
+    Runs("runs", "Direct API"),
     Offline("offline", "offline"),
 }
 
@@ -67,18 +66,6 @@ fun resolveChatTransportStatus(
             detail = "No reachable Hermes chat transport is available.",
         )
 
-    fun sseFallback(gatewayReason: String): ChatTransportStatus {
-        if (!serverCapabilities.healthy) return offline(gatewayReason)
-        val tier = preferredAvailableSseTier(serverCapabilities)
-            ?: return offline(gatewayReason)
-        return ChatTransportStatus(
-            tier = tier,
-            tone = ChatTransportTone.Fallback,
-            reason = "$gatewayReason → ${tier.plainName()}",
-            detail = "${tier.detailText()} Using this as the fallback while Gateway is unavailable.",
-        )
-    }
-
     fun manualSse(tier: ChatTransportTier, supported: Boolean): ChatTransportStatus {
         if (!serverCapabilities.healthy) return offline()
         return if (supported) {
@@ -94,23 +81,17 @@ fun resolveChatTransportStatus(
     }
 
     return when (preference) {
-        "auto" -> when {
+        "auto", "gateway" -> when {
             gatewayReady -> ChatTransportStatus(
                 tier = ChatTransportTier.Gateway,
                 tone = ChatTransportTone.Active,
-                reason = "auto → Gateway (best)",
+                reason = "Gateway connected",
                 detail = ChatTransportTier.Gateway.detailText(),
             )
-            else -> sseFallback(gatewayFallbackReason(gatewayAvailability))
-        }
-        "gateway" -> when {
-            gatewayReady -> ChatTransportStatus(
-                tier = ChatTransportTier.Gateway,
-                tone = ChatTransportTone.Active,
-                reason = "Gateway selected",
-                detail = ChatTransportTier.Gateway.detailText(),
+            else -> unavailable(
+                ChatTransportTier.Gateway,
+                gatewayFallbackReason(gatewayAvailability),
             )
-            else -> sseFallback(gatewayFallbackReason(gatewayAvailability))
         }
         "sessions" -> manualSse(ChatTransportTier.Sessions, serverCapabilities.sessionsChatStream)
         "completions" -> manualSse(ChatTransportTier.Completions, serverCapabilities.portable)
@@ -119,42 +100,34 @@ fun resolveChatTransportStatus(
     }
 }
 
-private fun preferredAvailableSseTier(capabilities: ServerCapabilities): ChatTransportTier? =
-    when {
-        capabilities.sessionsChatStream -> ChatTransportTier.Sessions
-        capabilities.portable -> ChatTransportTier.Completions
-        capabilities.runs -> ChatTransportTier.Runs
-        else -> null
-    }
-
 private fun gatewayFallbackReason(availability: GatewayAvailability): String =
     when (availability) {
-        GatewayAvailability.SignInRequired -> "gateway sign-in required"
-        GatewayAvailability.Unreachable -> "gateway unavailable"
-        GatewayAvailability.Unsupported -> "gateway unsupported"
-        GatewayAvailability.Unknown -> "checking gateway"
-        GatewayAvailability.Ready -> "gateway ready"
+        GatewayAvailability.SignInRequired -> "Gateway sign-in required"
+        GatewayAvailability.Unreachable -> "Gateway unavailable"
+        GatewayAvailability.Unsupported -> "Gateway unsupported"
+        GatewayAvailability.Unknown -> "Checking Gateway"
+        GatewayAvailability.Ready -> "Gateway ready"
     }
 
 private fun ChatTransportTier.plainName(): String =
     when (this) {
         ChatTransportTier.Gateway -> "Gateway"
-        ChatTransportTier.Sessions -> "Sessions"
-        ChatTransportTier.Completions -> "Completions"
-        ChatTransportTier.Runs -> "Runs"
+        ChatTransportTier.Sessions -> "Direct API"
+        ChatTransportTier.Completions -> "Direct API"
+        ChatTransportTier.Runs -> "Direct API"
         ChatTransportTier.Offline -> "offline"
     }
 
 private fun ChatTransportTier.detailText(): String =
     when (this) {
         ChatTransportTier.Gateway ->
-            "Gateway uses the dashboard WebSocket /api/ws for live thinking and rich tool events."
+            "Hermes Chat uses the signed-in Dashboard connection."
         ChatTransportTier.Sessions ->
-            "Sessions uses /api/sessions/{id}/chat/stream with server-side session history."
+            "Direct API compatibility chat with server-side session history."
         ChatTransportTier.Completions ->
-            "Completions uses OpenAI-compatible SSE at /v1/chat/completions."
+            "Direct API compatibility chat."
         ChatTransportTier.Runs ->
-            "Runs uses /v1/runs plus streamed run events."
+            "Direct API compatibility chat with streamed run events."
         ChatTransportTier.Offline ->
             "No chat transport is reachable."
     }
@@ -166,18 +139,13 @@ fun ChatTransportStatusBadge(
     modifier: Modifier = Modifier,
     onClick: (() -> Unit)? = null,
 ) {
-    val context = LocalContext.current
     val textColor = status.textColor()
     val background = status.backgroundColor()
     Surface(
         modifier = modifier.combinedClickable(
             onClick = { onClick?.invoke() },
             onLongClick = {
-                Toast.makeText(
-                    context,
-                    "${status.reason}: ${status.detail}",
-                    Toast.LENGTH_LONG,
-                ).show()
+                UiMessageBus.info("${status.reason}: ${status.detail}")
             },
         ),
         shape = RoundedCornerShape(999.dp),

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ConnectionHandoffBanner.kt

@@ -73,7 +73,7 @@ private const val SWIPE_DISMISS_THRESHOLD_PX = 80f
  * progress" moment (pairing, long upload, a bridge action sequence). When first
  * reused, decouple it from [ConnectionStatusSnapshot] and rename to a generic
  * `StatusToast`. It also anchors [UpdateAvailableBanner]'s visual language + the
- * shared [ConnectionStepRow]/[StepGlyph] helpers. See TODO.md.
+ * shared [ConnectionStepRow]/[StepGlyph] helpers. See docs/project/TODO.md.
  *
  * Rendered as a top-aligned overlay inside a `Box` — it slides down OVER the UI
  * without shifting layout. Pair it with `AnimatedVisibility(enter =

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ConnectionInfoSheet.kt

@@ -741,6 +741,7 @@ fun AgentInfoSheet(
     val relayConnectionState by connectionViewModel.relayConnectionState.collectAsState()
     val streamingEndpoint by connectionViewModel.streamingEndpoint.collectAsState()
     val voiceReady by connectionViewModel.voiceReady.collectAsState()
+    val standardVoiceReady by connectionViewModel.standardVoiceReady.collectAsState()
     val proactiveEnabled by connectionViewModel.proactiveEnabled.collectAsState()
     val activeEndpoint by connectionViewModel.activeEndpoint.collectAsState()
     val allConnections by connectionViewModel.connectionStore.connections.collectAsState()
@@ -842,6 +843,7 @@ fun AgentInfoSheet(
     val sessionCaps = sessionCapabilities(
         transport = sessionTransport,
         gatewayAvailability = gatewayAvailability,
+        upstreamMediaAvailable = gatewayAvailability == GatewayAvailability.Ready || standardVoiceReady,
         relayConnected = relayConnectionState == ConnectionState.Connected,
         relayConfigured = relayUrl.isNotBlank(),
         voiceReady = voiceReady,
@@ -3423,6 +3425,8 @@ private fun LegacyAgentInfoSheet(
                 val sessionCaps = sessionCapabilities(
                     transport = sessionTransport,
                     gatewayAvailability = gatewayAvailability,
+                    upstreamMediaAvailable = gatewayAvailability == GatewayAvailability.Ready ||
+                        connectionViewModel.standardVoiceReady.collectAsState().value,
                     relayConnected = relayConnected,
                     relayConfigured = relayUrl.isNotBlank(),
                     voiceReady = voiceReady,
@@ -3621,7 +3625,7 @@ internal fun ProfileDisplayManagerDialog(
                     val isServerDefault = key == AgentDisplay.SERVER_DEFAULT_PROFILE_KEY
                     val profile = profiles.firstOrNull { it.name == key }
                     val label = if (isServerDefault) {
-                        stringResource(R.string.conn_info_server_default)
+                        stringResource(R.string.profile_follow_server_default)
                     } else {
                         profile?.let(AgentDisplay::profileDisplayName)
                             ?: key.replaceFirstChar { it.uppercase() }

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ConnectionSetupTimeline.kt

@@ -13,6 +13,8 @@ import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -20,10 +22,12 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
+import com.hermesandroid.relay.viewmodel.ConnectionStepState
 
 data class ConnectionSetupTimelineStep(
     val title: String,
     val detail: String,
+    val state: ConnectionStepState = ConnectionStepState.Done,
 )
 
 /** Compact completed-state timeline shared by connection and auth flows. */
@@ -43,13 +47,21 @@ fun ConnectionSetupTimeline(
                     Box(
                         modifier = Modifier
                             .size(28.dp)
-                            .background(MaterialTheme.colorScheme.primaryContainer, CircleShape),
+                            .background(when (step.state) {
+                                ConnectionStepState.Failed -> MaterialTheme.colorScheme.errorContainer
+                                ConnectionStepState.Pending -> MaterialTheme.colorScheme.surfaceVariant
+                                else -> MaterialTheme.colorScheme.primaryContainer
+                            }, CircleShape),
                         contentAlignment = Alignment.Center,
                     ) {
-                        Icon(
-                            imageVector = Icons.Filled.Check,
+                        if (step.state == ConnectionStepState.Active) {
+                            CircularProgressIndicator(Modifier.size(17.dp), strokeWidth = 2.dp)
+                        } else if (step.state == ConnectionStepState.Pending) {
+                            Text("·", color = MaterialTheme.colorScheme.onSurfaceVariant)
+                        } else Icon(
+                            imageVector = if (step.state == ConnectionStepState.Failed) Icons.Filled.Close else Icons.Filled.Check,
                             contentDescription = null,
-                            tint = MaterialTheme.colorScheme.onPrimaryContainer,
+                            tint = if (step.state == ConnectionStepState.Failed) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onPrimaryContainer,
                             modifier = Modifier.size(17.dp),
                         )
                     }

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ConnectionWizard.kt

@@ -6,7 +6,7 @@ import android.Manifest
 import android.content.ClipData
 import android.content.Intent
 import android.net.Uri
-import android.widget.Toast
+import com.hermesandroid.relay.ui.UiMessageBus
 import androidx.annotation.StringRes
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
@@ -132,7 +132,7 @@ import java.net.URI
  * Settings → Gateways. Hermes setup starts with the one Dashboard address
  * the phone can open, probes public `/api/status`, and lets advertised
  * capabilities select authentication. A separate public sign-in URL is never
- * universally required. API fallback, Relay pairing, and extra LAN/Tailscale
+ * universally required. Direct API, Relay pairing, and extra LAN/Tailscale
  * routes remain explicit advanced paths.
  *
  * Steps:
@@ -343,11 +343,7 @@ fun ConnectionWizard(
             // user at the manual pairing paths (URL entry / 6-char code)
             // instead of leaving them on a vanishing toast with no scanner.
             step = WizardStep.Nearby
-            Toast.makeText(
-                context,
-                context.getString(R.string.cw_camera_denied),
-                Toast.LENGTH_LONG
-            ).show()
+            UiMessageBus.warning(context.getString(R.string.cw_camera_denied))
         }
     }
 

app/src/main/kotlin/com/hermesandroid/relay/ui/components/CrashReportDialog.kt

@@ -1,7 +1,6 @@
 package com.hermesandroid.relay.ui.components
 
-import android.content.Context
-import android.widget.Toast
+import com.hermesandroid.relay.ui.UiMessageBus
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -104,120 +103,119 @@ private fun CrashReportDialog(report: ReliabilityReport, onDismiss: () -> Unit)
         onDismissRequest = onDismiss,
         properties = DialogProperties(usePlatformDefaultWidth = false),
     ) {
-        Surface(
-            modifier = Modifier.fillMaxWidth(0.94f),
-            shape = appearanceRoundedCornerShape(24.dp),
-            color = MaterialTheme.colorScheme.surface,
-            tonalElevation = 6.dp,
-        ) {
-            Column(modifier = Modifier.padding(20.dp)) {
-                Row(verticalAlignment = Alignment.CenterVertically) {
-                    Icon(
-                        imageVector = Icons.Filled.WarningAmber,
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.error,
-                        modifier = Modifier.size(24.dp),
-                    )
-                    Spacer(Modifier.width(12.dp))
+        MessageOverlayScope {
+            Surface(
+                modifier = Modifier.fillMaxWidth(0.94f),
+                shape = appearanceRoundedCornerShape(24.dp),
+                color = MaterialTheme.colorScheme.surface,
+                tonalElevation = 6.dp,
+            ) {
+                Column(modifier = Modifier.padding(20.dp)) {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        Icon(
+                            imageVector = Icons.Filled.WarningAmber,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.error,
+                            modifier = Modifier.size(24.dp),
+                        )
+                        Spacer(Modifier.width(12.dp))
+                        Text(
+                            text = stringResource(R.string.crash_title),
+                            style = MaterialTheme.typography.titleMedium,
+                            fontWeight = FontWeight.SemiBold,
+                        )
+                    }
+
+                    Spacer(Modifier.height(8.dp))
                     Text(
-                        text = stringResource(R.string.crash_title),
-                        style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.SemiBold,
+                        text = stringResource(R.string.crash_body),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
-                }
 
-                Spacer(Modifier.height(8.dp))
-                Text(
-                    text = stringResource(R.string.crash_body),
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                )
+                    Text(
+                        text = stringResource(R.string.crash_privacy),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.padding(top = 6.dp),
+                    )
 
-                Text(
-                    text = stringResource(R.string.crash_privacy),
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    modifier = Modifier.padding(top = 6.dp),
-                )
-
-                if (showDetails) {
-                    Spacer(Modifier.height(14.dp))
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .heightIn(min = 120.dp, max = 300.dp)
-                            .clip(appearanceRoundedCornerShape(12.dp))
-                            .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.45f)),
-                    ) {
-                        SelectionContainer {
-                            Text(
-                                text = reportText,
-                                fontFamily = FontFamily.Monospace,
-                                fontSize = 11.sp,
-                                lineHeight = 15.sp,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                modifier = Modifier
-                                    .verticalScroll(rememberScrollState())
-                                    .padding(12.dp),
-                            )
+                    if (showDetails) {
+                        Spacer(Modifier.height(14.dp))
+                        Box(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .heightIn(min = 120.dp, max = 300.dp)
+                                .clip(appearanceRoundedCornerShape(12.dp))
+                                .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.45f)),
+                        ) {
+                            SelectionContainer {
+                                Text(
+                                    text = reportText,
+                                    fontFamily = FontFamily.Monospace,
+                                    fontSize = 11.sp,
+                                    lineHeight = 15.sp,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                    modifier = Modifier
+                                        .verticalScroll(rememberScrollState())
+                                        .padding(12.dp),
+                                )
+                            }
                         }
                     }
-                }
 
-                Spacer(Modifier.height(18.dp))
-                // FlowRow so the actions wrap instead of clipping on narrow /
-                // foldable cover screens now that a fourth (Share) action exists.
-                FlowRow(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End),
-                    verticalArrangement = Arrangement.spacedBy(4.dp),
-                ) {
-                    TextButton(onClick = onDismiss) { Text(stringResource(R.string.common_dismiss)) }
-                    if (!showDetails) {
-                        Button(onClick = { showDetails = true }) {
-                            Text(stringResource(R.string.crash_review))
-                        }
-                    } else {
-                        OutlinedButton(
-                            onClick = {
-                                IssueReport.copyToClipboard(context, reportText)
-                                toast(context, copiedMessage)
-                            },
-                        ) { Text(stringResource(R.string.common_copy)) }
-                    // Universal, GitHub-free path: hand the full report to the
-                    // system share sheet (email, chat apps, notes, Drive…). The
-                    // user picks the destination, so nothing leaves the device
-                    // until they choose to send it — same privacy posture as Copy.
-                        OutlinedButton(
-                            onClick = {
-                                val shared = IssueReport.share(
-                                    context,
-                                    reportSubject,
-                                    reportText,
-                                    chooserTitle = shareTitle,
-                                )
-                                if (!shared) {
+                    Spacer(Modifier.height(18.dp))
+                    // FlowRow so the actions wrap instead of clipping on narrow /
+                    // foldable cover screens now that a fourth (Share) action exists.
+                    FlowRow(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End),
+                        verticalArrangement = Arrangement.spacedBy(4.dp),
+                    ) {
+                        TextButton(onClick = onDismiss) { Text(stringResource(R.string.common_dismiss)) }
+                        if (!showDetails) {
+                            Button(onClick = { showDetails = true }) {
+                                Text(stringResource(R.string.crash_review))
+                            }
+                        } else {
+                            OutlinedButton(
+                                onClick = {
                                     IssueReport.copyToClipboard(context, reportText)
-                                    toast(context, noShareMessage)
-                                }
-                                onDismiss()
-                            },
-                        ) { Text(stringResource(R.string.common_share)) }
-                        Button(
-                            onClick = {
-                                IssueReport.copyToClipboard(context, reportText)
-                                val opened = IssueReport.openUrl(context, CrashReporter.buildGithubIssueUrl(report))
-                                toast(context, if (opened) openedMessage else noBrowserMessage)
-                                onDismiss()
-                            },
-                        ) { Text(stringResource(R.string.common_report)) }
+                                    UiMessageBus.success(copiedMessage)
+                                },
+                            ) { Text(stringResource(R.string.common_copy)) }
+                        // Universal, GitHub-free path: hand the full report to the
+                        // system share sheet (email, chat apps, notes, Drive…). The
+                        // user picks the destination, so nothing leaves the device
+                        // until they choose to send it — same privacy posture as Copy.
+                            OutlinedButton(
+                                onClick = {
+                                    val shared = IssueReport.share(
+                                        context,
+                                        reportSubject,
+                                        reportText,
+                                        chooserTitle = shareTitle,
+                                    )
+                                    if (!shared) {
+                                        IssueReport.copyToClipboard(context, reportText)
+                                        UiMessageBus.warning(noShareMessage)
+                                    }
+                                    onDismiss()
+                                },
+                            ) { Text(stringResource(R.string.common_share)) }
+                            Button(
+                                onClick = {
+                                    IssueReport.copyToClipboard(context, reportText)
+                                    val opened = IssueReport.openUrl(context, CrashReporter.buildGithubIssueUrl(report))
+                                    if (opened) UiMessageBus.success(openedMessage)
+                                    else UiMessageBus.warning(noBrowserMessage)
+                                    onDismiss()
+                                },
+                            ) { Text(stringResource(R.string.common_report)) }
+                        }
                     }
                 }
             }
         }
     }
 }
-
-private fun toast(context: Context, message: String) {
-    Toast.makeText(context, message, Toast.LENGTH_LONG).show()
-}

app/src/main/kotlin/com/hermesandroid/relay/ui/components/DiagnosticDetailDialog.kt

@@ -1,7 +1,7 @@
 package com.hermesandroid.relay.ui.components
 
 import android.text.format.DateFormat
-import android.widget.Toast
+import com.hermesandroid.relay.ui.UiMessageBus
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -78,159 +78,158 @@ fun DiagnosticDetailDialog(entry: DiagnosticLogEntry, onDismiss: () -> Unit) {
         onDismissRequest = onDismiss,
         properties = DialogProperties(usePlatformDefaultWidth = false),
     ) {
-        Surface(
-            modifier = Modifier.fillMaxWidth(0.94f),
-            shape = appearanceRoundedCornerShape(24.dp),
-            color = MaterialTheme.colorScheme.surface,
-            tonalElevation = 6.dp,
-        ) {
-            Column(modifier = Modifier.padding(20.dp)) {
-                Row(verticalAlignment = Alignment.CenterVertically) {
-                    DiagnosticSeverityChip(entry.severity)
-                    Spacer(Modifier.width(10.dp))
-                    Text(
-                        text = entry.category.label,
-                        style = MaterialTheme.typography.labelMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    )
-                }
+        MessageOverlayScope {
+            Surface(
+                modifier = Modifier.fillMaxWidth(0.94f),
+                shape = appearanceRoundedCornerShape(24.dp),
+                color = MaterialTheme.colorScheme.surface,
+                tonalElevation = 6.dp,
+            ) {
+                Column(modifier = Modifier.padding(20.dp)) {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        DiagnosticSeverityChip(entry.severity)
+                        Spacer(Modifier.width(10.dp))
+                        Text(
+                            text = entry.category.label,
+                            style = MaterialTheme.typography.labelMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
 
-                Spacer(Modifier.height(10.dp))
-                Text(
-                    text = entry.title,
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.SemiBold,
-                )
-
-                Spacer(Modifier.height(10.dp))
-                // Metadata rows — only render the ones that are present.
-                MetaRow("When", DateFormat.format("yyyy-MM-dd HH:mm:ss", entry.timestampMs).toString())
-                MetaRow("Severity", severityName)
-                MetaRow("Category", entry.category.label)
-                entry.operation?.let { MetaRow("Operation", it) }
-                entry.endpointRole?.let { MetaRow("Route", it) }
-                entry.configuredUrl?.let { MetaRow("Configured URL", it) }
-                entry.requestUrl?.let { MetaRow("Request", it) }
-                if (entry.configuredUrl == null && entry.requestUrl == null) {
-                    entry.url?.let { MetaRow("URL", it) }
-                }
-                entry.elapsedMs?.let { MetaRow("Elapsed", "${it}ms") }
-                entry.suggestion?.let { suggestion ->
                     Spacer(Modifier.height(10.dp))
                     Text(
-                        text = "Suggested next step",
-                        style = MaterialTheme.typography.labelMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        text = entry.title,
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.SemiBold,
                     )
-                    Text(
-                        text = suggestion,
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurface,
-                    )
-                }
 
-                Spacer(Modifier.height(14.dp))
-                val body = entry.stacktrace ?: entry.detail
-                if (body != null) {
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .heightIn(min = 120.dp, max = 320.dp)
-                            .background(
-                                MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.45f),
-                                appearanceRoundedCornerShape(12.dp),
-                            ),
-                    ) {
-                        SelectionContainer {
-                            Text(
-                                text = body,
-                                fontFamily = FontFamily.Monospace,
-                                fontSize = 11.sp,
-                                lineHeight = 15.sp,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                modifier = Modifier
-                                    .verticalScroll(rememberScrollState())
-                                    .padding(12.dp),
-                            )
-                        }
+                    Spacer(Modifier.height(10.dp))
+                    // Metadata rows — only render the ones that are present.
+                    MetaRow("When", DateFormat.format("yyyy-MM-dd HH:mm:ss", entry.timestampMs).toString())
+                    MetaRow("Severity", severityName)
+                    MetaRow("Category", entry.category.label)
+                    entry.operation?.let { MetaRow("Operation", it) }
+                    entry.endpointRole?.let { MetaRow("Route", it) }
+                    entry.configuredUrl?.let { MetaRow("Configured URL", it) }
+                    entry.requestUrl?.let { MetaRow("Request", it) }
+                    if (entry.configuredUrl == null && entry.requestUrl == null) {
+                        entry.url?.let { MetaRow("URL", it) }
+                    }
+                    entry.elapsedMs?.let { MetaRow("Elapsed", "${it}ms") }
+                    entry.suggestion?.let { suggestion ->
+                        Spacer(Modifier.height(10.dp))
+                        Text(
+                            text = "Suggested next step",
+                            style = MaterialTheme.typography.labelMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                        Text(
+                            text = suggestion,
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurface,
+                        )
                     }
-                } else {
-                    Text(
-                        text = stringResource(R.string.diagnostic_no_detail),
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    )
-                }
 
-                if (expectationVisible) {
                     Spacer(Modifier.height(14.dp))
-                    OutlinedTextField(
-                        value = expectation,
-                        onValueChange = { expectation = it },
-                        label = { Text("What were you expecting to happen?") },
-                        supportingText = {
-                            Text(stringResource(R.string.diagnostic_routine_hint))
-                        },
-                        minLines = 2,
-                        modifier = Modifier.fillMaxWidth(),
-                    )
-                }
-
-                Spacer(Modifier.height(18.dp))
-                FlowRow(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End),
-                    verticalArrangement = Arrangement.spacedBy(4.dp),
-                ) {
-                    TextButton(onClick = onDismiss) { Text(stringResource(R.string.common_close)) }
-                    OutlinedButton(
-                        onClick = {
-                            IssueReport.copyToClipboard(context, plainText)
-                            toast(context, copiedToast)
-                        },
-                    ) { Text(stringResource(R.string.common_copy)) }
-                    OutlinedButton(
-                        onClick = {
-                            val shared = IssueReport.share(
-                                context,
-                                subject = "Hermes-Relay diagnostic — ${entry.title}",
-                                text = plainText,
-                                chooserTitle = exportChooserTitle,
-                            )
-                            if (!shared) {
-                                IssueReport.copyToClipboard(context, plainText)
-                                toast(context, "Copied — no app found to share to")
-                            }
-                        },
-                    ) { Text(stringResource(R.string.common_export)) }
-                    Button(
-                        enabled = !expectationVisible || expectation.isNotBlank(),
-                        onClick = {
-                            if (needsExpectation && !expectationVisible) {
-                                expectationVisible = true
-                                return@Button
-                            }
-                            // Copy full text first; the GitHub URL only carries the
-                            // head of long traces, so the user can paste the rest.
-                            IssueReport.copyToClipboard(context, plainText)
-                            val opened = IssueReport.openUrl(
-                                context,
-                                IssueReport.buildGithubIssueUrl(
-                                    title = DiagnosticIssuePrefill.issueTitle(entry),
-                                    bodyMarkdown = DiagnosticIssuePrefill.issueBody(
-                                        entry,
-                                        expectation = expectation.takeIf { expectationVisible },
-                                    ),
-                                    labels = DiagnosticIssuePrefill.issueLabels(entry),
+                    val body = entry.stacktrace ?: entry.detail
+                    if (body != null) {
+                        Box(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .heightIn(min = 120.dp, max = 320.dp)
+                                .background(
+                                    MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.45f),
+                                    appearanceRoundedCornerShape(12.dp),
                                 ),
-                            )
-                            toast(
-                                context,
-                                if (opened) "Full diagnostic copied — paste it into the issue if truncated"
-                                else "Copied — no browser found to open GitHub",
-                            )
-                        },
-                    ) { Text(stringResource(R.string.common_report)) }
+                        ) {
+                            SelectionContainer {
+                                Text(
+                                    text = body,
+                                    fontFamily = FontFamily.Monospace,
+                                    fontSize = 11.sp,
+                                    lineHeight = 15.sp,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                    modifier = Modifier
+                                        .verticalScroll(rememberScrollState())
+                                        .padding(12.dp),
+                                )
+                            }
+                        }
+                    } else {
+                        Text(
+                            text = stringResource(R.string.diagnostic_no_detail),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
+
+                    if (expectationVisible) {
+                        Spacer(Modifier.height(14.dp))
+                        OutlinedTextField(
+                            value = expectation,
+                            onValueChange = { expectation = it },
+                            label = { Text("What were you expecting to happen?") },
+                            supportingText = {
+                                Text(stringResource(R.string.diagnostic_routine_hint))
+                            },
+                            minLines = 2,
+                            modifier = Modifier.fillMaxWidth(),
+                        )
+                    }
+
+                    Spacer(Modifier.height(18.dp))
+                    FlowRow(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End),
+                        verticalArrangement = Arrangement.spacedBy(4.dp),
+                    ) {
+                        TextButton(onClick = onDismiss) { Text(stringResource(R.string.common_close)) }
+                        OutlinedButton(
+                            onClick = {
+                                IssueReport.copyToClipboard(context, plainText)
+                                UiMessageBus.success(copiedToast)
+                            },
+                        ) { Text(stringResource(R.string.common_copy)) }
+                        OutlinedButton(
+                            onClick = {
+                                val shared = IssueReport.share(
+                                    context,
+                                    subject = "Hermes-Relay diagnostic — ${entry.title}",
+                                    text = plainText,
+                                    chooserTitle = exportChooserTitle,
+                                )
+                                if (!shared) {
+                                    IssueReport.copyToClipboard(context, plainText)
+                                    UiMessageBus.warning("Copied — no app found to share to")
+                                }
+                            },
+                        ) { Text(stringResource(R.string.common_export)) }
+                        Button(
+                            enabled = !expectationVisible || expectation.isNotBlank(),
+                            onClick = {
+                                if (needsExpectation && !expectationVisible) {
+                                    expectationVisible = true
+                                    return@Button
+                                }
+                                // Copy full text first; the GitHub URL only carries the
+                                // head of long traces, so the user can paste the rest.
+                                IssueReport.copyToClipboard(context, plainText)
+                                val opened = IssueReport.openUrl(
+                                    context,
+                                    IssueReport.buildGithubIssueUrl(
+                                        title = DiagnosticIssuePrefill.issueTitle(entry),
+                                        bodyMarkdown = DiagnosticIssuePrefill.issueBody(
+                                            entry,
+                                            expectation = expectation.takeIf { expectationVisible },
+                                        ),
+                                        labels = DiagnosticIssuePrefill.issueLabels(entry),
+                                    ),
+                                )
+                                if (opened) UiMessageBus.success("Full diagnostic copied — paste it into the issue if truncated")
+                                else UiMessageBus.warning("Copied — no browser found to open GitHub")
+                            },
+                        ) { Text(stringResource(R.string.common_report)) }
+                    }
                 }
             }
         }
@@ -276,10 +275,6 @@ internal fun DiagnosticSeverityChip(severity: DiagnosticSeverity) {
     }
 }
 
-private fun toast(context: android.content.Context, message: String) {
-    Toast.makeText(context, message, Toast.LENGTH_LONG).show()
-}
-
 /** Full, copy/share-ready plain-text rendering of a single diagnostic entry. */
 private fun DiagnosticLogEntry.toPlainText(): String = buildString {
     appendLine("Hermes-Relay diagnostic")

app/src/main/kotlin/com/hermesandroid/relay/ui/components/EndpointsCard.kt

@@ -847,7 +847,7 @@ internal fun routeSurfaceSecurityPresentation(
     val label = when (surface) {
         EndpointSurface.Standard,
         EndpointSurface.Dashboard -> "Dashboard & Gateway"
-        EndpointSurface.Api -> "API fallback"
+        EndpointSurface.Api -> "Direct API"
         EndpointSurface.Relay -> "Relay tools"
     }
     val securityVerdict = classifySurfaceSecurity(

app/src/main/kotlin/com/hermesandroid/relay/ui/components/GatewayBackgroundProcesses.kt

@@ -24,12 +24,12 @@ import androidx.compose.material.icons.filled.AccountTree
 import androidx.compose.material.icons.filled.CheckCircle
 import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.ErrorOutline
+import androidx.compose.material.icons.filled.HelpOutline
+import androidx.compose.material.icons.filled.PauseCircleOutline
 import androidx.compose.material.icons.filled.ExpandLess
 import androidx.compose.material.icons.filled.ExpandMore
 import androidx.compose.material.icons.filled.Refresh
-import androidx.compose.material.icons.filled.PauseCircleOutline
 import androidx.compose.material.icons.filled.Stop
-import androidx.compose.material.icons.filled.Terminal
 import androidx.compose.material.icons.filled.Visibility
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -66,7 +66,6 @@ import androidx.compose.ui.unit.dp
 import com.hermesandroid.relay.R
 import com.hermesandroid.relay.network.upstream.GatewayProcess
 import com.hermesandroid.relay.viewmodel.SubagentActivity
-import com.hermesandroid.relay.viewmodel.SubagentActivityPhase
 import com.hermesandroid.relay.viewmodel.SubagentChildPreview
 import kotlinx.coroutines.launch
 
@@ -84,27 +83,18 @@ internal fun GatewayBackgroundProcessStrip(
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    // Initial/switch refreshes are silent. The strip appears only after the
-    // session actually owns a process, avoiding a transient "Checking" row on
-    // every ordinary chat open.
+    // Completed work remains reachable from its transcript receipt. Only active
+    // work owns composer space; refreshing history must not resurrect the strip.
     val visibleActivities = subagentActivities.takeIf { subagentPreviewVisibility.showLifecycle }.orEmpty()
-    if (processes.isEmpty() && visibleActivities.isEmpty()) return
-
     val running = processes.count { it.isRunning }
     val runningAgents = visibleActivities.count { !it.isTerminal }
-    val failed = processes.count { !it.isRunning && (it.exitCode ?: 0) != 0 }
-    val failedAgents = visibleActivities.count { it.phase == SubagentActivityPhase.FAILED }
-    val interruptedAgents = visibleActivities.count {
-        it.phase == SubagentActivityPhase.INTERRUPTED ||
-            it.phase == SubagentActivityPhase.ENDED_WITH_PARENT
-    }
-    val failureCount = failed + failedAgents
+    if (running == 0 && runningAgents == 0) return
     val status = when {
+        runningAgents > 0 && running > 0 -> stringResource(
+            R.string.current_chat_activity_summary, runningAgents, running,
+        )
         runningAgents > 0 -> stringResource(R.string.subagent_lane_running_count, runningAgents)
-        running > 0 -> "$running ${stringResource(R.string.bg_processes_running)}"
-        failureCount > 0 -> "$failureCount ${stringResource(R.string.task_status_failed)}"
-        interruptedAgents > 0 -> stringResource(R.string.agent_activity_status_interrupted)
-        else -> stringResource(R.string.task_status_complete)
+        else -> "$running ${stringResource(R.string.bg_processes_running)}"
     }
     val openDescription = stringResource(R.string.current_chat_activity_open)
 
@@ -130,24 +120,7 @@ internal fun GatewayBackgroundProcessStrip(
             modifier = Modifier.padding(horizontal = 12.dp, vertical = 9.dp),
             verticalAlignment = Alignment.CenterVertically,
         ) {
-            if (running > 0 || runningAgents > 0 || loading) {
-                CircularProgressIndicator(modifier = Modifier.size(16.dp), strokeWidth = 2.dp)
-            } else {
-                Icon(
-                    imageVector = when {
-                        failureCount > 0 -> Icons.Filled.ErrorOutline
-                        interruptedAgents > 0 -> Icons.Filled.PauseCircleOutline
-                        else -> Icons.Filled.CheckCircle
-                    },
-                    contentDescription = null,
-                    modifier = Modifier.size(17.dp),
-                    tint = when {
-                        failureCount > 0 -> MaterialTheme.colorScheme.error
-                        interruptedAgents > 0 -> MaterialTheme.colorScheme.tertiary
-                        else -> MaterialTheme.colorScheme.primary
-                    },
-                )
-            }
+            CircularProgressIndicator(modifier = Modifier.size(16.dp), strokeWidth = 2.dp)
             Spacer(Modifier.width(9.dp))
             Text(
                 text = stringResource(R.string.current_chat_activity_title),
@@ -157,11 +130,7 @@ internal fun GatewayBackgroundProcessStrip(
             Text(
                 text = status,
                 style = MaterialTheme.typography.labelMedium,
-                color = if (failureCount > 0 && running == 0) {
-                    MaterialTheme.colorScheme.error
-                } else {
-                    MaterialTheme.colorScheme.onSurfaceVariant
-                },
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
             )
             Icon(
                 imageVector = Icons.Filled.Visibility,
@@ -190,6 +159,8 @@ internal fun GatewayBackgroundProcessSheet(
     onDismissProcess: (String) -> Unit,
     onOpenSubagentChild: (String) -> Unit,
     onDismiss: () -> Unit,
+    readOnlyHistory: Boolean = false,
+    historyNotice: String? = null,
 ) {
     val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = false)
     val listState = androidx.compose.foundation.lazy.rememberLazyListState()
@@ -246,17 +217,19 @@ internal fun GatewayBackgroundProcessSheet(
             ) {
                 Column(modifier = Modifier.weight(1f)) {
                     Text(
-                        stringResource(R.string.current_chat_activity_title),
+                        stringResource(
+                            if (readOnlyHistory) R.string.chat_activity_history_title else R.string.current_chat_activity_title,
+                        ),
                         modifier = Modifier.semantics { heading() },
                         style = MaterialTheme.typography.titleLarge,
                     )
                     Text(
-                        stringResource(R.string.current_chat_activity_subtitle),
+                        historyNotice ?: stringResource(R.string.current_chat_activity_subtitle),
                         style = MaterialTheme.typography.bodySmall,
                         color = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
                 }
-                if (processes.isNotEmpty()) IconButton(onClick = onRefresh, enabled = !loading) {
+                if (processes.isNotEmpty() && !readOnlyHistory) IconButton(onClick = onRefresh, enabled = !loading) {
                     if (loading) {
                         CircularProgressIndicator(modifier = Modifier.size(20.dp), strokeWidth = 2.dp)
                     } else {
@@ -300,7 +273,9 @@ internal fun GatewayBackgroundProcessSheet(
                         tint = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
                     Text(
-                        stringResource(R.string.current_chat_activity_empty),
+                        stringResource(
+                            if (readOnlyHistory) R.string.chat_activity_history_empty else R.string.current_chat_activity_empty,
+                        ),
                         modifier = Modifier.padding(top = 12.dp),
                         color = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
@@ -341,7 +316,7 @@ internal fun GatewayBackgroundProcessSheet(
                             GatewayProcessRow(
                                 process = process,
                                 stopping = process.id in stoppingProcessIds,
-                                onStop = { onStop(process.id) },
+                                onStop = if (readOnlyHistory) null else ({ onStop(process.id) }),
                                 onDismiss = null,
                             )
                         }
@@ -356,7 +331,7 @@ internal fun GatewayBackgroundProcessSheet(
                                 process = process,
                                 stopping = false,
                                 onStop = null,
-                                onDismiss = { onDismissProcess(process.id) },
+                                onDismiss = if (readOnlyHistory) null else ({ onDismissProcess(process.id) }),
                             )
                         }
                     }
@@ -384,7 +359,7 @@ private fun GatewayProcessRow(
     onDismiss: (() -> Unit)?,
 ) {
     var expanded by remember(process.id) { mutableStateOf(false) }
-    val failed = !process.isRunning && (process.exitCode ?: 0) != 0
+    val failed = processDisplayPhase(process) == ProcessDisplayPhase.FAILED
     val output = sanitizeTerminalText(
         process.outputTail.orEmpty().ifBlank { process.outputPreview.orEmpty() },
     ).trimEnd()
@@ -478,9 +453,11 @@ private fun GatewayProcessRow(
 
 @Composable
 private fun ProcessStateIcon(process: GatewayProcess, failed: Boolean, stopping: Boolean) {
+    val phase = processDisplayPhase(process)
     val tint: Color = when {
         failed -> MaterialTheme.colorScheme.error
         process.isRunning || stopping -> MaterialTheme.colorScheme.primary
+        phase == ProcessDisplayPhase.UNKNOWN || phase == ProcessDisplayPhase.CANCELLED -> MaterialTheme.colorScheme.onSurfaceVariant
         else -> MaterialTheme.colorScheme.tertiary
     }
     Surface(
@@ -501,6 +478,14 @@ private fun ProcessStateIcon(process: GatewayProcess, failed: Boolean, stopping:
                     modifier = Modifier.size(18.dp),
                     tint = tint,
                 )
+                phase == ProcessDisplayPhase.UNKNOWN || phase == ProcessDisplayPhase.CANCELLED -> Icon(
+                    imageVector = if (phase == ProcessDisplayPhase.UNKNOWN) Icons.Filled.HelpOutline else Icons.Filled.PauseCircleOutline,
+                    contentDescription = stringResource(
+                        if (phase == ProcessDisplayPhase.UNKNOWN) R.string.agent_activity_status_unavailable else R.string.task_status_cancelled,
+                    ),
+                    modifier = Modifier.size(18.dp),
+                    tint = tint,
+                )
                 else -> Icon(
                     Icons.Filled.CheckCircle,
                     contentDescription = stringResource(R.string.tool_completed_a11y),
@@ -514,8 +499,11 @@ private fun ProcessStateIcon(process: GatewayProcess, failed: Boolean, stopping:
 
 @Composable
 private fun processMetadata(process: GatewayProcess, failed: Boolean): String {
+    val phase = processDisplayPhase(process)
     val state = when {
         process.isRunning -> stringResource(R.string.bg_processes_running)
+        phase == ProcessDisplayPhase.UNKNOWN -> stringResource(R.string.agent_activity_status_unavailable)
+        phase == ProcessDisplayPhase.CANCELLED -> stringResource(R.string.task_status_cancelled)
         failed -> stringResource(R.string.task_status_failed) +
             process.exitCode?.let { " · exit $it" }.orEmpty()
         else -> stringResource(R.string.task_status_complete) +
@@ -525,6 +513,19 @@ private fun processMetadata(process: GatewayProcess, failed: Boolean): String {
         if (process.detached) " · recovered" else ""
 }
 
+internal enum class ProcessDisplayPhase { RUNNING, COMPLETE, FAILED, CANCELLED, UNKNOWN }
+
+/** A recovered or unfamiliar state is not evidence of successful completion. */
+internal fun processDisplayPhase(process: GatewayProcess): ProcessDisplayPhase = when {
+    process.isRunning -> ProcessDisplayPhase.RUNNING
+    process.status.equals("unknown", ignoreCase = true) -> ProcessDisplayPhase.UNKNOWN
+    process.status.equals("cancelled", ignoreCase = true) ||
+        process.status.equals("canceled", ignoreCase = true) -> ProcessDisplayPhase.CANCELLED
+    process.status.equals("failed", ignoreCase = true) || (process.exitCode ?: 0) != 0 -> ProcessDisplayPhase.FAILED
+    process.exitCode == 0 || process.status.lowercase() in setOf("complete", "completed", "exited") -> ProcessDisplayPhase.COMPLETE
+    else -> ProcessDisplayPhase.UNKNOWN
+}
+
 private val ansiTerminalEscape = Regex(
     "\u001B(?:\\].*?(?:\u0007|\u001B\\\\)|\\[[0-?]*[ -/]*[@-~]|[ -/]*[@-~])",
     RegexOption.DOT_MATCHES_ALL,

app/src/main/kotlin/com/hermesandroid/relay/ui/components/ImageGenerationPlaceholder.kt

@@ -57,6 +57,7 @@ import androidx.compose.ui.unit.IntSize
 import androidx.annotation.RequiresApi
 import com.hermesandroid.relay.R
 import com.hermesandroid.relay.data.ToolCall
+import com.hermesandroid.relay.data.isImageGenerationToolName
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
 import java.util.Locale
@@ -65,7 +66,6 @@ import kotlin.math.cos
 import kotlin.math.floor
 import kotlin.math.sin
 
-private const val IMAGE_GENERATION_TOOL = "image_generate"
 private const val GRID_COLUMNS = 42
 private const val GRID_ROWS = 24
 private const val DEFAULT_ANIMATION_DURATION_MS = 4_800
@@ -134,11 +134,11 @@ internal fun resolveImageGenerationVisualStyle(
 }
 
 internal fun ToolCall.showsImageGenerationPlaceholder(): Boolean =
-    !isComplete && name.trim().lowercase() == IMAGE_GENERATION_TOOL
+    !isComplete && isImageGenerationToolName(name)
 
 internal fun imageGenerationStartedAt(toolCalls: List<ToolCall>): Long? =
     toolCalls.lastOrNull {
-        it.name.trim().lowercase() == IMAGE_GENERATION_TOOL
+        isImageGenerationToolName(it.name)
     }?.startedAt
 
 internal fun formatGenerationDuration(elapsedMillis: Long): String =
@@ -155,7 +155,7 @@ internal fun shouldShowImageGenerationPlaceholder(
     hasMediaResult: Boolean,
 ): Boolean {
     val imageCalls = toolCalls.filter {
-        it.name.trim().lowercase() == IMAGE_GENERATION_TOOL
+        isImageGenerationToolName(it.name)
     }
     if (imageCalls.any { !it.isComplete }) return true
     return !hasMediaResult &&

app/src/main/kotlin/com/hermesandroid/relay/ui/components/InboundAttachmentCard.kt

@@ -5,7 +5,7 @@ import android.graphics.Bitmap
 import android.graphics.pdf.PdfRenderer
 import android.media.MediaMetadataRetriever
 import android.net.Uri
-import android.widget.Toast
+import com.hermesandroid.relay.ui.UiMessageBus
 import androidx.compose.ui.res.stringResource
 import com.hermesandroid.relay.R
 import com.hermesandroid.relay.ui.theme.appearanceRoundedCornerShape
@@ -14,6 +14,7 @@ import androidx.compose.foundation.Image
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.aspectRatio
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -44,6 +45,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -206,29 +208,49 @@ private fun FailedCard(
     modifier: Modifier,
     maxWidth: Dp
 ) {
+    val hostOnly = attachment.errorMessage == ChatViewModel.MEDIA_HOST_ONLY
     Surface(
         shape = appearanceRoundedCornerShape(10.dp),
-        color = MaterialTheme.colorScheme.errorContainer,
+        color = if (hostOnly) MaterialTheme.colorScheme.surfaceVariant else MaterialTheme.colorScheme.errorContainer,
         modifier = modifier
             .widthIn(max = maxWidth)
-            .clickable { onRetry() }
+            .then(if (hostOnly) Modifier else Modifier.clickable { onRetry() })
     ) {
         Row(
             modifier = Modifier.padding(12.dp),
             verticalAlignment = Alignment.CenterVertically,
             horizontalArrangement = Arrangement.spacedBy(10.dp)
         ) {
-            Text(text = "\u26A0\uFE0F", style = MaterialTheme.typography.titleMedium)
+            Text(
+                text = if (hostOnly) "\uD83D\uDCCE" else "\u26A0\uFE0F",
+                style = MaterialTheme.typography.titleMedium,
+            )
             Column(modifier = Modifier.weight(1f)) {
                 Text(
-                    text = attachment.errorMessage ?: stringResource(R.string.inbound_attach_failed),
+                    text = if (hostOnly) {
+                        stringResource(R.string.inbound_attach_host_only)
+                    } else {
+                        attachment.errorMessage ?: stringResource(R.string.inbound_attach_failed)
+                    },
                     style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onErrorContainer
+                    color = if (hostOnly) {
+                        MaterialTheme.colorScheme.onSurfaceVariant
+                    } else {
+                        MaterialTheme.colorScheme.onErrorContainer
+                    },
                 )
                 Text(
-                    text = stringResource(R.string.inbound_attach_tap_retry),
+                    text = if (hostOnly) {
+                        stringResource(R.string.inbound_attach_host_only_help)
+                    } else {
+                        stringResource(R.string.inbound_attach_tap_retry)
+                    },
                     style = MaterialTheme.typography.labelSmall,
-                    color = MaterialTheme.colorScheme.onErrorContainer.copy(alpha = 0.7f)
+                    color = if (hostOnly) {
+                        MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.7f)
+                    } else {
+                        MaterialTheme.colorScheme.onErrorContainer.copy(alpha = 0.7f)
+                    },
                 )
             }
         }
@@ -282,17 +304,21 @@ private fun ImageRender(
     }
     LaunchedEffect(attachment.cachedUri, attachment.content) {
         val decoded = withContext(Dispatchers.IO) {
-            runCatching {
-                val bytes: ByteArray? = when {
+            try {
+                when {
                     !attachment.cachedUri.isNullOrBlank() ->
-                        context.contentResolver.openInputStream(Uri.parse(attachment.cachedUri))
-                            ?.use { it.readBytes() }
+                        decodeBoundedOrientedBitmap(context, Uri.parse(attachment.cachedUri))
+                            ?.asImageBitmap()
                     attachment.content.isNotBlank() ->
-                        android.util.Base64.decode(attachment.content, android.util.Base64.DEFAULT)
+                        android.util.Base64.decode(
+                            attachment.content,
+                            android.util.Base64.DEFAULT,
+                        ).let { decodeBoundedOrientedBitmap(it)?.asImageBitmap() }
                     else -> null
                 }
-                bytes?.let { decodeOrientedBitmap(it)?.asImageBitmap() }
-            }.getOrNull()
+            } catch (_: Exception) {
+                null
+            }
         }
         if (decoded != null) bitmap = decoded else decodeFailed = true
     }
@@ -309,9 +335,14 @@ private fun ImageRender(
     }
 
     val blurMode = LocalMediaBlurMode.current
+    val viewerController = LocalChatMediaViewerController.current
     var revealed by remember(attachment.cachedUri, attachment.content) { mutableStateOf(false) }
     val blurred = !revealed && shouldBlurImage(blurMode, attachment.sensitive)
-    var viewerOpen by remember { mutableStateOf(false) }
+    var viewerOpen by rememberSaveable(
+        attachment.cachedUri,
+        attachment.relayToken,
+        attachment.fileName,
+    ) { mutableStateOf(false) }
     var menuExpanded by remember { mutableStateOf(false) }
 
     val bmp = bitmap
@@ -332,7 +363,7 @@ private fun ImageRender(
         return
     }
 
-    if (viewerOpen) {
+    if (viewerController == null && viewerOpen) {
         AttachmentViewer(
             attachment = attachment,
             onDismiss = { viewerOpen = false },
@@ -347,12 +378,25 @@ private fun ImageRender(
                 contentDescription = attachment.fileName,
                 modifier = Modifier
                     .widthIn(max = maxWidth)
+                    .fillMaxWidth()
+                    .aspectRatio(bmp.width.toFloat() / bmp.height.coerceAtLeast(1))
                     .clip(RoundedCornerShape(8.dp))
                     .combinedClickable(
-                        onClick = { viewerOpen = true },
+                        onClick = {
+                            if (viewerController != null) {
+                                viewerController.openAttachment(
+                                    attachment = attachment,
+                                    initiallyRevealed = revealed,
+                                    blurMode = blurMode,
+                                    exportAllowed = exportAllowed,
+                                )
+                            } else {
+                                viewerOpen = true
+                            }
+                        },
                         onLongClick = { menuExpanded = true },
                     ),
-                contentScale = ContentScale.FillWidth,
+                contentScale = ContentScale.Fit,
             )
         }
         // One-tap save overlay — hidden while the blur cover is up so it
@@ -386,15 +430,20 @@ private fun FileCardRender(
     val scope = rememberCoroutineScope()
     val (emoji, typeLabel) = emojiAndLabelFor(attachment.renderMode, attachment.contentType)
     var menuExpanded by remember { mutableStateOf(false) }
-    var viewerOpen by remember { mutableStateOf(false) }
+    var viewerOpen by rememberSaveable(
+        attachment.cachedUri,
+        attachment.relayToken,
+        attachment.fileName,
+    ) { mutableStateOf(false) }
 
     // Real thumbnail when one is cheap (video first frame, PDF first page);
     // null falls back to the type emoji.
     val thumbnail = rememberAttachmentThumbnail(attachment)
     val blurMode = LocalMediaBlurMode.current
+    val viewerController = LocalChatMediaViewerController.current
     val blurThumb = thumbnail != null && shouldBlurThumb(blurMode, attachment)
 
-    if (viewerOpen) {
+    if (viewerController == null && viewerOpen) {
         // Non-image types don't blur in the viewer; open straight through.
         AttachmentViewer(
             attachment = attachment,
@@ -410,7 +459,18 @@ private fun FileCardRender(
             .widthIn(max = maxWidth)
             // Tap previews in-app; long-press surfaces Open-externally / Share / Save.
             .combinedClickable(
-                onClick = { viewerOpen = true },
+                onClick = {
+                    if (viewerController != null) {
+                        viewerController.openAttachment(
+                            attachment = attachment,
+                            initiallyRevealed = true,
+                            blurMode = blurMode,
+                            exportAllowed = exportAllowed,
+                        )
+                    } else {
+                        viewerOpen = true
+                    }
+                },
                 onLongClick = { menuExpanded = true },
             )
     ) {
@@ -556,7 +616,7 @@ fun SaveOverlayButton(onClick: () -> Unit, modifier: Modifier = Modifier) {
 private suspend fun shareAttachment(context: Context, attachment: Attachment) {
     val bytes = attachmentBytes(context, attachment)
     if (bytes == null) {
-        attachmentToast(context, context.getString(R.string.inbound_attach_share_failed))
+        UiMessageBus.error(context.getString(R.string.inbound_attach_share_failed))
         return
     }
     val uri = MediaSaver.stageForShare(context, bytes, attachment.fileName, attachment.contentType)
@@ -566,7 +626,7 @@ private suspend fun shareAttachment(context: Context, attachment: Attachment) {
 suspend fun saveAttachment(context: Context, attachment: Attachment) {
     val bytes = attachmentBytes(context, attachment)
     if (bytes == null) {
-        attachmentToast(context, context.getString(R.string.inbound_attach_share_failed))
+        UiMessageBus.error(context.getString(R.string.inbound_attach_share_failed))
         return
     }
     val result = if (attachment.renderMode == AttachmentRenderMode.IMAGE) {
@@ -576,13 +636,13 @@ suspend fun saveAttachment(context: Context, attachment: Attachment) {
     }
     when (result) {
         is MediaSaver.SaveResult.Saved ->
-            attachmentToast(context, context.getString(R.string.inbound_attach_saved, result.location))
+            UiMessageBus.success(context.getString(R.string.inbound_attach_saved, result.location))
         MediaSaver.SaveResult.UseShareInstead -> {
             val uri = MediaSaver.stageForShare(context, bytes, attachment.fileName, attachment.contentType)
             MediaSaver.share(context, uri, attachment.contentType)
         }
         is MediaSaver.SaveResult.Failed ->
-            attachmentToast(context, context.getString(R.string.inbound_attach_save_failed, result.message))
+            UiMessageBus.error(context.getString(R.string.inbound_attach_save_failed, result.message))
     }
 }
 
@@ -598,7 +658,7 @@ private suspend fun openAttachmentExternally(context: Context, attachment: Attac
     if (uri != null) {
         MediaSaver.open(context, uri, attachment.contentType)
     } else {
-        attachmentToast(context, context.getString(R.string.inbound_attach_open_failed))
+        UiMessageBus.error(context.getString(R.string.inbound_attach_open_failed))
     }
 }
 
@@ -628,7 +688,11 @@ private fun rememberAttachmentThumbnail(attachment: Attachment): ImageBitmap? {
     }
     LaunchedEffect(attachment.cachedUri, attachment.content, attachment.renderMode) {
         thumb = withContext(Dispatchers.IO) {
-            runCatching { generateThumbnail(context, attachment) }.getOrNull()
+            try {
+                generateThumbnail(context, attachment)
+            } catch (_: Exception) {
+                null
+            }
         }
     }
     return thumb
@@ -710,10 +774,6 @@ internal suspend fun attachmentBytes(context: Context, attachment: Attachment):
     }
 }
 
-private fun attachmentToast(context: Context, message: String) {
-    Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
-}
-
 @Composable
 private fun emojiAndLabelFor(
     mode: AttachmentRenderMode,

app/src/main/kotlin/com/hermesandroid/relay/ui/components/InlineImageDataUrl.kt

@@ -46,7 +46,11 @@ internal fun decodeInlineImageDataUrl(
     // ceil(maxBytes / 3) * 4 plus at most two trailing padding characters.
     val maxEncoded = ((maxBytes.toLong() + 2L) / 3L) * 4L
     if (encoded.length.toLong() > maxEncoded) return null
-    val bytes = runCatching { Base64.getDecoder().decode(encoded) }.getOrNull() ?: return null
+    val bytes = try {
+        Base64.getDecoder().decode(encoded)
+    } catch (_: IllegalArgumentException) {
+        return null
+    }
     if (bytes.isEmpty() || bytes.size > maxBytes || !matchesImageMagic(mime, bytes)) return null
     return DecodedInlineImageData(bytes, mime)
 }

app/src/main/kotlin/com/hermesandroid/relay/ui/components/MarkdownContent.kt

@@ -73,7 +73,7 @@ fun MarkdownContent(
     modifier: Modifier = Modifier
 ) {
     ConfiguredMarkdownContent(
-        content = content,
+        content = markdownRenderWindow(content),
         textColor = textColor,
         modifier = modifier,
     )
@@ -318,7 +318,7 @@ fun StreamingMarkdownContent(
     var generation by remember { mutableIntStateOf(0) }
     key(generation) {
         NativeStreamingMarkdownGeneration(
-            content = content.withoutLeadingBlankLines(),
+            content = markdownRenderWindow(content.withoutLeadingBlankLines()),
             textColor = textColor,
             modifier = modifier,
             onResetRequired = { generation += 1 },
@@ -353,6 +353,17 @@ private fun NativeStreamingMarkdownGeneration(
     )
 }
 
+internal const val MAX_RENDERED_MARKDOWN_CHARS = 256_000
+private const val MARKDOWN_TRUNCATION_NOTICE =
+    "\n\n---\n_Response display was shortened for Android memory safety._"
+
+internal fun markdownRenderWindow(content: String): String =
+    if (content.length <= MAX_RENDERED_MARKDOWN_CHARS) {
+        content
+    } else {
+        content.take(MAX_RENDERED_MARKDOWN_CHARS) + MARKDOWN_TRUNCATION_NOTICE
+    }
+
 internal data class StreamingMarkdownAppendPlan(
     val resetRequired: Boolean,
     val delta: String,

app/src/main/kotlin/com/hermesandroid/relay/ui/components/MessageBanner.kt

@@ -26,11 +26,13 @@ import androidx.compose.material.icons.filled.Info
 import androidx.compose.material.icons.filled.KeyboardArrowDown
 import androidx.compose.material.icons.filled.KeyboardArrowUp
 import androidx.compose.material.icons.filled.Sync
+import androidx.compose.material.icons.filled.Warning
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -46,6 +48,7 @@ import androidx.compose.ui.semantics.LiveRegionMode
 import androidx.compose.ui.semantics.liveRegion
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.compositeOver
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
@@ -53,7 +56,9 @@ import androidx.compose.ui.unit.dp
 import com.hermesandroid.relay.R
 import com.hermesandroid.relay.ui.UiMessage
 import com.hermesandroid.relay.ui.UiMessageBus
+import com.hermesandroid.relay.ui.UiMessageEvent
 import com.hermesandroid.relay.ui.UiMessageSeverity
+import com.hermesandroid.relay.ui.reduceUiMessages
 import kotlinx.coroutines.delay
 
 private const val MAX_RETAINED = 6
@@ -61,20 +66,26 @@ private const val MAX_VISIBLE_EXPANDED = 3
 private const val ROW_MIN_HEIGHT_DP = 34
 
 /**
- * Top, thin, info-only banner host. Collects [UiMessageBus] and renders the
+ * Top, thin, themed banner host. Collects [UiMessageBus] and renders the
  * newest transient message on one line; tapping expands to the recent few
  * (scrolling past three). It takes its own vertical space — the Scaffold below
  * reflows, so content slides down smoothly instead of being covered by an
  * overlay. Auto-dismisses (paused while expanded) and coalesces duplicates so a
  * burst of the same status collapses to one refreshed row.
  *
- * Errors stay on the snackbar — only post info/success/status here.
+ * Actionable messages use ThemedMessageHost. Modal hosts render above their
+ * dialog while the primary host retains messages for the return to the app.
  */
 @Composable
 fun MessageBannerHost(
     modifier: Modifier = Modifier,
     includeStatusBarPadding: Boolean = true,
+    primary: Boolean = true,
 ) {
+    val hostId = remember { UiMessageBus.registerHost(primary) }
+    val activeHost by UiMessageBus.activeHost.collectAsState()
+    val active = activeHost == hostId
+    DisposableEffect(hostId) { onDispose { UiMessageBus.unregisterHost(hostId) } }
     // Backing queue (oldest first; newest is last). expiresAt is kept in a
     // parallel map so coalescing/auto-dismiss can address rows by id.
     val shown = remember { mutableStateListOf<UiMessage>() }
@@ -82,18 +93,19 @@ fun MessageBannerHost(
     var expanded by remember { mutableStateOf(false) }
 
     LaunchedEffect(Unit) {
-        UiMessageBus.events.collect { msg ->
-            // Coalesce identical text so e.g. repeated "Reconnecting…" collapses
-            // to a single, freshly-timed row rather than stacking.
-            shown.filter { it.text == msg.text }.forEach { dup ->
-                shown.remove(dup)
-                expiresAt.remove(dup.id)
-            }
-            shown.add(msg)
-            expiresAt[msg.id] = nowMs() + msg.ttlMillis
-            while (shown.size > MAX_RETAINED) {
-                val dropped = shown.removeAt(0)
-                expiresAt.remove(dropped.id)
+        UiMessageBus.events.collect { event ->
+            val next = reduceUiMessages(shown, event, MAX_RETAINED)
+            val retainedIds = next.mapTo(mutableSetOf()) { it.id }
+            expiresAt.keys.filterNot(retainedIds::contains).forEach { expiresAt.remove(it) }
+            shown.clear()
+            shown.addAll(next)
+            if (event is UiMessageEvent.Show) {
+                val msg = event.message
+                expiresAt[msg.id] = if (msg.ttlMillis == 0L) {
+                    Long.MAX_VALUE
+                } else {
+                    nowMs() + msg.ttlMillis
+                }
             }
         }
     }
@@ -104,6 +116,7 @@ fun MessageBannerHost(
         while (shown.isNotEmpty()) {
             val now = nowMs()
             val soonest = shown.minOfOrNull { expiresAt[it.id] ?: Long.MAX_VALUE } ?: break
+            if (soonest == Long.MAX_VALUE) break
             if (soonest <= now) {
                 shown.filter { (expiresAt[it.id] ?: Long.MAX_VALUE) <= now }.forEach { expired ->
                     shown.remove(expired)
@@ -116,12 +129,12 @@ fun MessageBannerHost(
     }
 
     // Collapse + report count to the scaffold (for inset accounting).
-    LaunchedEffect(shown.size) {
+    LaunchedEffect(shown.size, active) {
         if (shown.isEmpty()) expanded = false
-        UiMessageBus.reportActiveCount(shown.size)
+        if (primary) UiMessageBus.reportActiveCount(if (active) shown.size else 0)
     }
     DisposableEffect(Unit) {
-        onDispose { UiMessageBus.reportActiveCount(0) }
+        onDispose { if (primary) UiMessageBus.reportActiveCount(0) }
     }
 
     // Mirror the live queue into a retained copy so the exit animation still
@@ -141,7 +154,7 @@ fun MessageBannerHost(
     // under the notch. The smooth "slide" lives in animateContentSize below
     // (collapsed↔expanded and message-count changes).
     AnimatedVisibility(
-        visible = shown.isNotEmpty(),
+        visible = active && shown.isNotEmpty(),
         enter = fadeIn(tween(180)),
         exit = fadeOut(tween(160)),
         modifier = modifier,
@@ -149,7 +162,7 @@ fun MessageBannerHost(
         MessageBannerContent(
             messages = rendered,
             expanded = expanded,
-            onToggle = { if (rendered.size > 1) expanded = !expanded },
+            onToggle = { expanded = !expanded },
             includeStatusBarPadding = includeStatusBarPadding,
         )
     }
@@ -164,6 +177,7 @@ private fun MessageBannerContent(
 ) {
     val newest = messages.lastOrNull() ?: return
     val multiple = messages.size > 1
+    val expandable = multiple || newest.text.length > 80 || newest.severity in setOf(UiMessageSeverity.Warning, UiMessageSeverity.Error)
     val insetModifier = if (includeStatusBarPadding) {
         Modifier.windowInsetsPadding(WindowInsets.statusBars)
     } else {
@@ -184,14 +198,14 @@ private fun MessageBannerContent(
             tonalElevation = 0.dp,
             modifier = Modifier
                 .fillMaxWidth()
-                .then(if (multiple) Modifier.clickable(onClick = onToggle) else Modifier)
+                .then(if (expandable) Modifier.clickable(onClick = onToggle) else Modifier)
                 .animateContentSize(animationSpec = tween(durationMillis = 180)),
         ) {
             if (!expanded) {
                 MessageRow(
                     message = newest,
                     trailing = {
-                        if (multiple) {
+                        if (expandable) {
                             Row(
                                 horizontalArrangement = Arrangement.spacedBy(2.dp),
                                 verticalAlignment = Alignment.CenterVertically,
@@ -230,6 +244,7 @@ private fun MessageBannerContent(
                     ordered.forEachIndexed { index, message ->
                         MessageRow(
                             message = message,
+                            expanded = true,
                             trailing = {
                                 if (index == 0) {
                                     Icon(
@@ -250,6 +265,7 @@ private fun MessageBannerContent(
 @Composable
 private fun MessageRow(
     message: UiMessage,
+    expanded: Boolean = false,
     trailing: @Composable (() -> Unit)? = null,
 ) {
     Row(
@@ -269,7 +285,7 @@ private fun MessageRow(
         Text(
             text = message.text,
             style = MaterialTheme.typography.labelMedium,
-            maxLines = 1,
+            maxLines = if (expanded) 12 else 1,
             overflow = TextOverflow.Ellipsis,
             modifier = Modifier.weight(1f),
         )
@@ -278,22 +294,28 @@ private fun MessageRow(
 }
 
 @Composable
-private fun severityContainer(severity: UiMessageSeverity): Color = when (severity) {
+internal fun severityContainer(severity: UiMessageSeverity): Color = (when (severity) {
+    UiMessageSeverity.Error -> MaterialTheme.colorScheme.errorContainer
     UiMessageSeverity.Success -> MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.58f)
     UiMessageSeverity.Status -> MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.74f)
+    UiMessageSeverity.Warning -> MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.72f)
     UiMessageSeverity.Info -> MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.90f)
-}
+}).compositeOver(MaterialTheme.colorScheme.surface)
 
 @Composable
-private fun severityOnContainer(severity: UiMessageSeverity): Color = when (severity) {
+internal fun severityOnContainer(severity: UiMessageSeverity): Color = when (severity) {
+    UiMessageSeverity.Error -> MaterialTheme.colorScheme.onErrorContainer
     UiMessageSeverity.Success -> MaterialTheme.colorScheme.onTertiaryContainer
     UiMessageSeverity.Status -> MaterialTheme.colorScheme.onSecondaryContainer
+    UiMessageSeverity.Warning -> MaterialTheme.colorScheme.onErrorContainer
     UiMessageSeverity.Info -> MaterialTheme.colorScheme.onSurfaceVariant
 }
 
-private fun severityIcon(severity: UiMessageSeverity): ImageVector = when (severity) {
+internal fun severityIcon(severity: UiMessageSeverity): ImageVector = when (severity) {
+    UiMessageSeverity.Error -> Icons.Filled.Warning
     UiMessageSeverity.Success -> Icons.Filled.CheckCircle
     UiMessageSeverity.Status -> Icons.Filled.Sync
+    UiMessageSeverity.Warning -> Icons.Filled.Warning
     UiMessageSeverity.Info -> Icons.Filled.Info
 }
 

app/src/main/kotlin/com/hermesandroid/relay/ui/components/MessageBubble.kt

@@ -83,6 +83,7 @@ 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.isImageGenerationToolName
 import com.hermesandroid.relay.data.parseChatQuotedPrompt
 import com.hermesandroid.relay.ui.components.pet.petObstacleSurface
 import com.hermesandroid.relay.ui.components.pet.petPerchSurface
@@ -292,9 +293,7 @@ fun MessageBubble(
         append(streamingStatusLabel ?: visibleMessageContent.take(100))
     }
     val hasImageGenerationCall = remember(message.toolCalls) {
-        message.toolCalls.any {
-            it.name.trim().lowercase() == "image_generate"
-        }
+        message.toolCalls.any { isImageGenerationToolName(it.name) }
     }
     val imageGenerationStartMillis = remember(message.toolCalls) {
         imageGenerationStartedAt(message.toolCalls)
@@ -857,13 +856,13 @@ fun MessageBubble(
                     }
                 }
 
-                // Delivery status — only on agent-Thread reply bubbles (a user
-                // message routed over the relay proactive channel). Null on every
-                // ordinary chat message, which render nothing here.
+                // Delivery status for local user messages, including steering.
+                // Use the bubble's foreground: accent-on-accent hides the label.
                 message.deliveryStatus?.takeIf { isUser }?.let { status ->
                     Spacer(modifier = Modifier.height(2.dp))
                     MessageDeliveryIndicator(
                         status = status,
+                        contentColor = textColor,
                         text = MessageDeliveryIndicatorText(
                             sending = stringResource(R.string.msg_bubble_sending),
                             queued = stringResource(R.string.msg_bubble_queued),

app/src/main/kotlin/com/hermesandroid/relay/ui/components/MessageDeliveryIndicator.kt

@@ -18,6 +18,7 @@ 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.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.semantics.LiveRegionMode
 import androidx.compose.ui.semantics.Role
@@ -57,6 +58,7 @@ fun MessageDeliveryIndicator(
     modifier: Modifier = Modifier,
     failureMessage: String? = null,
     onRetry: (() -> Unit)? = null,
+    contentColor: Color? = null,
 ) {
     val retryAction = onRetry.takeIf { status == MessageDeliveryStatus.FAILED }
     val retryable = retryAction != null
@@ -67,7 +69,7 @@ fun MessageDeliveryIndicator(
         retryable = retryable,
     )
     val presentation = messageDeliveryPresentation(status)
-    val tint = when (presentation.colorRole) {
+    val tint = contentColor ?: when (presentation.colorRole) {
         DeliveryColorRole.NEUTRAL -> MaterialTheme.colorScheme.onSurfaceVariant
         DeliveryColorRole.ACCENT -> MaterialTheme.colorScheme.primary
         DeliveryColorRole.QUEUED -> MaterialTheme.colorScheme.tertiary

app/src/main/kotlin/com/hermesandroid/relay/ui/components/OrientationOverride.kt

@@ -11,16 +11,15 @@ import androidx.compose.ui.platform.LocalContext
 
 /**
  * Temporarily allow the device to rotate (portrait or landscape, following the
- * sensor) while this composable is in the composition, overriding the app-wide
- * portrait lock declared in the manifest (`MainActivity` screenOrientation).
+ * user's rotation preference) while this composable is in the composition,
+ * overriding the app-wide portrait lock declared in the manifest
+ * (`MainActivity` screenOrientation).
  * Restores the previous orientation (portrait) when it leaves the composition.
  *
  * Used by the full-screen media viewers ([ChatImageViewer], [AttachmentViewer])
  * so wide images and video can be viewed in landscape while the rest of the app
- * stays portrait-locked. Uses `SENSOR` (portrait + both landscapes, no
- * upside-down) so the viewer rotates with the device regardless of the system
- * auto-rotate toggle; swap to `SCREEN_ORIENTATION_USER` to instead respect that
- * toggle.
+ * stays portrait-locked. Uses `USER` so the viewer follows the device only when
+ * the user has enabled rotation instead of overriding their system preference.
  */
 @Composable
 fun AllowDeviceRotation() {
@@ -28,7 +27,7 @@ fun AllowDeviceRotation() {
     DisposableEffect(Unit) {
         val activity = context.findActivity()
         val previous = activity?.requestedOrientation
-        activity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR
+        activity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER
         onDispose {
             activity?.requestedOrientation =
                 previous ?: ActivityInfo.SCREEN_ORIENTATION_PORTRAIT