release(android): android-v1.13.2

fix(android): keep unknown session activity neutral
(cherry picked from commit ae9b22a9e6)
2026-08-25 19:45:39 -04:00 · 2026-08-25 19:44:28 -04:00
639 changed files with 10473 additions and 68354 deletions
@@ -0,0 +1,38 @@
+## 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
@@ -5,8 +5,9 @@ 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. `CLAUDE.md` imports that same canonical file. Follow
-`AGENTS.md` and its linked project records; don't restate them here.
+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.

 Quick non-negotiables (the full list and rationale are in `AGENTS.md`):

@@ -16,8 +17,6 @@ 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. 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.
+  OkHttp (no Ktor), `wss://` only; run `./gradlew lint` before pushing Kotlin.
 - **Public repo:** no personal names, no private infrastructure, no
  AI/assistant self-narration in committed prose.
@@ -1,47 +0,0 @@
-## Summary
-
-<!-- Describe the user/developer outcome and why this change is needed. Link related issues, e.g. Closes #123. -->
-
-## Changes
-
-<!-- List the focused implementation changes. Avoid repeating the commit log. -->
-
-
-
-## Verification
-
-<!-- List exact commands and results. Say explicitly when a check was not run or when device/UI proof remains outstanding. -->
-
-
-
-## Screenshots
-
-<!-- UI change: include screenshots/video plus device, viewport, or emulator details. Otherwise write: No visual change. -->
-
-## Compatibility / risk
-
-<!-- Note Standard Hermes/upstream compatibility, migrations/state changes, security/privacy impact, rollout/rollback, or write N/A. -->
-
-## Lineage / contributor credit
-
-<!-- Preserve prior contributor work when replacing, salvaging, or rebuilding another PR. -->
-
- Source PR(s): N/A
- Attribution preserved by: N/A
-
-## Checklist
-
-<!-- Check an item when satisfied or when its N/A rationale is stated above. -->
-
- [ ] Target branch is `dev`, unless this is a `dev` → `main` release PR or a focused production-tag hotfix PR to `main`
- [ ] Scope is focused and related issues/PRs are linked
- [ ] Android changes: lint and focused tests ran, or rationale is listed above
- [ ] Translation changes: locale validation/review ran, or N/A is listed above
- [ ] Server/plugin changes: focused tests ran, or N/A/rationale is listed above
- [ ] Desktop changes: build/tests ran, or N/A/rationale is listed above
- [ ] Docs/site changes: build or link/route checks ran, or N/A/rationale is listed above
- [ ] UI changes were tested on a relevant device/emulator/desktop surface, or the missing proof is stated above
- [ ] Commit messages follow [Conventional Commits](https://www.conventionalcommits.org/)
- [ ] `CHANGELOG.md` is updated for user-visible changes, or N/A is listed above
- [ ] Public writing hygiene checked: no secrets, private infrastructure, personal names, or AI/process narration
- [ ] Salvaged/replacement work links source PRs and preserves contributor authorship, or N/A is listed above
@@ -3,45 +3,29 @@
 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',
-    'scripts/tests/plan_release_backmerge_test.py',
  ].includes(path));
  const exact = (values) => paths.some((path) => values.includes(path));
  const under = (prefixes) => paths.some((path) => prefixes.some((prefix) => path.startsWith(prefix)));

  return {
-    android: forceAll || under(['app/', 'gradle/']) || exact([
+    android: forceAll || under(['app/', 'relay-core/', 'relay-ui/', 'ui-preview/', 'quest/', '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',
-      'scripts/tests/android_release_artifacts_test.py',
-      '.github/workflows/android-on-demand.yml', '.github/workflows/ci-android.yml',
+      'scripts/check-android-collection-apis.py', '.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',
@@ -1,8 +1,6 @@
 '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 = {
@@ -16,25 +14,7 @@ const none = {

 assert.deepEqual(classifyCiPaths(['README.md']), none);
 assert.deepEqual(classifyCiPaths(['desktop/src/cli.ts']), { ...none, desktop: 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(['relay-core/src/main/kotlin/Wire.kt']), { ...none, android: 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 });
@@ -50,81 +30,5 @@ assert.deepEqual(classifyCiPaths(['.github/workflows/ci-required.yml']), {
  contract: true,
  docs: true,
 });
-assert.deepEqual(classifyCiPaths(['.github/workflows/release-backmerge.yml']), {
-  android: true,
-  desktop: true,
-  plugin: true,
-  dashboard: true,
-  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.');
@@ -1,226 +0,0 @@
-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
@@ -40,10 +40,6 @@ 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"
@@ -60,21 +56,13 @@ jobs:
          RELEASE_TREE: ${{ steps.metadata.outputs.tree }}
        run: |
          ARTIFACT_NAME="play-preflight-${VERSION}-${RELEASE_TREE}"
-          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
+          COUNT=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/artifacts?name=${ARTIFACT_NAME}" \
+            --jq '[.artifacts[] | select(.expired == false)] | length')
+          if [ "$COUNT" -lt 1 ]; then
            echo "::error::No successful Play preflight found for version $VERSION with tree $RELEASE_TREE"
            exit 1
          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/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)"
+          echo "Verified Play preflight proof: $ARTIFACT_NAME"

      - name: Ensure release tag does not already exist
        env:
@@ -1,158 +0,0 @@
-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"
@@ -1,120 +0,0 @@
-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"
@@ -20,26 +20,20 @@ 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"
-      - "scripts/check-android-native-compat.py"
-      - "scripts/check-android-release-notes.py"
-      - "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"
@@ -63,7 +57,7 @@ jobs:
        uses: actions/checkout@v7

      - name: Set up JDK 17
-        uses: actions/setup-java@v6
+        uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 17
@@ -79,15 +73,6 @@ jobs:
      - name: Reject unsafe Android collection APIs
        run: python3 scripts/check-android-collection-apis.py

-      - 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
-        run: python3 -m unittest scripts.tests.check_android_native_compat_test
-
      - name: Run Android lint
        run: ./gradlew lint --console=plain

@@ -104,7 +89,7 @@ jobs:
        uses: actions/checkout@v7

      - name: Set up JDK 17
-        uses: actions/setup-java@v6
+        uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 17
@@ -117,12 +102,6 @@ jobs:
      - name: Build debug APK
        run: ./gradlew assembleDebug --console=plain

-      - name: Verify packaged ONNX Runtime 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 APK
        uses: actions/upload-artifact@v7
        if: ${{ github.ref == 'refs/heads/main' }}
@@ -154,7 +133,7 @@ jobs:
        uses: actions/checkout@v7

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

      - name: Set up JDK 17
-        uses: actions/setup-java@v6
+        uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 17
@@ -239,9 +218,3 @@ jobs:
          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 ONNX Runtime compatibility
-        run: |
-          python3 scripts/check-android-native-compat.py \
-            app/build/outputs/apk/googlePlay/release/*.apk \
-            app/build/outputs/apk/sideload/release/*.apk
@@ -11,9 +11,6 @@

 name: CI — Upstream Contract

-permissions:
-  contents: read
-
 on:
  workflow_call:
  push:
@@ -43,64 +40,45 @@ jobs:
    steps:
      - name: Checkout hermes-relay
        uses: actions/checkout@v7
-        with:
-          persist-credentials: false

      - name: Resolve upstream ref
        id: ref
-        env:
-          REQUESTED_REF: ${{ github.event.inputs.upstream_ref }}
        run: |
-          set -euo pipefail
          # PR/push runs use a known-good NousResearch/hermes-agent commit so
          # normal CI is stable. The weekly schedule below intentionally tracks
          # main as the upstream-drift siren.
          DEFAULT_REF="ef4b897a1843cd32c4f141f55db60f0f0602cc98"
          if [ "${{ github.event_name }}" = "schedule" ]; then
            REF="main"                                   # weekly drift siren
-          elif [ -n "$REQUESTED_REF" ]; then
-            REF="$REQUESTED_REF"                          # manual override
+          elif [ -n "${{ github.event.inputs.upstream_ref }}" ]; then
+            REF="${{ github.event.inputs.upstream_ref }}" # manual override
          else
            REF="$DEFAULT_REF"
          fi
-
-          # The ref is passed to git below, so reject option-like or malformed
-          # values before it reaches that boundary. Full commit IDs and normal
-          # branch/tag names remain supported for manual contract checks.
-          if [[ "$REF" == -* ]] ||
-             ! git check-ref-format --allow-onelevel "$REF" >/dev/null; then
-            echo "FAIL: invalid upstream branch or tag name." >&2
-            exit 1
-          fi
-
          echo "ref=$REF" >> "$GITHUB_OUTPUT"
          echo "Checking standard-path route contract against upstream ref: $REF"

-      - name: Extract trusted upstream contract sources
-        env:
-          UPSTREAM_REF: ${{ steps.ref.outputs.ref }}
-        run: |
-          set -euo pipefail
-          UPSTREAM_GIT="$RUNNER_TEMP/hermes-agent-contract.git"
-          git init --bare "$UPSTREAM_GIT"
-          git -C "$UPSTREAM_GIT" remote add origin \
-            "https://github.com/NousResearch/hermes-agent.git"
-          git -C "$UPSTREAM_GIT" fetch --no-tags --depth=1 origin -- "$UPSTREAM_REF"
-          UPSTREAM_COMMIT="$(git -C "$UPSTREAM_GIT" rev-parse 'FETCH_HEAD^{commit}')"
-
-          mkdir -p _upstream/gateway/platforms _upstream/hermes_cli
-          git -C "$UPSTREAM_GIT" show \
-            "$UPSTREAM_COMMIT:gateway/platforms/api_server.py" \
-            > _upstream/gateway/platforms/api_server.py
-          git -C "$UPSTREAM_GIT" show \
-            "$UPSTREAM_COMMIT:hermes_cli/web_server.py" \
-            > _upstream/hermes_cli/web_server.py
-          echo "Extracted contract sources from upstream commit: $UPSTREAM_COMMIT"
+      - name: Checkout vanilla upstream (no plugin, no bootstrap)
+        uses: actions/checkout@v7
+        with:
+          repository: NousResearch/hermes-agent
+          ref: ${{ steps.ref.outputs.ref }}
+          path: _upstream
+          fetch-depth: 1

      - name: Set up Python 3.11
        uses: actions/setup-python@v7
        with:
          python-version: "3.11"

+      - name: Assert upstream checkout is vanilla (no relay bootstrap/plugin)
+        run: |
+          if [ -e "_upstream/hermes_relay_bootstrap" ] || \
+             [ -e "_upstream/plugin/hermes_relay_bootstrap" ] || \
+             find _upstream -name "hermes_relay_bootstrap.pth" 2>/dev/null | grep -q .; then
+            echo "FAIL: upstream checkout contains a relay bootstrap — not vanilla."; exit 1
+          fi
+          echo "OK: upstream checkout carries no relay plugin/bootstrap."
+
      - name: Run route-surface contract
        run: python scripts/check-upstream-route-contract.py "_upstream"
@@ -38,10 +38,6 @@ jobs:
        working-directory: plugin/dashboard
        run: npm run build

-      - name: Test dashboard source
-        working-directory: plugin/dashboard
-        run: npm test
-
      - name: Setup Python
        uses: actions/setup-python@v7
        with:
@@ -58,11 +54,7 @@ jobs:
        run: pip install -r relay_server/requirements.txt fastapi httpx requests

      - name: Run dashboard API tests
-        run: >-
-          python -m unittest
-          plugin.dashboard.test_plugin_api
-          plugin.dashboard.test_git_api
-          plugin.dashboard.test_mobile_plugin_api
+        run: python -m unittest plugin.dashboard.test_plugin_api

      - name: Verify dashboard bundle outputs
        run: |
@@ -107,18 +107,6 @@ 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

@@ -101,18 +101,9 @@ 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_native_layout_imports.py \
            plugin/tests/test_profile_discovery.py \
-            plugin/tests/test_profiles_updated_broadcast.py \
-            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_android_tool.py \
-            plugin/tests/test_android_navigate.py \
-            plugin/tests/test_phone_platform.py \
-            plugin/tests/test_desktop_tool_availability.py
+            plugin/tests/test_profiles_updated_broadcast.py
@@ -10,36 +10,13 @@ on:
  pull_request:
    branches: [main, dev]
    types: [opened, synchronize, reopened, ready_for_review]
-  workflow_dispatch:
-    inputs:
-      base_sha:
-        description: "Exact base commit for a trusted release-backmerge candidate"
-        required: true
-        type: string
-      head_sha:
-        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.event_name == 'workflow_dispatch' && format('{0}-{1}', inputs.head_sha, inputs.android_preset) || github.ref }}
+  group: ci-required-${{ github.ref }}
  cancel-in-progress: true

 jobs:
@@ -53,86 +30,23 @@ 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'
+      - name: Checkout repository
        uses: actions/checkout@v7
        with:
          fetch-depth: 2

-      - name: Checkout exact dispatched candidate
-        if: github.event_name == 'workflow_dispatch'
-        uses: actions/checkout@v7
-        with:
-          fetch-depth: 0
-          ref: ${{ inputs.head_sha }}
-
      - 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
-        env:
-          DISPATCH_BASE_SHA: ${{ inputs.base_sha }}
-          DISPATCH_HEAD_SHA: ${{ inputs.head_sha }}
        with:
          script: |
-            let diffArgs;
-            if (context.eventName === 'workflow_dispatch') {
-              const base = process.env.DISPATCH_BASE_SHA || '';
-              const head = process.env.DISPATCH_HEAD_SHA || '';
-              const shaPattern = /^[0-9a-f]{40}$/;
-              if (!shaPattern.test(base) || !shaPattern.test(head)) {
-                core.setFailed('Exact-tree dispatch requires full 40-character base/head SHAs.');
-                return;
-              }
-              const { stdout: checkedOut } = await exec.getExecOutput(
-                'git',
-                ['rev-parse', 'HEAD'],
-              );
-              if (checkedOut.trim() !== head) {
-                core.setFailed(`Checked out ${checkedOut.trim()}, expected ${head}.`);
-                return;
-              }
-              const ancestry = await exec.exec(
-                'git',
-                ['merge-base', '--is-ancestor', base, head],
-                { ignoreReturnCode: true },
-              );
-              if (ancestry !== 0) {
-                core.setFailed(`Candidate ${head} does not descend from base ${base}.`);
-                return;
-              }
-              diffArgs = ['diff', '--name-only', base, head];
-            } else {
-              diffArgs = ['diff', '--name-only', 'HEAD^1', 'HEAD^2'];
-            }
            const { stdout } = await exec.getExecOutput(
              'git',
-              diffArgs,
+              ['diff', '--name-only', 'HEAD^1', 'HEAD^2'],
            );
            const paths = stdout.split(/\r?\n/).filter(Boolean);
            const { classifyCiPaths } = require(
@@ -146,117 +60,35 @@ jobs:
            core.notice(`Changed paths: ${paths.join(', ')}`);
            core.notice(`Selected checks: ${Object.entries(outputs).filter(([, value]) => value).map(([key]) => key).join(', ') || 'none'}`);

-  release-proof:
-    name: Reuse exact-tree required checks
-    needs: changes
-    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') }}
+    needs: changes
+    if: needs.changes.outputs.android == 'true'
    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, 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') }}
+    needs: changes
+    if: needs.changes.outputs.desktop == 'true'
    uses: ./.github/workflows/ci-desktop.yml

  plugin:
-    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') }}
+    needs: changes
+    if: needs.changes.outputs.plugin == 'true'
    uses: ./.github/workflows/ci-plugin.yml

  dashboard:
-    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') }}
+    needs: changes
+    if: needs.changes.outputs.dashboard == 'true'
    uses: ./.github/workflows/ci-dashboard.yml

  contract:
-    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') }}
+    needs: changes
+    if: needs.changes.outputs.contract == 'true'
    uses: ./.github/workflows/ci-contract.yml

  docs:
    name: Build public docs
-    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') }}
+    needs: changes
+    if: needs.changes.outputs.docs == 'true'
    runs-on: ubuntu-latest
    defaults:
      run:
@@ -278,14 +110,11 @@ jobs:
  guard:
    name: Required checks
    if: always()
-    needs: [changes, release-proof, android, android_on_demand, desktop, plugin, dashboard, contract, docs]
+    needs: [changes, android, 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 }}
@@ -296,7 +125,7 @@ jobs:
        shell: bash
        run: |
          failed=0
-          for check in CHANGES RELEASE_PROOF ANDROID ANDROID_ON_DEMAND DESKTOP PLUGIN DASHBOARD CONTRACT DOCS; do
+          for check in CHANGES ANDROID DESKTOP PLUGIN DASHBOARD CONTRACT DOCS; do
            result_var="${check}_RESULT"
            result="${!result_var}"
            echo "$check: $result"
@@ -306,26 +135,3 @@ 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
@@ -70,7 +70,7 @@ jobs:
      - uses: actions/checkout@v7

      - name: Set up JDK 17
-        uses: actions/setup-java@v6
+        uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 17
@@ -2,11 +2,10 @@
 #
 # Run manually from the final dev or untagged main tree before creating
 # android-v*. The job
-# 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.
+# 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.

 name: Hermes-Relay Android Play Preflight

@@ -69,7 +68,7 @@ jobs:
          fi

      - name: Set up JDK 17
-        uses: actions/setup-java@v6
+        uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 17
@@ -82,10 +81,10 @@ jobs:
      - name: Validate release metadata and source compatibility
        run: |
          python3 scripts/check-version-tracks.py
-          python3 scripts/check-android-release-notes.py
          python3 scripts/check-privacy-policy.py --live
          python3 scripts/check-android-locales.py
          python3 scripts/check-android-collection-apis.py
+          python3 -m json.tool app/src/main/assets/changelog.json >/dev/null

      - name: Decode release keystore
        env:
@@ -99,12 +98,7 @@ jobs:
          HERMES_KEYSTORE_PASSWORD: ${{ secrets.HERMES_KEYSTORE_PASSWORD }}
          HERMES_KEY_ALIAS: ${{ secrets.HERMES_KEY_ALIAS }}
          HERMES_KEY_PASSWORD: ${{ secrets.HERMES_KEY_PASSWORD }}
-        run: |
-          ./gradlew \
-            :app:bundleGooglePlayRelease \
-            :app:assembleGooglePlayRelease \
-            :app:assembleSideloadRelease \
-            --console=plain
+        run: ./gradlew bundleRelease assembleRelease --console=plain

      - name: Scan final release DEX
        run: |
@@ -112,12 +106,6 @@ 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 }}
@@ -133,27 +121,27 @@ jobs:
            --resolution-strategy=ignore \
            --release-name="Hermes-Relay Android v${{ steps.metadata.outputs.version }}"

-      - name: Package immutable preflight artifacts
+      - name: Record successful preflight for the exact commit
        run: |
-          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
+          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

-      - name: Upload immutable preflight artifacts
+      - name: Upload preflight proof
        uses: actions/upload-artifact@v7
        with:
          name: play-preflight-${{ steps.metadata.outputs.version }}-${{ steps.metadata.outputs.tree }}
-          path: app/build/preflight-artifacts/*
+          path: app/build/reports/play-preflight.json
          if-no-files-found: error
          retention-days: 30
-          compression-level: 0

      - name: Preflight summary
        run: |
@@ -164,4 +152,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, 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"
+          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"
@@ -36,9 +36,6 @@ 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:
@@ -69,7 +66,6 @@ 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: |
@@ -114,38 +110,25 @@ 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="${{ steps.version.outputs.release_tree }}"
+          RELEASE_TREE=$(git rev-parse 'HEAD^{tree}')
          ARTIFACT_NAME="play-preflight-${VERSION}-${RELEASE_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
+          COUNT=$(gh api "/repos/${GITHUB_REPOSITORY}/actions/artifacts?name=${ARTIFACT_NAME}" \
+            --jq '[.artifacts[] | select(.expired == false)] | length')
+          if [ "$COUNT" -lt 1 ]; 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
-          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)"
+          echo "Play preflight proof found: $ARTIFACT_NAME"

  ci:
-    name: CI Checks (prerelease only)
+    name: CI Checks
    needs: validate
-    if: ${{ needs.validate.outputs.prerelease == 'true' }}
    runs-on: ubuntu-latest
    timeout-minutes: 30
    steps:
@@ -154,7 +137,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@v6
+        uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 17
@@ -167,7 +150,6 @@ jobs:
      - name: Validate release metadata and Android API compatibility
        run: |
          python3 scripts/check-version-tracks.py
-          python3 scripts/check-android-release-notes.py
          python3 scripts/check-privacy-policy.py
          python3 scripts/check-android-locales.py
          python3 scripts/check-android-collection-apis.py
@@ -185,7 +167,6 @@ 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:
@@ -194,7 +175,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@v6
+        uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 17
@@ -204,33 +185,31 @@ jobs:
        with:
          cache-read-only: false

-      - 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
+      - name: Decode release keystore
        env:
          HERMES_KEYSTORE_BASE64: ${{ secrets.HERMES_KEYSTORE_BASE64 }}
-        if: ${{ needs.validate.outputs.prerelease == 'true' && env.HERMES_KEYSTORE_BASE64 != '' }}
+        if: 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:
@@ -254,10 +233,10 @@ jobs:
        if: ${{ needs.validate.outputs.prerelease != 'true' }}
        uses: actions/upload-artifact@v7
        with:
-          name: android-r8-mappings-${{ needs.validate.outputs.version }}-${{ needs.validate.outputs.release_tree }}
+          name: android-r8-mappings-${{ needs.validate.outputs.version }}-${{ github.sha }}
          path: |
-            app/build/preflight-artifacts/mapping-googlePlayRelease.txt
-            app/build/preflight-artifacts/mapping-sideloadRelease.txt
+            app/build/outputs/mapping/googlePlayRelease/mapping.txt
+            app/build/outputs/mapping/sideloadRelease/mapping.txt
          if-no-files-found: error
          retention-days: 90

@@ -274,7 +253,8 @@ jobs:
        if: ${{ needs.validate.outputs.prerelease != 'true' }}
        run: |
          python3 scripts/check-android-collection-apis.py \
-            --apk app/build/preflight-artifacts/*-sideload-release.apk
+            --apk app/build/outputs/apk/googlePlay/release/*.apk \
+            --apk app/build/outputs/apk/sideload/release/*.apk

      - name: Scan candidate DEX for unsupported collection APIs
        if: ${{ needs.validate.outputs.prerelease == 'true' }}
@@ -282,24 +262,25 @@ jobs:
          python3 scripts/check-android-collection-apis.py \
            --apk app/build/outputs/apk/sideload/candidate/*.apk

-      - name: Verify stable packaged ONNX Runtime compatibility
-        if: ${{ needs.validate.outputs.prerelease != 'true' }}
-        run: |
-          python3 scripts/check-android-native-compat.py \
-            app/build/preflight-artifacts/*-sideload-release.apk
-
-      - name: Verify candidate packaged ONNX Runtime compatibility
-        if: ${{ needs.validate.outputs.prerelease == 'true' }}
-        run: |
-          python3 scripts/check-android-native-compat.py \
-            app/build/outputs/apk/sideload/candidate/*.apk
-
      - name: List produced artifacts (debug aid)
        run: |
-          echo "=== Reused stable artifacts ==="
-          find app/build/preflight-artifacts -maxdepth 1 -type f -print 2>/dev/null || true
-          echo "=== Candidate APK outputs ==="
+          echo "=== 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' }}
@@ -345,9 +326,9 @@ jobs:
          # Deliberate 2-asset policy (#144): attach ONLY the installable
          # sideload APK and Play AAB, plus checksums covering those files.
          files: |
-            app/build/preflight-artifacts/*-sideload-release.apk
-            app/build/preflight-artifacts/*-googlePlay-release.aab
-            app/build/preflight-artifacts/SHA256SUMS.txt
+            app/build/outputs/apk/sideload/release/*.apk
+            app/build/outputs/bundle/googlePlayRelease/*.aab
+            app/build/outputs/SHA256SUMS.txt

      - name: Create candidate GitHub prerelease
        if: ${{ needs.validate.outputs.prerelease == 'true' }}
@@ -369,36 +350,18 @@ jobs:
        run: |
          echo "## Hermes-Relay Android v${{ needs.validate.outputs.version }}" >> "$GITHUB_STEP_SUMMARY"
          echo "" >> "$GITHUB_STEP_SUMMARY"
-          if [ "$PRERELEASE" != "true" ]; then
-            echo "✅ **Published the exact signed Play-preflight artifacts**" >> "$GITHUB_STEP_SUMMARY"
-          elif [ -n "$HERMES_KEYSTORE_BASE64" ]; then
+          if [ "$PRERELEASE" = "true" ] && [ -n "$HERMES_KEYSTORE_BASE64" ]; then
            echo "✅ **Release-signed HR Candidate app** — separate package ID; never uploaded to Play" >> "$GITHUB_STEP_SUMMARY"
-          else
+          elif [ "$PRERELEASE" = "true" ]; then
            echo "⚠️ **Debug-signed HR Candidate app** — separate package ID; never uploaded to Play" >> "$GITHUB_STEP_SUMMARY"
+          elif [ -n "$HERMES_KEYSTORE_BASE64" ]; then
+            echo "✅ **Signed with release keystore** — suitable for Play Store upload" >> "$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"
          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"
-
-  request-backmerge:
-    name: Request stable release backmerge
-    needs: [validate, release]
-    if: needs.validate.outputs.prerelease != 'true'
-    permissions:
-      actions: write
-      contents: read
-    runs-on: ubuntu-latest
-    steps:
-      - name: Dispatch fail-closed release reconciliation
-        env:
-          GH_TOKEN: ${{ github.token }}
-          RELEASE_TAG: android-v${{ needs.validate.outputs.version }}
-        run: |
-          gh workflow run release-backmerge.yml \
-            --repo "$GITHUB_REPOSITORY" \
-            --ref main \
-            -f release_tag="$RELEASE_TAG"
@@ -1,267 +0,0 @@
-# Reconcile a completed stable hotfix into dev without adding a ceremonial PR
-# merge commit. Normal dev -> main releases are detected and intentionally no-op.
-# A conflicted merge, failed exact-tree CI, stale dev ref, or denied branch update
-# stops without mutating dev and falls back to the normal reconciliation PR path.
-
-name: Release Backmerge
-
-on:
-  workflow_dispatch:
-    inputs:
-      release_tag:
-        description: "Published stable tag to reconcile (android-v*, server-v*, or desktop-v*)"
-        required: true
-        type: string
-
-permissions:
-  contents: read
-
-concurrency:
-  group: release-backmerge-dev
-  cancel-in-progress: false
-
-jobs:
-  prepare:
-    name: Prepare exact backmerge candidate
-    permissions:
-      contents: write
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    outputs:
-      outcome: ${{ steps.prepare.outputs.outcome }}
-      base_dev_sha: ${{ steps.prepare.outputs.base_dev_sha }}
-      candidate_branch: ${{ steps.prepare.outputs.candidate_branch }}
-      candidate_sha: ${{ steps.prepare.outputs.candidate_sha }}
-      release_commit: ${{ steps.prepare.outputs.release_commit }}
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          fetch-depth: 0
-          ref: main
-
-      - name: Validate release and prepare merge commit
-        id: prepare
-        env:
-          GH_TOKEN: ${{ github.token }}
-          RELEASE_TAG: ${{ inputs.release_tag }}
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          if [[ ! "$RELEASE_TAG" =~ ^(android|server|desktop)-v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            echo "::error::Release Backmerge accepts stable SemVer production tags only; got $RELEASE_TAG"
-            exit 1
-          fi
-
-          git fetch origin \
-            "+refs/heads/main:refs/remotes/origin/main" \
-            "+refs/heads/dev:refs/remotes/origin/dev" \
-            "+refs/tags/${RELEASE_TAG}:refs/tags/${RELEASE_TAG}"
-          release_commit="$(git rev-parse "${RELEASE_TAG}^{commit}")"
-          base_dev_sha="$(git rev-parse origin/dev)"
-          echo "release_commit=$release_commit" >> "$GITHUB_OUTPUT"
-          echo "base_dev_sha=$base_dev_sha" >> "$GITHUB_OUTPUT"
-
-          if ! git merge-base --is-ancestor "$release_commit" origin/main; then
-            echo "::error::$RELEASE_TAG ($release_commit) is not contained in origin/main"
-            exit 1
-          fi
-
-          read -r is_draft is_prerelease < <(
-            gh release view "$RELEASE_TAG" --json isDraft,isPrerelease \
-              --jq '[.isDraft, .isPrerelease] | @tsv'
-          )
-          if [ "$is_draft" != "false" ] || [ "$is_prerelease" != "false" ]; then
-            echo "::error::$RELEASE_TAG is not a published stable GitHub release"
-            exit 1
-          fi
-
-          plan="$(
-            python3 scripts/plan_release_backmerge.py \
-              --release-commit "$release_commit" \
-              --dev-commit "$base_dev_sha"
-          )"
-          case "$plan" in
-            already-contained)
-              echo "outcome=noop" >> "$GITHUB_OUTPUT"
-              echo "## Release backmerge not needed" >> "$GITHUB_STEP_SUMMARY"
-              echo "\`$RELEASE_TAG\` is already contained in \`dev\`." >> "$GITHUB_STEP_SUMMARY"
-              exit 0
-              ;;
-            normal-release)
-              echo "outcome=noop" >> "$GITHUB_OUTPUT"
-              echo "## Normal release: no backmerge" >> "$GITHUB_STEP_SUMMARY"
-              echo "The released merge's integration parent is already contained in \`dev\`." >> "$GITHUB_STEP_SUMMARY"
-              exit 0
-              ;;
-            hotfix) ;;
-            *)
-              echo "::error::Unknown release-backmerge plan: $plan"
-              exit 1
-              ;;
-          esac
-
-          candidate_branch="chore/release-backmerge/${RELEASE_TAG}-${GITHUB_RUN_ID}"
-          git config user.name "github-actions[bot]"
-          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git switch --detach "$base_dev_sha"
-
-          set +e
-          git merge --no-ff -m "chore: back-merge ${RELEASE_TAG}" "$release_commit"
-          merge_status=$?
-          set -e
-          if [ "$merge_status" -ne 0 ]; then
-            conflicts="$(git diff --name-only --diff-filter=U | paste -sd ', ' -)"
-            echo "outcome=conflict" >> "$GITHUB_OUTPUT"
-            echo "::error::Automatic backmerge conflicts: ${conflicts:-unknown}. Open a reconciliation PR."
-            echo "## Manual reconciliation PR required" >> "$GITHUB_STEP_SUMMARY"
-            echo "\`$RELEASE_TAG\` conflicts with current \`dev\`: ${conflicts:-unknown}." >> "$GITHUB_STEP_SUMMARY"
-            git merge --abort || true
-            exit 1
-          fi
-
-          candidate_sha="$(git rev-parse HEAD)"
-          first_parent="$(git rev-parse HEAD^1)"
-          second_parent="$(git rev-parse HEAD^2)"
-          if [ "$first_parent" != "$base_dev_sha" ] || [ "$second_parent" != "$release_commit" ]; then
-            echo "::error::Candidate parents do not match dev + release commit"
-            exit 1
-          fi
-
-          git push origin "$candidate_sha:refs/heads/$candidate_branch"
-          echo "outcome=candidate" >> "$GITHUB_OUTPUT"
-          echo "candidate_branch=$candidate_branch" >> "$GITHUB_OUTPUT"
-          echo "candidate_sha=$candidate_sha" >> "$GITHUB_OUTPUT"
-
-          echo "## Backmerge candidate prepared" >> "$GITHUB_STEP_SUMMARY"
-          echo "- Release: \`$RELEASE_TAG\` (\`$release_commit\`)" >> "$GITHUB_STEP_SUMMARY"
-          echo "- Dev base: \`$base_dev_sha\`" >> "$GITHUB_STEP_SUMMARY"
-          echo "- Candidate: \`$candidate_sha\`" >> "$GITHUB_STEP_SUMMARY"
-          echo "- Temporary ref: \`$candidate_branch\`" >> "$GITHUB_STEP_SUMMARY"
-
-  gate:
-    name: Run exact-tree required checks
-    needs: prepare
-    if: needs.prepare.outputs.outcome == 'candidate'
-    permissions:
-      actions: write
-      contents: read
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    outputs:
-      check_run_id: ${{ steps.gate.outputs.check_run_id }}
-    steps:
-      - name: Dispatch and await Required checks
-        id: gate
-        env:
-          GH_TOKEN: ${{ github.token }}
-          BASE_DEV_SHA: ${{ needs.prepare.outputs.base_dev_sha }}
-          CANDIDATE_BRANCH: ${{ needs.prepare.outputs.candidate_branch }}
-          CANDIDATE_SHA: ${{ needs.prepare.outputs.candidate_sha }}
-        shell: bash
-        run: |
-          set -euo pipefail
-          gh workflow run ci-required.yml \
-            --repo "$GITHUB_REPOSITORY" \
-            --ref "$CANDIDATE_BRANCH" \
-            -f base_sha="$BASE_DEV_SHA" \
-            -f head_sha="$CANDIDATE_SHA"
-
-          check_run_id=""
-          for _ in {1..20}; do
-            check_run_id="$(
-              gh run list \
-                --repo "$GITHUB_REPOSITORY" \
-                --workflow ci-required.yml \
-                --branch "$CANDIDATE_BRANCH" \
-                --event workflow_dispatch \
-                --limit 20 \
-                --json databaseId,headSha \
-                --jq ".[] | select(.headSha == \"$CANDIDATE_SHA\") | .databaseId" \
-                | head -n 1
-            )"
-            if [ -n "$check_run_id" ]; then
-              break
-            fi
-            sleep 3
-          done
-          if [ -z "$check_run_id" ]; then
-            echo "::error::Required checks dispatch was not observed for $CANDIDATE_SHA"
-            exit 1
-          fi
-
-          echo "check_run_id=$check_run_id" >> "$GITHUB_OUTPUT"
-          gh run watch "$check_run_id" --repo "$GITHUB_REPOSITORY" --exit-status
-
-  promote:
-    name: Compare-and-swap dev
-    needs: [prepare, gate]
-    if: needs.prepare.outputs.outcome == 'candidate' && needs.gate.result == 'success'
-    permissions:
-      contents: write
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          fetch-depth: 0
-          ref: main
-
-      - name: Fast-forward dev to the tested candidate
-        env:
-          BASE_DEV_SHA: ${{ needs.prepare.outputs.base_dev_sha }}
-          CANDIDATE_BRANCH: ${{ needs.prepare.outputs.candidate_branch }}
-          CANDIDATE_SHA: ${{ needs.prepare.outputs.candidate_sha }}
-          RELEASE_COMMIT: ${{ needs.prepare.outputs.release_commit }}
-        shell: bash
-        run: |
-          set -euo pipefail
-          git fetch origin --no-tags \
-            "+refs/heads/dev:refs/remotes/origin/dev" \
-            "+refs/heads/$CANDIDATE_BRANCH:refs/remotes/origin/$CANDIDATE_BRANCH"
-          current_dev="$(git rev-parse origin/dev)"
-          remote_candidate="$(git rev-parse "origin/$CANDIDATE_BRANCH")"
-
-          if [ "$current_dev" != "$BASE_DEV_SHA" ]; then
-            echo "::error::dev moved from $BASE_DEV_SHA to $current_dev; rerun or open a reconciliation PR"
-            exit 1
-          fi
-          if [ "$remote_candidate" != "$CANDIDATE_SHA" ]; then
-            echo "::error::Candidate ref moved from $CANDIDATE_SHA to $remote_candidate"
-            exit 1
-          fi
-          if [ "$(git rev-parse "$CANDIDATE_SHA^1")" != "$BASE_DEV_SHA" ] || \
-             [ "$(git rev-parse "$CANDIDATE_SHA^2")" != "$RELEASE_COMMIT" ]; then
-            echo "::error::Candidate ancestry changed after verification"
-            exit 1
-          fi
-
-          # The explicit lease is the atomic stale-base guard. The update is a
-          # fast-forward from BASE_DEV_SHA; no unrelated history can be replaced.
-          git push \
-            --force-with-lease="refs/heads/dev:$BASE_DEV_SHA" \
-            origin "$CANDIDATE_SHA:refs/heads/dev"
-
-          git push origin --delete "$CANDIDATE_BRANCH" || \
-            echo "::warning::Could not remove temporary branch $CANDIDATE_BRANCH"
-
-          echo "## Release backmerge complete" >> "$GITHUB_STEP_SUMMARY"
-          echo "Fast-forwarded \`dev\` from \`$BASE_DEV_SHA\` to tested merge \`$CANDIDATE_SHA\`." >> "$GITHUB_STEP_SUMMARY"
-
-  fallback:
-    name: Report PR fallback
-    needs: [prepare, gate, promote]
-    if: always() && needs.prepare.outputs.outcome == 'candidate' && needs.promote.result != 'success'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Preserve safe fallback instructions
-        env:
-          CANDIDATE_BRANCH: ${{ needs.prepare.outputs.candidate_branch }}
-          CANDIDATE_SHA: ${{ needs.prepare.outputs.candidate_sha }}
-          CHECK_RUN_ID: ${{ needs.gate.outputs.check_run_id }}
-        run: |
-          echo "## Automatic backmerge stopped" >> "$GITHUB_STEP_SUMMARY"
-          echo "\`dev\` was not updated. Open or refresh a reconciliation PR after addressing the failed/stale gate." >> "$GITHUB_STEP_SUMMARY"
-          echo "- Candidate ref: \`${CANDIDATE_BRANCH:-not-created}\`" >> "$GITHUB_STEP_SUMMARY"
-          echo "- Candidate SHA: \`${CANDIDATE_SHA:-n/a}\`" >> "$GITHUB_STEP_SUMMARY"
-          echo "- Required-check run: \`${CHECK_RUN_ID:-n/a}\`" >> "$GITHUB_STEP_SUMMARY"
@@ -3,12 +3,6 @@ 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
@@ -26,7 +20,6 @@ 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
@@ -41,16 +34,10 @@ jobs:
      - name: Extract and validate tag version
        id: version
        shell: bash
-        env:
-          DISPATCHED_VERSION: ${{ inputs.version }}
        run: |
          set -euo pipefail
-          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
+          version="${GITHUB_REF_NAME#desktop-v}"
+          if [[ -z "$version" || "$version" == "$GITHUB_REF_NAME" ]]; then
            echo "Expected a desktop-v* tag, got $GITHUB_REF_NAME" >&2
            exit 1
          fi
@@ -64,12 +51,11 @@ 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
-          tag_commit="$(git rev-parse HEAD)"
-          if [[ "$TAG_VERSION" == *-* ]]; then
+          version="${GITHUB_REF_NAME#desktop-v}"
+          tag_commit="$(git rev-parse "${GITHUB_REF_NAME}^{commit}")"
+          if [[ "$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
@@ -92,8 +78,6 @@ 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
@@ -287,8 +271,6 @@ 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
@@ -307,18 +289,6 @@ 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

@@ -441,11 +411,6 @@ 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'
@@ -486,7 +451,7 @@ jobs:
              throw "installer lifecycle changed the pre-existing tray startup preference"
            }

-            Write-Host "packaged installer lifecycle smoke OK cli=$versionOutput ui=$trayVersion install=$installDir"
+            Write-Host "packaged installer lifecycle smoke OK version=$versionOutput install=$installDir"
          } finally {
            Get-Process -Name 'hermes-relay-tray' -ErrorAction SilentlyContinue |
              Stop-Process -Force -ErrorAction SilentlyContinue
@@ -518,7 +483,6 @@ 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
@@ -528,8 +492,10 @@ 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
-        with:
-          ref: ${{ github.event_name == 'workflow_dispatch' && format('desktop-v{0}', inputs.version) || github.ref }}
+
+      - name: Extract CLI+UI version
+        id: version
+        run: echo "version=${GITHUB_REF_NAME#desktop-v}" >> "$GITHUB_OUTPUT"

      - uses: actions/download-artifact@v8
        with:
@@ -549,8 +515,8 @@ jobs:
      # (desktop-v0.3.0) so install/pin commands stay accurate without manual edits.
      - name: Render release notes
        env:
-          VERSION: ${{ needs.validate-release.outputs.version }}
-          TAG: desktop-v${{ needs.validate-release.outputs.version }}
+          VERSION: ${{ steps.version.outputs.version }}
+          TAG: ${{ github.ref_name }}
        run: |
          sed -e "s/__VERSION__/${VERSION}/g" -e "s/__TAG__/${TAG}/g" \
            CLI_RELEASE_NOTES.md > cli_release_notes_rendered.md
@@ -559,10 +525,10 @@ jobs:
      - name: Publish GitHub Release
        uses: softprops/action-gh-release@v3
        with:
-          name: Hermes-Relay CLI+UI v${{ needs.validate-release.outputs.version }}
-          tag_name: desktop-v${{ needs.validate-release.outputs.version }}
+          name: Hermes-Relay CLI+UI v${{ steps.version.outputs.version }}
+          tag_name: ${{ github.ref_name }}
          draft: false
-          prerelease: ${{ contains(needs.validate-release.outputs.version, '-') }}
+          prerelease: ${{ contains(steps.version.outputs.version, 'alpha') || contains(steps.version.outputs.version, 'beta') || contains(steps.version.outputs.version, 'rc') }}
          fail_on_unmatched_files: true
          body_path: cli_release_notes_rendered.md
          files: |
@@ -573,22 +539,3 @@ jobs:
            release-assets/cli-binaries/hermes-relay-darwin-arm64
            release-assets/cli-windows-installer/hermes-relay-windows-x64-setup.exe
            release-assets/SHA256SUMS.txt
-
-  request-backmerge:
-    name: Request stable release backmerge
-    needs: [validate-release, publish-release]
-    if: ${{ !contains(needs.validate-release.outputs.version, '-') }}
-    permissions:
-      actions: write
-      contents: read
-    runs-on: ubuntu-latest
-    steps:
-      - name: Dispatch fail-closed release reconciliation
-        env:
-          GH_TOKEN: ${{ github.token }}
-          RELEASE_TAG: desktop-v${{ needs.validate-release.outputs.version }}
-        run: |
-          gh workflow run release-backmerge.yml \
-            --repo "$GITHUB_REPOSITORY" \
-            --ref main \
-            -f release_tag="$RELEASE_TAG"
@@ -4,12 +4,6 @@ on:
  push:
    tags:
      - "server-v*"
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "Approved Plugin version"
-        required: true
-        type: string

 permissions:
  contents: write
@@ -25,19 +19,10 @@ 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
-        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"
+        run: echo "version=${GITHUB_REF#refs/tags/server-v}" >> "$GITHUB_OUTPUT"

      - name: Verify Plugin version sync and changelog
        run: |
@@ -76,8 +61,6 @@ 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
@@ -102,16 +85,11 @@ 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_tool.py \
-            plugin/tests/test_android_navigate.py \
-            plugin/tests/test_phone_platform.py \
-            plugin/tests/test_desktop_tool_availability.py
+            plugin/tests/test_android_phone_status.py

  package:
    name: Build and publish Plugin package
@@ -120,8 +98,6 @@ 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
@@ -162,22 +138,3 @@ jobs:
            dist/*.whl
            dist/*.tar.gz
            dist/SHA256SUMS.txt
-
-  request-backmerge:
-    name: Request stable release backmerge
-    needs: [validate, package]
-    if: ${{ !contains(needs.validate.outputs.version, '-') }}
-    permissions:
-      actions: write
-      contents: read
-    runs-on: ubuntu-latest
-    steps:
-      - name: Dispatch fail-closed release reconciliation
-        env:
-          GH_TOKEN: ${{ github.token }}
-          RELEASE_TAG: server-v${{ needs.validate.outputs.version }}
-        run: |
-          gh workflow run release-backmerge.yml \
-            --repo "$GITHUB_REPOSITORY" \
-            --ref main \
-            -f release_tag="$RELEASE_TAG"
@@ -83,7 +83,7 @@ jobs:
        run: test "$(git rev-parse HEAD)" = "$EXPECTED_SHA"

      - name: Set up JDK 17
-        uses: actions/setup-java@v6
+        uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 17
@@ -24,7 +24,10 @@ Thumbs.db
 local.properties
 /build/
 /app/build/
-/experiments/quest/**/build/
+/relay-core/build/
+/relay-ui/build/
+/ui-preview/build/
+/quest/build/
 /app/release/
 *.apk
 *.aab
@@ -7,17 +7,14 @@ 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)** import this file instead of duplicating
-policy. They do not redefine the branch, release, hotfix, or verification
-contract here and in `RELEASE.md`.
+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`.

 - 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 → **[docs/project/TODO.md](docs/project/TODO.md)** (the single home for "what's next" — never DEVLOG, never scattered code comments)
+- Follow-ups / deferred work / known gaps → **[TODO.md](TODO.md)** (the single home for "what's next" — never DEVLOG, never scattered code comments)

 ## Branch contract

@@ -31,7 +28,7 @@ contract here and in `RELEASE.md`.
 | Staging source | An exact tested `dev` SHA or release-candidate tag; staging is an environment, never a branch |
 | Production source | Immutable `android-v*`, `server-v*`, or `desktop-v*` tags, selected by surface |
 | Hotfix base | The immutable production tag for the affected surface |
-| Back-merge target | `dev`; stable hotfixes reconcile automatically when the exact tested merge is conflict-free, otherwise through a PR |
+| Back-merge target | `dev`; merge `main` back immediately after every hotfix |

 Feature completion means merged and verified on `dev`; it does not mean
 released. A release train is separate work owned by a Forge release
@@ -40,14 +37,6 @@ open the `dev` → `main` release PR, tag the resulting `main` tip, publish the
 surface artifacts, deploy or roll out, and verify the live result. Never create
 a staging branch.

-A normal `dev` → `main` release needs no back-merge: the released integration
-parent is already in `dev`. A production-tag hotfix is different. After its
-stable release succeeds, `Release Backmerge` prepares a `dev`-first merge
-commit, runs the same path-aware required checks on that exact SHA, verifies
-that `dev` has not moved, and fast-forwards `dev`. Conflicts, failed checks,
-stale refs, or denied branch updates fail closed and require a reconciliation
-PR; never resolve those cases by choosing a side automatically.
-
 ### Local integration discipline

 - Fetch `origin/dev` before creating a task branch or worktree; do not base new
@@ -65,10 +54,8 @@ 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 explicit API-only/headless
-  compatibility surface; Relay adds optional extensions. A Gateway-owned
-  conversation never changes transport because Gateway auth or reachability
-  changes. This
+  and Vanilla Hermes voice. The API server is an optional automatic fallback and
+  advanced headless-compatibility surface; Relay adds optional extensions. 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` /
@@ -88,21 +75,11 @@ 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. 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.
+  OkHttp (no Ktor), `wss://` only. Run `./gradlew lint` before pushing Kotlin.
 - **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/`. Contributor
-  commands and the development loop live in `CONTRIBUTING.md`.
+  zero runtime deps, strict TS + ES modules, ship compiled `dist/`. Full
+  per-language style and the dev loop live in CLAUDE.md → "Code Style".

 ## Review guidelines

@@ -117,40 +94,6 @@ PR; never resolve those cases by choosing a side automatically.
 - Prioritize findings that warrant holding the merge. State the impacted path
  and the concrete failure mode.

-## Automated public issue triage
-
-New public issues may receive one clearly labeled **Hermes-Relay automated
-triage** reply. That first response may classify the report with existing
-type/area labels, point to related issues or current code/docs, ask for safe
-sanitized diagnostics, and flag the thread for maintainer review.
-
-GitHub attributes that reply to the repository-scoped
-`hermes-relay-triage[bot]` App, never to a maintainer's personal account.
-
-The automated lane may assign only the fixed maintainer account `Codename-11`
-as follow-up ownership; that assignment does not imply acceptance, priority,
-implementation, or a release commitment. It never closes, milestones,
-prioritizes, promises a fix/release/timeline, chooses another assignee, or
-continues replying after its first response. A related issue is not
-automatically a duplicate. Human maintainer comments and decisions remain
-authoritative; read the complete live thread before acting on an issue.
-
-## Automated public PR intake
-
-New external-contributor, non-draft pull requests may receive one clearly
-labeled **Hermes-Relay automated PR intake** reply from
-`hermes-relay-triage[bot]`. Owner-authored `Codename-11` PRs and bot PRs are
-dropped before model dispatch. For eligible PRs, the intake compares the live PR
-metadata/body and changed-path list with trusted `origin/dev` policy and
-`.github/pull_request_template.md` without checking out or executing contributor
-code. It may add genuine area labels plus `documentation`, `ci`, or
-`needs-maintainer-review` and point out missing intake evidence.
-
-The automated lane never approves, requests changes, merges, closes, assigns,
-requests reviewers, milestones, prioritizes, pushes commits, edits PR text,
-reruns workflows, applies `review-candidate`, or claims code correctness. Human
-maintainer review and CI remain authoritative.
-
 ## Public-repo writing hygiene

 Everything committed is public. In CHANGELOG, DEVLOG, README, docs, and release
@@ -6,142 +6,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this

 ## [Unreleased]

-### Fixed
-
- Android Dashboard sign-in removes pasted line breaks from username and password fields, matching the browser login while preserving every other credential character. (#541)
- **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 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)
- **`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
-
-### Added
-
- **Android can preview delegated agent work without leaving the parent chat.** The current-chat activity sheet shows bounded lifecycle, progress, and tool previews for concurrent children, opens vanilla Hermes child history read-only when the Gateway exposes it, and stays explicit when reconnect gaps or older routes leave details unavailable. (#447)
- **Android presents Relay Git as a first-class native workspace.** A compact optional Chat rail opens repository status, line totals, filters, diffs, branches, staging, commits, and remotes; the full workspace remains available from Settings when Chat controls are hidden. An updated optional Hermes-Relay Plugin is required for Git operations.
-
-### Changed
-
- **Connections now explain and recover each Dashboard, Relay, and optional API route independently.** LAN, Tailscale, and public HTTPS can fail over without allowing an unauthenticated or different-origin Relay route to borrow Dashboard credentials. Protected same-origin Relay health challenges are recognized as authentication boundaries instead of outages. An updated optional Hermes-Relay Plugin is required for same-origin Relay ingress. (Related: #399)
- **Android What's New leads with one curated release highlight without interrupting startup.** A timed post-update toast can be swiped or closed, previews additional feature/fix counts when a release has meaningful secondary items, expands into the centered highlight view on request, and keeps the full technical history available. Each release can present one plain-language summary, up to three primary benefits, and up to two quieter improvements, while release checks keep the structured entry, fallback, Play copy, and public release records aligned.
-
-### Fixed
-
- **Android wake-word detection now loads a compatible native ONNX Runtime.** Packaged sherpa and Java JNI consumers are checked against the shared runtime for every supported ABI before release. (#444)
- **Android Continuous voice waits for barge-in microphone teardown before listening again.** Multi-turn hands-free conversations no longer lose the microphone after a response finishes with barge-in enabled. (#464)
- **Opening Android no longer claims or interrupts a turn already running in Hermes Desktop/TUI.** Passive foreground and session browsing now use read-only Gateway status plus profile-scoped history; live-session resume remains reserved for explicit Android actions and exact Android-owned recovery. (Related: #365)
- **Android provisional Threads can be removed without touching server history.** The drawer now offers a local-only removal action, reconciles promoted phone sessions without duplicate rows, and keeps Thread routing isolated to the active saved connection. (#461)
- **Android Clarify cards make custom answers explicit and keyboard-friendly.** Choice prompts label their Other answer field, submit trimmed text from the keyboard, and do not restore an authoritatively expired prompt after session navigation. (#446)
- **The visible Android Sphere keeps its smooth procedural motion across startup and chat.** Backgrounded and motion-disabled surfaces remain still without reducing foreground animation to a stepped ambient pulse.
- **Android Voice Focus keeps Stop and immediate spoken steering available across every interaction mode.** Hold-to-talk now interrupts Thinking and Transcribing turns before capturing the replacement direction, remains operable through TalkBack, Switch Access, and keyboard controls, preserves pointer press-and-release behavior across floating controls, and Google Play no longer offers the sideload-only system overlay action.
- **Android Assistant sessions explain when no speech was captured instead of appearing stuck at Ready.** Retry feedback survives the separate system overlay process, recreated session UI requests the current turn state, and locked sessions keep transcript, response, and technical error text private. (Related: #424)
- **Android New Chat keeps the current profile and stays fresh across profile switches.** Starting from All Profiles no longer forces the literal default profile, choosing another profile from an empty draft no longer reopens that profile's previous session after route settlement or restart, and leaving a provisional phone Thread cannot route the next turn to its old chat under the new profile. (#436)
- **Android Dashboard connections and profile drawers no longer wait on unavailable optional routes.** Dashboard, API fallback, and Relay probes run independently; API/Relay never gate a normal Dashboard connection, Gateway auth/ticket failures are not blindly retried, and authenticated session history remains available without a live Gateway socket. Concurrent route probes are shared and generation-safe, healthy same-priority routes win immediately, superseded session reads cancel their HTTP calls, and optional PR decoration stays outside the session-list critical path.
-
-### Removed
-
- **Android Chat no longer includes the hidden clean-focus presentation.** The long-press gesture, overlapping instructional pill, reduced composer, and alternate fading transcript were removed so Chat keeps one complete interaction model. Voice Focus remains available.
-
-## [Plugin 1.11.0] - 2026-08-30
-
-### Added
-
- **Hermes-Relay Plugin provides a bounded Git workspace API for authenticated Dashboard clients.** Configured repository roots, path validation, tracked line totals, scoped write grants, and explicit confirmation protect repository reads and mutations.
- **Relay extensions can use the authenticated Dashboard origin as one network ingress.** Fixed allowlisted HTTP and WebSocket paths proxy to the local Relay while Dashboard admission and Relay session authentication remain separate. (Related: #399)
-
-### Changed
-
- **Hermes-Relay Dashboard management is organized around operator tasks.** Overview, Devices, Activity, Remote Access, Git, and Settings now have separate native Dashboard surfaces; pairing is QR-first, paired clients use responsive cards, and token-backed media is labeled as a bounded diagnostic instead of a health counter. (#486)
- **Dashboard, CLI, and TUI pairing advertise the same explicit route set.** Recommended Tailscale uses dedicated HTTPS `:10443` for local Dashboard `:9119`, public HTTPS and LAN stay visible fallbacks, and old `:443`/`:9119` plus direct `:8767` remain migration compatibility.
- **Pairing receipts explain transport protection before exposing an invite.** Per-surface probes distinguish application TLS, tailnet encryption, optional API fallback, and authenticated Relay ingress.
-
-### Fixed
-
- **Public and roaming pairing no longer invent closed direct Relay or Dashboard ports.** Exact Dashboard origins own their same-origin Relay paths, ambiguous or plaintext public candidates fail closed, and inactive optional API routes are omitted.
- **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-31
-
-### Changed
-
- **Hermes-Relay CLI+UI preserves the complete multi-route pairing topology.** Dashboard, Relay, optional API, priorities, and transport protection remain attached to one saved host across LAN, Tailscale, and public routes. (Related: #399)
-
-### Fixed
-
- **Desktop rejects Dashboard-ingress Relay dials until it can mint Dashboard WebSocket tickets.** The daemon and host selector choose a compatible direct Relay fallback instead of attempting an unauthenticated same-origin ingress.
- **API-less pairing remains valid.** Dashboard and direct Relay routes can pair without inventing an optional API server, while secure-first ranking keeps plain LAN as the final fallback.
-
 ## [Android 1.13.2] - 2026-08-25

-### Added
-
- **Android Supervised Mode presents a parent-controlled, profile-pinned chat surface.** Parents can limit attachments, Standard voice, generated media, conversation history, actions, and technical metadata while device authentication protects full settings. Hermes-Relay can identify and revoke a paired supervised client without becoming the policy enforcement boundary.
-
 ### Fixed

 - **Android session rows stay neutral when optional live activity is unavailable or still loading.** Directory refreshes no longer restore a persistent Checking state, and full-row activity borders are reserved for actual Starting or Working turns.
- **Returning from parent settings keeps Supervised Chat rendered.** Parent access now relocks without rebuilding the active navigation graph, and full Settings keeps a prominent shortcut back to Supervised Mode controls.

 ## [Android 1.13.1] - 2026-08-25

@@ -1309,7 +1178,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 `docs/project/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 `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.
@@ -2126,7 +1995,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`
- **`docs/project/TODO.md`** — captures open research questions around proper
+- **`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,
@@ -1 +1,525 @@
-@AGENTS.md
+# 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)
+
@@ -1,18 +1,33 @@
 # Hermes-Relay CLI+UI v__VERSION__

-**Release Date:** 2026-09-02
+**Release Date:** 2026-08-25

-This beta fixes Windows updates so the installed CLI and management UI advance together. Explicit CLI-only installations keep their standalone update path.
+This beta makes the Desktop connector resilient through Relay interruptions,
+aligns Windows computer control with current CUA Driver releases, adds a native
+Linux ARM64 build, and hardens installation and update discovery.

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

+### Added
+
+- **Linux ARM64 is a first-class release target.** The one-line installer,
+  updater, checksums, and release artifacts now cover both Linux x64 and arm64.
+- **The public site shows the real Windows CLI UI.** Deterministic screenshots
+  cover connections, host access, activity, computer control, and updates.
+
+### Changed
+
+- **Public naming is aligned.** Releases use `Hermes-Relay CLI+UI` while the
+  beta keeps its existing `desktop-v*` tag and updater contract.
+
 ### Fixed

- `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.
+- **The daemon reconnects instead of exiting after an interrupted Relay socket.** Relay restarts and repeated transient replacement failures stay on bounded automatic backoff, and terminal failures persist an accurate stopped reason for the UI.
+- **Oversized desktop-tool output no longer closes the shared connection.** PowerShell output and every serialized desktop response stay inside the Relay WebSocket budget.
+- **Current CUA Driver releases remain compatible by contract.** Driver 0.20 and newer are accepted when their manifest and required tools match Hermes, and Windows uses the manifest-declared direct standard-mode runtime instead of a stale machine-wide daemon.
+- **Install and update discovery paginates the multi-surface release history.** Desktop releases remain discoverable after more Android and Server releases, Windows cooperative updates clean their released backup, and unsigned installers retain the normal SmartScreen warning.

 ## Install

@@ -43,4 +58,9 @@ hermes-relay --version
 hermes-relay hosts list --json
 hermes-relay daemon start
 hermes-relay daemon status --json
+hermes-relay computer-use status --json
 ```
+
+On Windows, click the Hermes-Relay CLI UI notification-area icon to open the management popup directly above it.
+
+See the [CLI and tray guide](https://hermes-relay.dev/docs/desktop/) for installation, access modes, grants, and troubleshooting.
@@ -61,15 +61,6 @@ 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.
@@ -77,15 +68,7 @@ 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. `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.
+4. `scripts/dev.bat prepush` before pushing Android work.

 `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
@@ -121,24 +104,6 @@ The legacy `relay_server/` directory is a thin compatibility shim around `plugin
 | **CI/CD** | GitHub Actions (lint, build, test, signed APK artifacts) |
 | **Min SDK** | 26 (Android 8.0) / Target SDK 36 |

-## Issues and automated triage
-
-New issues may receive one first response headed **Hermes-Relay automated
-triage**. It reads the live report against current code, documentation, related
-issues, and public release state; it may add existing type/area labels and ask
-for a focused, safe diagnostic such as the app version, interaction mode, or a
-sanitized log excerpt.
-
-GitHub displays the response as authored by `hermes-relay-triage[bot]`, a
-repository-scoped App rather than a maintainer's personal account.
-
-That reply is an acknowledgement and initial analysis, not a maintainer
-decision. The automated path may assign `Codename-11` as the fixed owner for
-follow-up, but assignment does not mean acceptance, priority, implementation,
-or a release commitment. It does not close issues, choose another assignee, set
-milestones or priority, promise a fix or release, or continue the conversation.
-A maintainer will follow up on the thread.
-
 ## Running the Relay Locally

 Only needed if you're working on the bridge, voice, notifications, or media features. Chat alone doesn't need the relay.
@@ -180,23 +145,6 @@ documentation fixes.
 `main` is release history, not the normal contribution target; it receives
 approved release PRs from `dev` and focused hotfix PRs based on production tags.

-Pull requests use [the repository template](.github/pull_request_template.md).
-Keep the body grounded: describe the outcome and focused changes, list exact
-verification, include visual evidence when applicable, state compatibility or
-risk, and preserve contributor lineage when replacing or salvaging prior work.
-Check an item when it is satisfied or when its N/A rationale is written in the
-body; do not use checked boxes as a substitute for evidence.
-
-New external-contributor, non-draft pull requests may receive one
-**Hermes-Relay automated PR intake** reply from `hermes-relay-triage[bot]`.
-Owner-authored `Codename-11` PRs and bot PRs skip this lane. For eligible PRs,
-the bot checks the live body, base branch, changed-path areas, template
-completeness, stated verification, visual proof, and lineage without checking
-out or executing contributor code. It may add bounded area/intake labels and
-identify missing evidence, but it does not review code correctness, approve,
-request changes, merge, close, assign, request reviewers, push commits, edit the
-PR, rerun workflows, or select review bundles.
-
 `origin/dev` is the canonical integration ref. Keep local `dev` as a clean,
 fast-forward-only mirror and create each task in its own branch/worktree from the
 current `origin/dev`. Do not accumulate unpublished commits on local `dev`. If a
@@ -259,36 +207,28 @@ 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 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.
+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.

 ## Changelog & writing conventions

-This is a **public repo** — `CHANGELOG.md`, `docs/project/DEVLOG.md`, the README, and everything under `docs/` ship publicly. Keep them clean:
+This is a **public repo** — `CHANGELOG.md`, `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 `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.
+- **`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.
 - **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 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.
+- **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.
 - **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)
@@ -297,7 +237,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. 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.
+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.
 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.
@@ -1,176 +1,5 @@
 # Hermes-Relay — Dev Log

-## 2026-09-02 — Android 1.15.1 and CLI+UI beta.7 release preparation
-
-Prepared Android 1.15.1 (versionCode 54) and CLI+UI 0.4.0-beta.7 from the integrated release tree. Android notes cover chat memory bounds, media previews, Gateway readiness, follow-up controls, and voice recovery. CLI+UI notes cover the Windows unified updater. Plugin metadata remains at 1.11.1; its only unreleased change is a documentation-comment path.
-
-The Android release uses the immutable signed Play preflight artifact for public publication. CLI+UI remains a prerelease and is approved from the exact prepared dev commit.
-
-## 2026-09-01 — Exact-tree release artifact promotion
-
-Android Play preflight now packages the signed sideload APK, Play AAB, R8
-mappings, manifest, and public checksums as one immutable tree-keyed artifact.
-Stable approval revalidates and publishes those exact bytes instead of
-recompiling the release after Play accepted the draft. Final DEX and native
-compatibility checks still run against the promoted package.
-
-Required CI records a separate short-lived proof keyed to the complete Git
-tree. Canonical `dev` to `main` promotion reuses that proof only when the
-simulated merge tree is byte-identical; missing evidence or any tree change
-falls back to the full path-aware matrix. Local Android release iteration now
-uses a metadata-and-presentation lane, and a coordinated approval workflow can
-start independent Android, Plugin, and CLI+UI release jobs concurrently.
-The Windows tray lane also carries an exact-source Cargo/target cache from
-trusted branch CI into the tag installer build, with lockfile-scoped incremental
-fallback when tray sources change.
-
-## 2026-09-01 — Unified Windows desktop update contract
-
-The desktop updater now treats a detected Windows management UI as an installed
-bundle rather than updating only the CLI executable. Update checks compare the
-embedded CLI version with the tray executable's product version, expose the
-selected `cli` or `cli_ui` target in JSON, and route drift repair through the
-checksum-verified NSIS installer. Windows installations without the tray keep
-the standalone cooperative CLI swap.
-
-Bundle updates wait for the invoking CLI to exit, stop installer-owned CLI,
-daemon, and tray processes, then restore only the daemon and tray processes that
-were running before the update. Focused tests cover bundle detection, installer
-selection, drift reporting, headless preservation, and stopped-tray behavior.
-
-## 2026-08-31 — Android Gateway compaction watchdog lease
-
-Gateway turns now recognize the upstream `status.update` payload kind
-`compacting` and arm a ten-minute idle lease instead of the ordinary
-three-minute watchdog. A single current-Gateway status protects silent
-compaction, while repeated status heartbeats from newer gateways refresh the
-same lease. Other status payloads retain the ordinary watchdog.
-
-Focused Gateway client coverage uses shortened timeout seams to prove the
-single-status, repeated-heartbeat, ordinary-silence, and payload-fencing paths
-without waiting production minutes. The declarative vanilla-Gateway fixture
-also models repeated compaction status before terminal completion.
-
-## 2026-08-31 — Complete, readable Android release notes
-
-Android release metadata now keeps one overall title and summary plus a complete
-typed inventory of user-visible additions, improvements, and fixes. Stable
-change ids prevent duplicate records, selected highlights lead the expanded
-view, and compatibility boundaries remain visible without turning the compact
-notice into technical release documentation. Toast counts and previews are
-derived from the same non-highlighted changes the dialog and history render, so
-View all reaches every counted item. Older bundled changelog entries retain
-their existing rendering path.
-
-The Android 1.14.0 record was migrated to the complete schema and reconciled
-against its released Android changelog: four highlights, two additional
-improvements, ten fixes, and three compatibility notes. The dialog, full
-history, large-text toast, seven Android resource catalogs, legacy text
-fallback, Play note, listing copy, release-prep instructions, and validation
-tests were updated together.
-
-Structured release-note tests, focused Kotlin tests, Android locale and
-collection-API gates, rendered 360×640 dark-theme screenshots including 135%
-text, sideload APK assembly, Android lint, and diff checks passed.
-
-## 2026-08-27 — Fixed issue ownership and bounded PR intake
-
-The automated issue first-response lane now assigns only `Codename-11` when the
-maintainer is absent. The assignee is fixed in the write wrapper rather than
-chosen by webhook or model output, and represents follow-up ownership only—not
-acceptance, priority, implementation, or a release promise.
-
-A separate pull-request route now handles external-contributor, non-bot,
-non-draft `opened`, `reopened`, and `ready_for_review` events. Owner-authored
-`Codename-11` PRs are dropped before model dispatch. Eligible PRs are read from
-live metadata plus trusted `dev` policy/template without executing contributor
-code; the route applies only bounded area/intake labels and posts one
-App-authored intake reply. It cannot approve, request changes, merge, close,
-assign, request reviewers, push, edit PR text, rerun CI, select
-`review-candidate`, or claim correctness. The external-contributor production
-canary retained its exact head/base/open state and proved marker idempotency.
-
-## 2026-08-26 — Canonical pull request intake contract
-
-The repository now supplies one pull request template derived from the structure
-already used by successful Android, plugin, desktop, docs, release, and salvage
-PRs. It asks for a concise summary, focused changes, exact verification, visual
-evidence when applicable, compatibility/risk notes, contributor lineage, and the
-existing cross-surface checklist.
-
-Checkboxes require evidence or an explicit N/A rationale. The template does not
-turn every surface into a mandatory test lane, does not replace CI or maintainer
-review, and keeps normal work targeting `dev` while preserving the documented
-release/hotfix exceptions.
-
-## 2026-08-26 — Android OIDC origin continuity and route latency
-
-Dashboard authentication now follows upstream `/api/status.auth_flows`:
-interactive redirect and password providers use native PKCE when advertised,
-with exact-host cookies retained only for older gateways or client-local native
-failure. A different provider-declared callback is fenced by installation
-identity and explicit review before becoming the authenticated Dashboard/Gateway
-origin. Public origins require HTTPS; reviewed literal LAN, Tailscale, and
-loopback HTTP retains upstream compatibility. Cookies are never copied between
-hosts, API and Relay ownership remain separate, unsafe callbacks are rejected,
-and third-party cookies are enabled only for the short-lived compatibility
-WebView.
-
-The saved authenticated origin is now modeled as connection-level
-Dashboard/Gateway state rather than as a synthetic network candidate. The
-Routes screen presents a dedicated Dashboard & Gateway card with edit and
-re-check actions, keeps LAN, Tailscale, API, and Relay under Network routes, and
-does not expose internal role keys or describe arbitrary routes as VPNs. Changing
-the Dashboard origin clears origin-bound cookies and bearer state before the new
-address is verified. The compact footer shows the active surface and transport
-without allowing long model or profile names to displace the route label.
-
-For self-hosted OIDC, authorization and callback use one exact Dashboard
-address. Split DNS remains the preferred public-HTTPS/local-performance shape,
-but a second public URL is not a universal onboarding field. Android does not
-treat the identity origin as ownership of optional API or Relay paths.
-
-Optional API discovery no longer blocks a healthy Dashboard/Gateway route.
-Concurrent probes are shared, negative results are cached for a bounded window,
-same-priority routes race by completion, and connection generations prevent a
-late old route from overwriting a new one. Invalidated probes cannot publish a
-stale unreachable result or diagnostic. Dashboard session and message reads
-now cancel with their coroutine, one bounded budget covers the complete session
-list, WebSocket-ticket minting is bounded, and optional pull-request decoration
-falls off the critical path while preserving exact profile-scoped rows.
-Gateway ticket/auth failures receive one bounded classified attempt rather than
-two serialized waits. A pre-ready WebSocket close settles immediately, while
-optional API and Relay work remains background capability discovery.
-
-Focused auth, Dashboard, resolver, route, and native-sign-in coverage passed
-135 tests on the final `origin/dev` merge, followed by Android lint and sideload
-assembly. The matching Android 16 sideload was installed in place with app data
-preserved. Cold-route evidence showed Dashboard selection completing in hundreds
-of milliseconds, unavailable API fallback work continuing in the background,
-and unauthenticated ticket failures returning immediately instead of stalling.
-An upstream-compatible live-writer certification separately kept five full
-profile-roster RPCs below one second while concurrent ticket mints stayed in
-single-digit milliseconds. Final interactive provider consent/callback remains
-a human gate because the test device was locked after deployment.
-
-## 2026-08-26 — Bounded public issue triage contract
-
-New GitHub issues may receive one clearly identified Hermes-Relay automated
-triage response grounded in the live report, current code and documentation,
-related open/closed issues, and verified public release state. The lane may add
-existing type/area labels, request focused sanitized diagnostics, and flag a
-thread for maintainer review.
-
-The automated path is intentionally not an issue-lifecycle owner: it cannot
-close, assign, milestone, prioritize, promise a fix/release/timeline, or continue
-replying after the first response. Replies identify themselves as automated and
-explicitly hand the remaining decision to a maintainer. Contributor guidance and
-agent instructions carry the same boundary.
-
-Public labels and comments are attributed to the repository-scoped
-`hermes-relay-triage[bot]` GitHub App rather than a maintainer's personal
-account. The App identity does not expand the bounded action contract.
-
 ## 2026-08-24 — Single dev integration authority

 `origin/dev` is the sole integration authority. Primary local `dev` checkouts are
@@ -4233,7 +4062,7 @@ Expected new keyless cold start: client ~+1–2s after first DataStore emission,

 ## 2026-05-19 — Experimental Realtime Hermes Voice Agent

-**Plan.** [`2026-05-19-realtime-hermes-voice-agent.md`](../plans/2026-05-19-realtime-hermes-voice-agent.md) — add a switchable Android voice engine that brokers a realtime provider session (OpenAI first, xAI ready) while keeping Hermes as authority for profiles, sessions, memory, tool execution, Android bridge safety, confirmations, and cancellation. Stable `Hermes chat + voice output` remains the default and is untouched.
+**Plan.** [docs/plans/2026-05-19-realtime-hermes-voice-agent.md](docs/plans/2026-05-19-realtime-hermes-voice-agent.md) — add a switchable Android voice engine that brokers a realtime provider session (OpenAI first, xAI ready) while keeping Hermes as authority for profiles, sessions, memory, tool execution, Android bridge safety, confirmations, and cancellation. Stable `Hermes chat + voice output` remains the default and is untouched.

 **Surface added.**

@@ -4390,7 +4219,7 @@ Post-fix smoke: Victor called `desktop_terminal("hostname")` → returned `{"std

 ## 2026-04-23 — Desktop CLI thin-client v0.1 (`@hermes-relay/cli`)

-**Context.** An earlier private design note decomposed the desktop-client work into two independent pieces: (A) "one Node binary with CLI + TUI modes that talks to a remote Hermes over WSS" and (B) "per-tool dispatch routing so local tools run on the client while the brain stays on the server." This session ships **A** — with CLI mode specifically — and defers B to a separate hermes-agent PR on `fork/tool-relay`. The two are decoupled: the CLI consumes the existing `tui` WSS channel and `tui_gateway` subprocess shape without any server-side change.
+**Context.** The broader ask from the vault's [Desktop Client.md](../../../SynologyDrive/-Vault-/Axiom-Vault/3.%20System/Projects/Hermes-Relay/Desktop%20Client.md) decomposes into two independent pieces: (A) "one Node binary with CLI + TUI modes that talks to a remote Hermes over WSS" and (B) "per-tool dispatch routing so local tools run on the client while the brain stays on the server." This session ships **A** — with CLI mode specifically — and defers B to a separate hermes-agent PR on `fork/tool-relay`. The two are decoupled: the CLI consumes the existing `tui` WSS channel and `tui_gateway` subprocess shape without any server-side change.

 ### Architecture decision — same channel, different renderer

@@ -1,15 +1,26 @@
 # Hermes-Relay Plugin v__VERSION__

-**Release Date:** August 31, 2026
+**Release Date:** August 25, 2026

 ## Summary

-This patch restores native installation compatibility on affected Hermes versions and makes Relay prompt context advertise only capabilities the selected session can actually call. Standard Chat, Manage, standard voice, and ordinary inbound files remain upstream-owned.
+This release adds a provider-neutral account-usage surface for Android and Dashboard clients. Relay resolves Codex credential pools, structured Nous balances, and OpenCode Go windows on the Hermes host without returning provider credentials.
+
+Standard chat, session history, and Vanilla Hermes voice remain upstream-owned and do not require this plugin.
+
+## Added
+
+- **Provider-neutral usage snapshots.** Authenticated Dashboard clients can resolve the exact active Codex pool entry, Nous balances, and OpenCode Go account windows through one normalized schema.
+- **Bounded paired-client fallback.** Operators may explicitly enable the Relay usage route for paired standalone clients while credentials remain host-side.
+
+## Changed
+
+- **Usage capabilities are explicit.** Responses identify Relay-enhanced credential pools, structured balances, and provider adapters instead of implying unsupported upstream data.
+- **Public product naming is aligned.** Releases use `Hermes-Relay Plugin` while retaining the `server-v*` tag and installation contract.

 ## Fixed

- **Native installer compatibility.** The plugin keeps its complete current manifest while avoiding the installer/runtime schema mismatch that caused `manifest_version 2` installs to fail after an apparent Hermes update.
- **Capability-gated phone context.** Phone-control and cross-platform delivery guidance now follows the selected session/profile tool catalog instead of implying unavailable `android_*` or `send_message` callables.
+- **Custom Hermes homes resolve correctly.** Relay profile discovery and session persistence follow `HERMES_HOME` by default while preserving the explicit `RELAY_HERMES_CONFIG` override.

 ## Install / update

@@ -21,8 +32,6 @@ This patch restores native installation compatibility on affected Hermes version
    # or, if already installed:
    hermes-relay-update

-Restart or reload the Hermes Dashboard and Relay after updating so the new manifest and prompt context are active.
-
 ## Verify

    hermes relay doctor
@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="assets/readme-hero-v2.jpg" alt="Hermes-Relay — Your Hermes agent. Wherever you are. Android, Voice, Desktop." width="1000">
+  <img src="assets/play-store-feature-1024x500.png" alt="Hermes-Relay — your Hermes agent, in your pocket" width="800">
 </p>

 <p align="center">
@@ -21,13 +21,7 @@
 </p>

 <p align="center">
-  <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>
+  <strong>English</strong> · <a href="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> ·
@@ -44,10 +38,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, 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.**
+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.**

 <p align="center">
-  <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">
+  <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">
 </p>

 ## Quick Start (Android)
@@ -56,7 +50,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, Manage, and inbound files work with standard Hermes; pairing the Hermes-Relay plugin adds Terminal/TUI, notifications, Relay sessions, and media enhancements.
+- **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.
 - **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.
@@ -64,7 +58,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, voice, and inbound files. Installing Hermes and choosing a
+chat, sign-in, sessions, Manage, and voice. Installing Hermes and choosing a
 provider is vanilla Hermes setup:

 ```bash
@@ -83,15 +77,16 @@ the [remote-access guide](https://hermes-relay.dev/docs/guide/remote-access/).

 ### 3 · Connect and talk

-Use **Find Hermes on LAN** or enter the Dashboard address manually
-(conventionally `http://<host>:9119`). Sign in through the
+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
 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
@@ -104,19 +99,19 @@ 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) |
-| **Direct API** | Optional API-only compatibility route available/unavailable |
+| **API fallback** | Optional API 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
 the whole Vanilla Hermes setup.

-> **Going places?** Add the Dashboard's Tailscale address — for example `http://100.x.y.z:9119` or a separately published `https://host.ts.net` URL — under **Settings → Gateways → Routes**. Android tests it as a Dashboard route; no API server or API key is required. The app uses LAN at home and switches routes automatically when you leave. See [Remote access](https://hermes-relay.dev/docs/guide/remote-access).
+> **Going places?** Add the Dashboard's Tailscale address — for example `http://100.x.y.z:9119` or a separately published `https://host.ts.net` URL — under **Settings → Connections → Routes**. Android tests it as a Dashboard route; no API server or API key is required. The app uses LAN at home and switches routes automatically when you leave. See [Remote access](https://hermes-relay.dev/docs/guide/remote-access).

 ### 4 · Recommended: pair Relay for the complete experience

-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:
+Install Relay for Terminal/TUI, notifications, media handoff, desktop tools,
+enhanced voice, Relay sessions, approval-gated page drafts, and optional Device
+Control:

 ```bash
 hermes plugins install Codename-11/hermes-relay/plugin --enable
@@ -129,7 +124,7 @@ Use `--no-ssl` only on a trusted LAN or VPN. Use the
 exposing any Hermes surface beyond that network.

 Refresh or restart the Dashboard/Gateway, open **Relay → Pair new device**, and
-scan the one-time QR from Android **Settings → Gateways → Access → Pair Relay**.
+scan the one-time QR from Android **Settings → Connections → Pair Hermes Relay**.
 Leave mode on **Auto** for the recommended route discovery. The same dialog
 shows a copyable invite for Desktop CLI clients:

@@ -145,7 +140,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. Direct API 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. The API fallback is optional; the Hermes-Relay plugin is encouraged for the complete experience.

 ## Screenshots

@@ -159,16 +154,11 @@ manual fallbacks when QR or clipboard transfer is unavailable.
  <tr>
    <td align="center" width="25%"><img src="assets/screenshots/05_themes.png" alt="App themes" width="100%"><br><sub><b>App themes</b></sub></td>
    <td align="center" width="25%"><img src="assets/screenshots/06_manage.png" alt="Manage your agent" width="100%"><br><sub><b>Manage your agent</b></sub></td>
-    <td align="center" width="25%"><img src="assets/screenshots/07_connections.png" alt="Gateways and routes" width="100%"><br><sub><b>Gateways &amp; routes</b></sub></td>
+    <td align="center" width="25%"><img src="assets/screenshots/07_connections.png" alt="Connections and routes" width="100%"><br><sub><b>Connections &amp; routes</b></sub></td>
    <td align="center" width="25%"><img src="assets/screenshots/08_appearance.png" alt="Agent avatar &amp; skins" width="100%"><br><sub><b>Avatars &amp; skins</b></sub></td>
  </tr>
 </table>

-<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> — upstream session context with optional Relay discovery and operations</sub>
-</p>
-
 ### Simplified Chinese

 <table>
@@ -220,7 +210,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. `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.
+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.

 <table>
  <tr>
@@ -244,17 +234,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, 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]
+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]
 CLI          (WSS)      --> Relay             (:8767)   [machine tools, tui, terminal]
 ```

-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
+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
 voice ride the Hermes dashboard with its own one-time sign-in, so a vanilla
-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
+install needs no plugin for either. The optional relay on `:8767` adds the power
+surfaces: terminal, bridge phone control, media handoff, 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.

@@ -0,0 +1,109 @@
+<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)
@@ -200,11 +200,6 @@ never create a staging branch. Stable production tags are cut only from the new
 10. Build and publish that surface's artifacts, roll out or deploy from the
    immutable tag, and verify the release and live environment.

-Do not back-merge a normal release. The `main` release merge already has the
-released `dev` tip as its integration parent, so merging it back only adds
-history noise. The release-backmerge workflow detects this topology and exits
-successfully without changing `dev`.
-
 ### Branch names

 | Prefix | When | Example |
@@ -263,9 +258,7 @@ The intended settings are:
 - **`main`** — PRs required; `Required checks` required and current; force push
  and deletion blocked. Normal work does not target this branch.
 - **`dev`** — PRs and `Required checks` required; force push and deletion
-  blocked. This is the normal contribution target. The release-backmerge
-  workflow is the sole exception: its automation identity may compare-and-swap
-  `dev` to an exact checked merge commit after a stable hotfix release.
+  blocked. This is the normal contribution target.
 - **Merge policy** — merge commits allowed; squash and rebase merges disabled so
  the no-ff contract cannot be bypassed in the GitHub UI.
 - **Default branch** — `main`, which remains the release-history branch and the
@@ -530,17 +523,10 @@ the new app version and a higher `appVersionCode`.
  run Android's retrace tool with the matching flavor mapping:
  `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 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/main/assets/whats_new.txt` — in-app "What's New" content
+  shown in the settings/about screen. Update with the version number
+  and a brief feature summary. Gets stale silently if forgotten
+  (v0.4.0 shipped with 0.1.0 content until caught post-release).
 - `app/src/googlePlay/play/release-notes/en-US/default.txt` — the Play
  Console **"What's new"** text, which gradle-play-publisher reads at
  upload to fill the Production-draft release notes. This is **separate**
@@ -548,62 +534,19 @@ the new app version and a higher `appVersionCode`.
  this file is missing or stale, the Play draft ships with empty/wrong
  notes (shipped empty in v1.1.0 until caught post-release). Keep it
  **≤500 chars per language**, user-facing, Android-only.
- `docs/play-store-listing.md` — Play Store listing copy. Its release-note
-  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 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
+- `docs/play-store-listing.md` — Play Store listing copy. Update
+  the version reference and the "Release Notes" section that gets
+  pasted into the Play Console "What's new" field. Keep the Play
+  "What's new" within **500 characters** and framed around the
+  release's themes, not a feature dump. Compare its **Foreground service
  permissions** section with the merged `googlePlayRelease` manifest and
  complete Play Console declarations for every declared service type before
  approval; the Publisher API can upload a draft and still reject promotion
  when an App content declaration is missing.

-#### Generate release copy from the verified changes
-
-When release copy is generated with an agent, this section is the canonical
-authoring contract; do not maintain a separate prompt file.
-
-1. Read the exact Android version/SHA, the Android-only entries selected from
-   `[Unreleased]`, the implemented behavior, and any compatibility or security
-   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 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`: 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
-   names, makes no unverified device claim, and passes the public-distribution
-   scrub below.
-
 #### Scrub for public distribution

-This is a **public repo** and these release-note files are user-facing. Before
+This is a **public repo** and these four files are user-facing. Before
 promoting the `[Unreleased]` block and writing the notes, scrub the
 versioned CHANGELOG block and all three release-notes artifacts for
 wording that shouldn't ship publicly. The CHANGELOG accumulates in a
@@ -628,21 +571,6 @@ 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
@@ -676,17 +604,14 @@ 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. 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.
+6. records a 30-day preflight proof keyed to the version and Git tree hash.

 No sideload APK or GitHub Release is published by preflight. A successful signed
-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.
+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.

 GitHub exposes manual workflows only after their workflow file exists on the
 default branch. For the first release that introduces this process, merge the
@@ -707,9 +632,7 @@ git checkout dev
 git pull --ff-only origin dev

 git add gradle/libs.versions.toml RELEASE_NOTES.md CHANGELOG.md \
-        app/src/main/assets/changelog.json app/src/main/assets/whats_new.txt \
-        app/src/googlePlay/play/release-notes/en-US/default.txt \
-        docs/play-store-listing.md
+        app/src/main/assets/whats_new.txt docs/play-store-listing.md
 git commit -m "release(android): android-v0.6.2"
 git push origin dev

@@ -727,13 +650,12 @@ 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` 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.
+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.

 Plugin/Python version files are intentionally not part of an Android app
 release unless the plugin package itself is also being released.
@@ -762,19 +684,14 @@ git commit -m "release(server): server-v0.6.2"
 git push origin dev

 # Open the release PR (dev -> main) and merge with --no-ff.
-# 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.
+# 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
 ```

-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
+Pushing `server-v*` triggers `.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
@@ -805,25 +722,20 @@ 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

-# 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.
+# 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
 ```

-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.
+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.

 ### 6. Play review and publishing behavior

@@ -924,7 +836,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 `docs/project/DEVLOG.md` with a short entry for the release.
+- Update `DEVLOG.md` with a short entry for the release.

 ## CI Behavior

@@ -932,40 +844,28 @@ 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. 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
+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
   `completed`; prereleases never upload to Play.
-6. Creates a GitHub Release named `Hermes-Relay Android v<version>` with `RELEASE_NOTES.md` as
+7. 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.
-7. Prints a `$GITHUB_STEP_SUMMARY` with the release and Play result.
+8. Prints a `$GITHUB_STEP_SUMMARY` with the release and Play result.

-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`,
+On every push of a tag matching `server-v*`,
 `.github/workflows/release-plugin.yml`:

 1. Verifies a stable tag commit is contained in `main`, or a prerelease tag is
@@ -978,8 +878,7 @@ dispatch from `.github/workflows/approve-release-extensions.yml`,
 5. Creates a GitHub Release named `Hermes-Relay Plugin v<version>` with the wheel,
   sdist, and checksum file attached.

-On every direct push of a tag matching `desktop-v*`, or after an approved
-dispatch from `.github/workflows/approve-release-extensions.yml`,
+On every push of a tag matching `desktop-v*`,
 `.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
@@ -1023,23 +922,8 @@ When production has a bug, use the same invariant for every surface:
 4. Open the focused hotfix PR into `main` and merge with a merge commit/no-ff.
 5. Tag the new `main` tip with the affected surface's patch tag.
 6. Verify the artifacts and production rollout or deployment.
-7. Let the stable release workflow dispatch `Release Backmerge`. A
-   conflict-free candidate runs the same path-aware `Required checks` against
-   its exact SHA, then compare-and-swaps `dev` only if the base ref is unchanged.
-   Conflicts, failed checks, stale refs, or a denied update require a normal
-   reconciliation PR.
-
-`Release Backmerge` accepts only published stable `android-v*`, `server-v*`, or
-`desktop-v*` SemVer tags contained in `main`. It exits without mutation for a
-normal release whose integration parent is already in `dev`. For a selective
-hotfix, it pushes a temporary merge ref, dispatches `Required checks` with full
-base/head SHAs, and updates `dev` with an explicit force-with-lease only after
-that exact candidate passes. The lease is a compare-and-swap guard, not
-permission to rewrite history: the candidate's first parent must be the
-unchanged `dev` tip and its second parent the released commit. The repository
-ruleset must allow this workflow's automation identity to perform that one
-checked branch update; if it does not, the workflow fails closed and the
-reconciliation uses a PR.
+7. Merge `main` back into `dev` immediately so integration inherits the fix and
+   version history.

 For an Android app hotfix:

@@ -1054,21 +938,21 @@ For an Android app hotfix:
 6. `git tag android-v0.6.2` from the new `main` tip and `git push origin android-v0.6.2`
   so Android release CI builds and publishes.
 7. Verify the automated Play submission, GitHub artifacts, and rollout.
-8. Verify the automated release backmerge completed. If it stopped, open a
-   reconciliation PR so `dev` picks up the hotfix and versionCode bump. Without
-   reconciliation, `dev`'s `appVersionCode` lags behind `main` and the next app
-   release bump collides.
+8. Merge `main` back into `dev` (`git checkout dev && git merge --no-ff main`)
+   so `dev` picks up the hotfix and the versionCode bump. Without this,
+   `dev`'s `appVersionCode` lags behind `main` and the next app release
+   bump collides.

 For a Plugin hotfix, branch from the affected `server-v*` tag, apply
 the fix, run `bash scripts/bump-plugin-version.sh <next-version>`, merge to
-`main`, tag `server-v<next-version>`, verify the package/deployment, and verify
-the automated release backmerge. Do not touch
+`main`, tag `server-v<next-version>`, verify the package/deployment, and merge
+`main` back to `dev`. Do not touch
 `gradle/libs.versions.toml` unless an Android app release is also shipping.

 For a CLI+UI hotfix, branch from the affected `desktop-v*` tag, update only
 `desktop/package.json` and its generated lock/runtime/tray metadata, merge to
 `main`, tag `desktop-v<next-version>`, verify all binaries and the installer,
-then verify the automated release backmerge or use the PR fallback.
+then merge `main` back to `dev`.

 ## Troubleshooting

@@ -1,10 +1,10 @@
-# Hermes-Relay Android v1.15.1
+# Hermes-Relay Android v1.13.2

-**Release Date:** September 2, 2026
+**Release Date:** August 25, 2026

 ## Download

-> Installing on your phone? Download `hermes-relay-1.15.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).
+> Installing on your phone? Download `hermes-relay-1.13.2-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,29 +12,16 @@ Verify the download against `SHA256SUMS.txt`. See the [sideload guide](https://h

 ## Summary

-This patch improves chat, media, and voice reliability. It reduces memory-heavy work, keeps attachment previews stable through rotation, and makes follow-up message behavior and voice errors easier to understand.
-
-## Changed
-
- Choose Correct now or Queue next from a slim tray behind the composer. Chat settings sets the default; the tray overrides one message. Stop pauses the queue, Resume continues it, and editing or removing an item preserves its successors.
- Chat and Voice use readable centered layouts on wider screens, including landscape Voice Focus.
+This patch keeps session rows neutral while optional live activity is unavailable or still loading. Full-row activity borders now appear only for actual Starting or Working turns.

 ## Fixed

- Correction and delivery labels remain visible inside user-message bubbles.
- Voice errors open in a scrollable dialog with separate Retry and Dismiss actions.
- Attachment previews remain open through rotation, and video previews preserve their proportions.
- Release optimization preserves the native speech configuration required for wake-word startup.
- Standard Hermes attachments download directly to disk with bounded size checks.
- Session refresh avoids repeated request loops; history loads, Markdown, image previews, and media exports keep memory use bounded.
- Image-generation progress stays visible through gaps between interim replies and returned media.
- The first prompt waits for Gateway session readiness. Ownership refusals retain the prompt for retry and show the original server error.
+- Stop unavailable or in-flight activity checks from presenting a persistent Checking state.
+- Reserve full-row activity borders for actual Starting and Working turns.

 ## Install / Verify

- App version: **1.15.1** (versionCode **54**).
- 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.1** remains the current optional plugin release; this Android patch does not require a new plugin version.
- Paused text queues can be restored. Attachment bytes are not persisted in preferences; unrestorable attachment queues must be reviewed and sent again.
- 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 version: **1.13.2** (versionCode **51**).
+- Standard Chat, sessions, Manage, sharing, profile switching, and Vanilla Hermes voice continue to work against unmodified upstream Hermes.
+- Granular Device Control remains sideload-only; the Google Play build continues to ship Hermes Bridge Core without AccessibilityService Device Control.
+- The optional Relay plugin remains unnecessary for standard Android chat, sessions, Manage, and Vanilla Hermes voice.
@@ -1,6 +1,6 @@
 # Hermes-Relay Roadmap

-> Where Hermes-Relay is headed. Short, high-level, grouped by release milestone. For detailed implementation plans of active work see [`docs/plans/`](../plans/); for shipped work see [`CHANGELOG.md`](../../CHANGELOG.md); for the session-by-session narrative see [`DEVLOG.md`](DEVLOG.md).
+> Where Hermes-Relay is headed. Short, high-level, grouped by release milestone. For detailed implementation plans of active work see [`docs/plans/`](docs/plans/); for shipped work see [`CHANGELOG.md`](CHANGELOG.md); for the session-by-session narrative see [`DEVLOG.md`](DEVLOG.md).

 ## Vision

@@ -8,29 +8,29 @@ Native Android companion for the [Hermes agent platform](https://github.com/Nous

 ## Shipped

- **v0.3.0** — Bridge channel (sideload), voice mode, notification companion, two build flavors, full safety rails system. [CHANGELOG](../../CHANGELOG.md#030---2026-04-13)
- **v0.2.0** — Voice mode foundation, terminal preview, TOFU cert pinning, Paired Devices screen. [CHANGELOG](../../CHANGELOG.md)
+- **v0.3.0** — Bridge channel (sideload), voice mode, notification companion, two build flavors, full safety rails system. [CHANGELOG](CHANGELOG.md#030---2026-04-13)
+- **v0.2.0** — Voice mode foundation, terminal preview, TOFU cert pinning, Paired Devices screen. [CHANGELOG](CHANGELOG.md)
 - **v0.1.0** — Chat, sessions, QR pairing, encrypted storage, Play Store submission.

 ### Desktop track (parallel lane to Android) — **experimental**

-Release tags: `cli-v*` (separate cadence from Android `android-v*` and Plugin `plugin-v*`). Historical alpha prereleases used `desktop-v*`, and the installer/updater keep a migration fallback. Curl-installed prebuilt binaries (no Node required); Windows first, macOS / Linux same release. Workflows: [`ci-desktop.yml`](../../.github/workflows/ci-desktop.yml) + [`release-cli.yml`](../../.github/workflows/release-cli.yml).
+Release tags: `cli-v*` (separate cadence from Android `android-v*` and Plugin `plugin-v*`). Historical alpha prereleases used `desktop-v*`, and the installer/updater keep a migration fallback. Curl-installed prebuilt binaries (no Node required); Windows first, macOS / Linux same release. Workflows: [`ci-desktop.yml`](.github/workflows/ci-desktop.yml) + [`release-cli.yml`](.github/workflows/release-cli.yml).

 **Shipped (2026-04-23 — first tagged release `desktop-v0.3.0-alpha.1`):**

- **`@hermes-relay/cli` v0.1** — Node thin-client at [`desktop/`](../../desktop/). Remote chat + pair + status + tools subcommands over the relay's `tui` WSS channel. Shares `~/.hermes/remote-sessions.json` with the Android client (pair once, both work).
+- **`@hermes-relay/cli` v0.1** — Node thin-client at [`desktop/`](desktop/). Remote chat + pair + status + tools subcommands over the relay's `tui` WSS channel. Shares `~/.hermes/remote-sessions.json` with the Android client (pair once, both work).
 - **v0.2 — resilience + pairing UX** — multi-endpoint pairing (ADR 24: `--pair-qr` probes LAN/Tailscale/Public, strict-priority within-tier race, 4s timeout, 60s cache), reconnect-on-drop state machine (1s→30s exp backoff, 5min on 429, gate re-check post-sleep), TOFU cert pinning via pre-WS TLS probe (SPKI sha256, `sha256/<base64>` OkHttp-compatible).
 - **v0.2 — UX polish** — bare `hermes-relay` → `shell` (full Hermes CLI over PTY with `clear; exec hermes` after tmux settles); contextual connect banner (`Connected via LAN (plain) — server 0.6.0`); `status` surfaces grants + TTL + endpoint role from `auth.ok`; new `devices` subcommand talking to relay `GET/DELETE/PATCH /sessions` over HTTP.
 - **Phase B — client-side tool routing** — server-side `plugin/relay/channels/desktop.py` + `plugin/tools/desktop_tool.py` register `desktop_read_file` / `_write_file` / `_terminal` / `_search_files` / `_patch` via `tools.registry` (mirror of `android_*` pattern — **zero hermes-agent core change**). Client-side `DesktopToolRouter` attaches to the `desktop` channel, dispatches under a 30s AbortController, heartbeats `desktop.status` every 30s. One-time per-URL consent gate + `--no-tools` kill-switch.
 - **`hermes-relay daemon`** — headless WSS + tool router that keeps desktop tools serving without a visible shell. Fails closed on missing stored consent (`--allow-tools` escape hatch with an explicit `--token`). JSON-line logs by default, auto-human on TTY. Inherits transport's reconnect state machine; `setImmediate(exit)` to flush final log line before process dies.
 - **Pre-release hardening** — `hermes-relay doctor` (local diagnostic report, human + `--json`, no token leakage); `uninstall.{sh,ps1}` (3-tier: default keeps session store, `--purge` wipes it with cross-surface warning, `--service` stub); interactive first-run prompts (`resolveFirstRunUrl` — auto-picks single stored session, numbered picker for multiple, welcome banner for fresh install); version-aware install (`upgrading X → Y` readback pre-install, post-install confirmation).
- **Self-setup skill** — [`skills/devops/hermes-relay-desktop-setup/SKILL.md`](../../skills/devops/hermes-relay-desktop-setup/SKILL.md) lets any Hermes agent install, pair, and troubleshoot the CLI with **live local diagnostics** via `desktop_terminal` (can read the user's Node version, PATH, binary location directly — something the Android setup skill can't match).
+- **Self-setup skill** — [`skills/devops/hermes-relay-desktop-setup/SKILL.md`](skills/devops/hermes-relay-desktop-setup/SKILL.md) lets any Hermes agent install, pair, and troubleshoot the CLI with **live local diagnostics** via `desktop_terminal` (can read the user's Node version, PATH, binary location directly — something the Android setup skill can't match).

-**Shipped — `desktop-v0.3.0-alpha.6` (seamless-local dev pass, done 2026-04-23):** Plan at [`docs/plans/2026-04-23-desktop-alpha-6-seamless-local.md`](../plans/2026-04-23-desktop-alpha-6-seamless-local.md). Nine features across six parallel agent workstreams, all opt-in: workspace-awareness envelope + active-editor signal (#1+#8), `hermes-relay update` self-update subcommand (#2), `desktop_open_in_editor` tool + interactive patch approval with unified-diff rendering (#3+#4), conversation picker on connect (#5), clipboard bridge + screenshot handlers (#9+#12), and a `hermes` alias so muscle-memory works without the `-relay` suffix (#13). Integration day: 2026-04-23.
+**Shipped — `desktop-v0.3.0-alpha.6` (seamless-local dev pass, done 2026-04-23):** Plan at [`docs/plans/2026-04-23-desktop-alpha-6-seamless-local.md`](docs/plans/2026-04-23-desktop-alpha-6-seamless-local.md). Nine features across six parallel agent workstreams, all opt-in: workspace-awareness envelope + active-editor signal (#1+#8), `hermes-relay update` self-update subcommand (#2), `desktop_open_in_editor` tool + interactive patch approval with unified-diff rendering (#3+#4), conversation picker on connect (#5), clipboard bridge + screenshot handlers (#9+#12), and a `hermes` alias so muscle-memory works without the `-relay` suffix (#13). Integration day: 2026-04-23.

-**Active — `desktop-v0.3.0-alpha.7` (native image paste):** Plan at [`docs/plans/2026-04-23-desktop-alpha-7-native-paste.md`](../plans/2026-04-23-desktop-alpha-7-native-paste.md). Two-repo workstream: client slash commands `/paste` (clipboard), `/screenshot` (primary display), `/image <path>` (file) land in `hermes-relay chat`, each echoes a one-line feedback and attaches the image to the next `prompt.submit` so the vision-capable model sees it in the same turn — parity with Claude Desktop's paste UX minus OS-level Ctrl+V (terminals don't pipe image bytes to stdin). Client half is new `desktop/src/chatAttach.ts` + slash-command branches in `desktop/src/commands/chat.ts`. Server half is ONE new `@method("image.attach.bytes")` on the fork's `tui_gateway/server.py` (branch `feat/image-attach-bytes` → merged to `axiom`); the fork's existing `_enrich_with_attached_images` already handles multimodal payload plumbing and session-scoped image state, so this release is almost entirely about bridging client-captured bytes to server-side state that's been there for months. Relay channel unchanged — `tui` is a transparent RPC forwarder. Graceful fallback when hermes-host hasn't been updated yet: client catches `method not found`, prints a pointer at the axiom rollout, REPL stays alive.
+**Active — `desktop-v0.3.0-alpha.7` (native image paste):** Plan at [`docs/plans/2026-04-23-desktop-alpha-7-native-paste.md`](docs/plans/2026-04-23-desktop-alpha-7-native-paste.md). Two-repo workstream: client slash commands `/paste` (clipboard), `/screenshot` (primary display), `/image <path>` (file) land in `hermes-relay chat`, each echoes a one-line feedback and attaches the image to the next `prompt.submit` so the vision-capable model sees it in the same turn — parity with Claude Desktop's paste UX minus OS-level Ctrl+V (terminals don't pipe image bytes to stdin). Client half is new `desktop/src/chatAttach.ts` + slash-command branches in `desktop/src/commands/chat.ts`. Server half is ONE new `@method("image.attach.bytes")` on the fork's `tui_gateway/server.py` (branch `feat/image-attach-bytes` → merged to `axiom`); the fork's existing `_enrich_with_attached_images` already handles multimodal payload plumbing and session-scoped image state, so this release is almost entirely about bridging client-captured bytes to server-side state that's been there for months. Relay channel unchanged — `tui` is a transparent RPC forwarder. Graceful fallback when hermes-host hasn't been updated yet: client catches `method not found`, prints a pointer at the axiom rollout, REPL stays alive.

-**Active — desktop control / computer-use:** Enhanced plan at [`docs/plans/desktop-control-computer-use-enhanced.md`](../plans/desktop-control-computer-use-enhanced.md); earlier MVP implementation record at [`docs/plans/desktop-computer-use-mvp.md`](../plans/desktop-computer-use-mvp.md). Windows now has the first Tauri tray/overlay app as the primary Easy/Standard install surface: pair, start/pause daemon, Devices/Revoke, Task Log, Settings, overlay status chip, emergency stop, and bundled CLI sidecar. The existing CLI and daemon remain the primary advanced/headless surface. `desktop_computer_*` schemas are registered on the normal desktop tool channel but advertised only behind the explicit experimental computer-use flag. Host input still requires desktop-tool consent plus a visible, task-scoped assist/control grant; there is no unrestricted or silent mouse/keyboard automation.
+**Active — desktop control / computer-use:** Enhanced plan at [`docs/plans/desktop-control-computer-use-enhanced.md`](docs/plans/desktop-control-computer-use-enhanced.md); earlier MVP implementation record at [`docs/plans/desktop-computer-use-mvp.md`](docs/plans/desktop-computer-use-mvp.md). Windows now has the first Tauri tray/overlay app as the primary Easy/Standard install surface: pair, start/pause daemon, Devices/Revoke, Task Log, Settings, overlay status chip, emergency stop, and bundled CLI sidecar. The existing CLI and daemon remain the primary advanced/headless surface. `desktop_computer_*` schemas are registered on the normal desktop tool channel but advertised only behind the explicit experimental computer-use flag. Host input still requires desktop-tool consent plus a visible, task-scoped assist/control grant; there is no unrestricted or silent mouse/keyboard automation.

 **Desktop control UX direction:** Tauri v2 (Rust + static web UI) is the native shell for the polished Easy-tier experience: tray icon, always-visible overlay chip, task log, settings, and one-click pause/emergency stop. Easy tier pairs once, shows a connected/observing chip, and exposes Devices / Revoke / Task Log / Settings / Emergency Stop from the tray. Standard tier adds full tray management; Advanced tier remains CLI + daemon + JSON policy (`~/.hermes/desktop-control.json`) for operators. The default policy baseline blocks password managers, credential prompts, banking/payment/crypto surfaces, OS security/admin settings, and private-key/token material until locally overridden.

@@ -64,7 +64,7 @@ Moving the Play Store listing from a personal account to the DUNS-verified Axiom

 ## Next — v0.4: Bridge feature expansion

-Detailed plan: [`docs/plans/2026-04-13-bridge-feature-expansion.md`](../plans/2026-04-13-bridge-feature-expansion.md).
+Detailed plan: [`docs/plans/2026-04-13-bridge-feature-expansion.md`](docs/plans/2026-04-13-bridge-feature-expansion.md).

 Expands the bridge channel's tool surface substantially, ports reliability patterns from the broader Hermes-Android ecosystem, and ships a per-app playbook skill so the agent has ready-made procedures for common apps out of the box.

@@ -84,16 +84,16 @@ Expands the bridge channel's tool surface substantially, ports reliability patte

 Small follow-ons to v0.4 deliberately deferred to keep the v0.4.0 release surface focused.

-**Unattended access mode** *(sideload-only).* ~~Opt-in toggle on the Bridge tab that acquires `FULL_WAKE_LOCK + ACQUIRE_CAUSES_WAKEUP`, raises `SCREEN_OFF_TIMEOUT` to max while active, and requests `KeyguardManager.requestDismissKeyguard()` so the agent can drive the device while the user is away.~~ **SHIPPED in v0.4.1** — see [`CHANGELOG.md`](../../CHANGELOG.md#041---unreleased). Final shape: opt-in toggle on the Bridge tab (sideload-only) that acquires `SCREEN_BRIGHT_WAKE_LOCK | ACQUIRE_CAUSES_WAKEUP | ON_AFTER_RELEASE` per bridge action, calls `KeyguardManager.requestDismissKeyguard()` via the registered MainActivity host, and reports `keyguard_blocked` (HTTP 423) when a credential lock blocks the action. Hard-bounded by the existing bridge auto-disable timer; persistent foreground-service notification + amber "Unattended ON" status-overlay chip stay visible while active; first-enable shows a scary dialog explaining the security model and credential-lock limitation. The original spec mentioned a WiFi-disconnect failsafe — rejected during implementation because Tailscale / VPN invalidates the "leaving WiFi = leaving LAN" assumption; the existing relay-disconnect detection (master toggle drops on disconnect → `UnattendedAccessManager.release()`) plus the auto-disable timer cover that surface.
+**Unattended access mode** *(sideload-only).* ~~Opt-in toggle on the Bridge tab that acquires `FULL_WAKE_LOCK + ACQUIRE_CAUSES_WAKEUP`, raises `SCREEN_OFF_TIMEOUT` to max while active, and requests `KeyguardManager.requestDismissKeyguard()` so the agent can drive the device while the user is away.~~ **SHIPPED in v0.4.1** — see [`CHANGELOG.md`](CHANGELOG.md#041---unreleased). Final shape: opt-in toggle on the Bridge tab (sideload-only) that acquires `SCREEN_BRIGHT_WAKE_LOCK | ACQUIRE_CAUSES_WAKEUP | ON_AFTER_RELEASE` per bridge action, calls `KeyguardManager.requestDismissKeyguard()` via the registered MainActivity host, and reports `keyguard_blocked` (HTTP 423) when a credential lock blocks the action. Hard-bounded by the existing bridge auto-disable timer; persistent foreground-service notification + amber "Unattended ON" status-overlay chip stay visible while active; first-enable shows a scary dialog explaining the security model and credential-lock limitation. The original spec mentioned a WiFi-disconnect failsafe — rejected during implementation because Tailscale / VPN invalidates the "leaving WiFi = leaving LAN" assumption; the existing relay-disconnect detection (master toggle drops on disconnect → `UnattendedAccessManager.release()`) plus the auto-disable timer cover that surface.

 **Voice intent local dispatch loop.** The v0.4 voice intent handler builds `bridge.command` envelopes and routes them through the `ChannelMultiplexer` → WSS → relay → back-to-phone path, which the relay correctly rejects with `ignoring unexpected bridge.command from phone` (the wire protocol is server→phone only by design). Voice intents are phone-local, so the dispatch should be local: extend `BridgeCommandHandler` with a `handleLocalCommand(envelope)` entry point that runs the existing `when(path)` dispatch + the full Tier 5 safety check pipeline (blocklist → destructive verb modal → action executor) in-process, and have `RealVoiceBridgeIntentHandler.dispatch()` call it instead of `multiplexer.send()`. Single source of truth for "bridge command → action" preserved; safety modals still fire for destructive verbs; no WSS round-trip for an action that's happening on the same device. Caught by Bailey's on-device test 2026-04-14 after the multiplexer-wiring fix unblocked the dispatch path.

-**~~Tiered permission checklist with JIT permission errors~~ — shipped on `feature/tiered-permissions` (v0.4.1).** See [CHANGELOG.md](../../CHANGELOG.md) under `[Unreleased] → v0.4.1 Bridge fast-follows` for the landed surface. Original scope:
+**~~Tiered permission checklist with JIT permission errors~~ — shipped on `feature/tiered-permissions` (v0.4.1).** See [CHANGELOG.md](CHANGELOG.md) under `[Unreleased] → v0.4.1 Bridge fast-follows` for the landed surface. Original scope:

 - Tiered checklist with sideload-only sections gated on `BuildFlavor.SIDELOAD` (Core bridge / Notification companion / Voice & camera / Sideload features), Optional pills, runtime-permission launchers, ON_RESUME re-probes — done.
 - JIT permission-denied surfacing — bridge tool error envelope carries canonical `code` + `permission` aliases, Python `ResolveResult` types in `plugin/tools/resolve_result.py`, agent-tool wrappers upgrade `permission_denied` responses to structured LLM-readable envelopes, voice-mode JIT chip deep-links to `Settings.ACTION_APPLICATION_DETAILS_SETTINGS` for the running package — done.

-**Voice intent → server session sync.** ✅ **Shipped 2026-04-16** — see [CHANGELOG `[Unreleased]`](../../CHANGELOG.md#unreleased) for the implementation. Picked option (d) (not in the original menu): synthesize OpenAI-format `assistant` (with `tool_calls`) + `tool` (with `tool_call_id`) message pairs from local voice-intent traces and pass them under a new `messages` field on the existing `/v1/runs` and `/api/sessions/{id}/chat/stream` payloads. LLMs are trained on this exact shape so they read it as natural conversation history rather than a system-prompt side note (lower retry risk than option (b)). Zero server changes (option (a) avoided), no double-dispatch (option (c) avoided). Idempotency via a `syncedToServer` flag on each trace.
+**Voice intent → server session sync.** ✅ **Shipped 2026-04-16** — see [CHANGELOG `[Unreleased]`](CHANGELOG.md#unreleased) for the implementation. Picked option (d) (not in the original menu): synthesize OpenAI-format `assistant` (with `tool_calls`) + `tool` (with `tool_call_id`) message pairs from local voice-intent traces and pass them under a new `messages` field on the existing `/v1/runs` and `/api/sessions/{id}/chat/stream` payloads. LLMs are trained on this exact shape so they read it as natural conversation history rather than a system-prompt side note (lower retry risk than option (b)). Zero server changes (option (a) avoided), no double-dispatch (option (c) avoided). Idempotency via a `syncedToServer` flag on each trace.

 **Original problem statement (preserved for context):** Voice intents currently dispatch in-process (good for latency) and append a **local-only** trace to chat history (good for visual continuity), but the server-side session never sees them — so the gateway LLM has no memory of prior voice actions when the user follows up via text or voice. Symptom: user says "open Chrome" via voice (works), then says "did that work?" → LLM responds "I have no prior context for what you're asking about". Caught by Bailey's on-device test 2026-04-14: "The chat is resetting on voice or with our tools?" — actually voice intents bypass chat entirely, but the user-visible effect is the same.

@@ -117,7 +117,7 @@ Shape subject to change. Each theme needs a separate design + plan pass before i

 ### Desktop thin-client — Phase B (client-side tool routing)

-v0.1 ships a remote-chat CLI. Phase B is the bigger win: **per-tool dispatch routing** so file/terminal/browser tools run against the user's machine while state tools (memory, skills, sessions, cron) stay on the server. An earlier private design note supplied the initial decomposition. Key insertion point is hermes-agent `model_tools.py::handle_function_call()` (~line 517) — before `registry.dispatch()`, consult a session-scoped routing table populated by a relay handshake extension where the client advertises which tools it can service. Isomorphic to how `android_*` tools already flow through the `bridge.command` channel. Proposed branch: `fork/tool-relay` on the hermes-agent fork; upstream issue to open before merging. Blocked on: (a) the handshake extension in `plugin/relay/auth.py` to carry the advertised-tools list, (b) a new `desktop.command` channel mirroring `bridge.command` semantics, (c) the upstream PR conversation.
+v0.1 ships a remote-chat CLI. Phase B is the bigger win: **per-tool dispatch routing** so file/terminal/browser tools run against the user's machine while state tools (memory, skills, sessions, cron) stay on the server. Design detailed in the vault under `Axiom-Vault/3. System/Projects/Hermes-Relay/Desktop Client.md`. Key insertion point is hermes-agent `model_tools.py::handle_function_call()` (~line 517) — before `registry.dispatch()`, consult a session-scoped routing table populated by a relay handshake extension where the client advertises which tools it can service. Isomorphic to how `android_*` tools already flow through the `bridge.command` channel. Proposed branch: `fork/tool-relay` on the hermes-agent fork; upstream issue to open before merging. Blocked on: (a) the handshake extension in `plugin/relay/auth.py` to carry the advertised-tools list, (b) a new `desktop.command` channel mirroring `bridge.command` semantics, (c) the upstream PR conversation.

 ### Observability & introspection
 - Real-time accessibility event streaming for reactive workflows (`android_events`, `android_event_stream`)
@@ -154,6 +154,6 @@ Dedicated **"Hermes Phone"** — a device (or phone ROM) that boots straight int

 New ideas enter via: direct proposals in GitHub issues, comparison passes against similar projects, community feedback from users and contributors, or internal research that turns into a shipped prototype.

-Active work waves (like the v0.4 bridge feature expansion above) get their detailed implementation plans in [`docs/plans/`](../plans/). When a plan wave ships, its plan file is archived or removed and the items migrate into [`CHANGELOG.md`](../../CHANGELOG.md).
+Active work waves (like the v0.4 bridge feature expansion above) get their detailed implementation plans in [`docs/plans/`](docs/plans/). When a plan wave ships, its plan file is archived or removed and the items migrate into [`CHANGELOG.md`](CHANGELOG.md).

 Have an idea? [Open an issue](https://github.com/Codename-11/hermes-relay/issues/new) — every one is read.
@@ -6,71 +6,6 @@ For shipped work, see `DEVLOG.md`. For architectural decisions, see `docs/decisi

 ---

-## Restore the plugin manifest v2 declaration after the Hermes installer fix ships
-
-Hermes installers in affected stable releases reject `manifest_version: 2`
-before the v2-capable runtime loader can inspect the plugin. Track upstream
-[PR #85893](https://github.com/NousResearch/hermes-agent/pull/85893). Restore
-`plugin/plugin.yaml` to `manifest_version: 2` only after that fix ships in a
-stable Hermes release that Hermes-Relay can treat as its minimum supported
-version. Until then, keep the v1 compatibility declaration and the additive
-metadata consumed by newer hosts.
-
---
-
-## Consider hosted Android emulator execution
-
-The local API 36 Gradle Managed Device lanes are intentionally on demand and
-individually selected. The current Android On-Demand workflow covers hosted
-source, unit, lint, and build verification only; it does not run emulators. If
-local emulator capacity becomes a recurring constraint, evaluate a separately
-approved hosted-emulator design with explicit cost, concurrency, artifact
-retention, and trigger policy. Do not schedule the full form-factor matrix or
-add a device farm until that policy is approved; keep live-server mutation tests
-outside any automatic matrix.
-
---
-
-## Upstream a public Dashboard plugin WebSocket admission seam
-
-The same-origin Relay ingress follows current upstream's bundled Dashboard
-plugin pattern but must feature-detect private
-`hermes_cli.web_server._ws_request_is_allowed` and `_ws_auth_ok` helpers.
-Propose one public helper that combines Host/Origin policy, single-use ticket
-authentication, and runtime plugin-enabled gating for `APIRouter` WebSockets.
-After it is available in the supported Hermes baseline, replace the private
-imports and remove the Relay plugin's local runtime-disable polling. Until
-then, missing helpers fail closed and direct Relay remains an advanced
-compatibility route.
-
---
-
-## Upstream an Android Gateway platform hint
-
-Android currently identifies its standard Gateway sessions with the legacy
-`webui` source because upstream has no stable Android/mobile session platform.
-Current upstream deliberately removed the unused `webui` prompt hint and only
-ships renderer-verified `desktop` and `tui` guidance. Do not relabel Android as
-Desktop: that would also advertise Desktop-only inline widgets and directives.
-Propose an upstream Android/mobile platform hint, or a bounded authenticated
-client-surface context contract, that accurately describes mobile Markdown,
-standard upstream media/file delivery, and concise-response expectations. Once
-that contract is available in the supported Hermes baseline, adopt it and add
-Gateway conformance coverage proving the exact prompt bytes and session source.
-
---
-
-## Scope sensitive-media prompt guidance to capable clients
-
-The Relay plugin's sensitive-media prompt section currently describes the
-Android `||![...](...)||` and alt-text conventions profile-wide. Before
-expanding that behavior, make the section depend on an authoritative client
-capability or replace it with a portable convention verified against every
-renderer that receives the profile prompt. Do not make Desktop/TUI sessions
-emit Android-only spoiler syntax merely because the Relay plugin is installed.
-
---
-
 ## Certify Android session activity across lifecycle and profile boundaries

 The contract fixture now covers every upstream live status, complete-snapshot
@@ -79,11 +14,8 @@ and older Gateways without `session.active_list`. Before calling the status
 model device-certified:

 - Exercise working, quiet tool-heavy work, each pending-input surface, normal
-  completion, a lost terminal followed by an exact active-list Idle row, Stop,
-  reconnect, app restart, and process recreation against current vanilla
-  upstream. Confirm the lost-terminal path preserves the partial transcript,
-  settles composer/steering state, and drains or cancels queued corrections
-  exactly once according to the owning turn outcome.
+  completion, Stop, reconnect, app restart, and process recreation against
+  current vanilla upstream.
 - Verify All Profiles with duplicate session ids across two profiles and two
  saved connections; no late snapshot or old socket generation may mark the
  wrong row live.
@@ -94,9 +26,6 @@ model device-certified:
  renders as Working.
 - Run a background process that outlives its parent turn and verify Background
  work remains separate from the conversation's Idle state.
- On a physical phone, open and repeatedly foreground Android while the same
-  session is working in official Desktop/TUI; verify Android sends no live
-  attach/interrupt RPC, the producer completes, and final history appears.
 - Pursue an upstream `session.active_list` profile field/filter or an aggregate
  activity route with explicit profile ownership so multi-profile clients do
  not need to resolve process-wide rows from durable keys.
@@ -827,10 +756,8 @@ cancels). Ranked next increments, in value-per-complexity order:

 Plan: `docs/plans/2026-07-06-open-issue-resolution.md` (13 open issues triaged;
 fix-state claims verified against tags with `git merge-base --is-ancestor`).
-This historical batch remains owner-controlled. The bounded new-issue triage
-lane may post one clearly identified first response and basic type/area labels,
-but it does not execute backlog actions. Every comment, close, relabel, and
-milestone below remains an owner action deliberately queued here:
+**Automation never posts to GitHub** — every comment/close/label below is an
+owner action, deliberately queued here:

 - [ ] **#131** — close: fixed by `3573ba8` (PR #136), shipped android-v1.2.5
      (reporter was on 1.2.3). Optionally re-check Play vitals for the
@@ -1219,19 +1146,16 @@ The gateway-platform model is the *correct + sufficient architecture* (the phone

 ### Session drawer audit follow-ups

- **Certify first-open latency against a large profile store.** Verify a cold
-  launch, immediate drawer open, repeated close/open, and profile switches on a
-  real high-row-count Dashboard. The first bounded page must not wait on
-  Gateway socket readiness; cached rows must remain visible; a timeout must end
-  without another long automatic read; and the final failure must be retryable
-  **Unavailable**, never "No sessions." Capture both client timing and the
-  server's session-list request duration before calling the path fixed.
- **Certify progressive paging on large stores.** Android loads 50 visible-source
-  recents first and appends 50-row `offset` pages near the end of the drawer.
-  Exercise repeated near-end triggers, a profile/route switch during page load,
-  hidden-source preference changes, terminal short pages, and server search
-  without regressing ownership, cached rows, pin/archive state, or compression
-  tips.
+- **Persist and server-back Pin/Archive behavior.** The drawer currently keeps
+  both sets in composable memory. They reset when the drawer/app is recreated,
+  and Archive does not call the existing upstream profile-scoped archive API or
+  load archived rows. Either wire Archive end to end and persist Pin locally,
+  or remove the misleading actions until those contracts are complete.
+- **Paginate large session stores.** Android requests only the 200 most-recent
+  rows and filters/searches them locally. Older sessions are therefore
+  undiscoverable on long-lived profiles even though upstream list APIs support
+  `offset`. Add incremental paging (and server search where capability-backed)
+  without regressing profile scoping or compression-tip projection.

 The client-side mitigations shipped (see DEVLOG 2026-06-27): the `updateSessions` clobber guard, the post-turn title reconcile (gateway), and the subtle "not auto-named here" drawer note on SSE. These two are the larger follow-ups:

@@ -1374,12 +1298,7 @@ and whether the agent is waiting on the user.
  permissions; exercise compact, expanded, collapsed, and full-Voice handoff
  states, background tap-through, rotation and insets, cancel/back, microphone
  denial, network failure, process kill/recreation, and wake→voice→wake
-  resumption. For background and keyguard capture, record `AudioRecord`, AppOps,
-  and foreground-service state: the user-installed app owns capture outside the
-  separate session process, so confirm whether the selected Assistant role is
-  sufficient on each target OS or whether activation needs an explicit,
-  activation-scoped microphone foreground-service lease. Measure idle battery
-  drain because third-party assistants do not
+  resumption. Measure idle battery drain because third-party assistants do not
  receive Google's dedicated low-power hotword hardware.

 - **Audio quality guardrails** — normalize output volume across realtime and
@@ -1533,5 +1452,5 @@ Follow-ups:
  - **On-device import/delete smoke.** Import `/sdcard/Download/lucy.zip` via Add a pet → confirm Lucy appears, selects, and animates all states; then remove it and confirm the avatar falls back to the Sphere.
 - **Pet behavior model — richer state association (spec'd 2026-06-19, `docs/pet-spec.md` "Agent states &amp; pet behavior").** Shipped: the honesty clamp (declared reactivity ∩ `PET_RENDERER_CAPABILITIES`), the friendly `writing` alias, the `**working`/tool-use overlay** (pet-local sub-state from `toolCallBurst`; opt-in `working` clip drives both the swap and the Tools badge), the **one-shot reaction layer** (`greet`/`wake` on appear, `done`/`celebrate` on turn-finish — opt-in, play-once-then-revert, transition-derived; `ONE_SHOT_MAX_MS` backstop), and `**intensity` modulation** (opt-in `reactive.intensity` → live playback speedup ≤1.6× via `rememberUpdatedState`; un-clamps the Activity badge). Voice · Tools · Activity reactivity is now complete. Remaining:
  - `**attention` one-shot (only deferred behavior).** A reaction on notification arrival — needs a host event the avatar doesn't yet receive (unlike `greet`/`done`, which ride state transitions). Would plumb a notification edge into `AvatarRenderState` (or a side channel) + a `PetOneShot.Attention`. Low priority: the avatar is rarely on-screen when notifications land (backgrounded) — see the value analysis; revisit only if the avatar becomes an always-on surface (persistent overlay / Quest port).
-  - **On-device verification (working + one-shots + intensity).** Use the normal Chat background visualization, which receives `toolCallBurst`, `streamingIntensity`, and state transitions. Confirm: a `working` clip swaps in during a tool run and releases ~600ms after (`WORKING_BURST_THRESHOLD` 0.5); a `done` clip plays once on reply completion then returns to idle; a `greet` clip plays once when the avatar appears; with `intensity:true`, a writing/working loop visibly quickens while streaming. Confirm each decoded clip swap holds the previous complete visual until the new state is ready.
+  - **On-device verification (working + one-shots + intensity).** Best seen in clean mode (`AgentTextFlow` feeds `toolCallBurst` + `streamingIntensity` + state transitions). Confirm: a `working` clip swaps in during a tool run and releases ~600ms after (`WORKING_BURST_THRESHOLD` 0.5); a `done` clip plays once on reply completion then returns to idle; a `greet` clip plays once when the avatar appears; with `intensity:true`, a writing/working loop visibly quickens while streaming. Confirm each decoded clip swap holds the previous complete visual until the new state is ready.
 - **Undecodable-but-present image appears valid (audit 2026-06-19).** A file that exists but isn't a decodable image passes the loader's `isFile` check, so the pet shows in the picker but renders blank. Documented as a caveat; consider a cheap header sniff at load time if false-valid pets become a support issue.
@@ -249,58 +249,6 @@ 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
-                }
-            }
-        }
    }
 }

@@ -367,9 +315,8 @@ dependencies {
    implementation(libs.okhttp)
    implementation(libs.okhttp.sse)

-    // Media3 ExoPlayer + lifecycle-aware Compose video surface.
+    // Media3 ExoPlayer — gapless TTS queue playback (replaces MediaPlayer in VoicePlayer)
    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.
@@ -443,12 +390,6 @@ 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)
@@ -458,8 +399,8 @@ dependencies {
    // [POC] Roborazzi host-side screenshot rendering (src/test, Robolectric).
    // Renders real composables on the JVM at an exact canvas — no device, no
    // status bar, no clipping. See StoreScreenshotTest.
-    testImplementation("io.github.takahirom.roborazzi:roborazzi:1.73.0")
-    testImplementation("io.github.takahirom.roborazzi:roborazzi-compose:1.73.0")
+    testImplementation("io.github.takahirom.roborazzi:roborazzi:1.72.0")
+    testImplementation("io.github.takahirom.roborazzi:roborazzi-compose:1.72.0")
    testImplementation(libs.compose.ui.test.junit4)
    testImplementation(libs.compose.ui.test.manifest)
    testImplementation("androidx.test.ext:junit:1.3.0")
@@ -55,9 +55,6 @@
 -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
@@ -6,7 +6,8 @@ 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.v2.createComposeRule
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
 import androidx.compose.ui.test.onNodeWithTag
 import androidx.compose.ui.test.onNodeWithText
 import androidx.test.platform.app.InstrumentationRegistry
@@ -27,6 +28,50 @@ class AmbientVisualizationVisibilityTest {
    @get:Rule
    val composeTestRule = createComposeRule()

+    @Test
+    fun cleanMode_backgroundOff_hidesSphereAndKeepsComposer() {
+        composeTestRule.setContent {
+            AmbientTestProviders(enabled = false) {
+                CleanChatMode(
+                    messages = emptyList(),
+                    isStreaming = false,
+                    sphereState = SphereState.Idle,
+                    streamingIntensity = 0f,
+                    toolCallBurst = 0f,
+                    animationEnabled = true,
+                    enabled = true,
+                    onSend = {},
+                    onExit = {},
+                )
+            }
+        }
+
+        composeTestRule.onNodeWithTag(AMBIENT_RENDERER_TAG).assertDoesNotExist()
+        composeTestRule.onNodeWithContentDescription(targetString(R.string.agent_text_send_cd))
+            .assertExists()
+    }
+
+    @Test
+    fun cleanMode_backgroundOn_rendersSphere() {
+        composeTestRule.setContent {
+            AmbientTestProviders(enabled = true) {
+                CleanChatMode(
+                    messages = emptyList(),
+                    isStreaming = false,
+                    sphereState = SphereState.Idle,
+                    streamingIntensity = 0f,
+                    toolCallBurst = 0f,
+                    animationEnabled = false,
+                    enabled = true,
+                    onSend = {},
+                    onExit = {},
+                )
+            }
+        }
+
+        composeTestRule.onNodeWithTag(AMBIENT_RENDERER_TAG).assertExists()
+    }
+
    @Test
    fun voiceMode_backgroundOff_hidesSphereAndKeepsVoiceUi() {
        composeTestRule.setContent {
@@ -95,7 +95,7 @@ class OnboardingFlowTest {
        composeTestRule.onNodeWithText("Connect").performClick()
        composeTestRule.waitForIdle()

-        composeTestRule.onNodeWithText("Add gateway").assertIsDisplayed()
+        composeTestRule.onNodeWithText("Connect to Hermes").assertIsDisplayed()
    }

    @Test
@@ -121,22 +121,16 @@ class OnboardingFlowTest {
    }

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

-        composeTestRule
-            .onNodeWithText("Hermes nearby")
-            .assertIsDisplayed()
-        composeTestRule
-            .onNodeWithText("Remote gateway")
-            .assertIsDisplayed()
        composeTestRule
            .onNodeWithText("Scan Hermes setup QR")
            .assertIsDisplayed()
        composeTestRule
            .onNodeWithText("Recommended")
-            .assertDoesNotExist()
+            .assertIsDisplayed()
    }

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

-        composeTestRule.onNodeWithText("Remote gateway").performClick()
+        composeTestRule.onNodeWithText("Server or VPS").performClick()
        composeTestRule.waitForIdle()

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

-        composeTestRule.onNodeWithText("Remote gateway").performClick()
+        composeTestRule.onNodeWithText("Server or VPS").performClick()
        composeTestRule.waitForIdle()

        composeTestRule
@@ -182,7 +176,7 @@ class OnboardingFlowTest {
    }

    @Test
-    fun addGatewayPage_keepsPairingOptional() {
+    fun connectPage_keepsPairingOptional() {
        setOnboardingContent()
        navigateToPage(4)

@@ -209,7 +203,7 @@ class OnboardingFlowTest {
    }

    @Test
-    fun skipButton_visibleOnIntroPages_andWizardSkipOnAddGatewayPage() {
+    fun skipButton_visibleOnIntroPages_andWizardSkipOnConnectPage() {
        setOnboardingContent()

        repeat(4) {
@@ -1,160 +0,0 @@
-package com.hermesandroid.relay.ui.screens
-
-import android.os.Handler
-import android.os.Looper
-import android.view.accessibility.AccessibilityNodeInfo
-import androidx.activity.compose.setContent
-import androidx.compose.material3.MaterialTheme
-import androidx.lifecycle.Lifecycle
-import androidx.test.core.app.ActivityScenario
-import androidx.test.platform.app.InstrumentationRegistry
-import com.hermesandroid.relay.data.BotGatewayRoute
-import com.hermesandroid.relay.data.BotGatewayRouteKey
-import com.hermesandroid.relay.data.BotRosterEntry
-import com.hermesandroid.relay.data.Profile
-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.models.MessageItem
-import com.hermesandroid.relay.viewmodel.AndroidGatewayContractFixture
-import com.hermesandroid.relay.viewmodel.ChatViewModel
-import java.util.concurrent.TimeUnit
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.serialization.json.JsonPrimitive
-import okhttp3.OkHttpClient
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
-
-/** On-device proof for the route-owned first-composition collection boundary. */
-class BotChatScreenBindingInstrumentedTest {
-    private lateinit var fixture: AndroidGatewayContractFixture
-    private lateinit var gatewayScope: CoroutineScope
-    private lateinit var dashboardClient: DashboardApiClient
-    private lateinit var gatewayClient: GatewayChatClient
-    private lateinit var viewModel: ChatViewModel
-    private lateinit var handler: ChatHandler
-    private var activityScenario: ActivityScenario<BotChatBindingTestActivity>? = null
-
-    @Before
-    fun setUp() {
-        fixture = AndroidGatewayContractFixture()
-        gatewayScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-        dashboardClient = DashboardApiClient(
-            baseUrl = fixture.server.url("/").toString().trimEnd('/'),
-            okHttpClient = OkHttpClient(),
-        )
-        gatewayClient = GatewayChatClient(
-            initialDashboardClient = dashboardClient,
-            okHttpClient = OkHttpClient(),
-            callbackDispatcher = { block -> Handler(Looper.getMainLooper()).post(block) },
-            scope = gatewayScope,
-            reconnectJitterUnit = { 0.0 },
-        )
-        viewModel = ChatViewModel()
-        handler = ChatHandler()
-    }
-
-    @After
-    fun tearDown() {
-        activityScenario?.close()
-        viewModel.updateGatewayClient(null)
-        gatewayClient.shutdown()
-        gatewayScope.cancel()
-        dashboardClient.shutdown()
-        fixture.shutdown()
-    }
-
-    @Test
-    fun fastInitialHistoryRendersBeforeNavigationAndSurvivesLifecycleResume() {
-        val route = BotGatewayRoute(
-            key = BotGatewayRouteKey("fixture-gateway", PROFILE_NAME),
-            connectionLabel = "Fixture gateway",
-        )
-        val bot = BotRosterEntry(
-            profile = Profile(
-                name = PROFILE_NAME,
-                model = "fixture-model",
-                description = "Fixture profile",
-            ),
-            displayName = "Research",
-            route = route,
-        )
-        val scenario = ActivityScenario.launch(BotChatBindingTestActivity::class.java)
-            .also { activityScenario = it }
-
-        scenario.onActivity { activity ->
-            activity.setContent {
-                MaterialTheme {
-                    BotChatScreen(
-                        route = route,
-                        bot = bot,
-                        sessionId = STORED_SESSION_ID,
-                        gatewayClient = gatewayClient,
-                        dashboardClient = dashboardClient,
-                        chatViewModel = viewModel,
-                        onBack = {},
-                        handlerFactory = { handler },
-                        historyLoader = { _, _, _ ->
-                            Result.success(
-                                listOf(
-                                    MessageItem(
-                                        id = HISTORY_ID,
-                                        sessionId = STORED_SESSION_ID,
-                                        role = "assistant",
-                                        content = JsonPrimitive(HISTORY_TEXT),
-                                        timestamp = 1.0,
-                                        finishReason = "stop",
-                                    ),
-                                ),
-                            )
-                        },
-                        profileIconFlow = { _, _ -> MutableStateFlow(null) },
-                    )
-                }
-            }
-        }
-
-        waitUntil { handler.messages.value.singleOrNull()?.content == HISTORY_TEXT }
-        waitUntil { renderedTextExists(HISTORY_TEXT) }
-
-        scenario.moveToState(Lifecycle.State.STARTED)
-        scenario.moveToState(Lifecycle.State.RESUMED)
-        waitUntil { renderedTextExists(HISTORY_TEXT) }
-        assertEquals(0, fixture.rpcCount("prompt.submit"))
-    }
-
-    private fun renderedTextExists(expected: String): Boolean {
-        val instrumentation = InstrumentationRegistry.getInstrumentation()
-        instrumentation.waitForIdleSync()
-        val root = instrumentation.uiAutomation.rootInActiveWindow ?: return false
-        return root.containsText(expected)
-    }
-
-    private fun AccessibilityNodeInfo.containsText(expected: String): Boolean {
-        if (text?.toString() == expected || contentDescription?.toString() == expected) return true
-        return (0 until childCount).any { index -> getChild(index)?.containsText(expected) == true }
-    }
-
-    private fun waitUntil(condition: () -> Boolean) {
-        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
-        while (System.nanoTime() < deadline) {
-            if (condition()) return
-            Thread.sleep(25)
-        }
-        assertTrue("Condition was not satisfied within 5 seconds", condition())
-    }
-
-    private companion object {
-        const val PROFILE_NAME = "research"
-        const val STORED_SESSION_ID = "20260829_120000_bot_chat"
-        const val HISTORY_ID = "persisted-bot-history"
-        const val HISTORY_TEXT = "Durable Bot Chat history is ready."
-    }
-}
@@ -1,65 +0,0 @@
-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()
-    }
-}
@@ -1,183 +0,0 @@
-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"
-    }
-}
@@ -15,10 +15,6 @@ 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
@@ -175,81 +171,6 @@ 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
@@ -4,7 +4,6 @@ import android.os.Handler
 import android.os.Looper
 import androidx.activity.ComponentActivity
 import androidx.compose.foundation.layout.Column
-import androidx.compose.material3.Button
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.Modifier
@@ -18,24 +17,16 @@ import androidx.compose.ui.test.onNodeWithTag
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.hermesandroid.relay.data.MessageRole
-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.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.network.upstream.models.MessageItem
-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.coroutines.flow.MutableStateFlow
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
@@ -53,7 +44,6 @@ 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
@@ -84,11 +74,10 @@ class GatewayForegroundRecoveryInstrumentedTest {

    @Volatile
    private var persistedHistory: List<MessageItem> = emptyList()
-    private val historySignInRequired = MutableStateFlow(false)

    @Before
    fun setUp() {
-        fixture = AndroidGatewayContractFixture().also { it.profileName = PROFILE_NAME }
+        fixture = AndroidGatewayContractFixture()
        gatewayScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
        val okHttp = OkHttpClient()
        gatewayClient = GatewayChatClient(
@@ -108,7 +97,6 @@ class GatewayForegroundRecoveryInstrumentedTest {
                handler,
            )
            it.streamingEndpoint = "gateway"
-            it.setSessionProfileNameProvider { PROFILE_NAME }
            it.setProfileMessageLoader { Result.success(persistedHistory) }
            it.updateGatewayClient(gatewayClient)
            it.setChatVisible(true)
@@ -117,18 +105,8 @@ 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()
            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"),
@@ -139,14 +117,6 @@ class GatewayForegroundRecoveryInstrumentedTest {
                            modifier = Modifier.testTag("message-${message.id}"),
                        )
                    }
-                    if (signInRequired) {
-                        Button(
-                            onClick = {},
-                            modifier = Modifier.testTag("dashboard-sign-in-recovery"),
-                        ) {
-                            Text("SIGN IN")
-                        }
-                    }
                }
            }
        }
@@ -164,37 +134,6 @@ 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")
@@ -300,243 +239,6 @@ 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)
-        viewModel.updateGatewayClient(null)
-        gatewayClient.shutdown()
-        gatewayScope.cancel()
-
-        val controlMethods = setOf(
-            "session.resume",
-            "session.activate",
-            "session.interrupt",
-            "prompt.submit",
-        )
-        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)
-        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)
-        compose.activityRule.scenario.moveToState(Lifecycle.State.RESUMED)
-        viewModel.setChatVisible(false)
-        viewModel.setChatVisible(true)
-        fixture.awaitRpcCount("session.active_list", baselineActiveList + 1)
-
-        controlMethods.forEach { method ->
-            assertEquals(
-                "passive lifecycle sent $method",
-                baseline.getValue(method),
-                fixture.rpcCount(method),
-            )
-        }
-        viewModel.updateGatewayClient(null)
-        gatewayClient.shutdown()
-        assertEquals(
-            "observer teardown interrupted the Desktop turn",
-            baseline.getValue("session.interrupt"),
-            fixture.rpcCount("session.interrupt"),
-        )
-    }
-
-    @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"
@@ -545,23 +247,6 @@ 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
    }
 }

@@ -578,15 +263,6 @@ internal class AndroidGatewayContractFixture {
    @Volatile
    var recoveryRunning = false

-    @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)
@@ -606,18 +282,6 @@ internal class AndroidGatewayContractFixture {
                "session.activate" -> sessionSnapshot(
                    (params["session_id"] as? JsonPrimitive)?.contentOrNull ?: "fixture-live-1",
                )
-                "session.active_list" -> buildJsonObject {
-                    put("sessions", kotlinx.serialization.json.buildJsonArray {
-                        activeSessionStatus?.let { status ->
-                            add(buildJsonObject {
-                                put("id", LIVE_SESSION_ID)
-                                put("session_key", STORED_SESSION_ID)
-                                put("status", status)
-                                put("last_active", 1.0)
-                            })
-                        }
-                    })
-                }
                "prompt.submit", "session.interrupt" -> buildJsonObject { put("ok", true) }
                else -> JsonObject(emptyMap())
            }
@@ -644,11 +308,6 @@ 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)
                }
            }
@@ -660,7 +319,7 @@ internal class AndroidGatewayContractFixture {
        put("session_id", sessionId)
        put("running", recoveryRunning)
        put("status", if (recoveryRunning) "streaming" else "idle")
-        put("info", buildJsonObject { put("profile_name", profileName) })
+        put("info", buildJsonObject { put("profile_name", "default") })
    }

    fun event(type: String, payload: JsonObject?, sessionId: String?): String =
@@ -678,7 +337,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(15)
+        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
        while (System.nanoTime() < deadline) {
            rpcLog.firstOrNull { it.first == method }?.let { return it.second }
            Thread.sleep(20)
@@ -686,30 +345,12 @@ internal class AndroidGatewayContractFixture {
        error("Gateway RPC $method not observed; saw ${rpcLog.map { it.first }}")
    }

-    fun awaitRpcCount(method: String, count: Int) {
-        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(15)
-        while (System.nanoTime() < deadline) {
-            if (rpcCount(method) >= count) return
-            Thread.sleep(20)
-        }
-        error("Gateway RPC $method count $count not observed; saw ${rpcLog.map { it.first }}")
-    }
-
    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() {
        allSockets.forEach { socket -> runCatching { socket.close(1001, "teardown") } }
        runCatching { server.shutdown() }
    }
-
-    private companion object {
-        const val STORED_SESSION_ID = "20260821_120000_fixture"
-        const val LIVE_SESSION_ID = "fixture-live-1"
-    }
 }
@@ -1,10 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application>
-        <activity
-            android:name="com.hermesandroid.relay.ui.screens.BotChatBindingTestActivity"
-            android:exported="false"
-            android:screenOrientation="portrait" />
        <activity
            android:name="com.hermesandroid.relay.ui.screens.VoiceSettingsDesignQaActivity"
            android:exported="true"
@@ -1,6 +0,0 @@
-package com.hermesandroid.relay.ui.screens
-
-import androidx.activity.ComponentActivity
-
-/** Empty debug-only host populated by the Bot Chat lifecycle instrumentation. */
-class BotChatBindingTestActivity : ComponentActivity()
@@ -1,3 +1 @@
-v1.15.1 - Steadier chat, media, and voice
-
-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.
+Session rows now stay neutral while optional live activity is unavailable or still loading. Full-row activity borders appear only for actual Starting or Working turns.
@@ -1 +1 @@
-新增监督模式：家长可配置并固定到指定配置文件，设置受设备身份验证保护。家长可限制附件、标准语音、生成媒体、历史记录、操作和技术详情。实时活动不可用时会话行保持中性显示，从家长设置返回时监督聊天也不再空白。
+当可选的实时活动状态不可用或仍在加载时，会话行现在保持中性显示。只有会话真正处于“启动中”或“工作中”时，才会显示整行活动边框。
@@ -1,333 +1,10 @@
 {
- "schema": 3,
 "versions": [
-  {
-   "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",
-   "title": "Supervised Mode and clearer activity",
+   "title": "Clear session activity",
   "date": "2026-08-25",
-   "highlight": {
-    "title": "Supervised Mode",
-    "summary": "Create a simpler, profile-focused chat and choose which features remain available.",
-    "bullets": [
-     "Protect parent settings with your phone's device authentication.",
-     "Choose access to attachments, Standard voice, generated media, history, actions, and technical details.",
-     "Keep Supervised Chat open when returning from parent settings."
-    ]
-   },
-   "improvements": [
-    "Activity indicators now appear only while Hermes is genuinely working."
-   ],
-   "toastDigest": {
-    "additionalFeatureCount": 0,
-    "fixCount": 2,
-    "preview": [
-     "Accurate activity",
-     "safer return"
-    ]
-   },
-   "playNotes": "Supervised Mode creates a simpler, profile-focused chat with device-protected parent settings and control over attachments, Standard voice, generated media, history, actions, and technical details. Activity indicators now appear only while Hermes is genuinely working, and returning from parent settings keeps Supervised Chat open.",
   "sections": [
-    {
-     "header": "Use a supervised chat",
-     "bullets": [
-      "Configure a profile-pinned restricted chat with parent-controlled attachments, voice, media, history, actions, and technical details.",
-      "Protect full settings with device authentication and keep Supervised Chat visible when parent access relocks."
-     ]
-    },
    {
     "header": "Show only confirmed activity",
     "bullets": [
@@ -1,24 +1,4 @@
-v1.15.1 - Steadier chat, media, and voice
+v1.13.2 - Clear session activity

-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.
-
-Highlights
-* Choose when follow-up messages are sent — 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.
-* Keep attachment previews open through rotation — Image, video, audio, PDF, text, and file previews stay open as the screen rotates. Videos retain their original proportions.
-* Keep large chats and media manageable — 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.
-
-Improved
-* Make better use of wider screens — Chat and Voice keep text and controls on readable centered layouts. Landscape Voice Focus separates identity controls from conversation activity.
-
-Fixed
-* Read message delivery status clearly — Correction and delivery labels use contrasting text instead of disappearing into the message bubble.
-* Read and dismiss voice errors — Voice errors open in a contained dialog with scrollable details and separate Retry and Dismiss actions, without overlapping chat controls.
-* Fix wake-word startup in release builds — Release optimization now preserves the native speech configuration names needed to initialize wake-word detection.
-* Download attachments with less memory — Standard Hermes attachments stream into the on-disk cache while download size limits remain enforced.
-* Keep image-generation progress visible — The working indicator stays visible between interim replies and the generated image, including gateways that omit tool activity events.
-* Wait for new chats to be ready — 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.
+* Keep session rows neutral while optional live activity is unavailable or loading.
+* Show full-row activity borders only during actual Starting or Working turns.
@@ -39,38 +39,14 @@ enum class AssistantSessionPhase {
    Closed,
 }

-enum class AssistantSessionNotice {
-    NoSpeech,
-}
-
 data class AssistantSessionSnapshot(
    val phase: AssistantSessionPhase = AssistantSessionPhase.Launching,
    val transcript: String? = null,
    val response: String = "",
-    val notice: AssistantSessionNotice? = null,
    val error: String? = null,
    val screenContextSupported: Boolean = false,
 )

-internal fun assistantSnapshotForPresentation(
-    snapshot: AssistantSessionSnapshot,
-    locked: Boolean,
-): AssistantSessionSnapshot = if (locked) {
-    snapshot.copy(
-        transcript = null,
-        response = "",
-        error = null,
-        screenContextSupported = false,
-    )
-} else {
-    snapshot
-}
-
-internal fun assistantSnapshotMatchesActivation(
-    expectedActivationId: String?,
-    receivedActivationId: String?,
-): Boolean = expectedActivationId != null && expectedActivationId == receivedActivationId
-
 object AssistantRole {
    fun status(context: Context): AssistantRoleStatus {
        val component = ComponentName(context, HermesVoiceInteractionService::class.java)
@@ -233,7 +209,6 @@ object AssistantSessionProtocol {
            onFailure = { failure ->
                publish(
                    application,
-                    activation.id,
                    AssistantSessionSnapshot(
                        phase = AssistantSessionPhase.Error,
                        error = failure.message ?: "Hermes voice could not start",
@@ -244,19 +219,13 @@ object AssistantSessionProtocol {
        return true
    }

-    fun publish(
-        context: Context,
-        activationId: String,
-        snapshot: AssistantSessionSnapshot,
-    ) {
+    fun publish(context: Context, snapshot: AssistantSessionSnapshot) {
        context.sendBroadcast(
            Intent(context, AssistantSessionStateReceiver::class.java).apply {
                action = ACTION_STATUS
-                putExtra(EXTRA_ACTIVATION_ID, activationId)
                putExtra(EXTRA_PHASE, snapshot.phase.name)
                putExtra(EXTRA_TRANSCRIPT, snapshot.transcript)
                putExtra(EXTRA_RESPONSE, snapshot.response)
-                putExtra(EXTRA_NOTICE, snapshot.notice?.name)
                putExtra(EXTRA_ERROR, snapshot.error)
                putExtra(EXTRA_SCREEN_CONTEXT_SUPPORTED, snapshot.screenContextSupported)
            }
@@ -269,6 +238,10 @@ object AssistantSessionProtocol {
        }
    }

+    fun publish(context: Context, state: VoiceUiState) {
+        publish(context, snapshotFromVoiceState(state))
+    }
+
    internal fun snapshotFromVoiceState(state: VoiceUiState): AssistantSessionSnapshot {
        val phase = when {
            !state.voiceMode -> AssistantSessionPhase.Closed
@@ -283,10 +256,7 @@ object AssistantSessionProtocol {
            phase = phase,
            transcript = state.transcribedText?.take(MAX_SESSION_TEXT_CHARS),
            response = state.responseText.take(MAX_SESSION_TEXT_CHARS),
-            notice = state.assistantNotice,
-            error = state.error
-                ?.takeIf { phase == AssistantSessionPhase.Error }
-                ?.take(MAX_SESSION_ERROR_CHARS),
+            error = state.error?.take(MAX_SESSION_ERROR_CHARS),
        )
    }

@@ -380,9 +350,6 @@ object AssistantSessionProtocol {
            phase = phase,
            transcript = intent.getStringExtra(EXTRA_TRANSCRIPT),
            response = intent.getStringExtra(EXTRA_RESPONSE).orEmpty(),
-            notice = intent.getStringExtra(EXTRA_NOTICE)?.let { raw ->
-                runCatching { AssistantSessionNotice.valueOf(raw) }.getOrNull()
-            },
            error = intent.getStringExtra(EXTRA_ERROR),
            screenContextSupported = intent.getBooleanExtra(
                EXTRA_SCREEN_CONTEXT_SUPPORTED,
@@ -393,33 +360,24 @@ object AssistantSessionProtocol {

    private const val MAX_SESSION_TEXT_CHARS = 4_000
    private const val MAX_SESSION_ERROR_CHARS = 1_000
-    private const val EXTRA_NOTICE = "notice"
 }

 object AssistantSessionState {
    private val _snapshot = MutableStateFlow(AssistantSessionSnapshot())
    val snapshot: StateFlow<AssistantSessionSnapshot> = _snapshot.asStateFlow()
-    @Volatile private var activationId: String? = null

-    internal fun update(receivedActivationId: String?, snapshot: AssistantSessionSnapshot) {
-        if (!assistantSnapshotMatchesActivation(activationId, receivedActivationId)) return
+    internal fun update(snapshot: AssistantSessionSnapshot) {
        _snapshot.value = snapshot
    }

-    internal fun reset(activationId: String) {
-        this.activationId = activationId
+    internal fun reset() {
        _snapshot.value = AssistantSessionSnapshot()
    }
 }

 class AssistantSessionStateReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
-        AssistantSessionState.update(
-            receivedActivationId = intent.getStringExtra(
-                AssistantSessionProtocol.EXTRA_ACTIVATION_ID
-            ),
-            snapshot = AssistantSessionProtocol.readSnapshot(intent),
-        )
+        AssistantSessionState.update(AssistantSessionProtocol.readSnapshot(intent))
    }
 }

@@ -465,7 +423,6 @@ class AssistantSessionLifecycleReceiver : BroadcastReceiver() {
                onFailure = { failure ->
                    AssistantSessionProtocol.publish(
                        application,
-                        id,
                        AssistantSessionSnapshot(
                            phase = AssistantSessionPhase.Error,
                            error = failure.message ?: "Hermes voice could not start",
@@ -473,7 +430,6 @@ class AssistantSessionLifecycleReceiver : BroadcastReceiver() {
                    )
                },
            )
-            application.runtime.republishAssistantSnapshot(id)
            return
        }
        if (AssistantSessionProtocol.isStartAction(intent.action)) {
@@ -3,11 +3,6 @@ package com.hermesandroid.relay.assistant
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.graphics.drawable.ColorDrawable
-import android.app.KeyguardManager
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
 import android.os.Bundle
 import android.service.voice.VoiceInteractionSession
 import android.service.voice.VoiceInteractionSessionService
@@ -72,7 +67,6 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
-import androidx.core.content.ContextCompat
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.LifecycleRegistry
@@ -114,11 +108,6 @@ internal fun shouldCancelVoiceWhenSessionUiEnds(
    presentation: AssistantSessionPresentation,
 ): Boolean = presentation == AssistantSessionPresentation.Overlay

-internal fun assistantPresentationLocked(
-    currentKeyguardLocked: Boolean?,
-    fallbackLocked: Boolean,
-): Boolean = currentKeyguardLocked ?: fallbackLocked
-
 private class HermesVoiceInteractionSession(
    private val service: HermesVoiceInteractionSessionService,
 ) : VoiceInteractionSession(service) {
@@ -129,19 +118,12 @@ private class HermesVoiceInteractionSession(
    private var surfaceExpanded by mutableStateOf(false)
    private var activationId: String? = null
    private var manualMic = false
-    private var keyguardLocked by mutableStateOf(false)
    private var expectScreenContext: Boolean? = null
    private var pendingSemantic = AssistantSemanticContext()
    private var pendingScreenshot: ByteArray? = null
    private var screenContextUi by mutableStateOf(AssistantScreenContextUi())
    private val contextStore = assistantContextStore(service)
    private var heartbeatJob: Job? = null
-    private var keyguardReceiverRegistered = false
-    private val keyguardReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
-            refreshKeyguardState()
-        }
-    }

    init {
        scope.launch {
@@ -157,17 +139,6 @@ private class HermesVoiceInteractionSession(

    override fun onCreate() {
        super.onCreate()
-        ContextCompat.registerReceiver(
-            service,
-            keyguardReceiver,
-            IntentFilter().apply {
-                addAction(Intent.ACTION_SCREEN_OFF)
-                addAction(Intent.ACTION_SCREEN_ON)
-                addAction(Intent.ACTION_USER_PRESENT)
-            },
-            ContextCompat.RECEIVER_NOT_EXPORTED,
-        )
-        keyguardReceiverRegistered = true
        window.window?.apply {
            setBackgroundDrawable(ColorDrawable(android.graphics.Color.TRANSPARENT))
            clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND)
@@ -184,7 +155,6 @@ private class HermesVoiceInteractionSession(
            PersistedHermesRelayTheme {
                AssistantSessionSurface(
                    expanded = surfaceExpanded,
-                    locked = keyguardLocked,
                    screenContext = screenContextUi,
                    onExpandedChange = { surfaceExpanded = it },
                    onCancel = { finishSession(cancelVoice = true) },
@@ -213,22 +183,11 @@ private class HermesVoiceInteractionSession(

    override fun onShow(args: Bundle?, showFlags: Int) {
        super.onShow(args, showFlags)
-        refreshKeyguardState(
-            fallbackLocked = args?.getBoolean(
-                HermesVoiceInteractionService.EXTRA_FROM_KEYGUARD,
-                false,
-            ) == true,
-        )
-        if (keyguardLocked) {
+        if (args?.getBoolean(HermesVoiceInteractionService.EXTRA_FROM_KEYGUARD, false) == true) {
            window.window?.addFlags(
                WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
                    WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
            )
-        } else {
-            window.window?.clearFlags(
-                WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-                    WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
-            )
        }
        setUiEnabled(true)
        val startsNewLifecycle = presentation == AssistantSessionPresentation.Inactive
@@ -236,10 +195,10 @@ private class HermesVoiceInteractionSession(
        if (!startsNewLifecycle) return

        surfaceExpanded = false
+        AssistantSessionState.reset()
        screenContextUi = AssistantScreenContextUi()
        activationId = args?.getString(AssistantSessionProtocol.EXTRA_ACTIVATION_ID)
            ?: UUID.randomUUID().toString()
-        AssistantSessionState.reset(activationId!!)
        manualMic = args?.getBoolean(AssistantSessionProtocol.EXTRA_MANUAL_MIC, false) ?: false
        expectScreenContext = args?.getBoolean(
            AssistantSessionProtocol.EXTRA_EXPECT_SCREEN_CONTEXT,
@@ -341,10 +300,6 @@ private class HermesVoiceInteractionSession(
        pendingSemantic = AssistantSemanticContext()
        pendingScreenshot = null
        screenContextUi = AssistantScreenContextUi()
-        if (keyguardReceiverRegistered) {
-            runCatching { service.unregisterReceiver(keyguardReceiver) }
-            keyguardReceiverRegistered = false
-        }
        viewOwner.stop()
        scope.cancel()
        super.onDestroy()
@@ -364,7 +319,6 @@ private class HermesVoiceInteractionSession(
            )
        }.onFailure {
            AssistantSessionState.update(
-                activationId,
                AssistantSessionSnapshot(
                    phase = AssistantSessionPhase.Error,
                    error = it.message ?: "Hermes could not open the voice session.",
@@ -383,7 +337,6 @@ private class HermesVoiceInteractionSession(
            setUiEnabled(false)
        }.onFailure {
            AssistantSessionState.update(
-                activationId,
                AssistantSessionSnapshot(
                    phase = AssistantSessionPhase.Error,
                    error = it.message ?: "Hermes could not open full voice.",
@@ -424,14 +377,6 @@ private class HermesVoiceInteractionSession(
        }
    }

-    private fun refreshKeyguardState(fallbackLocked: Boolean = keyguardLocked) {
-        keyguardLocked = assistantPresentationLocked(
-            currentKeyguardLocked = service.getSystemService(KeyguardManager::class.java)
-                ?.isKeyguardLocked,
-            fallbackLocked = fallbackLocked,
-        )
-    }
-
    @RequiresApi(android.os.Build.VERSION_CODES.Q)
    private fun stageAssistState(state: AssistState) {
        stageAssistData(state.assistStructure, state.assistContent)
@@ -518,7 +463,6 @@ private class AssistantSessionViewOwner :
@Composable
 private fun AssistantSessionSurface(
    expanded: Boolean,
-    locked: Boolean,
    screenContext: AssistantScreenContextUi,
    onExpandedChange: (Boolean) -> Unit,
    onCancel: () -> Unit,
@@ -527,8 +471,7 @@ private fun AssistantSessionSurface(
    onOpenFullVoice: () -> Unit,
    onSurfaceBoundsChanged: (android.graphics.Rect) -> Unit,
 ) {
-    val rawSnapshot by AssistantSessionState.snapshot.collectAsState()
-    val snapshot = assistantSnapshotForPresentation(rawSnapshot, locked)
+    val snapshot by AssistantSessionState.snapshot.collectAsState()
    val status = assistantStatus(snapshot.phase)
    val transmittedScreenContext = if (snapshot.screenContextSupported) {
        screenContext
@@ -707,13 +650,6 @@ private fun ExpandedAssistantSurface(
                color = MaterialTheme.colorScheme.onSurface,
            )
        }
-        snapshot.notice?.let { notice ->
-            Text(
-                text = assistantNoticeText(notice),
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                style = MaterialTheme.typography.bodyMedium,
-            )
-        }
        snapshot.error?.let { error ->
            Text(
                text = error,
@@ -960,11 +896,5 @@ private fun assistantStatus(phase: AssistantSessionPhase): String = when (phase)
 private fun compactAssistantText(snapshot: AssistantSessionSnapshot): String =
    snapshot.transcript?.takeIf { it.isNotBlank() }
        ?: snapshot.response.takeIf { it.isNotBlank() }
-        ?: snapshot.notice?.let { assistantNoticeText(it) }
        ?: snapshot.error?.takeIf { it.isNotBlank() }
        ?: assistantStatus(snapshot.phase)
-
-@Composable
-private fun assistantNoticeText(notice: AssistantSessionNotice): String = when (notice) {
-    AssistantSessionNotice.NoSpeech -> stringResource(R.string.voice_no_speech_try_again)
-}
@@ -11,7 +11,6 @@ import com.hermesandroid.relay.data.replaceHermesReachCredential
 import com.hermesandroid.relay.data.sameBrokerAuthority
 import com.hermesandroid.relay.data.PairingPreferences
 import com.hermesandroid.relay.data.Profile
-import com.hermesandroid.relay.data.SupervisedModePolicy
 import com.hermesandroid.relay.data.isSafeProfileUiMeta
 import com.hermesandroid.relay.network.relay.ChannelMultiplexer
 import com.hermesandroid.relay.network.relay.models.Envelope
@@ -19,8 +18,6 @@ import com.hermesandroid.relay.network.shared.InvalidCredentialException
 import com.hermesandroid.relay.network.shared.normalizeCredentialForHeader
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asSharedFlow
@@ -56,39 +53,6 @@ sealed class AuthState {
    data class Failed(val reason: String) : AuthState()
 }

-internal fun relaySupervisedModePayload(policy: SupervisedModePolicy): JsonObject {
-    if (!policy.isActive) return buildJsonObject { put("active", false) }
-    val capabilities = buildList {
-        add("text_chat")
-        if (policy.capabilities.newChat) add("new_chat")
-        if (policy.capabilities.cancelResponse) add("cancel")
-        if (policy.capabilities.steerResponse) add("steer")
-        if (policy.capabilities.attachments) add("attachments")
-        if (policy.capabilities.voice) add("voice")
-        if (policy.capabilities.generatedImages) add("generated_images")
-        if (policy.capabilities.shareGeneratedImages) add("share_images")
-        if (policy.capabilities.copyResponses) add("copy")
-        if (policy.capabilities.retryResponse) add("retry")
-        if (policy.capabilities.quoteReplies) add("quote_reply")
-        if (policy.visibility.resolved().showTimestamps) add("timestamps")
-    }.take(12)
-    return buildJsonObject {
-        put("active", true)
-        put("profile_label", policy.pinnedProfileName.orEmpty().take(80))
-        put("capabilities", JsonArray(capabilities.map(::JsonPrimitive)))
-    }
-}
-
-internal fun relaySupervisedModeUpdateEnvelope(
-    policy: SupervisedModePolicy,
-): Envelope = Envelope(
-    channel = "system",
-    type = "supervised.update",
-    payload = buildJsonObject {
-        put("supervised_mode", relaySupervisedModePayload(policy))
-    },
-)
-
@Serializable
 data class ConnectionAuthSecrets(
    val sessionToken: String? = null,
@@ -156,60 +120,6 @@ class AuthManager(
    private val eagerHydrate: Boolean = true,
 ) : ChannelMultiplexer.ChannelHandler {

-    @Volatile
-    private var supervisedMode: SupervisedModePolicy = SupervisedModePolicy()
-
-    @Volatile
-    private var supervisedMetadataReconnectFallback: (() -> Unit)? = null
-    private var pendingSupervisedUpdateId: String? = null
-    private var supervisedUpdateFallbackJob: Job? = null
-
-    /**
-     * Update the public client-mode tag sent on Relay auth. This does not grant
-     * authority: Relay labels enforcement_owner=android_client and the Android
-     * policy remains the enforcing surface.
-     */
-    fun updateSupervisedMode(policy: SupervisedModePolicy) {
-        if (supervisedMode == policy) return
-        supervisedMode = policy
-        if (_authState.value is AuthState.Paired) sendSupervisedModeUpdate()
-    }
-
-    /**
-     * Install the narrow compatibility path used when an older Relay ignores
-     * `system/supervised.update`. Reopening the authenticated socket causes
-     * the current policy to travel through the legacy `system/auth` payload.
-     */
-    fun setSupervisedMetadataReconnectFallback(callback: () -> Unit) {
-        supervisedMetadataReconnectFallback = callback
-    }
-
-    private fun sendSupervisedModeUpdate() {
-        val envelope = relaySupervisedModeUpdateEnvelope(supervisedMode)
-        pendingSupervisedUpdateId = envelope.id
-        supervisedUpdateFallbackJob?.cancel()
-        multiplexer.send(envelope)
-        supervisedUpdateFallbackJob = scope.launch {
-            delay(SUPERVISED_UPDATE_ACK_TIMEOUT_MS)
-            if (pendingSupervisedUpdateId == envelope.id) {
-                pendingSupervisedUpdateId = null
-                Log.i(TAG, "supervised.update unsupported or unacknowledged; refreshing Relay socket")
-                supervisedMetadataReconnectFallback?.invoke()
-            }
-        }
-    }
-
-    private fun settleSupervisedModeUpdate(envelope: Envelope, unsupported: Boolean) {
-        if (envelope.id != pendingSupervisedUpdateId) return
-        pendingSupervisedUpdateId = null
-        supervisedUpdateFallbackJob?.cancel()
-        supervisedUpdateFallbackJob = null
-        if (unsupported) {
-            Log.i(TAG, "supervised.update rejected; refreshing Relay socket for compatibility")
-            supervisedMetadataReconnectFallback?.invoke()
-        }
-    }
-
    companion object {
        private const val TAG = "AuthManager"
        private const val KEY_SESSION_TOKEN = "session_token"
@@ -224,7 +134,6 @@ class AuthManager(
        // migration has run, so we never rebuild the legacy keyset to re-check.
        private const val KEY_LEGACY_MIGRATED = "legacy_migrated"
        private const val PAIRING_CODE_LENGTH = 6
-        private const val SUPERVISED_UPDATE_ACK_TIMEOUT_MS = 2_000L
        private val PAIRING_CODE_CHARS = ('A'..'Z') + ('0'..'9')

        /**
@@ -926,10 +835,6 @@ class AuthManager(
        put("device_form_factor", "phone")
    }

-    private fun JsonObjectBuilder.putSupervisedMode() {
-        put("supervised_mode", relaySupervisedModePayload(supervisedMode))
-    }
-
    private fun relayDeviceName(): String {
        val configured = runCatching {
            Settings.Global.getString(context.contentResolver, "device_name")
@@ -985,7 +890,6 @@ class AuthManager(
                        put("device_id", deviceId)
                        putRelayDeviceIdentity()
                        putRelayClientSupports()
-                        putSupervisedMode()
                    }
                }
                else -> {
@@ -994,7 +898,7 @@ class AuthManager(
                    val serverSource = if (serverIssuedCode != null) "QR" else "local-fallback"
                    Log.i(
                        TAG,
-                        "authenticate: sending pairing credential source=$serverSource " +
+                        "authenticate: sending pairing_code=$codeToSend source=$serverSource " +
                            "ttl=$pendingTtlSeconds grants=${pendingGrants?.keys}"
                    )
                    buildJsonObject {
@@ -1002,7 +906,6 @@ class AuthManager(
                        put("device_id", deviceId)
                        putRelayDeviceIdentity()
                        putRelayClientSupports()
-                        putSupervisedMode()
                        pendingTtlSeconds?.let { put("ttl_seconds", it) }
                        pendingGrants?.let { grants ->
                            val obj = buildJsonObject {
@@ -1063,8 +966,7 @@ class AuthManager(
        _currentPairedSession.value = null
        Log.i(
            TAG,
-            "applyServerIssuedCodeAndReset: credential=present " +
-                "relayConfigured=${!relayUrl.isNullOrBlank()} " +
+            "applyServerIssuedCodeAndReset: code=$normalized relayUrl=$relayUrl " +
                "prevState=${prevState::class.simpleName} → Unpaired"
        )
        scope.launch {
@@ -1083,8 +985,6 @@ class AuthManager(
        when (envelope.type) {
            "auth.ok" -> handleAuthOk(envelope)
            "auth.fail" -> handleAuthFail(envelope)
-            "supervised.updated" -> settleSupervisedModeUpdate(envelope, unsupported = false)
-            "error" -> settleSupervisedModeUpdate(envelope, unsupported = true)
            // `profiles.updated` push — sent by the v0.7.1+ relay on
            // the "pairing" channel whenever its in-memory profile
            // snapshot changes (file-watcher, SIGHUP, or a manual
@@ -1229,11 +1129,6 @@ class AuthManager(
        get() = _authState.value is AuthState.Paired

    private fun handleAuthOk(envelope: Envelope) {
-        // A successful auth always carries the latest client report, including
-        // after the compatibility reconnect used for older Relay versions.
-        pendingSupervisedUpdateId = null
-        supervisedUpdateFallbackJob?.cancel()
-        supervisedUpdateFallbackJob = null
        scope.launch {
            try {
                val payload = envelope.payload
@@ -10,16 +10,6 @@ package com.hermesandroid.relay.data
 */
 object AgentDisplay {
    const val SERVER_DEFAULT_PROFILE_KEY: String = "__server_default__"
-    private const val PROFILE_CONTEXT_SEPARATOR = "::"
-
-    data class ProfileContextIdentity(
-        val connectionId: String,
-        val profileKey: String,
-    ) {
-        /** Null means the upstream request must inherit Server Default. */
-        val requestProfileName: String?
-            get() = profileRequestName(profileKey)
-    }
    private val GENERIC_MODEL_ALIASES = setOf(
        "hermes-agent",
        "hermes_agent",
@@ -173,25 +163,7 @@ object AgentDisplay {
        profileRequestName(profileName) ?: SERVER_DEFAULT_PROFILE_KEY

    fun profileContextKey(connectionId: String?, profileName: String?): String =
-        "${connectionId.orEmpty()}$PROFILE_CONTEXT_SEPARATOR${profileSessionKey(profileName)}"
-
-    /**
-     * Parse the canonical profile/context identity used by persisted chat state.
-     *
-     * Legacy or malformed opaque keys deliberately return null: recovery may
-     * still use the exact key for ownership, but must not invent an upstream
-     * profile override from it. The first separator is authoritative so legal
-     * profile names containing `::` remain round-trippable.
-     */
-    fun parseProfileContextKey(contextKey: String?): ProfileContextIdentity? {
-        val raw = contextKey?.trim().orEmpty()
-        val separator = raw.indexOf(PROFILE_CONTEXT_SEPARATOR)
-        if (separator <= 0 || separator + PROFILE_CONTEXT_SEPARATOR.length >= raw.length) return null
-        val connectionId = raw.substring(0, separator).trim()
-        val profileKey = raw.substring(separator + PROFILE_CONTEXT_SEPARATOR.length).trim()
-        if (connectionId.isEmpty() || profileKey.isEmpty()) return null
-        return ProfileContextIdentity(connectionId, profileKey)
-    }
+        "${connectionId.orEmpty()}::${profileSessionKey(profileName)}"

    fun localDisplayAlias(value: String?): String? =
        value
@@ -1,102 +0,0 @@
-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)?\)\.""",
-)
@@ -1,222 +0,0 @@
-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
-    },
-)
@@ -22,26 +22,6 @@ 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>,
@@ -49,13 +29,10 @@ 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 =
            booleanPreferencesKey("convert_large_pastes_to_attachments")
-        internal val KEY_SHOW_GIT_WORKSPACE_IN_CHAT =
-            booleanPreferencesKey("show_git_workspace_in_chat")
    }

    val physicalKeyboardEnterBehavior: Flow<PhysicalKeyboardEnterBehavior> = dataStore.data
@@ -66,22 +43,10 @@ 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()

-    val showGitWorkspaceInChat: Flow<Boolean> = dataStore.data
-        .map { preferences -> preferences[KEY_SHOW_GIT_WORKSPACE_IN_CHAT] ?: true }
-        .distinctUntilChanged()
-
    suspend fun setPhysicalKeyboardEnterBehavior(behavior: PhysicalKeyboardEnterBehavior) {
        dataStore.edit { preferences ->
            preferences[KEY_PHYSICAL_KEYBOARD_ENTER] = behavior.storedValue
@@ -93,10 +58,4 @@ class ChatInputPreferencesRepository(
            preferences[KEY_CONVERT_LARGE_PASTES] = enabled
        }
    }
-
-    suspend fun setShowGitWorkspaceInChat(enabled: Boolean) {
-        dataStore.edit { preferences ->
-            preferences[KEY_SHOW_GIT_WORKSPACE_IN_CHAT] = enabled
-        }
-    }
 }
@@ -10,16 +10,6 @@ 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).
@@ -170,12 +160,6 @@ 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(
@@ -23,8 +23,6 @@ import kotlinx.serialization.json.Json
 data class ChatTurnCheckpoint(
    val schemaVersion: Int = CURRENT_SCHEMA,
    val contextKey: String,
-    /** Explicit persisted profile identity; null only for legacy checkpoints. */
-    val profileKey: String? = null,
    val sessionId: String,
    val liveSessionId: String? = null,
    val transport: String,
@@ -35,9 +33,6 @@ 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,
 ) {
@@ -29,24 +29,3 @@ 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)
@@ -1,8 +1,6 @@
 package com.hermesandroid.relay.data

 import kotlinx.serialization.Serializable
-import java.net.Inet6Address
-import java.net.InetAddress
 import java.net.URI

@Serializable
@@ -67,14 +65,6 @@ data class Connection(
     * "derive from [apiServerUrl] using the conventional same-host :9119".
     */
    val dashboardUrl: String? = null,
-    /**
-     * Credential-free origin that most recently completed Dashboard
-     * authentication for this connection. Public origins require HTTPS;
-     * loopback/private-overlay HTTP retains upstream's trusted-network mode.
-     * Dashboard/Gateway consumers prefer this origin, while [routeCandidates]
-     * continue to own only network route selection for API and Relay.
-     */
-    val authenticatedDashboardOrigin: String? = null,
    val dashboardAuthRequired: Boolean? = null,
    val dashboardAuthProviders: List<String> = emptyList(),
    val dashboardLastStatus: DashboardConnectionStatus? = null,
@@ -87,11 +77,6 @@ data class Connection(
    val routeCandidates: List<EndpointCandidate> = emptyList(),
    /** Optional user preference such as "lan" or "tailscale"; null means Auto. */
    val preferredRouteRole: String? = null,
-    /**
-     * Explicit per-installation consent for Relay Git repository discovery.
-     * Missing legacy values remain off; route/profile changes do not broaden it.
-     */
-    val gitRepoScanningEnabled: Boolean = false,
    /** Epoch milliseconds. Pass `System.currentTimeMillis()`; do not pass seconds. */
    val pairedAt: Long? = null,
    /** Last time the user explicitly selected this connection. */
@@ -101,27 +86,21 @@ data class Connection(
    /** Epoch milliseconds. The auth.ok `expires_at` field is seconds — multiply by 1000 at the call site. */
    val expiresAt: Long? = null,
 ) {
-    /** Saved Dashboard/Gateway route before any authenticated-origin override. */
-    val configuredDashboardUrl: String
+    /**
+     * Effective Dashboard/Gateway endpoint. Legacy records did not persist a
+     * dashboard URL, so they retain the conventional same-host `:9119`
+     * derivation from the API server. Dashboard-only records persist an
+     * explicit URL and may leave [apiServerUrl] and [relayUrl] blank.
+     */
+    val resolvedDashboardUrl: String
        get() = dashboardUrl
            ?.trim()
            ?.takeIf { it.isNotBlank() }
            ?: deriveDefaultDashboardUrl(apiServerUrl).orEmpty()

-    /**
-     * Effective Dashboard/Gateway endpoint. A verified authenticated origin
-     * wins without rewriting the saved network route. Legacy records retain
-     * the conventional same-host `:9119` derivation through
-     * [configuredDashboardUrl].
-     */
-    val resolvedDashboardUrl: String
-        get() = authenticatedDashboardOrigin
-            ?.let(::normalizeCredentialFreeAuthenticatedDashboardOrigin)
-            ?: configuredDashboardUrl
-
    /** Stable display/host identity that does not depend on the API surface. */
    val primaryEndpointUrl: String
-        get() = configuredDashboardUrl.takeIf { it.isNotBlank() }
+        get() = resolvedDashboardUrl.takeIf { it.isNotBlank() }
            ?: apiServerUrl.trim().takeIf { it.isNotBlank() }
            ?: relayUrl.trim()

@@ -527,12 +506,6 @@ data class Connection(
            )
        }

-        /**
-         * Normalize a hand-typed Dashboard/Gateway address. Bare private,
-         * LAN, and Tailscale hosts use upstream's `http://…:9119` default;
-         * bare public hosts use `https://` on the standard HTTPS port.
-         * Explicit schemes and ports are preserved for precise validation.
-         */
        fun normalizeDashboardUrlInput(
            raw: String,
            defaultPort: Int = DEFAULT_DASHBOARD_PORT,
@@ -540,10 +513,7 @@ data class Connection(
            val trimmed = raw.trim().trimEnd('/')
            if (trimmed.isEmpty()) return trimmed
            if (SCHEME_REGEX.containsMatchIn(trimmed)) return trimmed
-            val provisionalHttpUrl = "http://$trimmed"
-            val publicAddress = inferRouteRole(provisionalHttpUrl) == "public"
-            val withScheme = if (publicAddress) "https://$trimmed" else provisionalHttpUrl
-            if (publicAddress) return withScheme
+            val withScheme = "http://$trimmed"
            val uri = runCatching { URI(withScheme) }.getOrNull()
            val canAppendPort = uri != null &&
                !uri.host.isNullOrBlank() &&
@@ -558,41 +528,16 @@ data class Connection(
                .getOrNull()
                ?.lowercase()
                ?: return "custom"
-            val normalizedHost = host.removePrefix("[").removeSuffix("]")
-            if (normalizedHost.contains(':')) {
-                val address = runCatching { InetAddress.getByName(normalizedHost) }
-                    .getOrNull() as? Inet6Address
-                    ?: return "public"
-                return when {
-                    isTailscaleIpv6(address) -> "tailscale"
-                    address.isAnyLocalAddress ||
-                        address.isLoopbackAddress ||
-                        address.isLinkLocalAddress ||
-                        isUniqueLocalIpv6(address) -> "lan"
-                    else -> "public"
-                }
-            }
            return when {
-                normalizedHost.endsWith(".ts.net") || isTailscaleIpv4(normalizedHost) -> "tailscale"
-                normalizedHost == "localhost" ||
-                    normalizedHost == "127.0.0.1" ||
-                    normalizedHost.endsWith(".local") ||
-                    normalizedHost.endsWith(".lan") ||
-                    !normalizedHost.contains('.') ||
-                    isPrivateLanIpv4(normalizedHost) -> "lan"
+                host.endsWith(".ts.net") || isTailscaleIpv4(host) -> "tailscale"
+                host == "localhost" ||
+                    host == "127.0.0.1" ||
+                    host == "::1" ||
+                    isPrivateLanIpv4(host) -> "lan"
                else -> "public"
            }
        }

-        private fun isTailscaleIpv6(address: Inet6Address): Boolean {
-            val bytes = address.address
-            val prefix = intArrayOf(0xfd, 0x7a, 0x11, 0x5c, 0xa1, 0xe0)
-            return prefix.indices.all { index -> bytes[index].toInt() and 0xff == prefix[index] }
-        }
-
-        private fun isUniqueLocalIpv6(address: Inet6Address): Boolean =
-            address.address.first().toInt() and 0xfe == 0xfc
-
        private fun isTailscaleIpv4(host: String): Boolean {
            val parts = host.split('.').mapNotNull { it.toIntOrNull() }
            if (parts.size != 4) return false
@@ -612,45 +557,3 @@ data class Connection(
        }
    }
 }
-
-/** Normalize an absolute, credential-free HTTPS origin for authenticated Dashboard use. */
-internal fun normalizeCredentialFreeHttpsOrigin(raw: String): String? {
-    val parsed = runCatching { URI(raw.trim()) }.getOrNull() ?: return null
-    if (!parsed.scheme.equals("https", ignoreCase = true)) return null
-    if (parsed.host.isNullOrBlank() || parsed.userInfo != null) return null
-    if (parsed.query != null || parsed.fragment != null) return null
-    if (parsed.port > 65_535) return null
-    return parsed.normalize().toASCIIString().trimEnd('/').takeIf { it.isNotBlank() }
-}
-
-/**
- * Normalize a reviewed Dashboard credential owner. Public origins require
- * HTTPS; cleartext is accepted only for literal loopback, RFC1918/link-local,
- * or Tailscale CGNAT addresses.
- */
-internal fun normalizeCredentialFreeAuthenticatedDashboardOrigin(raw: String): String? {
-    normalizeCredentialFreeHttpsOrigin(raw)?.let { return it }
-    val parsed = runCatching { URI(raw.trim()) }.getOrNull() ?: return null
-    if (!parsed.scheme.equals("http", ignoreCase = true)) return null
-    val host = parsed.host
-        ?.lowercase()
-        ?.removePrefix("[")
-        ?.removeSuffix("]")
-        ?.takeIf { it.isNotBlank() }
-        ?: return null
-    if (parsed.userInfo != null || parsed.query != null || parsed.fragment != null) return null
-    if (parsed.port > 65_535) return null
-    val trustedHost = host == "localhost" || host == "127.0.0.1" || host == "::1" ||
-        host.split('.').mapNotNull(String::toIntOrNull).let { octets ->
-            octets.size == 4 && octets.all { it in 0..255 } && when {
-                octets[0] == 10 -> true
-                octets[0] == 172 && octets[1] in 16..31 -> true
-                octets[0] == 192 && octets[1] == 168 -> true
-                octets[0] == 169 && octets[1] == 254 -> true
-                octets[0] == 100 && octets[1] in 64..127 -> true
-                else -> false
-            }
-        }
-    if (!trustedHost) return null
-    return parsed.normalize().toASCIIString().trimEnd('/').takeIf { it.isNotBlank() }
-}
@@ -18,9 +18,6 @@ package com.hermesandroid.relay.data
 */
 enum class SurfaceSecurityKind { Tls, Overlay, Plain }

-/** Whether a configured surface currently contributes traffic to the connection. */
-enum class SurfaceUseState { InUse, Available, Unavailable }
-
 /** Connection-level rollup across the surfaces actually in use. */
 enum class ConnectionSecurityLevel { Tls, Overlay, Mixed, Plain, Unknown }

@@ -31,7 +28,6 @@ data class SurfaceSecurity(
    /** Human mechanism: "TLS", "Tailscale", "WireGuard", "Proxy", "Plain". */
    val mechanism: String,
    val url: String,
-    val useState: SurfaceUseState = SurfaceUseState.InUse,
 )

 data class ConnectionSecurity(
@@ -90,7 +86,6 @@ fun classifySurfaceSecurity(
    url: String,
    activeEndpoint: EndpointCandidate?,
    isTailscaleDetected: Boolean,
-    useState: SurfaceUseState = SurfaceUseState.InUse,
 ): SurfaceSecurity {
    val secureLinkProtected = activeEndpoint.secureLinkProtects(label, url)
    val (kind, mechanism) = when {
@@ -101,13 +96,7 @@ fun classifySurfaceSecurity(
            SurfaceSecurityKind.Overlay to activeEndpoint.overlayMechanism(isTailscaleDetected)
        else -> SurfaceSecurityKind.Plain to "Plain"
    }
-    return SurfaceSecurity(
-        label = label,
-        kind = kind,
-        mechanism = mechanism,
-        url = url,
-        useState = useState,
-    )
+    return SurfaceSecurity(label = label, kind = kind, mechanism = mechanism, url = url)
 }

 private fun EndpointCandidate?.secureLinkProtects(label: String, url: String): Boolean {
@@ -123,8 +112,8 @@ private fun EndpointCandidate?.secureLinkProtects(label: String, url: String): B
        } ?: return false
    val normalized = url.trim().trimEnd('/')
    val service = when (label) {
-        "Chat & Manage", "Dashboard & Gateway" -> "dashboard"
-        "API / sessions", "API fallback", "Direct API" -> "api"
+        "Chat & Manage" -> "dashboard"
+        "API / sessions" -> "api"
        "Relay tools" -> "relay"
        else -> return false
    }
@@ -148,67 +137,23 @@ fun computeConnectionSecurity(
    relayConfigured: Boolean,
    activeEndpoint: EndpointCandidate?,
    isTailscaleDetected: Boolean,
-    dashboardInUse: Boolean = true,
-    apiInUse: Boolean = true,
-    apiAvailable: Boolean = apiInUse,
-    relayInUse: Boolean = relayConfigured,
-    apiEndpoint: EndpointCandidate? = activeEndpoint,
-    relayEndpoint: EndpointCandidate? = activeEndpoint,
 ): ConnectionSecurity {
    val surfaces = buildList {
        dashboardUrl.trim().takeIf { it.isNotBlank() }?.let {
-            add(
-                classifySurfaceSecurity(
-                    label = "Dashboard & Gateway",
-                    url = it,
-                    activeEndpoint = activeEndpoint,
-                    isTailscaleDetected = isTailscaleDetected,
-                    useState = if (dashboardInUse) SurfaceUseState.InUse else SurfaceUseState.Unavailable,
-                )
-            )
+            add(classifySurfaceSecurity("Chat & Manage", it, activeEndpoint, isTailscaleDetected))
        }
        apiUrl.trim().takeIf { it.isNotBlank() }?.let {
-            add(
-                classifySurfaceSecurity(
-                    label = "Direct API",
-                    url = it,
-                    activeEndpoint = apiEndpoint,
-                    isTailscaleDetected = isTailscaleDetected,
-                    useState = when {
-                        apiInUse -> SurfaceUseState.InUse
-                        apiAvailable -> SurfaceUseState.Available
-                        else -> SurfaceUseState.Unavailable
-                    },
-                )
-            )
+            add(classifySurfaceSecurity("API / sessions", it, activeEndpoint, isTailscaleDetected))
        }
        if (relayConfigured) {
            relayUrl.trim().takeIf { it.isNotBlank() }?.let {
-                add(
-                    classifySurfaceSecurity(
-                        label = "Relay tools",
-                        url = it,
-                        activeEndpoint = relayEndpoint,
-                        isTailscaleDetected = isTailscaleDetected,
-                        useState = if (relayInUse) SurfaceUseState.InUse else SurfaceUseState.Unavailable,
-                    )
-                )
+                add(classifySurfaceSecurity("Relay tools", it, activeEndpoint, isTailscaleDetected))
            }
        }
    }
    if (surfaces.isEmpty()) return ConnectionSecurity.UNKNOWN

-    // Configured-but-unavailable fallbacks remain visible in the breakdown,
-    // but do not make the active transport look insecure.
-    val activeSurfaces = surfaces.filter { it.useState == SurfaceUseState.InUse }
-    if (activeSurfaces.isEmpty()) {
-        return ConnectionSecurity(
-            level = ConnectionSecurityLevel.Unknown,
-            mechanism = "",
-            surfaces = surfaces,
-        )
-    }
-    val kinds = activeSurfaces.map { it.kind }.toSet()
+    val kinds = surfaces.map { it.kind }.toSet()
    val hasPlain = SurfaceSecurityKind.Plain in kinds
    val hasSecure = kinds.any { it != SurfaceSecurityKind.Plain }

@@ -222,7 +167,7 @@ fun computeConnectionSecurity(
    val mechanism = when (level) {
        ConnectionSecurityLevel.Tls -> "TLS"
        ConnectionSecurityLevel.Overlay ->
-            activeSurfaces.firstOrNull { it.kind == SurfaceSecurityKind.Overlay }?.mechanism ?: "Encrypted"
+            surfaces.firstOrNull { it.kind == SurfaceSecurityKind.Overlay }?.mechanism ?: "Encrypted"
        ConnectionSecurityLevel.Mixed -> "Mixed"
        ConnectionSecurityLevel.Plain -> when (activeEndpoint?.role?.lowercase()) {
            "lan" -> "LAN"
@@ -149,15 +149,15 @@ class ConnectionStore private constructor(
                // between the two names — `{"id": ..., "label": ..., ...}` —
                // so no per-record migration is needed.
                if (newJson == null && oldJson != null) {
-                    val restored = decodeConnections(oldJson)
                    dataStore.edit { p ->
-                        p[KEY_CONNECTIONS] = encodeConnections(restored)
+                        p[KEY_CONNECTIONS] = oldJson
                        p.remove(KEY_LEGACY_PROFILES)
                        if (activeNew == null && activeOld != null) {
                            p[KEY_ACTIVE_CONNECTION_ID] = activeOld
                            p.remove(KEY_LEGACY_ACTIVE_PROFILE_ID)
                        }
                    }
+                    val restored = decodeConnections(oldJson)
                    val validStartupId = startupId?.takeIf { id -> restored.any { it.id == id } }
                    _connections.value = restored
                    _startupConnectionId.value = validStartupId
@@ -168,12 +168,6 @@ class ConnectionStore private constructor(
                    )
                } else {
                    val restored = decodeConnections(newJson)
-                    if (newJson != null) {
-                        val normalizedJson = encodeConnections(restored)
-                        if (normalizedJson != newJson) {
-                            dataStore.edit { p -> p[KEY_CONNECTIONS] = normalizedJson }
-                        }
-                    }
                    val validStartupId = startupId?.takeIf { id -> restored.any { it.id == id } }
                    _connections.value = restored
                    _startupConnectionId.value = validStartupId
@@ -577,17 +571,7 @@ class ConnectionStore private constructor(
 internal fun Connection.withDashboardDefaults(): Connection {
    val derivedDashboardUrl = Connection.deriveDefaultDashboardUrl(apiServerUrl)
    val effectiveDashboardUrl = dashboardUrl?.takeIf { it.isNotBlank() } ?: derivedDashboardUrl
-    val legacyAuthenticatedRoute = routeCandidates.firstOrNull {
-        it.role.equals(LEGACY_AUTHENTICATED_DASHBOARD_ROUTE_ROLE, ignoreCase = true)
-    }
-    val migratedAuthenticatedOrigin = authenticatedDashboardOrigin
-        ?.let(::normalizeCredentialFreeAuthenticatedDashboardOrigin)
-        ?: legacyAuthenticatedRoute?.dashboard?.url
-            ?.let(::normalizeCredentialFreeAuthenticatedDashboardOrigin)
-    val routesWithoutLegacyAuthentication = routeCandidates.filterNot {
-        it.role.equals(LEGACY_AUTHENTICATED_DASHBOARD_ROUTE_ROLE, ignoreCase = true)
-    }
-    val storedOrDefaultRoutes = routesWithoutLegacyAuthentication.ifEmpty {
+    val storedOrDefaultRoutes = routeCandidates.ifEmpty {
        Connection.buildRouteCandidates(
            apiServerUrl = apiServerUrl,
            relayUrl = relayUrl,
@@ -598,18 +582,16 @@ internal fun Connection.withDashboardDefaults(): Connection {
        dashboardUrl = effectiveDashboardUrl,
        candidates = storedOrDefaultRoutes,
    )
-    val normalizedPreferredRouteRole = preferredRouteRole
-        ?.takeUnless { it.equals(LEGACY_AUTHENTICATED_DASHBOARD_ROUTE_ROLE, ignoreCase = true) }
-        ?.takeIf { preferred -> normalizedRoutes.any { it.role.equals(preferred, ignoreCase = true) } }
+    val normalizedPreferredRouteRole = preferredRouteRole?.takeIf { preferred ->
+        normalizedRoutes.any { it.role.equals(preferred, ignoreCase = true) }
+    }
    return if (
        dashboardUrl != effectiveDashboardUrl ||
-        authenticatedDashboardOrigin != migratedAuthenticatedOrigin ||
        normalizedRoutes != routeCandidates ||
        normalizedPreferredRouteRole != preferredRouteRole
    ) {
        copy(
            dashboardUrl = effectiveDashboardUrl,
-            authenticatedDashboardOrigin = migratedAuthenticatedOrigin,
            routeCandidates = normalizedRoutes,
            preferredRouteRole = normalizedPreferredRouteRole,
        )
@@ -617,5 +599,3 @@ internal fun Connection.withDashboardDefaults(): Connection {
        this
    }
 }
-
-internal const val LEGACY_AUTHENTICATED_DASHBOARD_ROUTE_ROLE = "authenticated_dashboard"
@@ -25,7 +25,7 @@ import java.net.URI
 *
 * **Semantics (locked by ADR 24):**
 *  - [role] is an open string. Known values `lan` / `tailscale` / `public`
- *    get styled labels; anything else renders generically (`Custom route (<role>)`).
+ *    get styled labels; anything else renders generically (`Custom VPN (<role>)`).
 *    No enum, no normalization — the raw role string must round-trip exactly
 *    so HMAC canonicalization holds.
 *  - [priority] is strict, `0 = highest`. Reachability never promotes a lower
@@ -145,19 +145,18 @@ data class BrokerEndpoint(
 *
 * Unknown roles (`"wireguard"`, `"zerotier"`, `"netbird-eu"`, operator-defined
 * labels) return false so the UI can fall back to [displayLabel]'s generic
- * "Custom route" treatment.
+ * "Custom VPN" treatment.
 */
 fun EndpointCandidate.isKnownRole(): Boolean {
    return when (role.lowercase()) {
-        "lan", "tailscale", "public", "plugin_proxy", "plugin-proxy", "outbound_broker", "https",
-        "dashboard", "authenticated_dashboard" -> true
+        "lan", "tailscale", "public", "plugin_proxy", "plugin-proxy", "outbound_broker", "https" -> true
        else -> false
    }
 }

 /**
 * Human-readable label for the UI. Known roles get fixed-case styled labels;
- * unknown roles render as `"Custom route (<role>)"` with the raw role preserved
+ * unknown roles render as `"Custom VPN (<role>)"` with the raw role preserved
 * so an operator can see exactly what they labeled it.
 *
 * The raw [role] on the [EndpointCandidate] is NOT modified — it stays in its
@@ -173,27 +172,12 @@ fun EndpointCandidate.displayLabel(): String {
            "Public"
        }
        "https" -> "HTTPS"
-        "dashboard", "authenticated_dashboard" -> if (
-            primaryRouteUrl()?.startsWith("https://", ignoreCase = true) == true
-        ) {
-            "HTTPS Dashboard"
-        } else {
-            "Dashboard"
-        }
        "plugin_proxy", "plugin-proxy" -> "Hermes Secure Link"
        "outbound_broker", "broker", "relay_broker" -> "Hermes Reach · Experimental"
-        else -> displayName?.trim()?.takeIf { it.isNotBlank() } ?: "Custom route ($role)"
+        else -> "Custom VPN ($role)"
    }
 }

-/**
- * True for a route created only to keep Dashboard/Gateway authentication on
- * its canonical origin. It is a service address, not another selectable
- * whole-connection or VPN route.
- */
-fun EndpointCandidate.isDashboardOnlyRoute(): Boolean =
-    api == null && relay == null && proxy == null && broker == null && dashboard != null
-
 /** Dashboard-first URL identity for routing, diagnostics, and UI labels. */
 fun EndpointCandidate.primaryRouteUrl(): String? =
    dashboard?.url?.trim()?.trimEnd('/')?.takeIf { it.isNotBlank() }
@@ -201,11 +185,6 @@ fun EndpointCandidate.primaryRouteUrl(): String? =
        ?: relay?.url?.trim()?.trimEnd('/')?.takeIf { it.isNotBlank() }
        ?: proxy?.url?.trim()?.trimEnd('/')?.takeIf { it.isNotBlank() }

-/** Dashboard/Gateway identity only; Relay and broker transports are extensions. */
-fun EndpointCandidate.gatewayRouteUrl(): String? =
-    dashboard?.url?.trim()?.trimEnd('/')?.takeIf { it.isNotBlank() }
-        ?: api?.url?.let(Connection::deriveDefaultDashboardUrl)
-
 /** Stable host/port identity without assuming that an API surface exists. */
 fun EndpointCandidate.routeAuthority(): String? {
    val rawUrl = primaryRouteUrl() ?: return null
@@ -1,410 +0,0 @@
-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
-import kotlinx.serialization.json.buildJsonObject
-import kotlinx.serialization.json.decodeFromJsonElement
-import kotlinx.serialization.json.put
-
-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(
-    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(
-        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())
-        }
-
-        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())
-        }
-
-        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,
-        )
-
-        // 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)
-    }
-
-    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> =
-        relayWrite(repo) { relay -> scoped.post("git/stage", buildJsonObject {
-            put("repo", relay)
-            put("paths", pathsArray(paths))
-        }).decodeMutation() }
-
-    suspend fun unstage(repo: String, paths: List<String>): Result<GitMutationResult> =
-        relayWrite(repo) { relay -> scoped.post("git/unstage", buildJsonObject {
-            put("repo", relay)
-            put("paths", pathsArray(paths))
-        }).decodeMutation() }
-
-    suspend fun discard(
-        repo: String,
-        paths: List<String>,
-        confirmation: String,
-        deleteUntracked: Boolean = false,
-    ): Result<GitMutationResult> = relayWrite(repo) { relay -> scoped.post("git/discard", buildJsonObject {
-        put("repo", relay)
-        put("paths", pathsArray(paths))
-        put("confirmation", confirmation)
-        put("delete_untracked", deleteUntracked)
-    }).decodeMutation() }
-
-    suspend fun commit(repo: String, message: String): Result<GitMutationResult> =
-        relayWrite(repo) { relay -> scoped.post("git/commit", buildJsonObject {
-            put("repo", relay)
-            put("message", message)
-        }).decodeMutation() }
-
-    suspend fun commitSelected(
-        repo: String,
-        message: String,
-        paths: List<String>,
-    ): Result<GitMutationResult> = relayWrite(repo) { relay -> scoped.post("git/commit_selected", buildJsonObject {
-        put("repo", relay)
-        put("message", message)
-        put("paths", pathsArray(paths))
-    }).decodeMutation() }
-
-    suspend fun fetch(repo: String, remote: String = "origin"): Result<GitMutationResult> =
-        relayWrite(repo) { relay -> scoped.post("git/fetch", buildJsonObject {
-            put("repo", relay)
-            put("remote", remote)
-        }).decodeMutation() }
-
-    suspend fun pull(repo: String, remote: String = "origin", branch: String = ""): Result<GitMutationResult> =
-        relayWrite(repo) { relay -> scoped.post("git/pull", buildJsonObject {
-            put("repo", relay)
-            put("remote", remote)
-            put("branch", branch)
-        }).decodeMutation() }
-
-    suspend fun push(
-        repo: String,
-        confirmation: String,
-        remote: String = "origin",
-        branch: String = "",
-    ): Result<GitMutationResult> = relayWrite(repo) { relay -> scoped.post("git/push", buildJsonObject {
-        put("repo", relay)
-        put("remote", remote)
-        put("branch", branch)
-        put("confirmation", confirmation)
-    }).decodeMutation() }
-
-    suspend fun checkout(
-        repo: String,
-        ref: String,
-        confirmation: String? = null,
-        newBranch: String = "",
-        track: Boolean = false,
-    ): 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)
-    }).decodeMutation() }
-
-    suspend fun commitMessage(repo: String): Result<GitCommitMessage> = relayWrite(repo) { relay ->
-        scoped.post("git/commit_message", buildJsonObject { put("repo", relay) })
-            .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) } }
-
-    suspend fun stashCheckout(
-        repo: String,
-        ref: String,
-        newBranch: String = "",
-        track: Boolean = false,
-    ): 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) } }
-
-    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 = "")
@@ -1,117 +0,0 @@
-package com.hermesandroid.relay.data
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-/** A current-session upstream repository or a Relay-discovered repository. */
-@Serializable
-data class GitRepo(
-    val id: String,
-    val name: String,
-    val root: String,
-    @SerialName("current_branch") val currentBranch: String? = null,
-    val dirty: Boolean = false,
-    val route: GitRepositoryRoute = GitRepositoryRoute.RELAY,
-)
-
-@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(),
-    val staged: List<GitStatusEntry> = emptyList(),
-    val modified: List<GitStatusEntry> = emptyList(),
-    val untracked: List<GitStatusEntry> = emptyList(),
-    val truncated: Boolean = false,
-)
-
-@Serializable
-data class GitStatusCounts(
-    val staged: Int = 0,
-    val modified: Int = 0,
-    val untracked: Int = 0,
-    /** Unique changed paths. -1 means an older plugin did not provide it. */
-    val changes: Int = -1,
-    val additions: Int = 0,
-    val deletions: Int = 0,
-)
-
-@Serializable
-data class GitStatusEntry(
-    val path: String,
-    val additions: Int? = null,
-    val deletions: Int? = null,
-)
-
-/** A branch from /git/branches. */
-@Serializable
-data class GitBranch(
-    val name: String,
-    val upstream: String? = null,
-    val ahead: Int = 0,
-    val behind: Int = 0,
-    @SerialName("is_current") val isCurrent: Boolean = false,
-)
-
-/** A per-file diff from /git/diff. */
-@Serializable
-data class GitDiff(
-    val path: String,
-    val kind: String,
-    val diff: String,
-    val truncated: Boolean = false,
-)
-
-/** A tracked-file read from /git/file. */
-@Serializable
-data class GitFile(
-    val path: String,
-    val content: String,
-    val truncated: Boolean = false,
-)
-
-/** Wrapper for /git/repos response. */
-@Serializable
-internal data class ReposResponse(
-    val repos: List<GitRepo> = emptyList(),
-    val notice: String? = null,
-)
-
-/** Wrapper for /git/branches response. */
-@Serializable
-internal data class BranchesResponse(
-    val branches: List<GitBranch> = emptyList(),
-)
-
-/** A mutation response: fresh HEAD oid + working-tree status (+ branches). */
-@Serializable
-data class GitMutationResult(
-    val head: String = "",
-    val status: GitStatus = GitStatus(),
-    val branches: List<GitBranch> = emptyList(),
-)
-
-/** A /git/commit_message suggestion: generated message + optional notice. */
-@Serializable
-data class GitCommitMessage(
-    val message: String = "",
-    val notice: String = "",
-)
-
-/** A /git/stash_checkout result: standard mutation shape + stash flag/message. */
-@Serializable
-data class GitStashCheckoutResult(
-    val head: String = "",
-    val status: GitStatus = GitStatus(),
-    val branches: List<GitBranch> = emptyList(),
-    val stashed: Boolean = false,
-    @SerialName("stash_message") val stashMessage: String = "",
-)
@@ -38,8 +38,6 @@ data class ProactiveInboxEntry(
    val connectionId: String? = null,
    /** Relay proved this row came from its bounded offline queue. */
    val arrivedWhileAway: Boolean = false,
-    /** Exact Android notification slot, when recorded by the receiving build. */
-    val notificationId: Int? = null,
 )

 private val Context.proactiveInboxStore: DataStore<Preferences> by
@@ -60,19 +58,15 @@ private const val MAX_ENTRIES = 100
 * bounded store also backs the provisional Thread until the user's first reply
 * promotes it to a real `source=phone` session.
 */
-class ProactiveInboxRepository internal constructor(
-    private val store: DataStore<Preferences>,
-) {
-
-    constructor(context: Context) : this(context.proactiveInboxStore)
+class ProactiveInboxRepository(private val context: Context) {

    private val json = Json { ignoreUnknownKeys = true }

    val entries: Flow<List<ProactiveInboxEntry>> =
-        store.data.map { prefs -> decode(prefs[INBOX_JSON]) }
+        context.proactiveInboxStore.data.map { prefs -> decode(prefs[INBOX_JSON]) }

    suspend fun add(entry: ProactiveInboxEntry) {
-        store.edit { prefs ->
+        context.proactiveInboxStore.edit { prefs ->
            val current = decode(prefs[INBOX_JSON]).toMutableList()
            current.removeAll { it.id == entry.id }
            current.add(0, entry)
@@ -82,40 +76,7 @@ class ProactiveInboxRepository internal constructor(
    }

    suspend fun clear() {
-        store.edit { it.remove(INBOX_JSON) }
-    }
-
-    /**
-     * Remove one provisional Thread owned by one saved connection.
-     *
-     * This only edits the bounded local inbox. A promoted Thread is server
-     * history and is deliberately outside this repository, so this operation
-     * can never delete it. Legacy entries without a connection owner are
-     * removed with the active row because they are rendered in that row; rows
-     * explicitly owned by another connection remain isolated.
-     */
-    suspend fun removeThread(
-        chatId: String,
-        connectionId: String,
-    ): List<ProactiveInboxEntry> {
-        val normalizedChatId = chatId.ifBlank { "phone" }
-        var removed = emptyList<ProactiveInboxEntry>()
-        store.edit { prefs ->
-            val current = decode(prefs[INBOX_JSON])
-            removed = current.filter {
-                (it.connectionId == null || it.connectionId == connectionId) &&
-                    (it.chatId ?: "phone") == normalizedChatId
-            }
-            if (removed.isNotEmpty()) {
-                val retained = current.filterNot { it in removed }
-                if (retained.isEmpty()) {
-                    prefs.remove(INBOX_JSON)
-                } else {
-                    prefs[INBOX_JSON] = json.encodeToString(retained)
-                }
-            }
-        }
-        return removed
+        context.proactiveInboxStore.edit { it.remove(INBOX_JSON) }
    }

    private fun decode(raw: String?): List<ProactiveInboxEntry> {
@@ -11,29 +11,6 @@ data class RelayEndpoints(
    val healthUrl: String,
 )

-/** Dashboard plugin namespace used when Relay rides the Dashboard origin. */
-const val DASHBOARD_RELAY_INGRESS_PATH: String =
-    "/api/plugins/hermes-relay/transport"
-
-/**
- * True when [raw] points at the Dashboard-mounted Relay transport rather than
- * a directly exposed Relay listener. The distinction is authentication
- * relevant: the outer Dashboard request keeps its cookie/bearer credential,
- * while Relay's independently scoped session travels in
- * `X-Hermes-Relay-Session`.
- */
-fun isDashboardRelayIngressUrl(raw: String?): Boolean {
-    val endpoints = RelayEndpointContract.parseOrNull(raw) ?: return false
-    val path = runCatching { URI(endpoints.httpBaseUrl).rawPath.orEmpty() }
-        .getOrDefault("")
-        .trimEnd('/')
-    val marker = path.indexOf(DASHBOARD_RELAY_INGRESS_PATH)
-    if (marker < 0) return false
-    val markerEndsAt = marker + DASHBOARD_RELAY_INGRESS_PATH.length
-    val suffixBoundary = markerEndsAt == path.length || path[markerEndsAt] == '/'
-    return suffixBoundary
-}
-
 /**
 * Parses the accepted Relay URL forms and derives every route from one base.
 *
@@ -1,234 +0,0 @@
-package com.hermesandroid.relay.data
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import com.hermesandroid.relay.ui.theme.AppThemes
-
-/**
- * Parent-configured restrictions for the official Android client.
- *
- * This policy deliberately describes a client presentation mode, not a server
- * authorization boundary. The pinned profile is expected to have already been
- * configured with the appropriate server-side tool and content restrictions.
- */
-@Serializable
-data class SupervisedModePolicy(
-    val enabled: Boolean = false,
-    val pinnedProfileName: String? = null,
-    val capabilities: SupervisedCapabilities = SupervisedCapabilities(),
-    val appearance: SupervisedAppearance = SupervisedAppearance(),
-    val visibility: SupervisedVisibility = SupervisedVisibility(),
-    val parentAccess: SupervisedParentAccess = SupervisedParentAccess(),
-) {
-    /** A saved policy is usable only when it names a concrete Hermes profile. */
-    val isConfigured: Boolean
-        get() = !pinnedProfileName.isNullOrBlank()
-
-    /** Consumers should use this instead of treating [enabled] alone as sufficient. */
-    val isActive: Boolean
-        get() = enabled && isConfigured
-
-    internal fun normalized(): SupervisedModePolicy = copy(
-        pinnedProfileName = pinnedProfileName?.trim()?.takeIf { it.isNotEmpty() },
-        capabilities = capabilities.normalized(),
-        appearance = appearance.normalized(),
-        parentAccess = parentAccess.normalized(),
-    )
-}
-
-/** Actions and content types the supervised chat surface may expose. */
-@Serializable
-data class SupervisedCapabilities(
-    val attachments: Boolean = false,
-    val voice: Boolean = false,
-    val generatedImages: Boolean = true,
-    val conversationHistory: Boolean = false,
-    val newChat: Boolean = true,
-    val cancelResponse: Boolean = true,
-    val steerResponse: Boolean = true,
-    val retryResponse: Boolean = true,
-    val copyResponses: Boolean = true,
-    val quoteReplies: Boolean = true,
-    val editAndResend: Boolean = false,
-    val shareGeneratedImages: Boolean = false,
-    val sessionActions: SupervisedSessionActions = SupervisedSessionActions(),
-    val attachmentMaxCount: Int = DEFAULT_ATTACHMENT_MAX_COUNT,
-    val attachmentMaxFileMb: Int = DEFAULT_ATTACHMENT_MAX_FILE_MB,
-    val attachmentCategories: Set<SupervisedAttachmentCategory> = setOf(
-        SupervisedAttachmentCategory.Images,
-    ),
-) {
-    internal fun normalized(): SupervisedCapabilities = copy(
-        attachmentMaxCount = attachmentMaxCount.coerceIn(1, MAX_ATTACHMENT_COUNT),
-        attachmentMaxFileMb = attachmentMaxFileMb.coerceIn(1, MAX_ATTACHMENT_FILE_MB),
-        attachmentCategories = attachmentCategories.ifEmpty {
-            setOf(SupervisedAttachmentCategory.Images)
-        },
-    )
-
-    companion object {
-        const val DEFAULT_ATTACHMENT_MAX_COUNT = 4
-        const val DEFAULT_ATTACHMENT_MAX_FILE_MB = 10
-        const val MAX_ATTACHMENT_COUNT = 10
-        const val MAX_ATTACHMENT_FILE_MB = 100
-    }
-}
-
-/** Appearance applied only while the supervised root is locked. */
-@Serializable
-data class SupervisedAppearance(
-    val appThemeId: String = AppThemes.DEFAULT_ID,
-    val themePreference: String = "auto",
-    val showPet: Boolean = false,
-    val allowProfileIconChanges: Boolean = false,
-    val allowBackgroundChanges: Boolean = false,
-) {
-    internal fun normalized(): SupervisedAppearance = copy(
-        appThemeId = AppThemes.byId(appThemeId).id,
-        themePreference = themePreference.takeIf { it in VALID_THEME_PREFERENCES } ?: "auto",
-    )
-
-    private companion object {
-        val VALID_THEME_PREFERENCES = setOf("auto", "light", "dark")
-    }
-}
-
-/** Mutable operations available from a supervised conversation-history row. */
-@Serializable
-data class SupervisedSessionActions(
-    val pin: Boolean = false,
-    val rename: Boolean = false,
-    val archive: Boolean = false,
-    val delete: Boolean = false,
-    val shareTranscript: Boolean = false,
-) {
-    val enabledCount: Int
-        get() = listOf(pin, rename, archive, delete, shareTranscript).count { it }
-
-    val allEnabled: Boolean
-        get() = enabledCount == TOTAL
-
-    val noneEnabled: Boolean
-        get() = enabledCount == 0
-
-    fun withAll(enabled: Boolean): SupervisedSessionActions = SupervisedSessionActions(
-        pin = enabled,
-        rename = enabled,
-        archive = enabled,
-        delete = enabled,
-        shareTranscript = enabled,
-    )
-
-    companion object {
-        const val TOTAL = 5
-    }
-}
-
-enum class SupervisedSessionAction {
-    Pin,
-    Rename,
-    Archive,
-    Delete,
-    ShareTranscript,
-}
-
-fun SupervisedModePolicy.allowsSessionAction(action: SupervisedSessionAction): Boolean {
-    if (!enabled) return true
-    if (!capabilities.conversationHistory) return false
-    return when (action) {
-        SupervisedSessionAction.Pin -> capabilities.sessionActions.pin
-        SupervisedSessionAction.Rename -> capabilities.sessionActions.rename
-        SupervisedSessionAction.Archive -> capabilities.sessionActions.archive
-        SupervisedSessionAction.Delete -> capabilities.sessionActions.delete
-        SupervisedSessionAction.ShareTranscript -> capabilities.sessionActions.shareTranscript
-    }
-}
-
-@Serializable
-enum class SupervisedAttachmentCategory {
-    @SerialName("images")
-    Images,
-
-    @SerialName("documents")
-    Documents,
-
-    @SerialName("audio")
-    Audio,
-
-    @SerialName("video")
-    Video,
-}
-
-/**
- * Controls which metadata and conversation affordances are rendered.
- *
- * [Simple] is the quiet default. [Transparent] is a useful preset for older or
- * technical users, while [Custom] tells the UI to honor every stored toggle.
- */
-@Serializable
-data class SupervisedVisibility(
-    val preset: SupervisedVisibilityPreset = SupervisedVisibilityPreset.Simple,
-    val showAgentIdentity: Boolean = true,
-    val showModelName: Boolean = false,
-    val showProfileName: Boolean = false,
-    val showConnectionStatus: Boolean = true,
-    val showTechnicalRoute: Boolean = false,
-    val showTimestamps: Boolean = true,
-    val showToolNames: Boolean = false,
-    val showToolDetails: Boolean = false,
-    val showWorkingStatus: Boolean = true,
-    val showReasoning: Boolean = false,
-    val showUsage: Boolean = false,
-) {
-    /** Resolve presets to the concrete flags consumed by chat presentation. */
-    fun resolved(): SupervisedVisibility = when (preset) {
-        SupervisedVisibilityPreset.Simple -> SIMPLE
-        SupervisedVisibilityPreset.Transparent -> TRANSPARENT
-        SupervisedVisibilityPreset.Custom -> this
-    }
-
-    companion object {
-        val SIMPLE = SupervisedVisibility(preset = SupervisedVisibilityPreset.Simple)
-
-        val TRANSPARENT = SupervisedVisibility(
-            preset = SupervisedVisibilityPreset.Transparent,
-            showModelName = true,
-            showProfileName = true,
-            showTechnicalRoute = true,
-            showToolNames = true,
-            showUsage = true,
-        )
-    }
-}
-
-@Serializable
-enum class SupervisedVisibilityPreset {
-    @SerialName("simple")
-    Simple,
-
-    @SerialName("transparent")
-    Transparent,
-
-    @SerialName("custom")
-    Custom,
-}
-
-/** Device-authentication and automatic relock behavior for parent access. */
-@Serializable
-data class SupervisedParentAccess(
-    /** Reserved for forward-compatible persistence; normalization never permits an auth bypass. */
-    val requireDeviceAuthentication: Boolean = true,
-    val relockOnBackground: Boolean = true,
-    val timeoutMinutes: Int = DEFAULT_TIMEOUT_MINUTES,
-) {
-    internal fun normalized(): SupervisedParentAccess = copy(
-        requireDeviceAuthentication = true,
-        timeoutMinutes = timeoutMinutes.coerceIn(MIN_TIMEOUT_MINUTES, MAX_TIMEOUT_MINUTES),
-    )
-
-    companion object {
-        const val DEFAULT_TIMEOUT_MINUTES = 5
-        const val MIN_TIMEOUT_MINUTES = 1
-        const val MAX_TIMEOUT_MINUTES = 60
-    }
-}
@@ -1,124 +0,0 @@
-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 kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
-import kotlinx.serialization.builtins.MapSerializer
-import kotlinx.serialization.builtins.serializer
-import kotlinx.serialization.json.Json
-
-/** Persists one independent [SupervisedModePolicy] per Hermes connection. */
-class SupervisedModeStore private constructor(
-    private val dataStore: DataStore<Preferences>,
-) {
-    constructor(context: Context) : this(context.relayDataStore)
-
-    private val json = Json {
-        encodeDefaults = true
-        ignoreUnknownKeys = true
-    }
-    private val serializer = MapSerializer(String.serializer(), SupervisedModePolicy.serializer())
-
-    fun policyFlow(connectionId: String): Flow<SupervisedModePolicy> =
-        dataStore.data.map { preferences ->
-            val decoded = decode(preferences[KEY_POLICIES])
-            if (decoded.corrupt) {
-                // A malformed persisted policy must never silently reopen the
-                // unrestricted app. Enabled + unconfigured renders the
-                // supervised recovery surface until an authenticated user
-                // repairs or clears the policy.
-                SupervisedModePolicy(enabled = true)
-            } else {
-                decoded.policies[connectionId]?.normalized() ?: SupervisedModePolicy()
-            }
-        }
-
-    suspend fun setPolicy(connectionId: String, policy: SupervisedModePolicy) {
-        require(connectionId.isNotBlank()) { "connectionId must not be blank" }
-        dataStore.edit { preferences ->
-            val policies = decode(preferences[KEY_POLICIES]).policies.toMutableMap()
-            policies[connectionId] = policy.normalized()
-            preferences[KEY_POLICIES] = json.encodeToString(serializer, policies)
-        }
-    }
-
-    suspend fun updatePolicy(
-        connectionId: String,
-        transform: (SupervisedModePolicy) -> SupervisedModePolicy,
-    ) {
-        require(connectionId.isNotBlank()) { "connectionId must not be blank" }
-        dataStore.edit { preferences ->
-            val policies = decode(preferences[KEY_POLICIES]).policies.toMutableMap()
-            val current = policies[connectionId]?.normalized() ?: SupervisedModePolicy()
-            policies[connectionId] = transform(current).normalized()
-            preferences[KEY_POLICIES] = json.encodeToString(serializer, policies)
-        }
-    }
-
-    suspend fun setEnabled(connectionId: String, enabled: Boolean) {
-        updatePolicy(connectionId) { it.copy(enabled = enabled) }
-    }
-
-    suspend fun clear(connectionId: String) {
-        dataStore.edit { preferences ->
-            val policies = decode(preferences[KEY_POLICIES]).policies.toMutableMap()
-            policies.remove(connectionId)
-            if (policies.isEmpty()) {
-                preferences.remove(KEY_POLICIES)
-            } else {
-                preferences[KEY_POLICIES] = json.encodeToString(serializer, policies)
-            }
-        }
-    }
-
-    /** Clear supervised policies without disturbing unrelated app settings. */
-    suspend fun clearAll() {
-        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 {
-            DecodeResult(json.decodeFromString(serializer, raw), corrupt = false)
-        } catch (error: Exception) {
-            Log.w(TAG, "Unable to decode supervised-mode policies; failing closed", error)
-            DecodeResult(emptyMap(), corrupt = true)
-        }
-    }
-
-    private data class DecodeResult(
-        val policies: Map<String, SupervisedModePolicy>,
-        val corrupt: Boolean,
-    )
-
-    internal companion object {
-        private const val TAG = "SupervisedModeStore"
-        private val KEY_POLICIES = stringPreferencesKey("supervised_mode_policies_v1")
-
-        fun forTesting(dataStore: DataStore<Preferences>): SupervisedModeStore =
-            SupervisedModeStore(dataStore)
-    }
-}
@@ -1,461 +0,0 @@
-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
-    }
-}
@@ -344,46 +344,6 @@ 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))
@@ -5,7 +5,6 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import com.hermesandroid.relay.reliability.ReliabilityCenter
 import com.hermesandroid.relay.reliability.ReliabilityRedactor
-import java.time.Instant

 enum class DiagnosticCategory(val label: String) {
    Api("API"),
@@ -84,8 +83,6 @@ data class StatusCheck(
 object DiagnosticsLog {
    private const val MAX_ENTRIES = 200
    private const val MAX_TEXT_LENGTH = 180
-    const val SUPPORT_ENTRY_LIMIT = 80
-    private const val MAX_SUPPORT_TEXT_LENGTH = 32_000

    /** Cap for the full stacktrace kept on an error entry — a few KB is plenty. */
    private const val MAX_TRACE_LENGTH = 8000
@@ -207,46 +204,6 @@ object DiagnosticsLog {
        }
    }

-    /**
-     * Exact, bounded diagnostics section used by the review-before-sharing
-     * support export. Entries were already sanitized at record time; the final
-     * redaction pass protects legacy entries and keeps this safe to compose with
-     * persistent reliability reports.
-     */
-    fun supportText(entries: List<DiagnosticLogEntry>): String {
-        val selected = entries.takeLast(SUPPORT_ENTRY_LIMIT)
-        if (selected.isEmpty()) return ""
-        return ReliabilityRedactor.redact(
-            buildString {
-                appendLine("Recent in-app diagnostics")
-                appendLine("Diagnostics: ${selected.size}")
-                selected.forEachIndexed { index, entry ->
-                    appendLine()
-                    appendLine("===== Diagnostic ${index + 1} =====")
-                    appendLine("Time:     ${Instant.ofEpochMilli(entry.timestampMs)}")
-                    appendLine("Category: ${entry.category.label}")
-                    appendLine("Severity: ${entry.severity.name}")
-                    appendLine("Title:    ${entry.title}")
-                    entry.operation?.let { appendLine("Operation: $it") }
-                    entry.endpointRole?.let { appendLine("Route:    $it") }
-                    entry.configuredUrl?.let { appendLine("Configured URL: $it") }
-                    entry.requestUrl?.let { appendLine("Request:  $it") }
-                    if (entry.configuredUrl == null && entry.requestUrl == null) {
-                        entry.url?.let { appendLine("URL:      $it") }
-                    }
-                    entry.elapsedMs?.let { appendLine("Elapsed:  ${it}ms") }
-                    entry.detail?.let { appendLine("Detail:   $it") }
-                    entry.suggestion?.let { appendLine("Next:     $it") }
-                    entry.stacktrace?.let {
-                        appendLine("Technical detail (redacted)")
-                        appendLine(it)
-                    }
-                }
-            },
-            MAX_SUPPORT_TEXT_LENGTH,
-        )
-    }
-
    fun sanitizeUrl(value: String?): String? {
        val trimmed = value?.trim()?.takeIf { it.isNotBlank() } ?: return null
        val noQuery = trimmed.substringBefore('?').substringBefore('#')
@@ -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 docs/project/ROADMAP.md.
+     * "voice intent local dispatch loop" entry in ROADMAP.md.
     */
    suspend fun handleLocalCommand(envelope: Envelope): LocalDispatchResult {
        if (envelope.type != "bridge.command") {
@@ -153,7 +153,7 @@ class ChannelMultiplexer {
                )
                send(pong)
            }
-            "auth.ok", "auth.fail", "supervised.updated", "error" -> {
+            "auth.ok", "auth.fail" -> {
                // Delegate to system handler if registered
                handlers["system"]?.onMessage(envelope)
            }
@@ -11,7 +11,6 @@ import com.hermesandroid.relay.R
 import com.hermesandroid.relay.auth.CertPinStore
 import com.hermesandroid.relay.data.EndpointCandidate
 import com.hermesandroid.relay.data.RelayEndpointContract
-import com.hermesandroid.relay.data.isDashboardRelayIngressUrl
 import com.hermesandroid.relay.data.primaryRouteUrl
 import com.hermesandroid.relay.data.PairingPreferences
 import com.hermesandroid.relay.network.shared.pluginProxyRoutesOrNull
@@ -44,7 +43,6 @@ import okhttp3.Response
 import okhttp3.WebSocket
 import okhttp3.WebSocketListener
 import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicLong

 enum class ConnectionState {
    Disconnected,
@@ -140,12 +138,6 @@ class ConnectionManager(
     * back to the legacy per-device PairingPreferences source below.
     */
    private val endpointCandidatesProvider: (suspend () -> List<EndpointCandidate>)? = null,
-    /**
-     * Dynamic ownership fence for Relay-only resolution. Production uses it
-     * to keep Dashboard ingress on the exact origin that owns Dashboard auth,
-     * while direct Relay and proxy routes remain independently eligible.
-     */
-    private val relayCandidateEligibility: (EndpointCandidate) -> Boolean = { true },
    /**
     * Suspending supplier for the active device id. Used to key into
     * [PairingPreferences.getDeviceEndpoints] during resolution. `null`
@@ -159,14 +151,6 @@ class ConnectionManager(
    private val proxyClientProvider: ((String) -> OkHttpClient?)? = null,
    /** Test seam for observing lifecycle teardown without opening a socket. */
    private val okHttpClientFactory: (() -> OkHttpClient)? = null,
-    /**
-     * Builds a Dashboard-authorized WebSocket request for plugin ingress.
-     * Implementations mint a fresh single-use Dashboard WS ticket on every
-     * invocation. Direct Relay listeners never call this provider.
-     */
-    private val dashboardRelayRequestProvider: (suspend (String) -> Request?)? = null,
-    /** Deterministic race seam immediately before an ingress failure may poison route state. */
-    private val beforeIngressFailureCommit: suspend () -> Unit = {},
 ) {
    private val supervisorJob = SupervisorJob()
    private val scope = CoroutineScope(supervisorJob + Dispatchers.IO)
@@ -207,9 +191,6 @@ class ConnectionManager(

    @Volatile
    private var webSocket: WebSocket? = null
-    private val socketGeneration = AtomicLong(0L)
-    @Volatile
-    private var activeSocketGeneration: Long = 0L

    @Volatile
    private var serverUrl: String? = null
@@ -292,11 +273,6 @@ class ConnectionManager(
    @Volatile
    private var networkResolveJob: kotlinx.coroutines.Job? = null

-    /** Optional API discovery is never part of Dashboard/Gateway readiness. */
-    @Volatile
-    private var apiResolveJob: Job? = null
-    private var apiResolveRevision: Long = 0L
-
    /** Deferred reaction to a network loss — cancelled if a network returns within the grace. */
    private var networkLossJob: kotlinx.coroutines.Job? = null

@@ -387,12 +363,13 @@ class ConnectionManager(
        // the synthesized list just collapses to the same URL anyway.
        scope.launch {
            val resolved = resolveBestEndpointSafe(EndpointSurface.Dashboard)
-                ?: resolveLegacyStandardFallbackSafe()
-            scheduleApiResolution()
-            val relayResolved = resolveBestRelayEndpointSafe()
+                ?: resolveBestEndpointSafe(EndpointSurface.Standard)
+            val apiResolved = resolveBestEndpointSafe(EndpointSurface.Api)
+            val relayResolved = resolveBestEndpointSafe(EndpointSurface.Relay)
            val resolvedRelayUrl = relayResolved?.relayWebSocketUrl()?.takeIf { it.isNotBlank() }
            val targetUrl = resolvedRelayUrl ?: url.takeIf { it.isNotBlank() }
            _activeRelayEndpoint.value = relayResolved
+            _activeApiEndpoint.value = apiResolved
            if (resolved != null) {
                _activeEndpoint.value = resolved
                Log.i(TAG, "connect: standard resolver picked role=${resolved.role} " +
@@ -430,18 +407,6 @@ class ConnectionManager(
        }
    }

-    /**
-     * Open the exact QR-advertised socket for a fresh pair. Relay health probes
-     * require an established Relay session, so running the normal resolver
-     * before `auth.ok` is circular and can consume the entire pairing window.
-     * Post-pair reconnects continue to use [connect] and full route resolution.
-     */
-    fun connectPairing(url: String) {
-        ensureNetworkCallbackRegistered()
-        _activeRelayEndpoint.value = null
-        connectToUrlOnMainPath(url, replaceReason = "Fresh Relay pairing")
-    }
-
    /**
     * Replace an ordinary scheduled reconnect with an immediate attempt.
     *
@@ -477,35 +442,6 @@ class ConnectionManager(
        return true
    }

-    /**
-     * Reopen the current authenticated Relay socket without discarding pair
-     * state. Used only as a compatibility fallback when an older Relay does
-     * not acknowledge a post-auth metadata update; the replacement socket's
-     * normal `system/auth` frame carries the latest metadata.
-     */
-    fun reconnectForAuthenticatedMetadataUpdate(): Boolean {
-        val targetUrl = serverUrl?.takeIf { it.isNotBlank() } ?: return false
-        if (isRelayRateLimitBackoffActive(
-                rateLimitBackoffUntilMs,
-                SystemClock.elapsedRealtime(),
-            )
-        ) {
-            Log.i(TAG, "metadata reconnect: preserving active rate-limit backoff")
-            return false
-        }
-        val previousSocket = webSocket
-        if (previousSocket == null) {
-            connect(targetUrl)
-        } else {
-            doConnect(
-                targetUrl,
-                previousSocketToClose = previousSocket,
-                replaceReason = "Relay metadata compatibility refresh",
-            )
-        }
-        return true
-    }
-
    /**
     * Same as [connect] but bypasses the resolver — used by the network-
     * change callback when we've already picked a winner and just want to
@@ -612,17 +548,10 @@ class ConnectionManager(
     */
    suspend fun resolveBestEndpoint(): EndpointCandidate? =
        resolveBestEndpointSafe(EndpointSurface.Dashboard)
-            ?: resolveLegacyStandardFallbackSafe()
-
-    private suspend fun resolveLegacyStandardFallbackSafe(): EndpointCandidate? =
-        resolveBestEndpointSafe(EndpointSurface.Standard) { candidate ->
-            candidate.dashboard?.url.isNullOrBlank() &&
-                candidate.pluginProxyRoutesOrNull()?.dashboardBaseUrl == null
-        }
+            ?: resolveBestEndpointSafe(EndpointSurface.Standard)

    private suspend fun resolveBestEndpointSafe(
        surface: EndpointSurface,
-        candidateFilter: (EndpointCandidate) -> Boolean = { true },
    ): EndpointCandidate? {
        val resolver = endpointResolver ?: return null
        val ctx = context ?: return null
@@ -651,14 +580,13 @@ class ConnectionManager(
            } ?: emptyList()
        }

-        val eligibleEndpoints = endpoints.filter(candidateFilter)
-        if (eligibleEndpoints.isEmpty()) return null
+        if (endpoints.isEmpty()) return null

        // Manual override: if the user pinned a role in the Endpoints card,
        // try that one first; fall through to the strict-priority algorithm
        // if it isn't reachable.
        _manualRoleOverride.value?.let { preferredRole ->
-            val preferred = eligibleEndpoints.firstOrNull {
+            val preferred = endpoints.firstOrNull {
                it.role.equals(preferredRole, ignoreCase = true)
            }
            if (preferred != null) {
@@ -670,54 +598,7 @@ class ConnectionManager(
            }
        }

-        return resolver.resolve(eligibleEndpoints, surface)
-    }
-
-    /** Every Relay selection path must apply the same live ownership fence. */
-    private suspend fun resolveBestRelayEndpointSafe(): EndpointCandidate? =
-        resolveBestEndpointSafe(
-            surface = EndpointSurface.Relay,
-            candidateFilter = relayCandidateEligibility,
-        )
-
-    /**
-     * Discover the optional API fallback without holding up the standard
-     * Dashboard/Gateway route. A single manager-level job coalesces lifecycle
-     * callers; [EndpointResolver] additionally shares an in-flight request per
-     * route/surface. The negative cache keeps ordinary profile changes cheap,
-     * while network callbacks and explicit probes still invalidate it.
-     */
-    private fun scheduleApiResolution() {
-        synchronized(this) {
-            apiResolveRevision += 1L
-            if (apiResolveJob?.isActive != true) {
-                startApiResolutionLocked(apiResolveRevision)
-            }
-        }
-    }
-
-    /** Caller must hold this manager's monitor. */
-    private fun startApiResolutionLocked(revision: Long) {
-        apiResolveJob = scope.launch {
-            try {
-                val resolved = resolveBestEndpointSafe(EndpointSurface.Api)
-                synchronized(this@ConnectionManager) {
-                    // A route/connection refresh may have arrived while this
-                    // optional probe was waiting. Never publish its stale
-                    // winner over the newer connection's API ownership.
-                    if (revision == apiResolveRevision) {
-                        _activeApiEndpoint.value = resolved
-                    }
-                }
-            } finally {
-                synchronized(this@ConnectionManager) {
-                    apiResolveJob = null
-                    if (revision != apiResolveRevision && supervisorJob.isActive) {
-                        startApiResolutionLocked(apiResolveRevision)
-                    }
-                }
-            }
-        }
+        return resolver.resolve(endpoints, surface)
    }

    /**
@@ -746,9 +627,9 @@ class ConnectionManager(
        endpointResolver?.clearCache()
        val current = serverUrl
        val resolved = resolveBestEndpointSafe(EndpointSurface.Dashboard)
-            ?: resolveLegacyStandardFallbackSafe()
-        scheduleApiResolution()
-        val relayResolved = resolveBestRelayEndpointSafe()
+            ?: resolveBestEndpointSafe(EndpointSurface.Standard)
+        val apiResolved = resolveBestEndpointSafe(EndpointSurface.Api)
+        val relayResolved = resolveBestEndpointSafe(EndpointSurface.Relay)
        if (resolved == null && _connectionState.value == ConnectionState.Connected) {
            // Transient probe miss while the relay socket is demonstrably up
            // — keep the live route published rather than downgrading every
@@ -756,6 +637,7 @@ class ConnectionManager(
            return _activeEndpoint.value
        }
        _activeEndpoint.value = resolved
+        _activeApiEndpoint.value = apiResolved
        if (relayResolved != null) _activeRelayEndpoint.value = relayResolved
        val targetUrl = relayResolved?.relayWebSocketUrl() ?: current ?: return resolved
        val normalizedTarget = normalizeRelayUrl(targetUrl)
@@ -795,8 +677,8 @@ class ConnectionManager(
    suspend fun refreshActiveEndpoint(clearProbeCache: Boolean = false): EndpointCandidate? {
        if (clearProbeCache) endpointResolver?.clearCache()
        val resolved = resolveBestEndpointSafe(EndpointSurface.Dashboard)
-            ?: resolveLegacyStandardFallbackSafe()
-        scheduleApiResolution()
+            ?: resolveBestEndpointSafe(EndpointSurface.Standard)
+        val apiResolved = resolveBestEndpointSafe(EndpointSurface.Api)
        if (resolved == null && _connectionState.value == ConnectionState.Connected) {
            // Transient probe miss while the relay socket is demonstrably up
            // (slow resume, mid-handoff blip) — keep publishing the live
@@ -805,6 +687,7 @@ class ConnectionManager(
            return _activeEndpoint.value
        }
        _activeEndpoint.value = resolved
+        _activeApiEndpoint.value = apiResolved
        return resolved
    }

@@ -826,46 +709,6 @@ class ConnectionManager(
        Log.i(TAG, "marked endpoint role=${active.role} unreachable ($reason)")
    }

-    /** Admission is stronger evidence than `/transport/health`: reject this ingress and retain direct fallback. */
-    private suspend fun fallbackFromBrokenDashboardIngress(
-        url: String,
-        reason: String,
-        failingSocket: WebSocket? = null,
-        failingGeneration: Long? = null,
-    ): Boolean {
-        if (!isDashboardRelayIngressUrl(url)) return false
-        if (failingGeneration != null) {
-            beforeIngressFailureCommit()
-            if (activeSocketGeneration != failingGeneration || webSocket !== failingSocket) {
-                Log.i(TAG, "Ignoring stale Dashboard ingress failure ($reason)")
-                return false
-            }
-        }
-        val failed = _activeRelayEndpoint.value ?: return false
-        val failedUrl = failed.relayWebSocketUrl()?.let(::normalizeRelayUrl)
-        if (failedUrl != normalizeRelayUrl(url)) return false
-        endpointResolver?.markUnreachable(failed, EndpointSurface.Relay) ?: return false
-        val replacement = resolveBestRelayEndpointSafe() ?: return false
-        val replacementUrl = replacement.relayWebSocketUrl()?.takeIf(String::isNotBlank) ?: return false
-        if (normalizeRelayUrl(replacementUrl) == normalizeRelayUrl(url)) return false
-        _activeRelayEndpoint.value = replacement
-        Log.i(TAG, "Dashboard Relay ingress rejected; switching to ${replacement.role} ($reason)")
-        DiagnosticsLog.record(
-            category = DiagnosticCategory.Relay,
-            severity = DiagnosticSeverity.Warning,
-            title = "Relay ingress unavailable",
-            detail = "Dashboard admission failed; using retained direct Relay route.",
-            operation = "Select Relay transport after admission failure",
-            endpointRole = failed.role,
-            requestUrl = url,
-        )
-        connectToUrlOnMainPath(
-            replacementUrl,
-            replaceReason = "Dashboard Relay ingress admission failed",
-        )
-        return true
-    }
-
    /**
     * Debounced network-change re-resolution, shared by both NetworkCallback
     * events. Re-runs the resolver and publishes the winner to
@@ -888,8 +731,8 @@ class ConnectionManager(
            if (wipeCache) endpointResolver.clearCache()
            val current = serverUrl
            val resolved = resolveBestEndpointSafe(EndpointSurface.Dashboard)
-                ?: resolveLegacyStandardFallbackSafe()
-            scheduleApiResolution()
+                ?: resolveBestEndpointSafe(EndpointSurface.Standard)
+            val apiResolved = resolveBestEndpointSafe(EndpointSurface.Api)
            if (resolved == null) {
                // Hysteresis for the AUTOMATIC (network-callback) path. A
                // transient cold-route probe miss must NOT null the published
@@ -926,6 +769,7 @@ class ConnectionManager(
            }
            sustainedLossDeclared = false
            _activeEndpoint.value = resolved
+            _activeApiEndpoint.value = apiResolved
            if (current == null) return@launch
            // After an explicit disconnect() the route still publishes above
            // (HTTP surfaces keep roaming), but no socket action: without
@@ -934,7 +778,7 @@ class ConnectionManager(
            // (connectToUrlOnMainPath force-sets shouldReconnect = true, so
            // the swap path never re-checked it.)
            if (!shouldReconnect) return@launch
-            val relayResolved = resolveBestRelayEndpointSafe()
+            val relayResolved = resolveBestEndpointSafe(EndpointSurface.Relay)
            if (relayResolved != null) _activeRelayEndpoint.value = relayResolved
            val relayUrl = relayResolved?.relayWebSocketUrl()?.takeIf { it.isNotBlank() }
                ?: return@launch
@@ -1101,8 +945,7 @@ class ConnectionManager(
        webSocket?.send(text)
    }

-    private fun isActiveSocket(socket: WebSocket, generation: Long): Boolean =
-        webSocket === socket && activeSocketGeneration == generation
+    private fun isActiveSocket(socket: WebSocket): Boolean = webSocket === socket

    private fun doConnect(
        url: String,
@@ -1138,7 +981,7 @@ class ConnectionManager(
        scope.launch { doConnectInternal(url, previousSocketToClose, replaceReason) }
    }

-    private suspend fun doConnectInternal(
+    private fun doConnectInternal(
        url: String,
        previousSocketToClose: WebSocket? = null,
        replaceReason: String = "Relay socket replaced",
@@ -1163,49 +1006,22 @@ class ConnectionManager(
            buildClient(url)
        }

-        val request = if (isDashboardRelayIngressUrl(url)) {
-            dashboardRelayRequestProvider?.invoke(url)
-        } else {
-            buildRelayRequestOrNull(url)
-        }
+        val request = buildRelayRequestOrNull(url)
        if (request == null) {
            // A malformed relay URL (an invalid/empty host from a corrupt or
            // hand-edited pairing payload) can't be built into a request. This
            // runs on a background coroutine, so letting OkHttp's url() throw
            // would crash the app — the #131 "Invalid URL host" class, relay-
            // socket half. Route it through the same path onFailure uses.
-            Log.e(
-                TAG,
-                if (isDashboardRelayIngressUrl(url)) {
-                    "doConnect: Dashboard Relay ticket/request unavailable for '$url'"
-                } else {
-                    "doConnect: malformed relay URL '$url' — not connecting"
-                },
-            )
+            Log.e(TAG, "doConnect: malformed relay URL '$url' — not connecting")
            DiagnosticsLog.record(
                category = DiagnosticCategory.Relay,
                severity = DiagnosticSeverity.Error,
-                title = if (isDashboardRelayIngressUrl(url)) {
-                    "Dashboard Relay authorization unavailable"
-                } else {
-                    "Invalid relay URL"
-                },
-                detail = if (isDashboardRelayIngressUrl(url)) {
-                    "Dashboard authorization could not prepare the Relay WebSocket request."
-                } else {
-                    "The relay address could not be parsed; re-pair to refresh it."
-                },
-                operation = if (isDashboardRelayIngressUrl(url)) {
-                    "Mint Dashboard Relay WebSocket ticket"
-                } else {
-                    "Build Relay WebSocket request"
-                },
+                title = "Invalid relay URL",
+                detail = "The relay address could not be parsed; re-pair to refresh it.",
+                operation = "Build Relay WebSocket request",
                configuredUrl = url,
-                suggestion = if (isDashboardRelayIngressUrl(url)) {
-                    "Sign in to the matching Dashboard route, then recheck Relay routes."
-                } else {
-                    "Edit or re-pair the Relay route to replace the invalid address."
-                },
+                suggestion = "Edit or re-pair the Relay route to replace the invalid address.",
            )
            authenticated = false
            _connectionState.value = ConnectionState.Disconnected
@@ -1213,18 +1029,14 @@ class ConnectionManager(
                runCatching { stale.close(1000, replaceReason) }
                stale.cancel()
            }
-            if (!fallbackFromBrokenDashboardIngress(url, "request provider or ticket unavailable")) {
-                scheduleReconnect()
-            }
+            scheduleReconnect()
            return
        }

        Log.i(TAG, "doConnect: opening WSS to $url")
-        val generation = socketGeneration.incrementAndGet()
-        activeSocketGeneration = generation
        val newSocket = client.newWebSocket(request, object : WebSocketListener() {
            override fun onOpen(webSocket: WebSocket, response: Response) {
-                if (!isActiveSocket(webSocket, generation)) {
+                if (!isActiveSocket(webSocket)) {
                    Log.i(TAG, "onOpen: stale WSS handshake ignored ($url)")
                    runCatching { webSocket.close(1000, "Stale relay socket") }
                    webSocket.cancel()
@@ -1267,7 +1079,7 @@ class ConnectionManager(
            }

            override fun onMessage(webSocket: WebSocket, text: String) {
-                if (!isActiveSocket(webSocket, generation)) {
+                if (!isActiveSocket(webSocket)) {
                    Log.i(TAG, "onMessage: stale WSS envelope ignored ($url)")
                    return
                }
@@ -1294,7 +1106,7 @@ class ConnectionManager(
            }

            override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
-                if (!isActiveSocket(webSocket, generation)) {
+                if (!isActiveSocket(webSocket)) {
                    Log.i(TAG, "onClosed: stale WSS close ignored ($url code=$code reason=$reason)")
                    return
                }
@@ -1308,28 +1120,13 @@ class ConnectionManager(
                    requestUrl = url,
                    suggestion = if (code == 1000) null else "Check the Relay server logs for the matching close code and reason.",
                )
-                val admitted = authenticated
                authenticated = false
                _connectionState.value = ConnectionState.Disconnected
-                if (isDashboardRelayIngressUrl(url) && !admitted && code != 1000) {
-                    scope.launch {
-                        if (!fallbackFromBrokenDashboardIngress(
-                                url,
-                                "pre-auth close $code",
-                                webSocket,
-                                generation,
-                            ) && activeSocketGeneration == generation
-                        ) {
-                            scheduleReconnect()
-                        }
-                    }
-                } else {
-                    scheduleReconnect()
-                }
+                scheduleReconnect()
            }

            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
-                if (!isActiveSocket(webSocket, generation)) {
+                if (!isActiveSocket(webSocket)) {
                    Log.i(TAG, "onFailure: stale WSS failure ignored ($url ${t.javaClass.simpleName}: ${t.message})")
                    return
                }
@@ -1351,22 +1148,6 @@ class ConnectionManager(
                    } ?: NetworkDiagnosticGuidance.forThrowable(t, "Relay"),
                )
                lastUpgradeResponseCode = code
-                if (isDashboardRelayIngressUrl(url) && response != null) {
-                    authenticated = false
-                    _connectionState.value = ConnectionState.Disconnected
-                    scope.launch {
-                        if (!fallbackFromBrokenDashboardIngress(
-                                url,
-                                "HTTP admission ${response.code}",
-                                webSocket,
-                                generation,
-                            ) && activeSocketGeneration == generation
-                        ) {
-                            scheduleReconnect()
-                        }
-                    }
-                    return
-                }
                if (response == null) {
                    // Transport-level failure (no HTTP upgrade response): on a
                    // remote (Tailscale) link the first handshake can fail cold.
@@ -1480,7 +1261,7 @@ class ConnectionManager(
            // expires, auth state may have changed (e.g., user hit Revoke
            // during the retry window).
            if (shouldReconnect && reconnectGate()) {
-                val resolved = resolveBestRelayEndpointSafe()
+                val resolved = resolveBestEndpointSafe(EndpointSurface.Relay)
                val targetUrl = resolved?.relayWebSocketUrl()
                if (resolved != null) {
                    // Mirror scheduleNetworkReResolve: clear the sustained-loss
@@ -102,18 +102,22 @@ class ProactiveMessageHandler(
    /** Route a parsed message: into the open Thread if it belongs there, else
     *  the durable inbox log + the surface its hint selects. */
    private fun dispatch(msg: ProactiveMessage) {
+        // Persist first even when the currently open Thread consumes the live
+        // message. Agent-initiated outbound sends do not create a gateway
+        // session until the phone replies, so this cache is the provisional
+        // Thread transcript during that gap.
+        toInbox?.invoke(msg)
        // The surfacing hint selects the additional surface. Thread injection
        // is best-effort presentation of the persisted row, not itself a reason
        // to suppress an explicitly requested notification.
-        val notificationId = when (msg.surfacing?.lowercase()) {
+        when (msg.surfacing?.lowercase()) {
            "inbox" -> {
                injectIntoThread?.invoke(msg)
-                null
            }
            "session" -> {
                val delivered = injectIntoThread?.invoke(msg) == true ||
                    toSession?.invoke(msg) == true
-                if (delivered) null else notify(msg)
+                if (!delivered) notify(msg)
            }
            // null / "default" / "notification" / anything unrecognized.
            else -> {
@@ -121,13 +125,9 @@ class ProactiveMessageHandler(
                notify(msg)
            }
        }
-        // Every message remains in the bounded local cache. Persist the exact
-        // posted notification slot as part of that row so a later local Thread
-        // removal can cancel only its own notification.
-        toInbox?.invoke(msg.copy(notificationId = notificationId))
    }

-    private fun notify(msg: ProactiveMessage): Int? =
+    private fun notify(msg: ProactiveMessage) {
        ProactiveMessageNotifier.notify(
            context = context,
            title = msg.title,
@@ -135,6 +135,7 @@ class ProactiveMessageHandler(
            messageId = msg.messageId,
            chatId = msg.chatId,
        )
+    }

    private fun parse(payload: JsonObject): ProactiveMessage? {
        val text = payload["text"]?.jsonPrimitive?.contentOrNull
@@ -171,6 +172,4 @@ data class ProactiveMessage(
    val replyTo: String? = null,
    /** True only when Relay explicitly marked this as a reconnect queue flush. */
    val arrivedWhileAway: Boolean = false,
-    /** Exact Android notification slot when this delivery posted one. */
-    val notificationId: Int? = null,
 )
@@ -5,7 +5,6 @@ import android.util.Log
 import com.hermesandroid.relay.R
 import com.hermesandroid.relay.auth.PairedDeviceInfo
 import com.hermesandroid.relay.data.RelayEndpointContract
-import com.hermesandroid.relay.data.isDashboardRelayIngressUrl
 import com.hermesandroid.relay.diagnostics.DiagnosticCategory
 import com.hermesandroid.relay.diagnostics.DiagnosticSeverity
 import com.hermesandroid.relay.diagnostics.DiagnosticsLog
@@ -28,19 +27,6 @@ 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"
-
-/** Keep Dashboard outer auth and Relay capability auth in separate headers. */
-internal fun Request.Builder.relaySessionCredential(
-    token: String,
-    dashboardIngress: Boolean,
-): Request.Builder = if (dashboardIngress) {
-    header(RELAY_SESSION_HEADER, token)
-} else {
-    header("Authorization", "Bearer $token")
-}

 /**
 * HTTP client for the Hermes relay media endpoint.
@@ -73,23 +59,13 @@ class RelayHttpClient(
    /** Application context for localized string resources. Nullable for
     *  backwards-compat with call sites that don't need localization. */
    private val context: Context? = null,
-    /** Dashboard-authenticated client for same-origin plugin ingress calls. */
-    private val dashboardHttpClientProvider: ((String) -> OkHttpClient?)? = null,
 ) {

    private fun relayHttpBaseOrNull(url: String): String? =
        RelayEndpointContract.parseOrNull(url)?.httpBaseUrl

-    private fun callClient(relayUrl: String): OkHttpClient =
-        if (isDashboardRelayIngressUrl(relayUrl)) {
-            dashboardHttpClientProvider?.invoke(relayUrl) ?: okHttpClient
-        } else {
-            okHttpClient
-        }
-
    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
@@ -223,10 +199,10 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .get()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()
-        val activityClient = callClient(relayUrl).newBuilder()
+        val activityClient = okHttpClient.newBuilder()
            .callTimeout(3, java.util.concurrent.TimeUnit.SECONDS)
            .build()

@@ -259,10 +235,7 @@ class RelayHttpClient(
     * underlying exception with a human-readable message suitable for
     * surfacing in the attachment's `errorMessage` field.
     */
-    suspend fun fetchMedia(
-        token: String,
-        maxBytes: Long = DEFAULT_MEDIA_DOWNLOAD_LIMIT_BYTES,
-    ): Result<FetchedMedia> = withContext(Dispatchers.IO) {
+    suspend fun fetchMedia(token: String): Result<FetchedMedia> = withContext(Dispatchers.IO) {
        val relayUrl = relayUrlProvider()?.trim().orEmpty()
        if (relayUrl.isEmpty()) {
            return@withContext Result.failure(
@@ -288,12 +261,12 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .get()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "*/*")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                if (!response.isSuccessful) {
                    val reason = when (response.code) {
                        401, 403 -> "Unauthorized — re-pair with the relay"
@@ -323,7 +296,7 @@ class RelayHttpClient(
                if (body == null) {
                    return@withContext Result.failure(IOException("Empty response body"))
                }
-                val bytes = body.readBytesBounded(maxBytes)
+                val bytes = body.bytes()
                Result.success(FetchedMedia(contentType, bytes, fileName, sensitive))
            }
        } catch (e: IOException) {
@@ -357,7 +330,6 @@ 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()) {
@@ -397,12 +369,12 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .get()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "*/*")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                if (!response.isSuccessful) {
                    val reason = when (response.code) {
                        401 -> "Unauthorized — re-pair with the relay"
@@ -433,16 +405,12 @@ class RelayHttpClient(
                if (body == null) {
                    return@withContext Result.failure(IOException("Empty response body"))
                }
-                val bytes = body.readBytesBounded(maxBytes)
+                val bytes = body.bytes()
                Result.success(FetchedMedia(contentType, bytes, fileName, sensitive))
            }
        } catch (e: IOException) {
            Log.w(TAG, "fetchMediaByPath failed for $path: ${e.message}")
-            if (e is RelayMediaLimitException) {
-                Result.failure(e)
-            } else {
-                Result.failure(IOException("Relay unreachable: ${e.message ?: "IO error"}"))
-            }
+            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)
@@ -488,12 +456,12 @@ class RelayHttpClient(
            val request = Request.Builder()
                .url(url)
                .get()
-                .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+                .header("Authorization", "Bearer $sessionToken")
                .header("Accept", "image/*")
                .build()

            try {
-                callClient(relayUrl).newCall(request).execute().use { response ->
+                okHttpClient.newCall(request).execute().use { response ->
                    if (!response.isSuccessful) {
                        val errorCode = runCatching {
                            sessionsJson.parseToJsonElement(response.body.string())
@@ -586,11 +554,11 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .get()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()

-        val auditClient = callClient(relayUrl).newBuilder()
+        val auditClient = okHttpClient.newBuilder()
            .callTimeout(3, java.util.concurrent.TimeUnit.SECONDS)
            .build()

@@ -672,10 +640,10 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .get()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()
-        val client = callClient(relayUrl).newBuilder()
+        val client = okHttpClient.newBuilder()
            .callTimeout(3, java.util.concurrent.TimeUnit.SECONDS)
            .build()
        try {
@@ -785,10 +753,10 @@ class RelayHttpClient(
            return@withContext Result.failure(IOException("Invalid relay URL: ${e.message}"))
        }
        val request = Request.Builder().url(url).get()
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json").build()
        try {
-            callClient(relayUrl).newBuilder().callTimeout(4, java.util.concurrent.TimeUnit.SECONDS).build()
+            okHttpClient.newBuilder().callTimeout(4, java.util.concurrent.TimeUnit.SECONDS).build()
                .newCall(request).execute().use { response ->
                    if (response.code == 404) return@withContext Result.success(null)
                    if (!response.isSuccessful) return@withContext Result.failure(IOException("HTTP ${response.code}"))
@@ -839,11 +807,11 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .post(sessionsJson.encodeToString(payload).toRequestBody("application/json".toMediaType()))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        try {
-            callClient(relayUrl).newBuilder().callTimeout(4, java.util.concurrent.TimeUnit.SECONDS).build()
+            okHttpClient.newBuilder().callTimeout(4, java.util.concurrent.TimeUnit.SECONDS).build()
                .newCall(request).execute().use { response ->
                    if (response.code == 404) return@withContext Result.success(null)
                    if (!response.isSuccessful) return@withContext Result.failure(IOException("HTTP ${response.code}"))
@@ -889,12 +857,12 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .get()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()
        // Slightly longer than the other reads — a cache-miss on the relay does a
        // GitHub round-trip in an executor before responding.
-        val client = callClient(relayUrl).newBuilder()
+        val client = okHttpClient.newBuilder()
            .callTimeout(8, java.util.concurrent.TimeUnit.SECONDS)
            .build()
        try {
@@ -973,12 +941,12 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .get()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                if (response.code == 404) {
                    // Server hasn't shipped the endpoint yet — degrade to
                    // empty list so the UI can render "No paired devices"
@@ -1060,12 +1028,12 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .delete()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                if (response.code == 404) {
                    // Already gone — treat as success so the UI can just
                    // drop the row on the next refresh.
@@ -1177,12 +1145,12 @@ class RelayHttpClient(
        val request = Request.Builder()
            .url(url)
            .patch(bodyJson.toRequestBody("application/json".toMediaType()))
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                if (!response.isSuccessful) {
                    val reason = when (response.code) {
                        400 -> "Invalid extend request (check TTL/grants)"
@@ -1274,7 +1242,7 @@ class RelayHttpClient(

        // Fast-timeout client — we don't want Save & Test to hang the UI
        // for 10 seconds on a dead URL.
-        val fastClient = callClient(relayUrl).newBuilder()
+        val fastClient = okHttpClient.newBuilder()
            .connectTimeout(3, java.util.concurrent.TimeUnit.SECONDS)
            .readTimeout(3, java.util.concurrent.TimeUnit.SECONDS)
            .writeTimeout(3, java.util.concurrent.TimeUnit.SECONDS)
@@ -1466,33 +1434,6 @@ 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.
     *
@@ -1505,7 +1446,7 @@ class RelayHttpClient(
        return value == "1" || value == "true"
    }

-    /** Provider-neutral enhancement for pools and providers upstream does not expose. */
+    /** Provider-neutral compatibility fetch for gateways without `account.usage`. */
    suspend fun fetchProviderUsage(
        profile: String? = null,
        sessionId: String? = null,
@@ -1543,12 +1484,12 @@ class RelayHttpClient(
            val request = Request.Builder()
                .url(url)
                .get()
-                .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+                .header("Authorization", "Bearer $sessionToken")
                .header("Accept", "application/json")
                .build()

            try {
-                callClient(relayUrl).newCall(request).execute().use { response ->
+                okHttpClient.newCall(request).execute().use { response ->
                    if (response.code == 404) {
                        // Older or operator-disabled hosts simply do not expose
                        // account usage. This is capability absence, not an error.
@@ -10,7 +10,6 @@ import com.hermesandroid.relay.data.ProfileMemoryUpdateResponse
 import com.hermesandroid.relay.data.LegacyProfileInspectorClient
 import com.hermesandroid.relay.data.RelaySkillToggleResult
 import com.hermesandroid.relay.data.RelayEndpointContract
-import com.hermesandroid.relay.data.isDashboardRelayIngressUrl
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.SerializationException
@@ -52,19 +51,11 @@ class RelayProfileInspectorClient(
    private val okHttpClient: OkHttpClient,
    private val relayUrlProvider: () -> String?,
    private val sessionTokenProvider: suspend () -> String?,
-    private val dashboardHttpClientProvider: ((String) -> OkHttpClient?)? = null,
 ) : LegacyProfileInspectorClient {

    private fun relayHttpBaseOrNull(url: String): String? =
        RelayEndpointContract.parseOrNull(url)?.httpBaseUrl

-    private fun callClient(relayUrl: String): OkHttpClient =
-        if (isDashboardRelayIngressUrl(relayUrl)) {
-            dashboardHttpClientProvider?.invoke(relayUrl) ?: okHttpClient
-        } else {
-            okHttpClient
-        }
-
    companion object {
        private const val TAG = "RelayProfileInspector"

@@ -220,12 +211,12 @@ class RelayProfileInspectorClient(
        val request = Request.Builder()
            .url(url)
            .put(body.toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                if (!response.isSuccessful) {
                    val reason = when (response.code) {
                        400 -> {
@@ -323,12 +314,12 @@ class RelayProfileInspectorClient(
        val request = Request.Builder()
            .url(url)
            .put(bodyJson.toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                when (response.code) {
                    in 200..299 -> Result.success(RelaySkillToggleResult.Ok)
                    501 -> Result.success(RelaySkillToggleResult.NotImplemented)
@@ -383,11 +374,11 @@ class RelayProfileInspectorClient(
        val request = Request.Builder()
            .url(url)
            .method("OPTIONS", null)
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                when (response.code) {
                    501 -> false
                    404, 405 -> false
@@ -473,12 +464,12 @@ class RelayProfileInspectorClient(
        val request = Request.Builder()
            .url(url)
            .get()
-            .relaySessionCredential(sessionToken, isDashboardRelayIngressUrl(relayUrl))
+            .header("Authorization", "Bearer $sessionToken")
            .header("Accept", "application/json")
            .build()

        try {
-            callClient(relayUrl).newCall(request).execute().use { response ->
+            okHttpClient.newCall(request).execute().use { response ->
                if (!response.isSuccessful) {
                    val reason = when (response.code) {
                        401, 403 -> "Unauthorized — re-pair with the relay"
@@ -7,7 +7,6 @@ import com.hermesandroid.relay.data.EnhancedVoiceOverrides
 import com.hermesandroid.relay.data.MessageRole
 import com.hermesandroid.relay.data.RealtimeConversationContextMessage
 import com.hermesandroid.relay.data.RelayEndpointContract
-import com.hermesandroid.relay.data.isDashboardRelayIngressUrl
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -90,7 +89,7 @@ import java.util.concurrent.atomic.AtomicReference
 */
 class RelayVoiceClient(
    private val context: Context,
-    okHttpClient: OkHttpClient,
+    private val okHttpClient: OkHttpClient,
    private val relayUrlProvider: () -> String?,
    private val sessionTokenProvider: suspend () -> String?,
    private val profileNameProvider: () -> String? = { null },
@@ -101,26 +100,8 @@ class RelayVoiceClient(
    private val realtimeResumeRetryIntervalMs: Long = REALTIME_RESUME_RETRY_INTERVAL_MS,
    private val realtimeResumeRetryWindowMs: Long = REALTIME_RESUME_RETRY_WINDOW_MS,
    private val voiceOutputFirstAudioTimeoutMs: Long = VOICE_OUTPUT_FIRST_AUDIO_TIMEOUT_MS,
-    /** Dashboard-authenticated transport for same-origin plugin ingress. */
-    private val dashboardHttpClientProvider: ((String) -> OkHttpClient?)? = null,
-    /** Fresh Dashboard ticket request for every ingress voice socket dial. */
-    private val dashboardIngressWebSocketRequestProvider:
-        (suspend (String) -> Request?)? = null,
 ) {

-    private val directOkHttpClient: OkHttpClient = okHttpClient
-
-    /** Resolve lazily so a Dashboard route/client handoff is observed. */
-    private val okHttpClient: OkHttpClient
-        get() {
-            val relayUrl = relayUrlProvider()?.trim().orEmpty()
-            return if (isDashboardRelayIngressUrl(relayUrl)) {
-                dashboardHttpClientProvider?.invoke(relayUrl) ?: directOkHttpClient
-            } else {
-                directOkHttpClient
-            }
-        }
-
    companion object {
        private const val TAG = "RelayVoiceClient"
        private val json = Json { ignoreUnknownKeys = true; isLenient = true }
@@ -163,36 +144,13 @@ class RelayVoiceClient(
        }
    }

-    private fun callClient(url: String): OkHttpClient =
-        if (isDashboardRelayIngressUrl(url)) {
-            dashboardHttpClientProvider?.invoke(url) ?: directOkHttpClient
-        } else {
-            directOkHttpClient
-        }
-
    private fun sessionClient(): OkHttpClient =
        okHttpClient.newBuilder()
            .callTimeout(SESSION_CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            .build()

    private fun openWebSocket(request: Request, listener: WebSocketListener): WebSocket =
-        webSocketFactory?.invoke(request, listener)
-            ?: callClient(request.url.toString()).newWebSocket(request, listener)
-
-    private suspend fun voiceWebSocketRequest(url: String, relayToken: String): Request {
-        val dashboardIngress = isDashboardRelayIngressUrl(url)
-        val outerRequest = if (dashboardIngress) {
-            val provider = dashboardIngressWebSocketRequestProvider
-                ?: throw IOException("Dashboard Relay voice authorization is unavailable")
-            provider(url)
-                ?: throw IOException("Dashboard Relay voice ticket could not be minted")
-        } else {
-            Request.Builder().url(url).build()
-        }
-        return outerRequest.newBuilder()
-            .relaySessionCredential(relayToken, dashboardIngress)
-            .build()
-    }
+        webSocketFactory?.invoke(request, listener) ?: okHttpClient.newWebSocket(request, listener)

    private fun requestRouteProbeOnce(
        surface: String,
@@ -238,7 +196,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/transcribe"))
            .post(body)
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -320,7 +278,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url("$httpBase/voice/synthesize")
            .post(bodyJson.toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "audio/mpeg")
            .build()

@@ -375,7 +333,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/config"))
            .get()
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -417,7 +375,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/realtime/config"))
            .get()
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -456,7 +414,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/realtime/providers/${pathSegment(provider)}/options"))
            .get()
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -504,7 +462,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/realtime/providers/${pathSegment(provider)}/validate"))
            .post(payload.toString().toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -557,7 +515,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/realtime/config"))
            .patch(payload.toString().toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -660,7 +618,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/realtime-agent/config"))
            .patch(payload.toString().toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        try {
@@ -692,7 +650,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/output/config"))
            .get()
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -731,7 +689,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/output/providers/${pathSegment(provider)}/options"))
            .get()
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -783,7 +741,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/output/providers/${pathSegment(provider)}/validate"))
            .post(payload.toString().toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -854,7 +812,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase/voice/output/config"))
            .patch(payload.toString().toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()

@@ -887,7 +845,6 @@ class RelayVoiceClient(
        onHandoff: (VoiceHandoffEvent) -> Unit = {},
        onEvent: (RealtimeVoiceEvent) -> Unit,
    ): Result<VoiceOutputSummary> = withContext(Dispatchers.IO) {
-        val owningScope = this
        val httpBase = resolveHttpBase()
            ?: return@withContext Result.failure(IllegalStateException("Relay URL not configured"))
        val token = resolveBearerToken()
@@ -912,7 +869,6 @@ class RelayVoiceClient(
        val completed = AtomicBoolean(false)
        val resumeAttempted = AtomicBoolean(false)
        val routeProbeRequested = AtomicBoolean(false)
-        val resumeDialPending = AtomicBoolean(false)
        val currentSocket = AtomicReference<WebSocket?>()
        val firstAudioSeen = AtomicBoolean(false)
        val socketGeneration = AtomicLong(0L)
@@ -951,14 +907,14 @@ class RelayVoiceClient(
            }
        }

-        suspend fun openSocket(resume: Boolean, overrideWsBase: String? = null): WebSocket {
+        fun openSocket(resume: Boolean, overrideWsBase: String? = null): WebSocket {
            val generation = socketGeneration.incrementAndGet()
            val currentWsBase = overrideWsBase ?: resolveWebSocketBase()
                ?: throw IOException("Relay URL not configured")
-            val request = voiceWebSocketRequest(
-                "$currentWsBase${session.websocketPath}",
-                token,
-            )
+            val request = Request.Builder()
+                .url("$currentWsBase${session.websocketPath}")
+                .header("Authorization", "Bearer $token")
+                .build()
            Log.i(
                TAG,
                "Voice output websocket opening resume=$resume url=${request.url}",
@@ -1088,28 +1044,23 @@ class RelayVoiceClient(
                        return
                    }
                    if (session.resumeSupported && !session.resumeToken.isNullOrBlank() && resumeAttempted.compareAndSet(false, true)) {
-                        Log.i(TAG, "Voice output websocket failed; scheduling resume: ${t.message}")
-                        requestRouteProbeOnce("Voice output", t.message, routeProbeRequested)
-                        onHandoff(
-                            VoiceHandoffEvent(
-                                label = context.getString(R.string.voice_diag_connection_changed),
-                                detail = t.message,
-                                route = routeLabel(webSocket.request().url.toString()),
-                                active = true,
+                        try {
+                            Log.i(TAG, "Voice output websocket failed; attempting resume: ${t.message}")
+                            requestRouteProbeOnce("Voice output", t.message, routeProbeRequested)
+                            onHandoff(
+                                VoiceHandoffEvent(
+                                    label = context.getString(R.string.voice_diag_connection_changed),
+                                    detail = t.message,
+                                    route = routeLabel(webSocket.request().url.toString()),
+                                    active = true,
+                                )
                            )
-                        )
-                        if (resumeDialPending.compareAndSet(false, true)) {
-                            owningScope.launch {
-                                try {
-                                    openSocket(resume = true)
-                                } catch (e: Exception) {
-                                    completeFailure("Voice output resume failed: ${e.message ?: "network error"}", e)
-                                } finally {
-                                    resumeDialPending.set(false)
-                                }
-                            }
+                            openSocket(resume = true)
+                            return
+                        } catch (e: Exception) {
+                            completeFailure("Voice output resume failed: ${e.message ?: "network error"}", e)
+                            return
                        }
-                        return
                    }
                    completeFailure("Voice output websocket failed: ${t.message}", t)
                }
@@ -1139,28 +1090,23 @@ class RelayVoiceClient(
                        return
                    }
                    if (session.resumeSupported && !session.resumeToken.isNullOrBlank() && resumeAttempted.compareAndSet(false, true)) {
-                        Log.i(TAG, "Voice output websocket closed code=$code; scheduling resume")
-                        requestRouteProbeOnce("Voice output", "Closed $code $reason", routeProbeRequested)
-                        onHandoff(
-                            VoiceHandoffEvent(
-                                label = context.getString(R.string.voice_diag_connection_changed),
-                                detail = "Closed $code $reason",
-                                route = routeLabel(webSocket.request().url.toString()),
-                                active = true,
+                        try {
+                            Log.i(TAG, "Voice output websocket closed code=$code; attempting resume")
+                            requestRouteProbeOnce("Voice output", "Closed $code $reason", routeProbeRequested)
+                            onHandoff(
+                                VoiceHandoffEvent(
+                                    label = context.getString(R.string.voice_diag_connection_changed),
+                                    detail = "Closed $code $reason",
+                                    route = routeLabel(webSocket.request().url.toString()),
+                                    active = true,
+                                )
                            )
-                        )
-                        if (resumeDialPending.compareAndSet(false, true)) {
-                            owningScope.launch {
-                                try {
-                                    openSocket(resume = true)
-                                } catch (e: Exception) {
-                                    completeFailure("Voice output resume failed: ${e.message ?: "network error"}", e)
-                                } finally {
-                                    resumeDialPending.set(false)
-                                }
-                            }
+                            openSocket(resume = true)
+                            return
+                        } catch (e: Exception) {
+                            completeFailure("Voice output resume failed: ${e.message ?: "network error"}", e)
+                            return
                        }
-                        return
                    }
                    completeFailure("Voice output websocket closed before completion: $code $reason")
                }
@@ -1232,7 +1178,10 @@ class RelayVoiceClient(
        var audioChunks = 0
        var audioBytes = 0

-        val request = voiceWebSocketRequest("$wsBase${session.websocketPath}", token)
+        val request = Request.Builder()
+            .url("$wsBase${session.websocketPath}")
+            .header("Authorization", "Bearer $token")
+            .build()

        val listener = object : WebSocketListener() {
            override fun onOpen(webSocket: WebSocket, response: Response) {
@@ -1357,7 +1306,6 @@ class RelayVoiceClient(
        prewarm: Boolean = false,
        onEvent: (RealtimeVoiceEvent, RealtimeAgentSessionControl) -> Unit,
    ): Result<RealtimeVoiceSummary> = withContext(Dispatchers.IO) {
-        val owningScope = this
        val persistent = turnInputs != null
        val httpBase = resolveHttpBase()
            ?: return@withContext Result.failure(IllegalStateException("Relay URL not configured"))
@@ -1701,7 +1649,7 @@ class RelayVoiceClient(
            }
        }

-        suspend fun openSocket(
+        fun openSocket(
            resume: Boolean,
            overrideWsBase: String? = null,
            expectedResumeEpisode: Long? = null,
@@ -1725,10 +1673,10 @@ class RelayVoiceClient(
            val (currentWsBase, request) = try {
                val base = overrideWsBase ?: resolveWebSocketBase()
                    ?: throw IOException("Relay URL not configured")
-                val socketRequest = voiceWebSocketRequest(
-                    "$base${session.websocketPath}",
-                    token,
-                )
+                val socketRequest = Request.Builder()
+                    .url("$base${session.websocketPath}")
+                    .header("Authorization", "Bearer $token")
+                    .build()
                Log.i(
                    TAG,
                    "Realtime agent websocket opening resume=$resume url=${socketRequest.url}",
@@ -1817,20 +1765,12 @@ class RelayVoiceClient(
                                // A synchronous failure callback can replace this
                                // socket while setup sends are still unwinding. A
                                // stale attempt must not terminate the newer route.
-                                if (
-                                    terminalCallbackSeen.get() ||
-                                    currentSocket.get() !== webSocket ||
-                                    completed.get()
-                                ) return
+                                if (currentSocket.get() !== webSocket || completed.get()) return
                                completeFailure("Realtime agent websocket rejected session setup")
                                webSocket.close(1011, "session setup failed")
                                return
                            }
-                            if (
-                                terminalCallbackSeen.get() ||
-                                currentSocket.get() !== webSocket ||
-                                completed.get()
-                            ) return
+                            if (currentSocket.get() !== webSocket || completed.get()) return
                            if (resume) {
                                Log.i(TAG, "Realtime agent resume sent; awaiting relay confirmation")
                            } else {
@@ -2044,17 +1984,16 @@ class RelayVoiceClient(
                            )
                        )
                        if (!claim.openImmediately) return
-                        owningScope.launch {
-                            try {
-                                openSocket(
-                                    resume = true,
-                                    expectedResumeEpisode = claim.waiting.episode,
-                                )
-                            } catch (e: Exception) {
-                                completeFailure("Realtime agent resume failed: ${e.message ?: "network error"}", e)
-                            }
+                        try {
+                            openSocket(
+                                resume = true,
+                                expectedResumeEpisode = claim.waiting.episode,
+                            )
+                            return
+                        } catch (e: Exception) {
+                            completeFailure("Realtime agent resume failed: ${e.message ?: "network error"}", e)
+                            return
                        }
-                        return
                    }
                    val transitionRevision = claimTerminalSocket(
                        webSocket,
@@ -2158,17 +2097,16 @@ class RelayVoiceClient(
                            )
                        )
                        if (!claim.openImmediately) return
-                        owningScope.launch {
-                            try {
-                                openSocket(
-                                    resume = true,
-                                    expectedResumeEpisode = claim.waiting.episode,
-                                )
-                            } catch (e: Exception) {
-                                completeFailure("Realtime agent resume failed: ${e.message ?: "network error"}", e)
-                            }
+                        try {
+                            openSocket(
+                                resume = true,
+                                expectedResumeEpisode = claim.waiting.episode,
+                            )
+                            return
+                        } catch (e: Exception) {
+                            completeFailure("Realtime agent resume failed: ${e.message ?: "network error"}", e)
+                            return
                        }
-                        return
                    }
                    val transitionRevision = claimTerminalSocket(
                        webSocket,
@@ -2356,7 +2294,9 @@ class RelayVoiceClient(
            null
        }

-        val initialSocket = openSocket(resume = false) ?: currentSocket.get()
+        val socket = openSocket(resume = false)
+            ?: currentSocket.get()
+            ?: throw IOException("Realtime agent websocket handshake was already pending")
        val routeWatcherResumeEpisode = AtomicLong(0L)
        val routeWatcher = startRouteResumeWatcher(
            surface = "Realtime agent",
@@ -2438,7 +2378,7 @@ class RelayVoiceClient(
            awaitRealtimeAgentCompletion()
        } catch (e: Exception) {
            currentSocket.get()?.close(1001, "timeout")
-            initialSocket?.close(1001, "timeout")
+            socket.close(1001, "timeout")
            Result.failure(IOException(e.message ?: "Realtime agent timed out", e))
        } finally {
            routeWatcher?.cancel()
@@ -2454,7 +2394,7 @@ class RelayVoiceClient(
        resumeSupported: Boolean,
        resumeToken: String?,
        currentSocket: AtomicReference<WebSocket?>,
-        openResumeSocket: suspend (String?) -> WebSocket?,
+        openResumeSocket: (String?) -> WebSocket?,
        onHandoff: (VoiceHandoffEvent) -> Unit,
        completeFailure: (String, Throwable?) -> Unit,
    ): Job? {
@@ -2514,7 +2454,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase$path"))
            .get()
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        try {
@@ -2553,7 +2493,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase$pathPrefix/${pathSegment(provider)}/options"))
            .get()
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        try {
@@ -2601,7 +2541,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase$pathPrefix/${pathSegment(provider)}/validate"))
            .post(payload.toString().toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        try {
@@ -2653,7 +2593,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url(urlWithProfile("$httpBase$path"))
            .patch(payload.toString().toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        try {
@@ -2738,7 +2678,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url("$httpBase/voice/realtime/session")
            .post(body.toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        return try {
@@ -2823,7 +2763,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url("$httpBase/voice/realtime-agent/session")
            .post(body.toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        return try {
@@ -2864,7 +2804,7 @@ class RelayVoiceClient(
        val request = Request.Builder()
            .url("$httpBase/voice/output/session")
            .post(body.toRequestBody(JSON_MEDIA_TYPE))
-            .relaySessionCredential(token, isDashboardRelayIngressUrl(httpBase))
+            .header("Authorization", "Bearer $token")
            .header("Accept", "application/json")
            .build()
        return try {
@@ -5,7 +5,6 @@ import android.util.Log
 import com.hermesandroid.relay.R
 import com.hermesandroid.relay.data.EndpointCandidate
 import com.hermesandroid.relay.data.RelayEndpointContract
-import com.hermesandroid.relay.data.isDashboardRelayIngressUrl
 import com.hermesandroid.relay.data.primaryRouteUrl
 import com.hermesandroid.relay.data.routeAuthority
 import com.hermesandroid.relay.diagnostics.DiagnosticCategory
@@ -13,24 +12,16 @@ import com.hermesandroid.relay.diagnostics.DiagnosticSeverity
 import com.hermesandroid.relay.diagnostics.DiagnosticsLog
 import com.hermesandroid.relay.diagnostics.NetworkDiagnosticGuidance
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.TimeoutCancellationException
 import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.currentCoroutineContext
-import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeoutOrNull
-import kotlinx.coroutines.launch
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
 import okhttp3.OkHttpClient
 import okhttp3.Request
@@ -52,7 +43,7 @@ import javax.net.ssl.SSLException
 */
 data class RouteProbeOutcome(
    val reachable: Boolean,
-    /** Short result detail; protected ingress may be reachable but require authorization. */
+    /** Short human-readable failure reason; null when [reachable]. */
    val detail: String? = null,
    /** Resolver-clock timestamp of when the probe finished. */
    val atMillis: Long,
@@ -77,15 +68,12 @@ enum class EndpointSurface {
 *
 * ### Semantics (locked by ADR 24)
 *
- *  * **Strict selection priority with speculative probes.** `priority = 0`
- *    is highest. All supported priority groups start probing together so one
- *    dead route cannot add its full timeout before the fallback even starts,
- *    but a lower-priority result is considered only after every higher group
- *    has failed. Reachability is **only** the tiebreaker among candidates that
- *    share the same priority.
- *  * **Reachability probe.** Dashboard-first routes use lightweight `GET
- *    ${dashboard.url}/api/health` and fall back to `/api/status` only for a
- *    confirmed legacy host without the health route. Legacy API routes use `GET
+ *  * **Strict priority.** `priority = 0` is highest. If a priority-0
+ *    candidate is reachable we use it; reachability never promotes a lower
+ *    priority over a higher one. Reachability is **only** the tiebreaker
+ *    among candidates that share the same priority.
+ *  * **Reachability probe.** Dashboard-first routes use `GET
+ *    ${dashboard.url}/api/status`; legacy API routes use `GET
 *    ${api.url}/health`. Relay-only routes use `GET ${relay.httpUrl}/health`.
 *    Each request has a 4-second
 *    per-candidate timeout. Positive results are cached longer than negative
@@ -138,21 +126,9 @@ class EndpointResolver(
        val baseUrl: String,
        val requestUrl: String,
        val path: String,
-        val legacyFallbackRequestUrl: String? = null,
-        val legacyFallbackPath: String? = null,
-    )
-
-    private data class ProbeHttpResult(
-        val code: Int,
-        val successful: Boolean,
-        val bodyPreview: String,
    )

    private val probeCache = ConcurrentHashMap<String, CacheEntry>()
-    private val inFlightProbes = ConcurrentHashMap<String, Deferred<Boolean>>()
-    private val probeScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-    private val probeStateLock = Any()
-    private var probeGeneration = 0L

    private val _probeOutcomes = MutableStateFlow<Map<String, RouteProbeOutcome>>(emptyMap())

@@ -164,12 +140,6 @@ class EndpointResolver(
     */
    val probeOutcomes: StateFlow<Map<String, RouteProbeOutcome>> = _probeOutcomes.asStateFlow()

-    /** Last independently observed verdict for one configured route surface. */
-    fun outcomeFor(
-        candidate: EndpointCandidate,
-        surface: EndpointSurface,
-    ): RouteProbeOutcome? = probeOutcomes.value[outcomeKey(candidate, surface)]
-
    private fun recordOutcome(
        candidate: EndpointCandidate,
        surface: EndpointSurface,
@@ -207,47 +177,40 @@ class EndpointResolver(
        const val CACHE_TTL_MS = 60_000L

        /**
-         * Failed probe-result cache TTL. Keep this bounded but long enough
-         * that ordinary screen/profile lifecycle work cannot repeatedly pay
-         * the full probe timeout:
+         * Failed probe-result cache TTL. Keep this intentionally short:
         * Android may report a new cellular/VPN network before Tailscale has
         * finished routing, so a single early ConnectException must not keep a
-         * viable fallback route suppressed for long. Network-change and
-         * explicit-probe paths invalidate the cache immediately.
+         * viable fallback route suppressed through the voice resume window.
         */
-        const val NEGATIVE_CACHE_TTL_MS = 15_000L
+        const val NEGATIVE_CACHE_TTL_MS = 2_000L

        /** Shared timeout wording so HEAD-timeout and socket-timeout read the same. */
        private const val PROBE_TIMEOUT_DETAIL = "No answer (timed out)"

        /**
-         * Stable outcome/cache key for one candidate surface:
-         * `"<surface>|<role>|<normalized service base>"`.
+         * Stable cache key for one candidate surface:
+         * `"<surface>|<role>|<surface host>:<port>"`.
         * Roles are preserved case-verbatim (HMAC canonicalization contract)
         * but hostnames are lowercased — two roles pointing at the same
         * host:port share reachability state.
         */
-        fun outcomeKey(
-            candidate: EndpointCandidate,
-            surface: EndpointSurface = EndpointSurface.Standard,
-        ): String {
-            val serviceIdentity = when (surface) {
-                EndpointSurface.Standard ->
-                    candidate.routeAuthority() ?: candidate.primaryRouteUrl().orEmpty().lowercase()
-                EndpointSurface.Dashboard ->
-                    routeIdentity(candidate.pluginProxyRoutesOrNull()?.dashboardBaseUrl ?: candidate.dashboard?.url)
-                EndpointSurface.Api ->
-                    routeIdentity(candidate.pluginProxyRoutesOrNull()?.apiBaseUrl ?: candidate.api?.url)
-                EndpointSurface.Relay ->
-                    routeIdentity(candidate.pluginProxyRoutesOrNull()?.relayHttpUrl ?: candidate.relay?.url)
-            }
-            return "${surface.name.lowercase()}|${candidate.role}|$serviceIdentity"
-        }
-
        internal fun cacheKey(
            candidate: EndpointCandidate,
            surface: EndpointSurface = EndpointSurface.Standard,
-        ): String = outcomeKey(candidate, surface)
+        ): String {
+            val authority = when (surface) {
+                EndpointSurface.Standard ->
+                    candidate.routeAuthority() ?: candidate.primaryRouteUrl().orEmpty().lowercase()
+                EndpointSurface.Dashboard ->
+                    routeAuthority(candidate.pluginProxyRoutesOrNull()?.dashboardBaseUrl ?: candidate.dashboard?.url).orEmpty()
+                EndpointSurface.Api ->
+                    routeAuthority(candidate.pluginProxyRoutesOrNull()?.apiBaseUrl ?: candidate.api?.url).orEmpty()
+                EndpointSurface.Relay ->
+                    candidate.pluginProxyRoutesOrNull()?.authority
+                        ?: routeAuthority(candidate.relay?.url).orEmpty()
+            }
+            return "${surface.name.lowercase()}|${candidate.role}|$authority"
+        }

        private fun routeAuthority(rawUrl: String?): String? {
            val candidate = rawUrl?.trim()?.takeIf { it.isNotBlank() } ?: return null
@@ -260,31 +223,17 @@ class EndpointResolver(
            }
            return httpUrl.toHttpUrlOrNull()?.let { url -> "${url.host}:${url.port}" }
        }
-
-        private fun routeIdentity(rawUrl: String?): String {
-            val candidate = rawUrl?.trim()?.takeIf { it.isNotBlank() } ?: return ""
-            val httpCandidate = when {
-                candidate.startsWith("ws://", ignoreCase = true) ->
-                    "http://${candidate.substringAfter("://")}"
-                candidate.startsWith("wss://", ignoreCase = true) ->
-                    "https://${candidate.substringAfter("://")}"
-                else -> candidate
-            }
-            return httpCandidate.toHttpUrlOrNull()?.let { url ->
-                val path = url.encodedPath.trimEnd('/').takeIf { it.isNotEmpty() }.orEmpty()
-                "${url.scheme}://${url.host}:${url.port}$path"
-            } ?: candidate.lowercase().trimEnd('/')
-        }
    }

    /**
     * Run the resolver against [candidates].
     *
-     *  1. Group by `priority` ascending and by supported/experimental tier.
-     *  2. Start every supported priority group speculatively, while awaiting
-     *     their results in strict priority order. Within a group, first 2xx
-     *     wins. If higher groups fail, a completed fallback is ready at once.
-     *  3. Probe the experimental tier only when every supported group fails.
+     *  1. Group by `priority` ascending.
+     *  2. For each priority group, race the selected surface's health probe
+     *     against every candidate in the group. First 2xx wins; ties
+     *     broken by whichever response lands first.
+     *  3. If the entire group is unreachable, fall through to the next
+     *     priority group.
     *  4. If no candidate is reachable, return `null` — the caller falls back
     *     to its legacy single-URL path.
     *
@@ -305,15 +254,14 @@ class EndpointResolver(
        // last-resort fallback without displacing Tailscale or direct TLS.
        val supported = eligible.filterNot { it.experimental || it.role.equals("outbound_broker", ignoreCase = true) }
        val experimental = eligible.filter { it.experimental || it.role.equals("outbound_broker", ignoreCase = true) }
-        val tiers = listOf(
-            supported.groupBy { it.priority }.toSortedMap().values.toList(),
-            experimental.groupBy { it.priority }.toSortedMap().values.toList(),
-        )
+        val groups = (supported.groupBy { it.priority }.toSortedMap().values +
+            experimental.groupBy { it.priority }.toSortedMap().values)

-        for (groups in tiers) {
-            val winner = racePriorityGroups(groups, surface)
+        for (group in groups) {
+            val priority = group.first().priority
+            Log.d(TAG, "probing priority=$priority group (size=${group.size})")
+            val winner = raceGroup(group, surface)
            if (winner != null) {
-                val priority = winner.priority
                val winnerUrl = probeTarget(winner, surface)?.baseUrl
                Log.i(TAG, "resolve winner: role=${winner.role} " +
                    "surface=$surface route=$winnerUrl priority=$priority")
@@ -339,76 +287,6 @@ class EndpointResolver(
        return null
    }

-    /**
-     * Start all groups in one stability tier together, but consume them in
-     * strict priority order. Cancelling losing waiters never cancels the shared
-     * physical probes, so their cache/outcome records still warm later calls.
-     */
-    private suspend fun racePriorityGroups(
-        groups: List<List<EndpointCandidate>>,
-        surface: EndpointSurface,
-    ): EndpointCandidate? = coroutineScope {
-        if (groups.isEmpty()) return@coroutineScope null
-        val races = groups.map { group ->
-            val priority = group.first().priority
-            Log.d(TAG, "probing priority=$priority group (size=${group.size})")
-            group to async(Dispatchers.IO) { raceGroup(group, surface) }
-        }
-        for ((_, race) in races) {
-            val winner = race.await()
-            if (winner != null) {
-                races.forEach { (_, other) -> if (other !== race) other.cancel() }
-                return@coroutineScope winner
-            }
-        }
-        null
-    }
-
-    /**
-     * Probe every independently configured route surface in parallel.
-     *
-     * Dashboard/Gateway, optional API fallback, and Relay do not vouch for one
-     * another even when they share a hostname. Unconfigured surfaces are
-     * omitted. Invalidated probes publish no result, preserving the prior
-     * outcome until a fresh physical probe completes.
-     */
-    suspend fun probeSurfaces(
-        candidate: EndpointCandidate,
-    ): Map<EndpointSurface, RouteProbeOutcome> = coroutineScope {
-        val configuredSurfaces = listOf(
-            EndpointSurface.Dashboard,
-            EndpointSurface.Api,
-            EndpointSurface.Relay,
-        ).filter { probeTarget(candidate, it) != null }
-
-        configuredSurfaces
-            .map { surface ->
-                async {
-                    isReachable(candidate, surface)
-                    surface to currentCachedOutcomeFor(candidate, surface)
-                }
-            }
-            .mapNotNull { deferred ->
-                val (surface, outcome) = deferred.await()
-                outcome?.let { surface to it }
-            }
-            .toMap()
-    }
-
-    /** Return only an outcome still backed by this generation's probe cache. */
-    private fun currentCachedOutcomeFor(
-        candidate: EndpointCandidate,
-        surface: EndpointSurface,
-    ): RouteProbeOutcome? = synchronized(probeStateLock) {
-        val key = cacheKey(candidate, surface)
-        val cached = probeCache[key]
-        if (cached != null && cached.expiresAt > clock()) {
-            probeOutcomes.value[key]
-        } else {
-            null
-        }
-    }
-
    /**
     * Race all candidates in [group] (same priority tier) in parallel. First
     * candidate that reports reachable — whether from cache or a fresh probe
@@ -438,23 +316,20 @@ class EndpointResolver(
        }

        return coroutineScope {
-            val completions = Channel<EndpointCandidate?>(group.size)
-            val waiters = group.map { candidate ->
-                launch(Dispatchers.IO) {
-                    completions.send(if (isReachable(candidate, surface)) candidate else null)
+            val deferred = group.map { candidate ->
+                async(Dispatchers.IO) {
+                    if (isReachable(candidate, surface)) candidate else null
                }
            }
-            repeat(group.size) {
-                val completed = completions.receive()
-                if (completed != null) {
-                    // Cancelling these waiters does not cancel the shared
-                    // physical probes below; their outcomes still populate
-                    // the cache for the next resolution.
-                    waiters.forEach { it.cancel() }
-                    return@coroutineScope completed
-                }
-            }
-            null
+            // Collect results in arrival order: iterate through awaitAll +
+            // pick the first non-null. awaitAll preserves input order, which
+            // means a slow-but-reachable priority-0 candidate would block a
+            // fast-and-reachable sibling. But HEAD /health against a healthy
+            // API route replies in <100ms and the timeout caps stragglers at 2s,
+            // so this is acceptable in practice. A true "first to arrive"
+            // would need kotlinx.coroutines Channel plumbing that's not
+            // worth the weight here.
+            deferred.awaitAll().firstOrNull { it != null }
        }
    }

@@ -475,33 +350,10 @@ class EndpointResolver(
            return cached.reachable
        }

-        // Resolution is triggered from several independent lifecycle paths
-        // (connection hydration, profile restoration, network callbacks, and
-        // explicit probes). Share one physical request per route/surface so a
-        // slow optional endpoint cannot accumulate duplicate 4-second probes.
-        val shared = synchronized(probeStateLock) {
-            inFlightProbes[key] ?: run {
-                val generation = probeGeneration
-                probeScope.async(start = CoroutineStart.LAZY) {
-                    probe(candidate, surface, generation)
-                }.also { deferred ->
-                    inFlightProbes[key] = deferred
-                    deferred.invokeOnCompletion { inFlightProbes.remove(key, deferred) }
-                    deferred.start()
-                }
-            }
-        }
-        return try {
-            shared.await()
-        } catch (_: CancellationException) {
-            // clearCache() owns cancellation of the shared physical probe. A
-            // still-active waiter treats that invalidated result as unknown so
-            // same-priority races can publish their non-winning completion.
-            // Genuine caller cancellation still propagates from ensureActive.
-            currentCoroutineContext().ensureActive()
-            Log.d(TAG, "probe invalidated for $key")
-            false
-        }
+        val reachable = probe(candidate, surface)
+        val ttl = if (reachable) CACHE_TTL_MS else NEGATIVE_CACHE_TTL_MS
+        probeCache[key] = CacheEntry(expiresAt = now + ttl, reachable = reachable)
+        return reachable
    }

    /**
@@ -515,7 +367,6 @@ class EndpointResolver(
    private suspend fun probe(
        candidate: EndpointCandidate,
        surface: EndpointSurface,
-        generation: Long,
    ): Boolean {
        val startedAtMs = clock()
        val operation = when (surface) {
@@ -527,25 +378,19 @@ class EndpointResolver(
        val target = probeTarget(candidate, surface)
        val url = target?.requestUrl?.toHttpUrlOrNull()
            ?: run {
-                return completeProbe(
-                    candidate = candidate,
-                    surface = surface,
-                    generation = generation,
-                    reachable = false,
-                    detail = "Invalid route URL",
-                ) {
-                    Log.w(TAG, "probe: invalid url for role=${candidate.role}")
-                    DiagnosticsLog.record(
-                        category = DiagnosticCategory.Endpoint,
-                        severity = DiagnosticSeverity.Error,
-                        title = context?.getString(R.string.endpoint_diag_probe_invalid) ?: "Endpoint probe invalid",
-                        detail = "No valid Dashboard, API, or Relay URL",
-                        operation = operation,
-                        endpointRole = candidate.role,
-                        configuredUrl = candidate.primaryRouteUrl(),
-                        suggestion = "Edit or re-pair this route so it contains a valid service URL.",
-                    )
-                }
+                Log.w(TAG, "probe: invalid url for role=${candidate.role}")
+                DiagnosticsLog.record(
+                    category = DiagnosticCategory.Endpoint,
+                    severity = DiagnosticSeverity.Error,
+                    title = context?.getString(R.string.endpoint_diag_probe_invalid) ?: "Endpoint probe invalid",
+                    detail = "No valid Dashboard, API, or Relay URL",
+                    operation = operation,
+                    endpointRole = candidate.role,
+                    configuredUrl = candidate.primaryRouteUrl(),
+                    suggestion = "Edit or re-pair this route so it contains a valid service URL.",
+                )
+                recordOutcome(candidate, surface, reachable = false, detail = "Invalid route URL")
+                return false
            }
        val fastClient = (clientForCandidate?.invoke(candidate) ?: httpClient).newBuilder()
            .connectTimeout(PROBE_TIMEOUT_MS, TimeUnit.MILLISECONDS)
@@ -553,96 +398,49 @@ class EndpointResolver(
            .writeTimeout(PROBE_TIMEOUT_MS, TimeUnit.MILLISECONDS)
            .callTimeout(PROBE_TIMEOUT_MS, TimeUnit.MILLISECONDS)
            .build()
+        val requestBuilder = Request.Builder()
+            .url(url)
+            .header("Accept", "*/*")
+        // Hermes API's aiohttp health route accepts GET but returns 405 to
+        // HEAD. That response proves connectivity while the old probe marked
+        // the route unreachable. Health payloads are tiny, so follow the
+        // endpoint's actual public contract on every surface.
+        val request = requestBuilder.get().build()
        return withContext(Dispatchers.IO) {
            try {
                withTimeoutOrNull(PROBE_TIMEOUT_MS + 200L) {
-                    val primary = executeProbeHttp(fastClient, url)
-                    val fallbackUrl = target.legacyFallbackRequestUrl
-                        ?.takeIf { dashboardHealthNeedsLegacyFallback(primary) }
-                        ?.toHttpUrlOrNull()
-                    val result = fallbackUrl?.let { executeProbeHttp(fastClient, it) } ?: primary
-                    val resultPath = if (fallbackUrl != null) {
-                        target.legacyFallbackPath ?: target.path
-                    } else {
-                        target.path
-                    }
-                    val resultUrl = fallbackUrl?.toString() ?: target.requestUrl
-                    result.let { response ->
-                        val authRequired = surface == EndpointSurface.Relay &&
-                            isDashboardRelayIngressUrl(candidate.relay?.url) &&
-                            response.code in setOf(401, 403)
-                        val reachable = response.successful || authRequired
-                        val probeTitle = if (reachable) {
+                    fastClient.newCall(request).execute().use { resp ->
+                        val ok = resp.isSuccessful
+                        val probeTitle = if (ok) {
                            context?.getString(R.string.endpoint_diag_probe_ok) ?: "Endpoint probe ok"
                        } else {
                            context?.getString(R.string.endpoint_diag_probe_failed) ?: "Endpoint probe failed"
                        }
-                        completeProbe(
-                            candidate = candidate,
-                            surface = surface,
-                            generation = generation,
-                            reachable = reachable,
-                            detail = when {
-                                authRequired -> "HTTP ${response.code} · Dashboard authorization required"
-                                reachable -> null
-                                else -> "HTTP ${response.code} from $resultPath"
-                            },
-                        ) {
-                            DiagnosticsLog.record(
-                                category = DiagnosticCategory.Endpoint,
-                                severity = if (reachable) DiagnosticSeverity.Info else DiagnosticSeverity.Warning,
-                                title = probeTitle,
-                                detail = when {
-                                    authRequired -> "HTTP ${response.code} · Dashboard authorization required"
-                                    reachable -> null
-                                    else -> "HTTP ${response.code}"
-                                },
-                                operation = operation,
-                                endpointRole = candidate.role,
-                                configuredUrl = target.baseUrl,
-                                requestUrl = resultUrl,
-                                elapsedMs = clock() - startedAtMs,
-                                suggestion = if (reachable) {
-                                    null
-                                } else {
-                                    NetworkDiagnosticGuidance.forHttpStatus(
-                                        response.code,
-                                        surface.diagnosticTarget(),
-                                    )
-                                },
-                            )
-                        }
-                    }
-                } ?: run {
-                    completeProbe(
-                        candidate = candidate,
-                        surface = surface,
-                        generation = generation,
-                        reachable = false,
-                        detail = PROBE_TIMEOUT_DETAIL,
-                    ) {
                        DiagnosticsLog.record(
                            category = DiagnosticCategory.Endpoint,
-                            severity = DiagnosticSeverity.Warning,
-                            title = context?.getString(R.string.endpoint_diag_probe_timeout) ?: "Endpoint probe timeout",
-                            detail = "No ${target.path} response in ${PROBE_TIMEOUT_MS}ms",
+                            severity = if (ok) DiagnosticSeverity.Info else DiagnosticSeverity.Warning,
+                            title = probeTitle,
+                            detail = if (ok) null else "HTTP ${resp.code}",
                            operation = operation,
                            endpointRole = candidate.role,
                            configuredUrl = target.baseUrl,
                            requestUrl = target.requestUrl,
                            elapsedMs = clock() - startedAtMs,
-                            suggestion = "Check network routing or firewall rules between this device and ${surface.diagnosticTarget()}.",
+                            suggestion = if (ok) {
+                                null
+                            } else {
+                                NetworkDiagnosticGuidance.forHttpStatus(resp.code, surface.diagnosticTarget())
+                            },
                        )
+                        recordOutcome(
+                            candidate,
+                            surface,
+                            reachable = ok,
+                            detail = if (ok) null else "HTTP ${resp.code} from ${target.path}",
+                        )
+                        ok
                    }
-                }
-            } catch (_: TimeoutCancellationException) {
-                completeProbe(
-                    candidate = candidate,
-                    surface = surface,
-                    generation = generation,
-                    reachable = false,
-                    detail = PROBE_TIMEOUT_DETAIL,
-                ) {
+                } ?: run {
                    DiagnosticsLog.record(
                        category = DiagnosticCategory.Endpoint,
                        severity = DiagnosticSeverity.Warning,
@@ -655,81 +453,45 @@ class EndpointResolver(
                        elapsedMs = clock() - startedAtMs,
                        suggestion = "Check network routing or firewall rules between this device and ${surface.diagnosticTarget()}.",
                    )
+                    recordOutcome(candidate, surface, reachable = false, detail = PROBE_TIMEOUT_DETAIL)
+                    false
                }
-            } catch (e: CancellationException) {
-                throw e
+            } catch (_: TimeoutCancellationException) {
+                DiagnosticsLog.record(
+                    category = DiagnosticCategory.Endpoint,
+                    severity = DiagnosticSeverity.Warning,
+                    title = context?.getString(R.string.endpoint_diag_probe_timeout) ?: "Endpoint probe timeout",
+                    detail = "No ${target.path} response in ${PROBE_TIMEOUT_MS}ms",
+                    operation = operation,
+                    endpointRole = candidate.role,
+                    configuredUrl = target.baseUrl,
+                    requestUrl = target.requestUrl,
+                    elapsedMs = clock() - startedAtMs,
+                    suggestion = "Check network routing or firewall rules between this device and ${surface.diagnosticTarget()}.",
+                )
+                recordOutcome(candidate, surface, reachable = false, detail = PROBE_TIMEOUT_DETAIL)
+                false
            } catch (e: Exception) {
-                completeProbe(
-                    candidate = candidate,
-                    surface = surface,
-                    generation = generation,
-                    reachable = false,
+                Log.d(TAG, "probe failed role=${candidate.role} " +
+                    "route=${target.baseUrl}: ${e.javaClass.simpleName}")
+                DiagnosticsLog.record(
+                    category = DiagnosticCategory.Endpoint,
+                    severity = DiagnosticSeverity.Warning,
+                    title = context?.getString(R.string.endpoint_diag_probe_failed) ?: "Endpoint probe failed",
                    detail = humanProbeFailure(e),
-                ) {
-                    Log.d(TAG, "probe failed role=${candidate.role} " +
-                        "route=${target.baseUrl}: ${e.javaClass.simpleName}")
-                    DiagnosticsLog.record(
-                        category = DiagnosticCategory.Endpoint,
-                        severity = DiagnosticSeverity.Warning,
-                        title = context?.getString(R.string.endpoint_diag_probe_failed) ?: "Endpoint probe failed",
-                        detail = humanProbeFailure(e),
-                        operation = operation,
-                        endpointRole = candidate.role,
-                        configuredUrl = target.baseUrl,
-                        requestUrl = target.requestUrl,
-                        elapsedMs = clock() - startedAtMs,
-                        suggestion = NetworkDiagnosticGuidance.forThrowable(e, surface.diagnosticTarget()),
-                    )
-                }
+                    operation = operation,
+                    endpointRole = candidate.role,
+                    configuredUrl = target.baseUrl,
+                    requestUrl = target.requestUrl,
+                    elapsedMs = clock() - startedAtMs,
+                    suggestion = NetworkDiagnosticGuidance.forThrowable(e, surface.diagnosticTarget()),
+                )
+                recordOutcome(candidate, surface, reachable = false, detail = humanProbeFailure(e))
+                false
            }
        }
    }

-    private fun executeProbeHttp(client: OkHttpClient, url: okhttp3.HttpUrl): ProbeHttpResult {
-        val request = Request.Builder()
-            .url(url)
-            .header("Accept", "application/json")
-            .get()
-            .build()
-        return client.newCall(request).execute().use { response ->
-            ProbeHttpResult(
-                code = response.code,
-                successful = response.isSuccessful,
-                bodyPreview = response.peekBody(4_096L).string(),
-            )
-        }
-    }
-
-    /** Official Desktop compatibility for Hermes versions predating `/api/health`. */
-    private fun dashboardHealthNeedsLegacyFallback(result: ProbeHttpResult): Boolean =
-        result.code == 404 ||
-            (result.code == 401 && result.bodyPreview.contains("no_cookie", ignoreCase = true))
-
-    /** Commit one physical probe only if it still belongs to the active cache generation. */
-    private suspend fun completeProbe(
-        candidate: EndpointCandidate,
-        surface: EndpointSurface,
-        generation: Long,
-        reachable: Boolean,
-        detail: String?,
-        recordDiagnostic: () -> Unit,
-    ): Boolean {
-        currentCoroutineContext().ensureActive()
-        synchronized(probeStateLock) {
-            if (generation != probeGeneration) {
-                throw CancellationException("Endpoint probe invalidated")
-            }
-            recordDiagnostic()
-            recordOutcome(candidate, surface, reachable, detail)
-            val ttl = if (reachable) CACHE_TTL_MS else NEGATIVE_CACHE_TTL_MS
-            probeCache[cacheKey(candidate, surface)] = CacheEntry(
-                expiresAt = clock() + ttl,
-                reachable = reachable,
-            )
-        }
-        return reachable
-    }
-
    /** Choose the standard Dashboard/Gateway surface first when advertised. */
    private fun probeTarget(
        candidate: EndpointCandidate,
@@ -737,22 +499,10 @@ class EndpointResolver(
    ): ProbeTarget? {
        if (surface == EndpointSurface.Dashboard) {
            candidate.pluginProxyRoutesOrNull()?.dashboardBaseUrl?.let { base ->
-                return ProbeTarget(
-                    baseUrl = base,
-                    requestUrl = "$base/api/health",
-                    path = "/dashboard/api/health",
-                    legacyFallbackRequestUrl = "$base/api/status",
-                    legacyFallbackPath = "/dashboard/api/status",
-                )
+                return ProbeTarget(base, "$base/api/status", "/dashboard/api/status")
            }
            candidate.dashboard?.url?.trim()?.trimEnd('/')?.takeIf { it.isNotBlank() }?.let { base ->
-                return ProbeTarget(
-                    baseUrl = base,
-                    requestUrl = "$base/api/health",
-                    path = "/api/health",
-                    legacyFallbackRequestUrl = "$base/api/status",
-                    legacyFallbackPath = "/api/status",
-                )
+                return ProbeTarget(base, "$base/api/status", "/api/status")
            }
            return null
        }
@@ -780,10 +530,8 @@ class EndpointResolver(
            ?.let { base ->
                return ProbeTarget(
                    baseUrl = base,
-                    requestUrl = "$base/api/health",
-                    path = "/api/health",
-                    legacyFallbackRequestUrl = "$base/api/status",
-                    legacyFallbackPath = "/api/status",
+                    requestUrl = "$base/api/status",
+                    path = "/api/status",
                )
            }

@@ -854,19 +602,17 @@ class EndpointResolver(
        candidate: EndpointCandidate,
        surface: EndpointSurface = EndpointSurface.Standard,
    ) {
-        synchronized(probeStateLock) {
-            val key = cacheKey(candidate, surface)
-            probeCache[key] = CacheEntry(
-                expiresAt = clock() + NEGATIVE_CACHE_TTL_MS,
-                reachable = false,
-            )
-            recordOutcome(
-                candidate,
-                surface,
-                reachable = false,
-                detail = "Network changed — assumed offline",
-            )
-        }
+        val key = cacheKey(candidate, surface)
+        probeCache[key] = CacheEntry(
+            expiresAt = clock() + NEGATIVE_CACHE_TTL_MS,
+            reachable = false,
+        )
+        recordOutcome(
+            candidate,
+            surface,
+            reachable = false,
+            detail = "Network changed — assumed offline",
+        )
    }

    /**
@@ -877,17 +623,7 @@ class EndpointResolver(
     * just-died route must not outlive the handoff.
     */
    internal fun clearCache() {
-        val staleProbes = synchronized(probeStateLock) {
-            probeGeneration += 1L
-            probeCache.clear()
-            inFlightProbes.values.toList().also { inFlightProbes.clear() }
-        }
-        // An explicit re-probe must not join a request that began before the
-        // invalidation signal. Cancellation is resolver-owned (not waiter-
-        // owned), so ordinary lifecycle cancellation still leaves shared
-        // probes alive for other callers. The generation check prevents a
-        // late InterruptedIOException/response from publishing stale state.
-        staleProbes.forEach { it.cancel() }
+        probeCache.clear()
    }

    /** Test-only: snapshot the current cache for assertion purposes. */
@@ -43,16 +43,15 @@ object HermesLanDiscovery {
    private const val TAG = "HermesLanDiscovery"
    private const val MAX_HOSTS = 254
    private const val MAX_CONCURRENT_PROBES = 32
-    private const val PROBE_TIMEOUT_MS = 750L
+    private const val PROBE_TIMEOUT_MS = 650L
    private const val IPV4_MASK = 0xFFFF_FFFFL

    suspend fun scan(
        context: Context,
        apiPort: Int = 8642,
        dashboardPort: Int = 9119,
-        dashboardOnly: Boolean = false,
    ): List<HermesLanDiscoveryResult> = withContext(Dispatchers.IO) {
-        val hosts = prioritizeHostSweep(localLanHosts(context.applicationContext))
+        val hosts = localLanHosts(context.applicationContext)
        if (hosts.isEmpty()) return@withContext emptyList()

        val client = OkHttpClient.Builder()
@@ -67,13 +66,7 @@ object HermesLanDiscovery {
            hosts.map { host ->
                async {
                    semaphore.withPermit {
-                        probeHost(
-                            client,
-                            host,
-                            apiPort,
-                            dashboardPort,
-                            dashboardOnly,
-                        )?.let { result ->
+                        probeHost(client, host, apiPort, dashboardPort)?.let { result ->
                            result.copy(hostname = resolveHostname(host))
                        }
                    }
@@ -95,7 +88,6 @@ object HermesLanDiscovery {
        host: String,
        apiPort: Int,
        dashboardPort: Int,
-        dashboardOnly: Boolean,
    ): HermesLanDiscoveryResult? {
        val apiUrl = "http://$host:$apiPort"
        val dashboardUrl = "http://$host:$dashboardPort"
@@ -103,18 +95,12 @@ object HermesLanDiscovery {
            client = client,
            url = "$dashboardUrl/api/status",
            expectedBody = ::looksLikeDashboardStatus,
-            attempts = 2,
        )
-        if (dashboardOnly && !dashboardReachable) return null
-        val apiReachable = if (dashboardOnly) {
-            false
-        } else {
-            probe(
-                client = client,
-                url = "$apiUrl/health",
-                expectedBody = ::looksLikeApiHealth,
-            )
-        }
+        val apiReachable = probe(
+            client = client,
+            url = "$apiUrl/health",
+            expectedBody = ::looksLikeApiHealth,
+        )
        if (!dashboardReachable && !apiReachable) return null
        return HermesLanDiscoveryResult(
            host = host,
@@ -129,7 +115,6 @@ object HermesLanDiscovery {
        client: OkHttpClient,
        url: String,
        expectedBody: (String, String) -> Boolean,
-        attempts: Int = 1,
    ): Boolean {
        val httpUrl = url.toHttpUrlOrNull() ?: return false
        val request = Request.Builder()
@@ -138,25 +123,21 @@ object HermesLanDiscovery {
            .header("Accept", "application/json, text/plain, */*")
            .build()

-        repeat(attempts.coerceAtLeast(1)) { attempt ->
-            try {
-                client.newCall(request).execute().use { response ->
-                    if (response.code == 401 || response.code == 403) {
-                        return true
-                    }
-                    if (!response.isSuccessful) {
-                        if (response.code >= 500 && attempt + 1 < attempts) return@use
-                        return false
-                    }
-                    val contentType = response.header("Content-Type").orEmpty()
-                    val body = response.body.string().take(2_048)
-                    if (expectedBody(body, contentType)) return true
+        return try {
+            client.newCall(request).execute().use { response ->
+                if (response.code == 401 || response.code == 403) {
+                    return true
                }
-            } catch (_: Exception) {
-                if (attempt + 1 >= attempts) return false
+                if (!response.isSuccessful) {
+                    return false
+                }
+                val contentType = response.header("Content-Type").orEmpty()
+                val body = response.body.string().take(2_048)
+                expectedBody(body, contentType)
            }
+        } catch (_: Exception) {
+            false
        }
-        return false
    }

    private suspend fun resolveHostname(address: String): String? =
@@ -177,23 +158,6 @@ object HermesLanDiscovery {
        return normalized
    }

-    /** Interleave low/high host suffixes so `.1` and `.250` are both early. */
-    internal fun prioritizeHostSweep(hosts: List<String>): List<String> {
-        val sorted = hosts.distinct().sortedBy { address ->
-            address.split('.').fold(0L) { acc, part ->
-                (acc shl 8) + (part.toLongOrNull() ?: 0L)
-            }
-        }
-        val prioritized = ArrayList<String>(sorted.size)
-        var low = 0
-        var high = sorted.lastIndex
-        while (low <= high) {
-            prioritized += sorted[low++]
-            if (low <= high) prioritized += sorted[high--]
-        }
-        return prioritized
-    }
-
    private fun looksLikeDashboardStatus(body: String, contentType: String): Boolean {
        val lower = body.lowercase()
        return contentType.contains("json", ignoreCase = true) && (
@@ -48,9 +48,6 @@ interface VoiceAudioClient {
    val effectiveRoute: VoiceAudioRoute
        get() = route

-    /** Temporary client-policy override; the shared router honors it before user prefs. */
-    fun setRouteOverride(route: VoiceAudioRoute?) = Unit
-
    suspend fun transcribe(audioFile: File): Result<String>
    suspend fun synthesize(text: String): Result<File>

@@ -85,15 +82,8 @@ class AutoVoiceAudioClient(
    private val standardReadyProvider: () -> Boolean,
    private val relayReadyProvider: () -> Boolean,
 ) : VoiceAudioClient {
-    @Volatile
-    private var routeOverride: VoiceAudioRoute? = null
-
-    override fun setRouteOverride(route: VoiceAudioRoute?) {
-        routeOverride = route
-    }
-
    override val route: VoiceAudioRoute
-        get() = routeOverride ?: routeProvider()
+        get() = routeProvider()

    /**
     * Resolve the configured preference to the backend a call would land on:
@@ -102,7 +92,7 @@ class AutoVoiceAudioClient(
     * decide whether standard-only limitations (global TTS) currently apply.
     */
    override val effectiveRoute: VoiceAudioRoute
-        get() = when (route) {
+        get() = when (routeProvider()) {
            VoiceAudioRoute.Standard -> VoiceAudioRoute.Standard
            VoiceAudioRoute.Relay -> VoiceAudioRoute.Relay
            VoiceAudioRoute.Auto ->
@@ -124,7 +114,7 @@ class AutoVoiceAudioClient(
    private suspend fun <T> runWithSelectedRoute(
        block: suspend (VoiceAudioClient) -> Result<T>,
    ): Result<T> {
-        return when (route) {
+        return when (routeProvider()) {
            VoiceAudioRoute.Standard -> {
                if (!standardReadyProvider()) {
                    Result.failure(
@@ -13,7 +13,6 @@ 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
@@ -1007,56 +1006,6 @@ class ChatHandler {
        }
    }

-    /**
-     * Bound the ephemeral, read-only child-watch projection. This is stricter
-     * than the main transcript: system rows and tool results are not part of
-     * the preview contract, and one live child must not retain unbounded text.
-     */
-    internal fun boundReadOnlyPreview(
-        maxMessages: Int = 100,
-        maxTotalChars: Int = 32_000,
-        maxFieldChars: Int = 8_000,
-        maxToolChars: Int = 1_000,
-    ): Boolean {
-        var truncated = false
-        _messages.update { current ->
-            val visible = current.filterNot { it.role == MessageRole.SYSTEM }
-            if (visible.size != current.size || visible.size > maxMessages) truncated = true
-            var remaining = maxTotalChars
-            val kept = mutableListOf<ChatMessage>()
-            visible.takeLast(maxMessages).asReversed().forEach { message ->
-                if (remaining <= 0) {
-                    truncated = true
-                    return@forEach
-                }
-                fun bounded(value: String, limit: Int): String {
-                    val allowed = minOf(limit, remaining)
-                    val next = value.takeLast(allowed)
-                    if (next.length != value.length) truncated = true
-                    remaining -= next.length
-                    return next
-                }
-                val content = bounded(message.content, maxFieldChars)
-                val thinking = bounded(message.thinkingContent, maxFieldChars)
-                val tools = message.toolCalls.takeLast(50).map { tool ->
-                    if (message.toolCalls.size > 50) truncated = true
-                    tool.copy(
-                        args = tool.args?.let { bounded(it, maxToolChars) },
-                        result = null,
-                        error = tool.error?.let { bounded(it, maxToolChars) },
-                    )
-                }
-                kept += message.copy(
-                    content = content,
-                    thinkingContent = thinking,
-                    toolCalls = tools,
-                )
-            }
-            kept.asReversed()
-        }
-        return truncated
-    }
-
    /**
     * Rehydrate the last client-owned state of an unfinished turn.
     *
@@ -1451,12 +1400,6 @@ 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" ||
@@ -1506,13 +1449,11 @@ 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, messageMediaHits)
+                extractMediaMarkersFromContent(messageId, persistedImages.cleanedText, pendingMediaHits)
            } else {
                persistedImages.cleanedText
            }
-            pendingMediaHits += messageMediaHits

            // Cards are synchronous (no async fetch) so we attach them
            // straight onto the reconstructed ChatMessage and strip their
@@ -1546,34 +1487,15 @@ 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. 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.
+            // content-keyed queue. Inbound attachments are intentionally
+            // excluded — they come back via the marker re-dispatch.
            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.ASSISTANT &&
-                                priorGeneratedImage &&
-                                attachment.isImage &&
-                                messageMediaHits.isEmpty()
+                            role == MessageRole.USER &&
+                                attachment.relayToken in persistedImagePaths
                            )
                }
                when {
@@ -1617,9 +1539,6 @@ 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,
@@ -1652,9 +1571,6 @@ class ChatHandler {
                // nothing local to carry).
                ChatMessage(
                    id = messageId,
-                    activitySourceId = activitySourceId,
-                    activityTaskCount = activityTaskCount,
-                    activityFailedCount = activityFailedCount,
                    rowId = item.resolvedRowId,
                    reactions = item.reactions,
                    role = role,
@@ -1729,27 +1645,15 @@ class ChatHandler {
                is MediaMarkerHit.RelayToken -> {
                    val dedupeKey = "$messageId:relay:${hit.token}"
                    if (dispatchedMediaMarkers.add(dedupeKey)) {
-                        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)
-                        }
+                        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)) {
-                        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)
-                        }
+                        Log.d(TAG, "Media marker (bare-path, reload): ${hit.path}")
+                        onMediaBarePathRequested(messageId, hit.path)
                    }
                }
            }
@@ -2132,7 +2036,7 @@ class ChatHandler {
    /**
     * Update sessions list from API response.
     */
-    fun updateSessions(items: List<SessionItem>, append: Boolean = false) {
+    fun updateSessions(items: List<SessionItem>) {
        // Index the current rows so a server row that arrives without a title
        // can inherit a title we already know locally. Auto-titling is a
        // fire-and-forget background job on the server (upstream
@@ -2205,22 +2109,9 @@ class ChatHandler {
        } else {
            null
        }
-        val resolved = if (append) {
-            (_sessions.value + mapped)
-                .distinctBy { it.sessionId }
-                .sortedByDescending { it.activityTimestamp }
-        } else {
-            mapped
-        }
-        _sessions.value = if (pending != null && resolved.none { it.sessionId == pending.sessionId }) {
-            listOf(pending) + resolved
-        } else {
-            resolved
-        }
+        _sessions.value = if (pending != null) listOf(pending) + mapped else mapped
    }

-    fun appendSessions(items: List<SessionItem>) = updateSessions(items, append = true)
-
    fun clearSessions() {
        _sessions.value = emptyList()
    }
@@ -3139,9 +3030,7 @@ class ChatHandler {
    fun onSubagentEvent(messageId: String, event: GatewaySubagentEvent) {
        val label = event.goal.trim().take(60).ifBlank { null }
        when (event.phase) {
-            GatewaySubagentEvent.Phase.SPAWN_REQUESTED,
-            GatewaySubagentEvent.Phase.START,
-            -> {
+            GatewaySubagentEvent.Phase.START -> {
                if (label != null) subagentLabels[event.taskIndex] = label
                event.subagentId?.takeIf(String::isNotBlank)?.let {
                    subagentIds[event.taskIndex] = it
@@ -18,8 +18,6 @@ import com.hermesandroid.relay.auth.SecureStoreCache
 import com.hermesandroid.relay.auth.SessionTokenStore
 import com.hermesandroid.relay.auth.buildRawTokenStore
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlinx.coroutines.withTimeoutOrNull
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.SerialName
@@ -36,8 +34,6 @@ import kotlinx.serialization.json.contentOrNull
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
 import kotlinx.serialization.json.put
-import okhttp3.Call
-import okhttp3.Callback
 import okhttp3.Cookie
 import okhttp3.CookieJar
 import okhttp3.HttpUrl
@@ -49,13 +45,11 @@ 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
 import java.net.URLEncoder
 import java.util.concurrent.TimeUnit
-import kotlin.coroutines.resume
 import okio.BufferedSink

 // Status/session/provider snapshots are @Serializable so the Manage tab's
@@ -294,34 +288,6 @@ 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,
@@ -339,19 +305,6 @@ 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).
 *
@@ -363,16 +316,12 @@ data class DashboardFetchedFile(
 class DashboardApiClient(
    baseUrl: String,
    private val okHttpClient: OkHttpClient = defaultClient(),
-    private val ownsHttpClient: Boolean = true,
    private val json: Json = Json {
        ignoreUnknownKeys = true
        isLenient = true
        coerceInputValues = true
    },
    private val nowMillis: () -> Long = System::currentTimeMillis,
-    private val sessionReadTimeoutMillis: Long = SESSION_READ_TIMEOUT_MILLIS,
-    private val controlReadTimeoutMillis: Long = CONTROL_READ_TIMEOUT_MILLIS,
-    private val sessionEnrichmentBudgetMillis: Long = SESSION_ENRICHMENT_BUDGET_MILLIS,
 ) {
    private val baseUrl: String = baseUrl.trim().trimEnd('/')
    private val sessionPrScanLock = Any()
@@ -423,58 +372,6 @@ 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()),
@@ -1130,20 +1027,16 @@ class DashboardApiClient(
    suspend fun listSessions(
        profile: String? = null,
        limit: Int = SESSION_LIST_WINDOW_LIMIT,
-        offset: Int = 0,
        archived: String? = null,
-        excludeSources: Collection<String> = emptyList(),
    ): Result<List<SessionItem>> =
        withContext(Dispatchers.IO) {
-            val readDeadlineNanos = System.nanoTime() +
-                TimeUnit.MILLISECONDS.toNanos(sessionReadTimeoutMillis.coerceAtLeast(1L))
            val sessions = linkedMapOf<String, SessionItem>()
            for (page in sessionListPages(limit)) {
                val query = buildList {
                    // Upstream dashboard GET /api/sessions rejects pages over 100.
                    // Keep Android's 200-row drawer window via two bounded pages.
                    add("limit=${page.limit}")
-                    add("offset=${offset.coerceAtLeast(0) + page.offset}")
+                    add("offset=${page.offset}")
                    add("order=recent")
                    add("min_messages=1")
                    val name = profile?.trim().orEmpty()
@@ -1152,33 +1045,8 @@ class DashboardApiClient(
                    // Omitted unless requested so older hosts see an unchanged request.
                    val archivedMode = archived?.trim().orEmpty()
                    if (archivedMode.isNotBlank()) add("archived=${pathSegment(archivedMode)}")
-                    val excluded = excludeSources
-                        .asSequence()
-                        .map(String::trim)
-                        .filter(String::isNotBlank)
-                        .map(String::lowercase)
-                        .distinct()
-                        .sorted()
-                        .toList()
-                    if (excluded.isNotEmpty()) {
-                        add("exclude_sources=${queryValue(excluded.joinToString(","))}")
-                    }
                }.joinToString(prefix = "?", separator = "&")
-                val remainingReadMillis = TimeUnit.NANOSECONDS.toMillis(
-                    readDeadlineNanos - System.nanoTime(),
-                )
-                if (remainingReadMillis <= 0L) {
-                    return@withContext Result.failure(
-                        IOException("Dashboard session list exceeded its bounded read window"),
-                    )
-                }
-                val pageResult = getJson(
-                    "/api/sessions$query",
-                    // One budget covers the complete 200-row operation. A slow
-                    // first page cannot silently turn the nominal 8s bound into
-                    // 16s when the second page is needed.
-                    callTimeoutMillis = remainingReadMillis,
-                ).mapCatching { root ->
+                val pageResult = getJson("/api/sessions$query").mapCatching { root ->
                    val parsed = json.decodeFromJsonElement(SessionListResponse.serializer(), root)
                    parsed.sessions ?: parsed.items ?: parsed.data ?: emptyList()
                }
@@ -1187,20 +1055,13 @@ class DashboardApiClient(
                pageSessions.forEach { sessions.putIfAbsent(it.id, it) }
                if (pageSessions.size < page.limit) break
            }
-            val listed = sessions.values.take(limit.coerceIn(1, SESSION_LIST_WINDOW_LIMIT))
-            // Repository/PR decoration is useful drawer metadata, but it is not
-            // authoritative session data. Keep it off the critical path when an
-            // older host or an unavailable GitHub helper stalls: return the exact
-            // profile-scoped rows within a small budget and retry decoration on a
-            // later refresh. Cancellation also cancels the active OkHttp call.
-            val enriched = withTimeoutOrNull(sessionEnrichmentBudgetMillis) {
+            Result.success(
                enrichSessionWorkState(
-                    listed,
+                    sessions.values.take(limit.coerceIn(1, SESSION_LIST_WINDOW_LIMIT)),
                    fixedProfile = profile?.trim()?.takeIf { it.isNotBlank() }
                        ?: DEFAULT_SESSION_PROFILE_SCOPE,
-                )
-            } ?: listed
-            Result.success(enriched)
+                ),
+            )
        }

    /**
@@ -1356,7 +1217,7 @@ class DashboardApiClient(
    suspend fun getSessionMessages(
        sessionId: String,
        profile: String? = null,
-        mode: SessionMessageLoadMode = SessionMessageLoadMode.LATEST,
+        mode: SessionMessageLoadMode = SessionMessageLoadMode.COMPLETE,
    ): Result<List<MessageItem>> = withContext(Dispatchers.IO) {
        val name = profile?.trim().orEmpty()
        loadSessionMessages(mode) { page ->
@@ -1366,10 +1227,7 @@ class DashboardApiClient(
                add("order=${page.order}")
                if (name.isNotBlank()) add("profile=${pathSegment(name)}")
            }.joinToString(prefix = "?", separator = "&")
-            getJson(
-                "/api/sessions/${pathSegment(sessionId)}/messages$query",
-                callTimeoutMillis = sessionReadTimeoutMillis,
-            ).mapCatching { root ->
+            getJson("/api/sessions/${pathSegment(sessionId)}/messages$query").mapCatching { root ->
                val parsed = json.decodeFromJsonElement(MessageListResponse.serializer(), root)
                SessionMessagePage(
                    messages = parsed.messages ?: parsed.data ?: parsed.items ?: emptyList(),
@@ -1525,14 +1383,10 @@ 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", normalizedUsername)
-            put("password", normalizedPassword)
+            put("username", username)
+            put("password", password)
            put("next", next)
        }
        val httpUrl = resolveUrl("/auth/password-login")
@@ -1617,14 +1471,10 @@ class DashboardApiClient(
            .post(ByteArray(0).toRequestBody(null))
            .build()

-        executeJson(
-            request,
-            "Dashboard websocket ticket",
-            callTimeoutMillis = controlReadTimeoutMillis,
-        ).mapCatching { root ->
+        executeJson(request, "Dashboard websocket ticket").mapCatching { root ->
            val ticket = root.stringField("ticket")
                ?: root.stringField("ws_ticket")
-                ?: throw IllegalStateException("Dashboard websocket ticket response missing ticket")
+                ?: throw IOException("Dashboard websocket ticket response missing ticket")
            DashboardWsTicket(
                ticket = ticket,
                ttlSeconds = root.intField("ttl_seconds") ?: root.intField("ttl"),
@@ -1646,77 +1496,44 @@ class DashboardApiClient(
        profile = profile,
    )

-    fun shutdown() {
-        if (!ownsHttpClient) return
-        shutdownOffMainThread("DashboardApiClient-shutdown") {
-            okHttpClient.dispatcher.executorService.shutdown()
-            okHttpClient.connectionPool.evictAll()
-        }
+    fun shutdown() = shutdownOffMainThread("DashboardApiClient-shutdown") {
+        okHttpClient.dispatcher.executorService.shutdown()
+        okHttpClient.connectionPool.evictAll()
    }

-    private suspend fun getJson(
-        path: String,
-        callTimeoutMillis: Long? = null,
-    ): Result<JsonObject> = withContext(Dispatchers.IO) {
+    private suspend fun getJson(path: String): Result<JsonObject> = withContext(Dispatchers.IO) {
        val httpUrl = resolveUrl(path) ?: return@withContext Result.failure(invalidUrlException())
        val request = Request.Builder()
            .url(httpUrl)
            .get()
            .build()
-        executeJson(request, path, callTimeoutMillis)
+        executeJson(request, path)
    }

-    private suspend fun executeJson(
-        request: Request,
-        operation: String,
-        callTimeoutMillis: Long? = null,
-    ): Result<JsonObject> = executeCancellable(request, operation, callTimeoutMillis) { response ->
-        response.readJsonObject(json)
-    }
-
-    private suspend fun executeJsonElement(
-        request: Request,
-        operation: String,
-    ): Result<JsonElement> = executeCancellable(request, operation) { response ->
-        response.readJsonElement(json)
-    }
-
-    /** Bridge OkHttp cancellation to the owning coroutine so superseded profile reads do not linger. */
-    private suspend fun <T> executeCancellable(
-        request: Request,
-        operation: String,
-        callTimeoutMillis: Long? = null,
-        decode: (Response) -> T,
-    ): Result<T> = suspendCancellableCoroutine { continuation ->
-        val call = okHttpClient.newCall(request)
-        callTimeoutMillis?.takeIf { it > 0L }?.let {
-            call.timeout().timeout(it, TimeUnit.MILLISECONDS)
+    private fun executeJson(request: Request, operation: String): Result<JsonObject> {
+        return try {
+            okHttpClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) {
+                    return Result.failure(apiFailure(response, operation))
+                }
+                Result.success(response.readJsonObject(json))
+            }
+        } catch (e: Exception) {
+            Result.failure(e)
        }
-        continuation.invokeOnCancellation { call.cancel() }
-        call.enqueue(object : Callback {
-            override fun onFailure(call: Call, e: IOException) {
-                runCatching {
-                    if (continuation.isActive) continuation.resume(Result.failure(e))
-                }
-            }
+    }

-            override fun onResponse(call: Call, response: Response) {
-                val result = response.use {
-                    try {
-                        if (!it.isSuccessful) {
-                            Result.failure(apiFailure(it, operation))
-                        } else {
-                            Result.success(decode(it))
-                        }
-                    } catch (error: Exception) {
-                        Result.failure(error)
-                    }
-                }
-                runCatching {
-                    if (continuation.isActive) continuation.resume(result)
+    private fun executeJsonElement(request: Request, operation: String): Result<JsonElement> {
+        return try {
+            okHttpClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) {
+                    return Result.failure(apiFailure(response, operation))
                }
+                Result.success(response.readJsonElement(json))
            }
-        })
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
    }

    private suspend fun download(
@@ -1753,18 +1570,10 @@ class DashboardApiClient(
    companion object {
        private val JSON_MEDIA = "application/json; charset=utf-8".toMediaType()
        private const val DEFAULT_SESSION_PROFILE_SCOPE = "__dashboard_default__"
-        // Desktop allows 60s for its 40-row recents request. Android uses a
-        // similarly small initial window and a bounded 20s mobile budget;
-        // the old 8s deadline repeatedly cancelled valid first-load reads on
-        // large profile databases before any row could be shown.
-        private const val SESSION_READ_TIMEOUT_MILLIS = 20_000L
-        private const val CONTROL_READ_TIMEOUT_MILLIS = 8_000L
-        private const val SESSION_ENRICHMENT_BUDGET_MILLIS = 1_500L
        internal const val ACTIVE_SESSION_PR_MISS_TTL_MILLIS = 60_000L
        // 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")
@@ -1903,9 +1712,8 @@ class DashboardApiClient(
            cookieStore: DashboardCookieStore = InMemoryDashboardCookieStore(),
            bearerAuth: DashboardBearerAuth? = null,
        ): OkHttpClient {
-            val cookieJar = DashboardCookieJar(cookieStore)
            val builder = OkHttpClient.Builder()
-                .cookieJar(cookieJar)
+                .cookieJar(DashboardCookieJar(cookieStore))
                .connectTimeout(10, TimeUnit.SECONDS)
                // Skills-hub search fans out server-side with a 30s overall
                // timeout; keep the read window above it so a slow-but-successful
@@ -1913,7 +1721,6 @@ class DashboardApiClient(
                .readTimeout(45, TimeUnit.SECONDS)
                .writeTimeout(30, TimeUnit.SECONDS)
            bearerAuth?.let {
-                it.preferCookiesWhen(cookieJar::hasCookiesFor)
                builder.addInterceptor(it)
                builder.authenticator(it)
            }
@@ -2273,20 +2080,14 @@ class DashboardCookieJar(
    private val store: DashboardCookieStore,
    private val clockMillis: () -> Long = { System.currentTimeMillis() },
 ) : CookieJar {
-    fun hasCookiesFor(url: HttpUrl): Boolean = loadForRequest(url).isNotEmpty()
-
    override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
        val now = clockMillis()
        val incoming = cookies.map { StoredDashboardCookie.fromCookie(it) }
            .filterNot { it.isExpired(now) }
-        val incomingSessionFamilies = incoming.mapNotNullTo(mutableSetOf()) {
-            it.sessionFamilyKey()
-        }
        val retained = store.load()
            .filterNot { it.isExpired(now) }
            .filterNot { old -> incoming.any { it.key == old.key } }
-            .filterNot { old -> old.sessionFamilyKey() in incomingSessionFamilies }
-        store.save(collapseDashboardSessionCookieVariants(retained + incoming))
+        store.save(retained + incoming)
    }

    override fun loadForRequest(url: HttpUrl): List<Cookie> {
@@ -2294,9 +2095,7 @@ class DashboardCookieJar(
        // Load once (each load() is a decrypt + JSON decode); prune expired
        // entries back to disk only when something actually expired.
        val all = store.load()
-        val stored = collapseDashboardSessionCookieVariants(
-            all.filterNot { it.isExpired(now) },
-        )
+        val stored = all.filterNot { it.isExpired(now) }
        if (stored.size != all.size) {
            store.save(stored)
        }
@@ -2305,6 +2104,61 @@ class DashboardCookieJar(
    }
 }

+/**
+ * Copy only Hermes' authenticated dashboard session cookies to another host
+ * that belongs to the same saved Connection. Dashboard cookies are host-only
+ * by design, while a Connection may reach one server through LAN and
+ * Tailscale hostnames/IPs. The encrypted store remains the source of truth and
+ * explicit sign-out clears every mirrored host together.
+ *
+ * PKCE, SSO-attempt, and unrelated application cookies are intentionally not
+ * copied. Secure cookies also remain Secure; this helper never downgrades them
+ * for an HTTP route.
+ */
+fun mirrorDashboardSessionCookies(
+    store: DashboardCookieStore,
+    targetUrl: String,
+    trustedHosts: Set<String>,
+    clockMillis: () -> Long = { System.currentTimeMillis() },
+): Int {
+    val targetHost = targetUrl.toHttpUrlOrNull()?.host?.lowercase() ?: return 0
+    val allowedHosts = trustedHosts.mapTo(mutableSetOf()) { it.lowercase() }
+    if (targetHost !in allowedHosts) return 0
+
+    val now = clockMillis()
+    val all = store.load()
+    val live = all.filterNot { it.isExpired(now) }
+    val existingTargetKeys = live.asSequence()
+        .filter { it.domain.equals(targetHost, ignoreCase = true) }
+        .map { "${it.name.lowercase()}|$targetHost|${it.path}" }
+        .toSet()
+    val mirrored = live.asSequence()
+        .filter { it.isDashboardSessionCookie() }
+        .filter { it.domain.lowercase() in allowedHosts }
+        .filterNot { it.domain.equals(targetHost, ignoreCase = true) }
+        .groupBy { "${it.name.lowercase()}|${it.path}" }
+        .values
+        .mapNotNull { candidates -> candidates.maxByOrNull { it.expiresAt } }
+        .map { it.copy(domain = targetHost, hostOnly = true) }
+        .filterNot { it.key in existingTargetKeys }
+        .toList()
+
+    if (mirrored.isNotEmpty() || live.size != all.size) {
+        store.save(live + mirrored)
+    }
+    return mirrored.size
+}
+
+private fun StoredDashboardCookie.isDashboardSessionCookie(): Boolean {
+    val bareName = name
+        .removePrefix("__Host-")
+        .removePrefix("__Secure-")
+    return bareName == "hermes_session" ||
+        bareName == "hermes_session_at" ||
+        bareName == "hermes_session_rt" ||
+        bareName == "hermes_session_provider"
+}
+
 /**
 * Cookie jar that resolves the backing per-connection store at request time.
 *
@@ -2366,78 +2220,13 @@ fun importDashboardCookieHeader(
        .filterNot { it.isExpired(now) }
    if (imported.isEmpty()) return 0

-    val importedSessionFamilies = imported.mapNotNullTo(mutableSetOf()) {
-        it.sessionFamilyKey()
-    }
    val retained = store.load()
        .filterNot { it.isExpired(now) }
        .filterNot { old -> imported.any { it.key == old.key } }
-        .filterNot { old -> old.sessionFamilyKey() in importedSessionFamilies }
-    store.save(collapseDashboardSessionCookieVariants(retained + imported))
+    store.save(retained + imported)
    return imported.size
 }

-private val DASHBOARD_SESSION_COOKIE_FAMILIES = setOf(
-    "hermes_session",
-    "hermes_session_at",
-    "hermes_session_rt",
-    "hermes_session_provider",
-)
-
-internal val DASHBOARD_SESSION_COOKIE_VARIANT_NAMES: List<String> =
-    DASHBOARD_SESSION_COOKIE_FAMILIES.flatMap { name ->
-        listOf(name, "__Host-$name", "__Secure-$name")
-    }
-
-private fun isDashboardSessionCookieName(name: String): Boolean =
-    name.lowercase()
-        .removePrefix("__host-")
-        .removePrefix("__secure-") in DASHBOARD_SESSION_COOKIE_FAMILIES
-
-/**
- * Clear only Hermes session cookies that would be attached to [requestUrl].
- * Called solely after an explicit provider selection; background 503 probes
- * never mutate auth state.
- */
-internal fun clearDashboardSessionCookiesForRequest(
-    store: DashboardCookieStore,
-    requestUrl: String,
-): Int {
-    val url = requestUrl.toHttpUrlOrNull() ?: return 0
-    val current = store.load()
-    val retained = current.filterNot { stored ->
-        isDashboardSessionCookieName(stored.name) && stored.toCookie()?.matches(url) == true
-    }
-    if (retained.size != current.size) store.save(retained)
-    return current.size - retained.size
-}
-
-private fun StoredDashboardCookie.sessionFamilyKey(): String? {
-    val normalized = name.lowercase()
-        .removePrefix("__host-")
-        .removePrefix("__secure-")
-    if (normalized !in DASHBOARD_SESSION_COOKIE_FAMILIES) return null
-    return "$normalized|${domain.lowercase()}|$path"
-}
-
-/**
- * HTTPS/proxy changes can leave bare, `__Host-`, and `__Secure-` variants in
- * Android's imported WebView store. Hermes treats those names as one logical
- * session family and prefers the strict prefix, so coexistence can revive an
- * older provider session. Preserve list order and keep only the newest variant.
- */
-private fun collapseDashboardSessionCookieVariants(
-    cookies: List<StoredDashboardCookie>,
-): List<StoredDashboardCookie> {
-    val lastIndexByFamily = mutableMapOf<String, Int>()
-    cookies.forEachIndexed { index, cookie ->
-        cookie.sessionFamilyKey()?.let { lastIndexByFamily[it] = index }
-    }
-    return cookies.filterIndexed { index, cookie ->
-        cookie.sessionFamilyKey()?.let { lastIndexByFamily[it] == index } ?: true
-    }
-}
-
@Serializable
 data class StoredDashboardCookie(
    val name: String,
@@ -2493,142 +2282,21 @@ data class StoredDashboardCookie(
 }

 private fun Response.readJsonObject(json: Json): JsonObject {
-    val raw = body.readUtf8Bounded(DashboardApiClient.MAX_JSON_RESPONSE_BYTES)
+    val raw = body.string()
    if (raw.isBlank()) return JsonObject(emptyMap())
    return json.parseToJsonElement(raw).jsonObject
 }

 private fun Response.readJsonElement(json: Json): JsonElement {
-    val raw = body.readUtf8Bounded(DashboardApiClient.MAX_JSON_RESPONSE_BYTES)
+    val raw = body.string()
    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,
-) : IOException(message)
-
-internal fun Throwable.isDashboardAuthProviderUnavailable(): 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 &&
-            current.statusCode == 503 &&
-            current.message.orEmpty().contains("Auth provider", ignoreCase = true) &&
-            current.message.orEmpty().contains("unreachable", ignoreCase = true)
-        ) {
-            return true
-        }
-        current = current.cause
-    }
-    return false
-}
-
-internal fun Throwable.isDashboardSignInRequiredFailure(): Boolean {
-    if (isDashboardAuthProviderUnavailable()) return true
-    var current: Throwable? = this
-    val seen = java.util.Collections.newSetFromMap(
-        java.util.IdentityHashMap<Throwable, Boolean>(),
-    )
-    while (current != null && seen.add(current)) {
-        // 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
-    }
-    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 = try {
-        response.body.readUtf8Bounded(4L * 1024L)
-    } catch (_: Exception) {
-        ""
-    }
+    val bodyDetail = runCatching { response.body.string() }.getOrDefault("")
    val detail = bodyDetail.take(240).ifBlank { response.message }
-    return DashboardHttpException(
-        statusCode = response.code,
-        message = "$operation failed - HTTP ${response.code}: $detail",
-    )
+    return IOException("$operation failed - HTTP ${response.code}: $detail")
 }

 private fun JsonObject?.stringField(name: String): String? =
@@ -7,7 +7,6 @@ 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

 /**
@@ -196,8 +195,7 @@ class GatewayEventMapper(

            "tool.start" -> {
                clearActivityStatuses()
-                val identity = payload.effectiveToolIdentity()
-                val name = identity.name
+                val name = payload.string("name") ?: "unknown"
                // 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()
@@ -209,7 +207,7 @@ class GatewayEventMapper(
                    }
                    else -> syntheticToolId(name)
                }
-                val argsPreview = identity.argsPreview ?: payload?.get("args")
+                val argsPreview = payload?.get("args")
                    ?.takeUnless { it is JsonPrimitive && it.contentOrNull.isNullOrBlank() }
                    ?.toString()
                    ?.takeIf { it.isNotBlank() && it != "null" }
@@ -221,7 +219,7 @@ class GatewayEventMapper(

            "tool.complete" -> {
                clearActivityStatuses()
-                val name = payload.effectiveToolIdentity().name
+                val name = payload.string("name") ?: "unknown"
                val toolId = payload.string("tool_id")
                    ?: openSyntheticIdsByName[name]?.removeFirstOrNull()
                    ?: return
@@ -280,19 +278,36 @@ class GatewayEventMapper(

            "error" -> {
                turnEnded = true
-                val message = payload.string("message") ?: "Gateway error"
-                if (isSessionOwnershipRejection(message)) {
-                    callbacks.onSubmitRejected(message)
-                } else {
-                    callbacks.onError(message)
-                }
+                callbacks.onError(payload.string("message") ?: "Gateway error")
            }

-            "subagent.spawn_requested", "subagent.start", "subagent.thinking", "subagent.tool",
+            "subagent.start", "subagent.thinking", "subagent.tool",
            "subagent.progress", "subagent.complete",
            -> {
                clearActivityStatuses()
-                parseSubagentEvent(type, payload)?.let(callbacks.onSubagentEvent)
+                val phase = when (type) {
+                    "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"),
+                    ),
+                )
            }

            "tool.output_risk" -> {
@@ -377,26 +392,8 @@ class GatewayEventMapper(
                }
            }

-            "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.
+            // Known-but-unrendered (notification.show, …) and unknown types
+            // alike: ignore.
            else -> Unit
        }
        previousEventType = type
@@ -440,42 +437,6 @@ 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"
@@ -484,19 +445,6 @@ 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:")
@@ -637,43 +585,12 @@ 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

@@ -1,6 +1,5 @@
 package com.hermesandroid.relay.network.upstream

-import com.hermesandroid.relay.network.upstream.models.MessageItem
 import com.hermesandroid.relay.network.upstream.models.UsageInfo
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonObject
@@ -29,7 +28,7 @@ enum class GatewayAvailability {
    /** No probe has completed yet (startup, connection switch). */
    Unknown,

-    /** The `/api/ws` socket completed `gateway.ready` for the active route. */
+    /** Dashboard reachable and authenticated (or auth not required). */
    Ready,

    /** Dashboard reachable and gated, but no signed-in session — Manage sign-in unlocks it. */
@@ -56,13 +55,6 @@ enum class GatewayConnectionState {
    Ready,
 }

-/** Whether an idle Gateway may be retried automatically by a visible Chat surface. */
-enum class GatewayReconnectDisposition {
-    None,
-    Retryable,
-    Terminal,
-}
-
 /** Profile-persisted approval policy introduced by upstream gateway contract v3. */
 enum class GatewayApprovalMode(val wireValue: String) {
    Manual("manual"),
@@ -91,19 +83,26 @@ enum class GatewayApprovalModeCapability {
 * is unit-testable without an AndroidViewModel. ConnectionViewModel
 * delegates here with its live state.
 *
- * 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.
+ * 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.
 */
 fun resolveStreamingEndpointPreference(
    preference: String,
    gateway: GatewayAvailability,
    capabilities: ServerCapabilities,
-    gatewayOwned: Boolean = true,
 ): String = when (preference) {
    "sessions", "completions", "runs", "gateway" -> preference
-    else -> if (gatewayOwned) "gateway" else capabilities.preferredChatEndpoint()
+    else -> if (
+        gateway == GatewayAvailability.Ready ||
+        gateway == GatewayAvailability.Unknown
+    ) {
+        "gateway"
+    } else {
+        capabilities.preferredChatEndpoint()
+    }
 }

 /**
@@ -256,20 +255,9 @@ 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)* →
- * COMPLETE. Field
+ * per task: START → (THINKING | TOOL | PROGRESS)* → COMPLETE. Field
 * availability varies by phase — [toolName]/[preview] ride TOOL,
 * [status]/[summary]/[durationSeconds] ride COMPLETE — and older emitters
 * omit everything beyond the three defaults-bearing fields.
@@ -285,38 +273,10 @@ data class GatewaySubagentEvent(
    val preview: String? = null,
    val durationSeconds: Double? = null,
    val subagentId: String? = null,
-    /** Durable child session id accepted by `session.resume {lazy:true}`. */
-    val childSessionId: String? = null,
-    /** Owning subagent id for nested delegation; null for first-level children. */
-    val parentId: String? = null,
-    /** Zero-based depth used by the upstream spawn-tree renderer. */
-    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 }
+    enum class Phase { START, THINKING, TOOL, PROGRESS, COMPLETE }
 }

-/**
- * One profile-pinned, read-only child-session watch opened through the vanilla
- * upstream Gateway. [storedSessionId] is the durable child id from
- * `subagent.*`; [liveSessionId] is the short runtime id that tags subsequent
- * mirror events on this socket. The bounded [messages] snapshot is child-only.
- */
-data class GatewayChildWatch(
-    val storedSessionId: String,
-    val liveSessionId: String,
-    val profile: String?,
-    val generation: Long,
-    val messages: List<MessageItem>,
-    /** True when Android retained only a bounded recent tail of the response. */
-    val historyTruncated: Boolean,
-    val running: Boolean,
-    val status: String?,
-)
-
 /**
 * One session-owned background process returned by the upstream gateway's
 * `process.list` RPC. The registry calls its process id `session_id`; Android
@@ -739,16 +699,6 @@ 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,
 )

 /**
@@ -726,10 +726,10 @@ class HermesApiClient(

    suspend fun getMessages(
        sessionId: String,
-        mode: SessionMessageLoadMode = SessionMessageLoadMode.LATEST,
+        mode: SessionMessageLoadMode = SessionMessageLoadMode.COMPLETE,
    ): List<MessageItem> = withContext(Dispatchers.IO) {
        loadSessionMessages(mode) { page ->
-            try {
+            runCatching {
                val url = "$baseUrl/api/sessions/$sessionId/messages".toHttpUrlOrNull()
                    ?.newBuilder()
                    ?.addQueryParameter("limit", page.limit.toString())
@@ -740,20 +740,14 @@ 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.readUtf8Bounded(
-                        DashboardApiClient.MAX_JSON_RESPONSE_BYTES,
-                    )
+                    val body = response.body?.string() ?: error("empty response body")
                    val parsed = json.decodeFromString<MessageListResponse>(body)
                    SessionMessagePage(
                        messages = parsed.data ?: parsed.items ?: parsed.messages ?: emptyList(),
                        pagination = parsed.pagination,
                        payloadChars = body.length,
                    )
-                }.let { Result.success(it) }
-            } catch (error: CancellationException) {
-                throw error
-            } catch (error: Exception) {
-                Result.failure(error)
+                }
            }
        }.getOrElse { error ->
            if (error is CancellationException) throw error
@@ -1,7 +1,5 @@
 package com.hermesandroid.relay.network.upstream

-import com.hermesandroid.relay.data.normalizeCredentialFreeAuthenticatedDashboardOrigin
-
 import android.content.Context
 import com.hermesandroid.relay.auth.SessionTokenStore
 import com.hermesandroid.relay.auth.SecureStoreCache
@@ -103,7 +101,6 @@ class NativeDashboardAuthorization internal constructor(
    internal val verifier: String,
    internal val state: String,
    internal val generation: Long,
-    internal val usesAlternateOrigin: Boolean,
 )

 class NativeDashboardAuthClient(
@@ -147,9 +144,14 @@ class NativeDashboardAuthClient(
            .addQueryParameter("code_challenge_method", "S256")
            .addQueryParameter("redirect_uri", redirectUri)
            .addQueryParameter("state", state)
+            // Match the official Desktop client for Nous-hosted gateways: the
+            // gateway selects its single native-eligible provider. The provider
+            // name advertised to UI clients is presentation/configuration data,
+            // not a stable native-broker identifier. Other providers retain the
+            // explicit selector for direct client use and tests.
            .apply {
                provider
-                    ?.takeIf { it.isNotBlank() }
+                    ?.takeIf { it.isNotBlank() && !it.equals("nous", ignoreCase = true) }
                    ?.let { addQueryParameter("provider", it) }
            }
            .build()
@@ -157,29 +159,29 @@ class NativeDashboardAuthClient(
        val generation = NativeTokenRefreshCoordinator.beginAuthorization(
            tokenStore.coordinationKey,
        )
-        return NativeDashboardAuthorization(
-            authorizationUrl = url,
-            verifier = verifier,
-            state = state,
-            generation = generation,
-            usesAlternateOrigin = !sameDashboardBase(authorizationBaseUrl, baseUrl),
-        )
+        return NativeDashboardAuthorization(url, verifier, state, generation)
    }

    /**
-     * Discover the callback-owning Dashboard origin for every interactive
-     * redirect provider. Provider names do not imply topology; upstream may
-     * advertise a canonical origin that differs from a LAN/Tailscale entry.
-     * Token exchange still uses [baseUrl], keeping the bearer scoped to this
-     * connection while the shared gateway process consumes its one-time code.
+     * A private-route dashboard may be configured with a canonical HTTPS
+     * callback origin for its provider. Starting the browser on the private
+     * origin would scope Hermes' temporary PKCE cookie to the wrong host, so
+     * discover the provider's declared callback and start native auth there.
+     * Token exchange still uses [baseUrl], keeping the resulting bearer bound
+     * to the active connection route.
     */
    private fun resolveAuthorizationBaseUrl(provider: String?): String {
        val configured = baseUrl.toHttpUrlOrNull() ?: return baseUrl
-        val selectedProvider = provider?.takeIf { it.isNotBlank() } ?: return baseUrl
-        if (isLoopbackDashboardHost(configured.host)) return baseUrl
+        if (
+            !provider.equals("nous", ignoreCase = true) ||
+            configured.scheme != "http" ||
+            !isPrivateNetworkLiteral(configured.host)
+        ) {
+            return baseUrl
+        }
        val loginUrl = configured.newBuilder()
            .addPathSegments("auth/login")
-            .addQueryParameter("provider", selectedProvider)
+            .addQueryParameter("provider", provider)
            .addQueryParameter("next", "/")
            .build()
        val discoveryClient = client.newBuilder()
@@ -191,14 +193,14 @@ class NativeDashboardAuthClient(
        ).execute().use { response ->
            if (response.code !in 300..399) null else response.header("Location")
        }
-        return canonicalDashboardBaseFromProviderRedirect(baseUrl, location)
+        return canonicalDashboardBaseFromNousRedirect(location)
+            ?: throw IOException("Dashboard did not advertise a secure Nous callback origin")
    }

    fun exchangeCallback(
        authorization: NativeDashboardAuthorization,
        callbackTarget: String,
        commitAllowed: () -> Boolean = { true },
-        onValidated: () -> Unit = {},
    ): NativeDashboardTokens {
        val callback = callbackTarget.toHttpUrlOrNull()
            ?: "http://127.0.0.1$callbackTarget".toHttpUrlOrNull()
@@ -222,7 +224,6 @@ class NativeDashboardAuthClient(
            ?: throw NativeDashboardCallbackException(
                "Native sign-in callback did not include an authorization code",
            )
-        runCatching(onValidated)
        val payload = NativeTokenExchange(code = code, codeVerifier = authorization.verifier)
        return postTokens(
            path = "/auth/native/token",
@@ -321,10 +322,6 @@ class NativeDashboardAuthClient(
                throw NativeDashboardInactiveAuthorizationException()
            }
            tokenStore.save(tokens)
-            NativeTokenRefreshCoordinator.markBootstrapApproved(
-                tokenStore.coordinationKey,
-                tokens.accessToken,
-            )
        }
        return tokens
    }
@@ -415,63 +412,6 @@ private fun isPrivateNetworkLiteral(host: String): Boolean {
        (first == 100 && second in 64..127)
 }

-private fun isLoopbackDashboardHost(host: String): Boolean =
-    host.equals("localhost", ignoreCase = true) ||
-        host == "127.0.0.1" ||
-        host == "::1"
-
-/**
- * Extract a callback-owning Dashboard base from an auth-provider redirect.
- * Different HTTPS origins are accepted after an HTTPS provider hop. HTTP is
- * retained for upstream-supported local/overlay callbacks only when both the
- * selected and callback hosts are private literals/loopback and no HTTPS-to-
- * HTTP downgrade occurs. Arbitrary public cleartext origins are rejected.
- */
-internal fun canonicalDashboardBaseFromProviderRedirect(
-    configuredBase: String,
-    location: String?,
-): String {
-    val configured = configuredBase.trim().trimEnd('/').toHttpUrlOrNull()
-        ?: return configuredBase
-    val fallback = configured.toString().trimEnd('/')
-    val providerUrl = location?.toHttpUrlOrNull() ?: return fallback
-    val callback = providerUrl.queryParameter("redirect_uri")
-        ?.toHttpUrlOrNull()
-        ?: return fallback
-    if (
-        providerUrl.username.isNotEmpty() || providerUrl.password.isNotEmpty() ||
-        callback.username.isNotEmpty() || callback.password.isNotEmpty() ||
-        callback.query != null || callback.fragment != null
-    ) {
-        return fallback
-    }
-    val callbackSuffix = "/auth/callback"
-    if (!callback.encodedPath.endsWith(callbackSuffix)) return fallback
-    val callbackBase = callback.newBuilder()
-        .encodedPath(callback.encodedPath.removeSuffix(callbackSuffix).ifBlank { "/" })
-        .query(null)
-        .fragment(null)
-        .build()
-    if (
-        configured.scheme == callbackBase.scheme &&
-        configured.host.equals(callbackBase.host, ignoreCase = true) &&
-        configured.port == callbackBase.port &&
-        configured.encodedPath.trimEnd('/') == callbackBase.encodedPath.trimEnd('/')
-    ) {
-        return fallback
-    }
-    if (providerUrl.scheme != "https") return fallback
-    val trustedDifferentOrigin = callbackBase.scheme == "https" || (
-        configured.scheme == "http" &&
-            callbackBase.scheme == "http" &&
-            normalizeCredentialFreeAuthenticatedDashboardOrigin(fallback) != null &&
-            normalizeCredentialFreeAuthenticatedDashboardOrigin(
-                callbackBase.toString().trimEnd('/'),
-            ) != null
-        )
-    return if (trustedDifferentOrigin) callbackBase.toString().trimEnd('/') else fallback
-}
-
 internal fun canonicalDashboardBaseFromNousRedirect(location: String?): String? {
    val providerUrl = location?.toHttpUrlOrNull() ?: return null
    if (
@@ -480,20 +420,28 @@ internal fun canonicalDashboardBaseFromNousRedirect(location: String?): String?
    ) {
        return null
    }
-    val resolved = canonicalDashboardBaseFromProviderRedirect(
-        configuredBase = "http://192.168.0.1:9119",
-        location = location,
-    )
-    return resolved.takeUnless { it == "http://192.168.0.1:9119" }
+    val callback = providerUrl.queryParameter("redirect_uri")
+        ?.toHttpUrlOrNull()
+        ?: return null
+    if (callback.scheme != "https") return null
+    val callbackSuffix = "/auth/callback"
+    if (!callback.encodedPath.endsWith(callbackSuffix)) return null
+    val basePath = callback.encodedPath
+        .removeSuffix(callbackSuffix)
+        .ifBlank { "/" }
+    return callback.newBuilder()
+        .encodedPath(basePath)
+        .query(null)
+        .fragment(null)
+        .build()
+        .toString()
+        .trimEnd('/')
 }

 /**
 * Adds the native bearer to dashboard REST calls and rotates it before expiry
- * or after one 401. Ticket mint also gets one bounded refresh on 503 because a
- * multi-provider Dashboard can report an expired token as provider-unreachable
- * before the owning provider gets to reject it. Refresh requests use a separate
- * bare client, so neither a stale bearer nor the authenticator can recurse into
- * token rotation.
+ * or after one 401. Refresh requests use a separate bare client, so neither a
+ * stale bearer nor the authenticator can recurse into token rotation.
 */
 class DashboardBearerAuth(
    baseUrl: String,
@@ -501,90 +449,20 @@ class DashboardBearerAuth(
    private val clockSeconds: () -> Long = { System.currentTimeMillis() / 1000L },
 ) : Interceptor, Authenticator {
    private val authClient = NativeDashboardAuthClient(baseUrl, tokenStore)
-    @Volatile
-    private var cookieAuthAvailable: ((okhttp3.HttpUrl) -> Boolean)? = null
-    @Volatile
-    private var preferNativeBearerAfterCookieProviderFailure = false
-
-    internal fun preferCookiesWhen(predicate: (okhttp3.HttpUrl) -> Boolean) {
-        cookieAuthAvailable = predicate
-    }
-
-    private fun shouldPreferCookie(url: okhttp3.HttpUrl): Boolean =
-        !preferNativeBearerAfterCookieProviderFailure &&
-            runCatching { cookieAuthAvailable?.invoke(url) == true }.getOrDefault(false)

    override fun intercept(chain: Interceptor.Chain): Response {
-        if (shouldPreferCookie(chain.request().url)) {
-            val cookieResponse = chain.proceed(chain.request())
-            if (!cookieResponse.isAuthProviderUnavailable()) return cookieResponse
-            val tokens = usableTokens(forceRefresh = false, failedAccessToken = null)
-                ?: return cookieResponse
-            val accessToken = normalizeCredentialForHeader(
-                tokens.accessToken,
-                "Dashboard credential",
-            )
-            cookieResponse.close()
-            val bearerResponse = chain.proceed(
-                chain.request().newBuilder()
-                    .bearerAuthorization(accessToken, "Dashboard credential")
-                    .build(),
-            )
-            if (bearerResponse.isSuccessful) {
-                // Preserve the cookie on disk: upstream's 503 intentionally
-                // avoids logging browsers out during an IdP outage. This exact
-                // Dashboard client merely stops presenting the stranded cookie
-                // first after its connection-scoped bearer proves valid.
-                preferNativeBearerAfterCookieProviderFailure = true
-            }
-            return bearerResponse
-        }
        val tokens = usableTokens(forceRefresh = false, failedAccessToken = null)
        val request = tokens?.let {
            chain.request().newBuilder()
                .bearerAuthorization(it.accessToken, "Dashboard credential")
                .build()
        } ?: chain.request()
-        val response = chain.proceed(request)
-        if (
-            response.code != 503 ||
-            !request.url.encodedPath.endsWith("/api/auth/ws-ticket")
-        ) {
-            return response
-        }
-        val previous = request.header("Authorization") ?: return response
-        val failedAccessToken = previous.removePrefix("Bearer ").takeIf { it != previous }
-            ?: return response
-        val refreshed = usableTokens(
-            forceRefresh = true,
-            failedAccessToken = failedAccessToken,
-        ) ?: return response
-        val accessToken = normalizeCredentialForHeader(
-            refreshed.accessToken,
-            "Dashboard credential",
-        )
-        if (accessToken == failedAccessToken) return response
-        response.close()
-        return chain.proceed(
-            request.newBuilder()
-                .bearerAuthorization(accessToken, "Dashboard credential")
-                .build(),
-        )
+        return chain.proceed(request)
    }

    override fun authenticate(route: Route?, response: Response): Request? {
        if (responseCount(response) >= 2) return null
-        val previous = response.request.header("Authorization")
-        if (previous == null) {
-            if (!shouldPreferCookie(response.request.url)) return null
-            val tokens = usableTokens(
-                forceRefresh = false,
-                failedAccessToken = null,
-            ) ?: return null
-            return response.request.newBuilder()
-                .bearerAuthorization(tokens.accessToken, "Dashboard credential")
-                .build()
-        }
+        val previous = response.request.header("Authorization") ?: return null
        val failedAccessToken = previous.removePrefix("Bearer ").takeIf { it != previous }
        val tokens = usableTokens(
            forceRefresh = true,
@@ -609,39 +487,11 @@ class DashboardBearerAuth(
            if (failedAccessToken != null && current.accessToken != failedAccessToken) {
                return@synchronized current
            }
-            val needsNousBootstrap = current.provider.equals("nous", ignoreCase = true) &&
-                current.refreshToken.isNotBlank() &&
-                !NativeTokenRefreshCoordinator.isBootstrapApproved(
-                    tokenStore.coordinationKey,
-                    current.accessToken,
-                )
-            if (needsNousBootstrap &&
-                NativeTokenRefreshCoordinator.isBootstrapRejected(
-                    tokenStore.coordinationKey,
-                    current.accessToken,
-                )
-            ) {
-                return@synchronized null
-            }
            val nearExpiry = current.expiresAt <= 0L || clockSeconds() >= current.expiresAt - 60L
-            if (!forceRefresh && !nearExpiry && !needsNousBootstrap) return@synchronized current
-            val refreshed = runCatching { authClient.refresh(current) }.getOrNull()
-            if (refreshed == null && needsNousBootstrap) {
-                NativeTokenRefreshCoordinator.markBootstrapRejected(
-                    tokenStore.coordinationKey,
-                    current.accessToken,
-                )
-            }
-            refreshed
+            if (!forceRefresh && !nearExpiry) return@synchronized current
+            runCatching { authClient.refresh(current) }.getOrNull()
        }

-    private fun Response.isAuthProviderUnavailable(): Boolean {
-        if (code != 503) return false
-        val detail = runCatching { peekBody(1_024L).string() }.getOrDefault("")
-        return detail.contains("Auth provider", ignoreCase = true) &&
-            detail.contains("unreachable", ignoreCase = true)
-    }
-
    private fun responseCount(response: Response): Int {
        var count = 1
        var prior = response.priorResponse
@@ -714,8 +564,6 @@ private inline fun <reified T : Throwable> Throwable.firstCauseOfType(): T? {
 private object NativeTokenRefreshCoordinator {
    private val locks = ConcurrentHashMap<String, Any>()
    private val generations = ConcurrentHashMap<String, Long>()
-    private val bootstrapApproved = ConcurrentHashMap<String, String>()
-    private val bootstrapRejected = ConcurrentHashMap<String, String>()

    fun lockFor(key: String): Any = locks.computeIfAbsent(key) { Any() }

@@ -735,28 +583,10 @@ private object NativeTokenRefreshCoordinator {
        }
    }

-    fun isBootstrapApproved(key: String, accessToken: String): Boolean =
-        bootstrapApproved[key] == accessToken
-
-    fun isBootstrapRejected(key: String, accessToken: String): Boolean =
-        bootstrapRejected[key] == accessToken
-
-    fun markBootstrapApproved(key: String, accessToken: String) {
-        bootstrapApproved[key] = accessToken
-        bootstrapRejected.remove(key)
-    }
-
-    fun markBootstrapRejected(key: String, accessToken: String) {
-        bootstrapRejected[key] = accessToken
-        bootstrapApproved.remove(key)
-    }
-
    fun clear(store: NativeDashboardTokenStore) {
        synchronized(lockFor(store.coordinationKey)) {
            generations[store.coordinationKey] =
                (generations[store.coordinationKey] ?: 0L) + 1L
-            bootstrapApproved.remove(store.coordinationKey)
-            bootstrapRejected.remove(store.coordinationKey)
            store.clear()
        }
    }
@@ -3,7 +3,6 @@ package com.hermesandroid.relay.network.upstream
 import com.hermesandroid.relay.BuildConfig
 import java.io.IOException
 import java.io.InputStream
-import java.io.InterruptedIOException
 import java.net.InetAddress
 import java.net.InetSocketAddress
 import java.net.ServerSocket
@@ -26,9 +25,6 @@ private const val ACCEPT_POLL_MILLIS = 500
 internal const val DEFAULT_NATIVE_SIGN_IN_TIMEOUT_MILLIS = 5 * 60 * 1000L
 internal val NATIVE_SIGN_IN_RETURN_URI = "${BuildConfig.APPLICATION_ID}://return"

-internal class NativeDashboardSignInTimeoutException :
-    InterruptedIOException("Dashboard sign-in timed out")
-
 private enum class CallbackPage(
    val modifier: String,
    val eyebrow: String,
@@ -113,24 +109,23 @@ internal fun dashboardRedirectAuthMode(authFlows: List<String>): DashboardRedire
        DashboardRedirectAuthMode.WebView
    }

-/** Match upstream Desktop's capability-driven redirect policy. */
-internal fun androidDashboardRedirectAuthMode(
-    @Suppress("UNUSED_PARAMETER") providerName: String,
-    authFlows: List<String>,
-    @Suppress("UNUSED_PARAMETER") competingRedirectProviders: Int = 1,
-): DashboardRedirectAuthMode = dashboardRedirectAuthMode(authFlows)
-
 /**
- * Hosted gateways commonly expose Nous as their single native provider and
- * require the selector to be omitted. Multi-provider self-hosted gateways need
- * the explicit selector so upstream can disambiguate the requested provider.
+ * Nous Portal uses Cloudflare Turnstile and does not support embedded Android
+ * WebViews. Keep self-hosted OIDC on the dashboard cookie flow, but use the
+ * gateway's brokered system-browser flow for Nous when it is advertised.
 */
-internal fun nativeDashboardAuthorizationProvider(
+internal fun androidDashboardRedirectAuthMode(
    providerName: String,
-    competingRedirectProviders: Int,
-): String? = providerName.takeUnless {
-    it.equals("nous", ignoreCase = true) && competingRedirectProviders <= 1
-}
+    authFlows: List<String>,
+): DashboardRedirectAuthMode =
+    if (
+        providerName.equals("nous", ignoreCase = true) &&
+        dashboardRedirectAuthMode(authFlows) == DashboardRedirectAuthMode.NativePkce
+    ) {
+        DashboardRedirectAuthMode.NativePkce
+    } else {
+        DashboardRedirectAuthMode.WebView
+    }

 /**
 * Owns one native dashboard sign-in attempt.
@@ -146,8 +141,6 @@ class NativeDashboardSignInCoordinator(
 ) {
    suspend fun signIn(
        provider: String?,
-        onAuthorizationPrepared: (usesAlternateOrigin: Boolean) -> Unit = {},
-        onCallbackValidated: () -> Unit = {},
        launchAuthorization: suspend (String) -> Unit,
    ): NativeDashboardTokens =
        try {
@@ -172,15 +165,11 @@ class NativeDashboardSignInCoordinator(
                        val attemptContext = currentCoroutineContext()
                        var completed = false
                        try {
-                            runCatching {
-                                onAuthorizationPrepared(authorization.usesAlternateOrigin)
-                            }
                            launchAuthorization(authorization.authorizationUrl)
                            awaitValidCallback(
                                server = server,
                                authorization = authorization,
                                commitAllowed = { attemptContext.isActive },
-                                onCallbackValidated = onCallbackValidated,
                            ).also { completed = true }
                        } finally {
                            if (!completed) {
@@ -191,14 +180,13 @@ class NativeDashboardSignInCoordinator(
                }
            }
        } catch (_: TimeoutCancellationException) {
-            throw NativeDashboardSignInTimeoutException()
+            throw IOException("Dashboard sign-in timed out")
        }

    private suspend fun awaitValidCallback(
        server: ServerSocket,
        authorization: NativeDashboardAuthorization,
        commitAllowed: () -> Boolean,
-        onCallbackValidated: () -> Unit,
    ): NativeDashboardTokens {
        while (true) {
            val callback = acceptCallback(server)
@@ -229,7 +217,6 @@ class NativeDashboardSignInCoordinator(
                        authorization,
                        target,
                        commitAllowed = commitAllowed,
-                        onValidated = onCallbackValidated,
                    ).also {
                        writeResponse(
                            socket,
@@ -72,7 +72,7 @@ internal suspend fun loadSessionMessages(
        Result.success(collected)
    } catch (error: CancellationException) {
        throw error
-    } catch (error: Exception) {
+    } catch (error: Throwable) {
        Result.failure(error)
    }
 }
@@ -195,7 +195,7 @@ class StandardHermesVoiceClient(
                .let { Result.success<VoiceSpeechStream?>(it) }
        } catch (cancelled: CancellationException) {
            throw cancelled
-        } catch (error: Exception) {
+        } catch (error: Throwable) {
            Result.failure(error)
        }
    }
@@ -222,9 +222,7 @@ class StandardHermesVoiceClient(
                if (!response.isSuccessful) {
                    return Result.failure(apiFailure(response, operation))
                }
-                val body = response.body.readUtf8Bounded(
-                    DashboardApiClient.MAX_JSON_RESPONSE_BYTES,
-                )
+                val body = response.body.string()
                if (body.isBlank()) {
                    return Result.failure(IOException("$operation returned an empty response"))
                }
@@ -247,11 +245,7 @@ class StandardHermesVoiceClient(
    }

    private fun apiFailure(response: Response, operation: String): IOException {
-        val body = try {
-            response.body.readUtf8Bounded(4L * 1024L)
-        } catch (_: Exception) {
-            ""
-        }
+        val body = runCatching { response.body.string() }.getOrDefault("")
        val detail = body.takeIf { it.isNotBlank() } ?: response.message
        val message = when (response.code) {
            400 -> "$operation rejected that input - ${detail.ifBlank { "bad request" }}"
@@ -3,12 +3,10 @@ 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.JsonObject
-import kotlinx.serialization.json.JsonPrimitive
-import kotlinx.serialization.json.booleanOrNull
-import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromJsonElement

-/** Upstream usage enriched by the optional Relay provider/pool surface. */
+/** Relay-enhanced usage with an upstream fallback for hosts without Relay support. */
 class ProviderUsageRepository(
    private val gatewayClientProvider: () -> GatewayChatClient?,
    private val dashboardClientProvider: () -> DashboardApiClient? = { null },
@@ -16,142 +14,33 @@ 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) {
-            enhancement = dashboard.getProviderUsage(profile, session)
+            val enhanced = dashboard.getProviderUsage(profile, session)
+            if (enhanced.isSuccess && enhanced.getOrNull() != null) return enhanced
        }

-        if (enhancement?.getOrNull() == null) {
-            enhancement = relayHttpClient.fetchProviderUsage(
-                profile = profile,
-                sessionId = session,
-            )
-        }
-
-        val merged = mergeProviderUsage(
-            upstream = upstream.getOrNull(),
-            enhancement = enhancement?.getOrNull(),
+        val relay = relayHttpClient.fetchProviderUsage(
+            profile = profile,
+            sessionId = session,
        )
-        if (merged != null) return Result.success(merged)
+        if (relay.isSuccess && relay.getOrNull() != null) return relay

-        return when {
-            upstream.isFailure && enhancement?.isFailure == true ->
-                Result.failure(enhancement?.exceptionOrNull()!!)
-            enhancement?.isFailure == true -> Result.failure(enhancement?.exceptionOrNull()!!)
-            else -> Result.success(null)
+        val gateway = gatewayClientProvider()
+        if (gateway != null) {
+            val upstream = gateway.providerUsage()
+                .mapCatching { json.decodeFromJsonElement<ProviderUsageResponse>(it) }
+            if (upstream.isSuccess) return upstream
        }
+        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
@@ -74,13 +74,13 @@ object ProactiveMessageNotifier {
        text: String,
        messageId: String?,
        chatId: String?,
-    ): Int? {
+    ) {
        ensureChannel(context)
        if (!hasPostNotificationsPermission(context)) {
            Log.i(TAG, "POST_NOTIFICATIONS not granted — skipping proactive notification")
-            return null
+            return
        }
-        if (text.isBlank()) return null
+        if (text.isBlank()) return

        val tapIntent = Intent(context, MainActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
@@ -89,7 +89,7 @@ object ProactiveMessageNotifier {
        val pendingFlags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        // Distinct requestCode per slot so each notification gets its own
        // PendingIntent rather than all sharing slot 0's intent.
-        val notificationId = slotFor(messageId, chatId)
+        val notificationId = slotFor(messageId)
        val tapPending =
            PendingIntent.getActivity(context, notificationId, tapIntent, pendingFlags)

@@ -108,15 +108,9 @@ object ProactiveMessageNotifier {
            .setCategory(NotificationCompat.CATEGORY_MESSAGE)
            .setPriority(NotificationCompat.PRIORITY_HIGH)

-        return runCatching {
+        runCatching {
            NotificationManagerCompat.from(context).notify(notificationId, builder.build())
-            notificationId
-        }.onFailure { Log.w(TAG, "notify failed", it) }.getOrNull()
-    }
-
-    /** Cancel one exact slot previously returned by [notificationIdFor]. */
-    fun cancel(context: Context, notificationId: Int) {
-        NotificationManagerCompat.from(context).cancel(notificationId)
+        }.onFailure { Log.w(TAG, "notify failed", it) }
    }

    /**
@@ -212,12 +206,8 @@ object ProactiveMessageNotifier {
    }

    /** Derive a stable notification slot from the message id. */
-    internal fun notificationIdFor(messageId: String?, chatId: String?): Int =
-        slotFor(messageId, chatId)
-
-    private fun slotFor(messageId: String?, chatId: String?): Int {
-        val key = messageId?.takeIf { it.isNotBlank() }
-            ?: "chat:${chatId?.takeIf { it.isNotBlank() } ?: "phone"}"
+    private fun slotFor(messageId: String?): Int {
+        val key = messageId?.takeIf { it.isNotBlank() } ?: return ID_BASE
        // Keep within a small positive window above the base so re-delivery of
        // the same id collapses to one slot and distinct ids spread out.
        return ID_BASE + (key.hashCode() and 0xFFFF)
@@ -240,25 +240,6 @@ class HermesProcessRuntime internal constructor(
        }
    }

-    fun republishAssistantSnapshot(activationId: String) {
-        val snapshot = synchronized(activationLock) {
-            if (currentActivationId != activationId ||
-                _initializationState.value != HermesRuntimeInitializationState.Ready
-            ) {
-                null
-            } else {
-                binder.assistantSnapshot.value
-            }
-        } ?: return
-        if (snapshot.phase != com.hermesandroid.relay.assistant.AssistantSessionPhase.Closed) {
-            com.hermesandroid.relay.assistant.AssistantSessionProtocol.publish(
-                application,
-                activationId,
-                snapshot,
-            )
-        }
-    }
-
    fun recordAssistantHeartbeat(
        activationId: String,
        nowElapsedMs: Long = SystemClock.elapsedRealtime(),
@@ -21,14 +21,11 @@ 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
 import com.hermesandroid.relay.network.shared.AutoVoiceAudioClient
-import com.hermesandroid.relay.network.shared.pluginProxyRoutesOrNull
 import com.hermesandroid.relay.network.upstream.StandardHermesVoiceClient
-import com.hermesandroid.relay.viewmodel.SESSION_DIRECTORY_PAGE_SIZE
 import com.hermesandroid.relay.viewmodel.StandardVoiceAvailability
 import com.hermesandroid.relay.viewmodel.VoiceState
 import java.util.concurrent.TimeUnit
@@ -92,10 +89,7 @@ internal class HermesRuntimeBinder(
                .build(),
            relayUrlProvider = { connection.effectiveRelayUrl.value },
            relayRouteChangesProvider = {
-                connection.activeRelayEndpoint.mapNotNull { endpoint ->
-                    endpoint?.pluginProxyRoutesOrNull()?.relayWebSocketUrl
-                        ?: endpoint?.relay?.url
-                }
+                connection.activeEndpoint.mapNotNull { it?.relay?.url }
            },
            routeProbeRequester = connection::probeNow,
            profileNameProvider = {
@@ -105,8 +99,6 @@ internal class HermesRuntimeBinder(
                (connection.authState.value as? AuthState.Paired)?.token
            },
            apiBearerTokenProvider = connection::getApiKey,
-            dashboardHttpClientProvider = connection::dashboardHttpClientForRelayIngress,
-            dashboardIngressWebSocketRequestProvider = connection::dashboardRelayRequestForIngress,
        )
        val standardVoiceClient = StandardHermesVoiceClient(
            context = application,
@@ -171,9 +163,6 @@ 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() }
@@ -196,31 +185,17 @@ internal class HermesRuntimeBinder(
            }
        }
        chat.setProfileSessionLister { profileName ->
-            connection.listProfileScopedSessions(
-                profileName = profileName,
-                limit = SESSION_DIRECTORY_PAGE_SIZE,
-                excludeSources = connection.hiddenSources.value,
-            )
-        }
-        chat.setProfileSessionPageLister { profileName, offset, limit ->
-            connection.listProfileScopedSessions(
-                profileName = profileName,
-                limit = limit,
-                offset = offset,
-                excludeSources = connection.hiddenSources.value,
-            )
+            connection.listProfileScopedSessions(profileName)
        }
        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
        chat.profileSessionPinner = connection::setSessionPinned
        chat.profileSessionArchiver = connection::setSessionArchived
        chat.onSessionChanged = connection::saveLastSessionId
-        chat.onFreshDraftSelected = connection::saveFreshDraft
        chat.setDemoModeWiring(
            isDemo = { connection.isDemoMode.value },
            handler = { connection.chatHandler },
@@ -266,11 +241,6 @@ 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,
@@ -291,36 +261,6 @@ 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,
@@ -351,41 +291,23 @@ internal class HermesRuntimeBinder(
                connection.activeConnectionId,
                connection.effectiveSessionProfileName,
                connection.lastSessionId,
-                connection.activeEndpoint,
-            ) { ready, connectionId, profileName, sessionId, activeEndpoint ->
-                ProfileContextInputs(
-                    ready,
-                    connectionId,
-                    profileName,
-                    sessionId,
-                    dashboardRouteResolved = activeEndpoint != null,
-                )
+            ) { ready, connectionId, profileName, sessionId ->
+                ProfileContextInputs(ready, connectionId, profileName, sessionId)
            }
            combine(
                contextInputs,
                connection.profileSelectionSettled,
                connection.lockedProfileName,
-                connection.hiddenSources,
-            ) { inputs, settled, lockedProfileName, hiddenSources ->
+            ) { inputs, settled, lockedProfileName ->
                inputs.copy(
                    profileSelectionSettled = settled,
                    profileLocked = lockedProfileName != null,
-                    hiddenSources = hiddenSources,
                )
            }.collectLatest { inputs ->
                profileContextReady.value = false
-                if (!shouldRefreshSessionDirectory(inputs.chatReady, inputs.dashboardRouteResolved)) {
-                    return@collectLatest
-                }
-                if (!inputs.profileSelectionSettled) {
-                    delay(PROFILE_SETTLE_BACKSTOP_MS)
-                    // The backstop is diagnostic patience, not permission to
-                    // issue an unscoped read. Server-default ownership remains
-                    // unknown until the lightweight active-profile scope lands.
-                    if (!connection.profileSelectionSettled.value) return@collectLatest
-                } else {
-                    delay(PROFILE_CONTEXT_COALESCE_MS)
-                }
+                if (!inputs.chatReady) return@collectLatest
+                if (!inputs.profileSelectionSettled) delay(PROFILE_SETTLE_BACKSTOP_MS)
+                else delay(PROFILE_CONTEXT_COALESCE_MS)
                val contextKey = AgentDisplay.profileContextKey(
                    connectionId = inputs.connectionId,
                    profileName = inputs.profileName,
@@ -399,28 +321,6 @@ internal class HermesRuntimeBinder(
                profileContextReady.value = true
            }
        }
-        jobs += runtime.coroutineScope.launch {
-            var metadataHydratedRoute: Pair<String, String>? = null
-            chat.sessionDirectoryReadyEvents.collect { event ->
-                if (!chat.ownsSessionDirectoryReadyEvent(event)) return@collect
-                val connectionId = connection.activeConnectionId.value ?: return@collect
-                val expectedContextKey = AgentDisplay.profileContextKey(
-                    connectionId = connectionId,
-                    profileName = connection.effectiveSessionProfileName.value,
-                )
-                if (event.contextKey != expectedContextKey) return@collect
-                val dashboardUrl = connection.effectiveDashboardUrl.value
-                    .takeIf(String::isNotBlank)
-                    ?: return@collect
-                val routeKey = connectionId to dashboardUrl.trim().trimEnd('/').lowercase()
-                if (metadataHydratedRoute == routeKey) return@collect
-                metadataHydratedRoute = routeKey
-                // `/api/profiles`, Gateway avatars, pets, skills, and model
-                // metadata are not session-directory prerequisites. Hydrate
-                // them only after exact-owner rows have already published.
-                connection.refreshDeferredProfileMetadata()
-            }
-        }
        jobs += runtime.coroutineScope.launch {
            connection.parseToolAnnotations.collect { enabled ->
                connection.chatHandler.parseToolAnnotations = enabled
@@ -437,22 +337,13 @@ internal class HermesRuntimeBinder(
                connection.chatReady,
                connection.standardVoiceAvailability,
                connection.relayVoiceReady,
-                connection.relayConfigured,
-            ) { settings, chatReady, standard, relayReady, relayConfigured ->
-                VoiceReadinessInputs(
-                    settings = settings,
-                    chatReady = chatReady,
-                    standardAvailability = standard,
-                    relayReady = relayReady,
-                    relayConfigured = relayConfigured,
-                )
-            }.combine(connection.profileSelectionSettled) { inputs, profileSettled ->
+                connection.profileSelectionSettled,
+            ) { settings, chatReady, standard, relayReady, profileSettled ->
                resolveVoiceActivationReadiness(
-                    inputs.settings,
-                    inputs.chatReady,
-                    inputs.standardAvailability,
-                    inputs.relayReady,
-                    inputs.relayConfigured,
+                    settings,
+                    chatReady,
+                    standard,
+                    relayReady,
                    profileSettled,
                )
            }
@@ -485,9 +376,7 @@ internal class HermesRuntimeBinder(
                if (!AssistantAppSessionState.active.value) return@collect
                if (state.voiceMode) AssistantAppSessionState.markVoiceStarted()
                if (state.voiceMode || AssistantAppSessionState.hasVoiceStarted()) {
-                    state.assistantActivationId?.let { activationId ->
-                        AssistantSessionProtocol.publish(application, activationId, snapshot)
-                    }
+                    AssistantSessionProtocol.publish(application, snapshot)
                }
            }
        }
@@ -600,26 +489,8 @@ internal class HermesRuntimeBinder(
        val connectionId: String?,
        val profileName: String?,
        val sessionId: String?,
-        val dashboardRouteResolved: Boolean,
        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 {
@@ -629,16 +500,6 @@ 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.
- */
-internal fun shouldRefreshSessionDirectory(
-    chatReady: Boolean,
-    dashboardRouteResolved: Boolean,
-): Boolean = chatReady || dashboardRouteResolved
-
 internal fun assistantCanTransmitScreenContext(engineMode: VoiceEngineMode): Boolean =
    engineMode == VoiceEngineMode.HermesVoiceOutput

@@ -660,14 +521,12 @@ internal fun resolveVoiceActivationReadiness(
    chatReady: Boolean,
    standardAvailability: StandardVoiceAvailability,
    relayReady: Boolean,
-    relayConfigured: Boolean,
    profileSettled: Boolean,
 ): HermesVoiceActivationReadiness {
    if (!profileSettled) {
        return HermesVoiceActivationReadiness.Waiting("Loading the selected Hermes profile")
    }
-    val effectiveSettings = voiceSettingsForRelayConfiguration(settings, relayConfigured)
-    return when (VoiceEngineMode.fromStorage(effectiveSettings.engineMode)) {
+    return when (VoiceEngineMode.fromStorage(settings.engineMode)) {
        VoiceEngineMode.RealtimeAgent -> {
            if (relayReady) {
                HermesVoiceActivationReadiness.Ready(HermesVoiceActivationRoute.Realtime)
@@ -679,7 +538,7 @@ internal fun resolveVoiceActivationReadiness(
            if (!chatReady) {
                return HermesVoiceActivationReadiness.Waiting("Waiting for Hermes chat")
            }
-            when (VoiceAudioRoute.fromStorage(effectiveSettings.audioRoute)) {
+            when (VoiceAudioRoute.fromStorage(settings.audioRoute)) {
                VoiceAudioRoute.Relay -> if (relayReady) {
                    HermesVoiceActivationReadiness.Ready(
                        HermesVoiceActivationRoute.RelayAudio
@@ -703,24 +562,6 @@ 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) {
@@ -1,40 +0,0 @@
-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
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Bailey Dixon	16233a712d	release(android): android-v1.13.2	2026-08-25 19:45:39 -04:00
Bailey Dixon	0e8b44080d	fix(android): keep unknown session activity neutral (cherry picked from commit `ae9b22a9e6`)	2026-08-25 19:44:28 -04:00