Merge pull request #394 from Codename-11/dev

release: Android 1.12.0 and Server 1.9.0
fix(ci): remove privileged review dispatch
2026-08-21 20:35:20 -04:00 · 2026-08-21 20:17:51 -04:00 · 2026-08-21 20:15:45 -04:00 · 2026-08-21 19:54:13 -04:00 · 2026-08-21 19:09:37 -04:00 · 2026-08-21 19:09:36 -04:00
688 changed files with 83838 additions and 7324 deletions
@@ -63,7 +63,7 @@ jobs:
          java-version: 17

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

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

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

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

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

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

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

@@ -67,7 +67,7 @@ jobs:
          fetch-depth: 1

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

@@ -39,7 +39,7 @@ jobs:
        run: npm run build

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v7
        with:
          python-version: "3.11"

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

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

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

      - name: Check tray formatting
        run: npm run tray:fmt
@@ -44,7 +44,7 @@ jobs:
        uses: actions/checkout@v7

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

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

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

@@ -30,7 +30,7 @@ jobs:
        working-directory: website
    steps:
      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v7
        with:
          node-version: 22
          cache: npm
@@ -44,7 +44,7 @@ jobs:
      - uses: actions/checkout@v7

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

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

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

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

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

@@ -34,6 +34,7 @@ jobs:
    outputs:
      version: ${{ steps.version.outputs.version }}
      version_code: ${{ steps.version.outputs.version_code }}
+      prerelease: ${{ steps.version.outputs.prerelease }}
    steps:
      - uses: actions/checkout@v7
        with:
@@ -56,8 +57,14 @@ jobs:
            REF_VERSION="${GITHUB_REF#refs/tags/android-v}"
          fi
          VERSION_CODE=$(grep -oP 'appVersionCode\s*=\s*"\K[^"]+' gradle/libs.versions.toml)
+          if [[ "$REF_VERSION" == *-* ]]; then
+            PRERELEASE=true
+          else
+            PRERELEASE=false
+          fi
          echo "version=$REF_VERSION" >> "$GITHUB_OUTPUT"
          echo "version_code=$VERSION_CODE" >> "$GITHUB_OUTPUT"
+          echo "prerelease=$PRERELEASE" >> "$GITHUB_OUTPUT"

      - name: Verify version sync
        run: |
@@ -81,14 +88,24 @@ jobs:
      - name: Verify public privacy policy URLs
        run: python3 scripts/check-privacy-policy.py --live

-      - name: Verify tagged commit belongs to main
+      - name: Verify tag belongs to the correct integration branch
+        env:
+          PRERELEASE: ${{ steps.version.outputs.prerelease }}
        run: |
          set -euo pipefail
-          git fetch origin main --no-tags
          tag_commit="$(git rev-parse HEAD)"
-          if ! git merge-base --is-ancestor "$tag_commit" origin/main; then
-            echo "Android releases must be tagged from main; $tag_commit is not in origin/main" >&2
-            exit 1
+          if [ "$PRERELEASE" = "true" ]; then
+            git fetch origin dev --no-tags
+            if ! git merge-base --is-ancestor "$tag_commit" origin/dev; then
+              echo "Android prereleases must be tagged from dev; $tag_commit is not in origin/dev" >&2
+              exit 1
+            fi
+          else
+            git fetch origin main --no-tags
+            if ! git merge-base --is-ancestor "$tag_commit" origin/main; then
+              echo "Stable Android releases must be tagged from main; $tag_commit is not in origin/main" >&2
+              exit 1
+            fi
          fi

      - name: Require successful Play preflight for this exact release tree
@@ -125,7 +142,7 @@ jobs:
          java-version: 17

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

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

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

@@ -175,7 +192,8 @@ jobs:
          echo "$HERMES_KEYSTORE_BASE64" | base64 -d > "$RUNNER_TEMP/release.keystore"
          echo "HERMES_KEYSTORE_PATH=$RUNNER_TEMP/release.keystore" >> "$GITHUB_ENV"

-      - name: Build release artifacts (APK + AAB)
+      - 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 }}
@@ -191,12 +209,58 @@ jobs:
        #   app/build/outputs/bundle/sideloadRelease/hermes-relay-<version>-sideload-release.aab
        run: ./gradlew bundleRelease assembleRelease

-      - name: Scan release DEX for unsupported collection APIs
+      - name: Build side-by-side release candidate APK
+        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 }}
+          VERSION: ${{ needs.validate.outputs.version }}
+        run: |
+          SOURCE_SHA="$(git rev-parse HEAD)"
+          ./gradlew :app:assembleSideloadCandidate \
+            -Pcandidate.kind=rc \
+            -Pcandidate.label="Android ${VERSION}" \
+            -Pcandidate.sourceRef="android-v${VERSION}" \
+            -Pcandidate.sourceSha="$SOURCE_SHA" \
+            --console=plain
+
+      # The Play AAB carries its mapping for Play Console deobfuscation, but
+      # sideload issue reports need the exact mapping from this immutable build.
+      # Keep both variants as a workflow artifact (not a public release asset).
+      - name: Retain R8 mappings for retrace
+        if: ${{ needs.validate.outputs.prerelease != 'true' }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: android-r8-mappings-${{ needs.validate.outputs.version }}-${{ github.sha }}
+          path: |
+            app/build/outputs/mapping/googlePlayRelease/mapping.txt
+            app/build/outputs/mapping/sideloadRelease/mapping.txt
+          if-no-files-found: error
+          retention-days: 90
+
+      - name: Retain candidate R8 mapping for retrace
+        if: ${{ needs.validate.outputs.prerelease == 'true' }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: android-rc-r8-mapping-${{ needs.validate.outputs.version }}-${{ github.sha }}
+          path: app/build/outputs/mapping/sideloadCandidate/mapping.txt
+          if-no-files-found: error
+          retention-days: 90
+
+      - name: Scan stable release DEX for unsupported collection APIs
+        if: ${{ needs.validate.outputs.prerelease != 'true' }}
        run: |
          python3 scripts/check-android-collection-apis.py \
            --apk app/build/outputs/apk/googlePlay/release/*.apk \
            --apk app/build/outputs/apk/sideload/release/*.apk

+      - name: Scan candidate DEX for unsupported collection APIs
+        if: ${{ needs.validate.outputs.prerelease == 'true' }}
+        run: |
+          python3 scripts/check-android-collection-apis.py \
+            --apk app/build/outputs/apk/sideload/candidate/*.apk
+
      - name: List produced artifacts (debug aid)
        run: |
          echo "=== APK outputs ==="
@@ -204,7 +268,8 @@ jobs:
          echo "=== AAB outputs ==="
          find app/build/outputs/bundle -name '*.aab' -print 2>/dev/null || true

-      - name: Generate checksums
+      - 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
@@ -216,6 +281,13 @@ jobs:
          sha256sum apk/sideload/release/*.apk bundle/googlePlayRelease/*.aab > SHA256SUMS.txt
          cat SHA256SUMS.txt

+      - name: Generate candidate checksums
+        if: ${{ needs.validate.outputs.prerelease == 'true' }}
+        run: |
+          cd app/build/outputs
+          sha256sum apk/sideload/candidate/*.apk > SHA256SUMS.txt
+          cat SHA256SUMS.txt
+
      - name: Require Play credentials for stable release
        env:
          PLAY_SERVICE_ACCOUNT_JSON: ${{ secrets.PLAY_SERVICE_ACCOUNT_JSON }}
@@ -242,13 +314,14 @@ jobs:
      # Public distribution happens only after Play accepts the production
      # submission above. This keeps a Play-detected release blocker from
      # appearing after the sideload APK is already public.
-      - name: Create GitHub Release
+      - name: Create stable GitHub Release
+        if: ${{ needs.validate.outputs.prerelease != 'true' }}
        uses: softprops/action-gh-release@v3
        with:
          name: Hermes-Relay-Android v${{ needs.validate.outputs.version }}
          tag_name: android-v${{ needs.validate.outputs.version }}
          body_path: RELEASE_NOTES.md
-          prerelease: ${{ contains(needs.validate.outputs.version, '-') }}
+          prerelease: false
          # Deliberate 2-asset policy (#144): attach ONLY the installable
          # sideload APK and Play AAB, plus checksums covering those files.
          files: |
@@ -256,13 +329,31 @@ jobs:
            app/build/outputs/bundle/googlePlayRelease/*.aab
            app/build/outputs/SHA256SUMS.txt

+      - name: Create candidate GitHub prerelease
+        if: ${{ needs.validate.outputs.prerelease == 'true' }}
+        uses: softprops/action-gh-release@v3
+        with:
+          name: Hermes-Relay-Android v${{ needs.validate.outputs.version }}
+          tag_name: android-v${{ needs.validate.outputs.version }}
+          body_path: RELEASE_NOTES.md
+          prerelease: true
+          fail_on_unmatched_files: true
+          files: |
+            app/build/outputs/apk/sideload/candidate/*.apk
+            app/build/outputs/SHA256SUMS.txt
+
      - name: Release summary
        env:
          HERMES_KEYSTORE_BASE64: ${{ secrets.HERMES_KEYSTORE_BASE64 }}
+          PRERELEASE: ${{ needs.validate.outputs.prerelease }}
        run: |
          echo "## Hermes-Relay-Android v${{ needs.validate.outputs.version }}" >> "$GITHUB_STEP_SUMMARY"
          echo "" >> "$GITHUB_STEP_SUMMARY"
-          if [ -n "$HERMES_KEYSTORE_BASE64" ]; then
+          if [ "$PRERELEASE" = "true" ] && [ -n "$HERMES_KEYSTORE_BASE64" ]; then
+            echo "✅ **Release-signed Candidate app** — separate package ID; never uploaded to Play" >> "$GITHUB_STEP_SUMMARY"
+          elif [ "$PRERELEASE" = "true" ]; then
+            echo "⚠️ **Debug-signed 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"
@@ -48,16 +48,25 @@ jobs:
            exit 1
          fi

-      - name: Verify tagged commit belongs to main
+      - name: Verify tag belongs to the correct integration branch
        shell: bash
        working-directory: .
        run: |
          set -euo pipefail
-          git fetch origin main --no-tags
+          version="${GITHUB_REF_NAME#desktop-v}"
          tag_commit="$(git rev-parse "${GITHUB_REF_NAME}^{commit}")"
-          if ! git merge-base --is-ancestor "$tag_commit" origin/main; then
-            echo "Desktop releases must be tagged from main; $tag_commit is not in origin/main" >&2
-            exit 1
+          if [[ "$version" == *-* ]]; then
+            git fetch origin dev --no-tags
+            if ! git merge-base --is-ancestor "$tag_commit" origin/dev; then
+              echo "Desktop prereleases must be tagged from dev; $tag_commit is not in origin/dev" >&2
+              exit 1
+            fi
+          else
+            git fetch origin main --no-tags
+            if ! git merge-base --is-ancestor "$tag_commit" origin/main; then
+              echo "Stable Desktop releases must be tagged from main; $tag_commit is not in origin/main" >&2
+              exit 1
+            fi
          fi

  build-cli-binaries:
@@ -80,7 +89,7 @@ jobs:
      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
-          bun-version: '1.3.x'
+          bun-version-file: 'desktop/.bun-version'

      - name: Install deps
        run: npm ci
@@ -153,6 +162,40 @@ jobs:
            desktop/dist/bin/hermes-relay-darwin-arm64
          retention-days: 7

+  smoke-windows-cli-release-asset:
+    name: Smoke exact Windows CLI release asset
+    runs-on: windows-latest
+    needs:
+      - validate-release
+      - build-cli-binaries
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: cli-binaries
+          path: release-assets
+
+      - name: Repeated launch and process cleanup gate
+        shell: pwsh
+        env:
+          EXPECTED_DESKTOP_VERSION: ${{ needs.validate-release.outputs.version }}
+        run: |
+          $ErrorActionPreference = 'Stop'
+          $exe = (Resolve-Path 'release-assets/hermes-relay-win-x64.exe').Path
+          1..20 | ForEach-Object {
+            $output = & $exe --version
+            if ($LASTEXITCODE -ne 0) { throw "Windows CLI smoke failed with exit $LASTEXITCODE" }
+            if ($output -ne "hermes-relay $env:EXPECTED_DESKTOP_VERSION") {
+              throw "Unexpected Windows CLI version output: $output"
+            }
+          }
+          Start-Sleep -Milliseconds 500
+          $leftovers = Get-CimInstance Win32_Process | Where-Object {
+            $_.ExecutablePath -eq $exe
+          }
+          if ($leftovers) {
+            throw "Windows CLI smoke left $(@($leftovers).Count) process(es) behind"
+          }
+
  build-windows-tray-installer:
    name: Build Windows tray installer
    runs-on: windows-latest
@@ -168,18 +211,20 @@ jobs:
        with:
          node-version: '22'
          cache: npm
-          cache-dependency-path: desktop/package-lock.json
+          cache-dependency-path: |
+            desktop/package-lock.json
+            desktop/tray/package-lock.json

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
-          bun-version: '1.3.x'
+          bun-version-file: 'desktop/.bun-version'

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

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

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

      - name: Upload Windows tray release asset
        uses: actions/upload-artifact@v4
@@ -232,6 +418,7 @@ jobs:
    runs-on: ubuntu-latest
    needs:
      - build-cli-binaries
+      - smoke-windows-cli-release-asset
      - build-windows-tray-installer
    steps:
      # Needed so CLI_RELEASE_NOTES.md is available to render into the release body
@@ -27,21 +27,31 @@ jobs:
      - name: Verify Server version sync and changelog
        run: |
          python scripts/check-plugin-version-sync.py --expect "$TAG_VERSION"
-          if ! grep -Fq "## [$TAG_VERSION]" CHANGELOG.md; then
-            echo "::error::CHANGELOG.md has no release heading for $TAG_VERSION"
+          if ! grep -Eq "^## \[Server ${TAG_VERSION}\]" CHANGELOG.md; then
+            echo "::error::CHANGELOG.md has no Server release heading for $TAG_VERSION"
            exit 1
          fi
        env:
          TAG_VERSION: ${{ steps.version.outputs.version }}

-      - name: Verify tagged commit belongs to main
+      - name: Verify tag belongs to the correct integration branch
+        env:
+          TAG_VERSION: ${{ steps.version.outputs.version }}
        run: |
          set -euo pipefail
-          git fetch origin main --no-tags
          tag_commit="$(git rev-parse HEAD)"
-          if ! git merge-base --is-ancestor "$tag_commit" origin/main; then
-            echo "Server releases must be tagged from main; $tag_commit is not in origin/main" >&2
-            exit 1
+          if [[ "$TAG_VERSION" == *-* ]]; then
+            git fetch origin dev --no-tags
+            if ! git merge-base --is-ancestor "$tag_commit" origin/dev; then
+              echo "Server prereleases must be tagged from dev; $tag_commit is not in origin/dev" >&2
+              exit 1
+            fi
+          else
+            git fetch origin main --no-tags
+            if ! git merge-base --is-ancestor "$tag_commit" origin/main; then
+              echo "Stable Server releases must be tagged from main; $tag_commit is not in origin/main" >&2
+              exit 1
+            fi
          fi

  test:
@@ -53,7 +63,7 @@ jobs:
      - uses: actions/checkout@v7

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

@@ -77,7 +87,9 @@ jobs:
          python -m pytest \
            plugin/tests/test_relay_security.py \
            plugin/tests/test_voice_routes.py \
-            plugin/tests/test_session_grants.py
+            plugin/tests/test_session_grants.py \
+            plugin/tests/test_proactive_channel.py \
+            plugin/tests/test_android_phone_status.py

  package:
    name: Build and publish Plugin package
@@ -88,7 +100,7 @@ jobs:
      - uses: actions/checkout@v7

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

@@ -0,0 +1,192 @@
+name: Build Review Bundle
+
+on:
+  pull_request:
+    branches:
+      - dev
+    types:
+      - labeled
+
+permissions:
+  contents: read
+  pull-requests: read
+
+concurrency:
+  group: review-bundle-pr-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  resolve:
+    if: ${{ github.event.label.name == 'review-candidate' }}
+    name: Resolve exact source
+    runs-on: ubuntu-latest
+    outputs:
+      repository: ${{ steps.source.outputs.repository }}
+      sha: ${{ steps.source.outputs.sha }}
+      short_sha: ${{ steps.source.outputs.short_sha }}
+      label: ${{ steps.source.outputs.label }}
+      artifact_slug: ${{ steps.source.outputs.artifact_slug }}
+      source_kind: ${{ steps.source.outputs.source_kind }}
+      source_value: ${{ steps.source.outputs.source_value }}
+    steps:
+      - name: Resolve pull request or exact SHA
+        id: source
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const kind = "pull_request";
+            const source = process.env.PR_NUMBER;
+            const repository = process.env.PR_HEAD_REPOSITORY;
+            const sha = process.env.PR_HEAD_SHA;
+            if (!repository || !sha) {
+              core.setFailed("the PR head repository is no longer available");
+              return;
+            }
+            const label = `PR #${source}`;
+            const slug = `pr-${source}`;
+
+            core.setOutput("repository", repository);
+            core.setOutput("sha", sha);
+            core.setOutput("short_sha", sha.slice(0, 12));
+            core.setOutput("label", label);
+            core.setOutput("artifact_slug", slug);
+            core.setOutput("source_kind", kind);
+            core.setOutput("source_value", source);
+        env:
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          PR_HEAD_REPOSITORY: ${{ github.event.pull_request.head.repo.full_name }}
+          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+
+  build:
+    name: Build matched Android + Relay bundle
+    needs: resolve
+    runs-on: ubuntu-latest
+    timeout-minutes: 40
+    steps:
+      - name: Checkout exact review source
+        uses: actions/checkout@v7
+        with:
+          repository: ${{ needs.resolve.outputs.repository }}
+          ref: ${{ needs.resolve.outputs.sha }}
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Verify immutable source
+        env:
+          EXPECTED_SHA: ${{ needs.resolve.outputs.sha }}
+        run: test "$(git rev-parse HEAD)" = "$EXPECTED_SHA"
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v6.3.0
+        with:
+          cache-read-only: true
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v7
+        with:
+          python-version: "3.11"
+
+      - name: Build side-by-side candidate APK
+        env:
+          SOURCE_LABEL: ${{ needs.resolve.outputs.label }}
+          SOURCE_REF: ${{ needs.resolve.outputs.source_kind }}:${{ needs.resolve.outputs.source_value }}
+          SOURCE_SHA: ${{ needs.resolve.outputs.sha }}
+        run: |
+          ./gradlew :app:assembleSideloadCandidate \
+            -Pcandidate.kind=review \
+            -Pcandidate.label="$SOURCE_LABEL" \
+            -Pcandidate.sourceRef="$SOURCE_REF" \
+            -Pcandidate.sourceSha="$SOURCE_SHA" \
+            --console=plain
+
+      - name: Build Relay packages
+        run: |
+          python -m pip install build
+          python -m build
+
+      - name: Verify candidate application identity
+        run: |
+          apk="$(find app/build/outputs/apk/sideload/candidate -name '*.apk' -print -quit)"
+          test -n "$apk"
+          aapt="$(find "$ANDROID_HOME/build-tools" -type f -name aapt -print | sort -V | tail -1)"
+          test -x "$aapt"
+          "$aapt" dump badging "$apk" | grep -F "package: name='com.axiomlabs.hermesrelay.sideload.candidate'"
+          "$aapt" dump badging "$apk" | grep -F "application-label:'Hermes Candidate'"
+
+      - name: Assemble review bundle
+        env:
+          SOURCE_KIND: ${{ needs.resolve.outputs.source_kind }}
+          SOURCE_VALUE: ${{ needs.resolve.outputs.source_value }}
+          SOURCE_REPOSITORY: ${{ needs.resolve.outputs.repository }}
+          SOURCE_SHA: ${{ needs.resolve.outputs.sha }}
+          SOURCE_LABEL: ${{ needs.resolve.outputs.label }}
+          SHORT_SHA: ${{ needs.resolve.outputs.short_sha }}
+        run: |
+          mkdir -p review-bundle/android review-bundle/relay
+          cp app/build/outputs/apk/sideload/candidate/*.apk review-bundle/android/
+          cp dist/*.whl dist/*.tar.gz review-bundle/relay/
+          git archive \
+            --format=tar.gz \
+            --output="review-bundle/relay/hermes-relay-source-${SHORT_SHA}.tar.gz" \
+            HEAD plugin pyproject.toml relay_server
+          cp docs/review-candidates.md review-bundle/INSTALL.md
+          python - <<'PY'
+          import json
+          import os
+          from datetime import datetime, timezone
+          from pathlib import Path
+
+          manifest = {
+              "schema_version": 1,
+              "kind": "review",
+              "label": os.environ["SOURCE_LABEL"],
+              "source": {
+                  "kind": os.environ["SOURCE_KIND"],
+                  "value": os.environ["SOURCE_VALUE"],
+                  "repository": os.environ["SOURCE_REPOSITORY"],
+                  "sha": os.environ["SOURCE_SHA"],
+              },
+              "android": {
+                  "application_id": "com.axiomlabs.hermesrelay.sideload.candidate",
+                  "stable_install_affected": False,
+              },
+              "relay": {
+                  "side_by_side_in_same_hermes_process": False,
+                  "staging_or_snapshot_rollback_required": True,
+              },
+              "generated_at": datetime.now(timezone.utc).isoformat(),
+          }
+          Path("review-bundle/REVIEW_MANIFEST.json").write_text(
+              json.dumps(manifest, indent=2, sort_keys=True) + "\n",
+              encoding="utf-8",
+          )
+          PY
+          cd review-bundle
+          find android relay -type f -print0 | sort -z | xargs -0 sha256sum > SHA256SUMS.txt
+
+      - name: Upload matched review bundle
+        uses: actions/upload-artifact@v7
+        with:
+          name: hermes-relay-review-${{ needs.resolve.outputs.artifact_slug }}-${{ needs.resolve.outputs.short_sha }}
+          path: review-bundle/
+          if-no-files-found: error
+          retention-days: 14
+
+      - name: Review summary
+        env:
+          SOURCE_LABEL: ${{ needs.resolve.outputs.label }}
+          SOURCE_SHA: ${{ needs.resolve.outputs.sha }}
+        run: |
+          echo "## Hermes-Relay review bundle" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "- Source: **$SOURCE_LABEL**" >> "$GITHUB_STEP_SUMMARY"
+          echo "- Commit: \`$SOURCE_SHA\`" >> "$GITHUB_STEP_SUMMARY"
+          echo "- Android package: \`com.axiomlabs.hermesrelay.sideload.candidate\`" >> "$GITHUB_STEP_SUMMARY"
+          echo "- Stable Android installs are not replaced." >> "$GITHUB_STEP_SUMMARY"
+          echo "- Relay review requires a staging Hermes instance or an explicit snapshot/rollback window." >> "$GITHUB_STEP_SUMMARY"
@@ -12,6 +12,7 @@ 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_*` toolset + MCP → **[docs/mcp-tooling.md](docs/mcp-tooling.md)**
 - Follow-ups / deferred work / known gaps → **[TODO.md](TODO.md)** (the single home for "what's next" — never DEVLOG, never scattered code comments)

@@ -21,7 +22,8 @@ not redefine the branch, release, or hotfix policy here and in `RELEASE.md`.
 |---|---|
 | Integration branch | `dev`; normal feature, fix, docs, and chore PRs target `dev` |
 | Release branch | `main`; release history and hotfix integration only |
-| Tag source | The new `main` tip after an approved `dev` → `main` release PR, or after an approved hotfix PR to `main` |
+| Production tag source | The new `main` tip after an approved `dev` → `main` release PR, or after an approved hotfix PR to `main` |
+| Candidate tag source | An exact release-prepared and tested `dev` SHA; prerelease suffix required (`-alpha`, `-beta`, or `-rc.N`) |
 | 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 |
@@ -44,6 +46,15 @@ a staging branch.
  through upstream PRs or the optional relay plugin, never fork patches.
 - **Verify endpoints against upstream** (`gateway/platforms/api_server.py` /
  `tui_gateway/server.py` in hermes-agent) before assuming a route exists.
+- **Use the Gateway contract lab when its boundary changes.** Changes to
+  Gateway chat events, session identity/resume/activation, streaming completion,
+  queue ownership, reconnect/lifecycle recovery, or authoritative history must
+  reuse or extend the declarative fixture scenarios, run the relevant Android
+  instrumentation when rendered/lifecycle behavior is affected, and run the
+  scenario manifest through current-upstream conformance. Physical ADB
+  certification is required only when device/runtime behavior is claimed. All
+  of these lanes are on demand; do not add scheduled execution without explicit
+  approval.
 - **Conventional Commits + `main`/`dev` branching.** Normal branches start at
  `dev` and PR back to `dev`; merge commits/no-ff are the repository policy.
  Version bumps happen only during release preparation on `dev`, and production
@@ -6,12 +6,334 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this

 ## [Unreleased]

+## [Android 1.12.0] - 2026-08-21
+
+### Added
+
+- **Android can create and save custom themes.** The Custom workshop provides a live chat preview, editable Background, Surface, Accent, and Text roles, Light or Dark ownership, saved Soft/Balanced/Sharp shape, and bounded rename, duplicate, and delete actions. Up to 20 presets remain local to the device.
+- **Maintainers can build matched Android and Relay review candidates without cutting a release.** Candidate artifacts share exact source provenance and checksums, install beside stable builds with isolated data, and remain excluded from stable update prompts.
+
+### Changed
+
+- **Appearance shape now applies consistently across the app.** Soft, Balanced, and Sharp styling reaches chat, settings, sheets, dialogs, terminal, voice, Bridge, and other shared surfaces, while accent and shape changes apply immediately. (#385)
+- **Selecting an All Profiles session now activates its owning agent.** Header identity, avatar, transcript, drafts, routing, and persistence move together. Merely browsing All Profiles changes nothing, and a profile lock hides All Profiles and rejects cross-profile opens.
+
 ### Fixed

- **Android chat and Voice keep one render identity through recovery.** Checkpoint restore, streamed callbacks, server-ID adoption, and replay now resolve the same owned transcript row before publication, preventing recurring Compose duplicate-key crashes.
- **Issue area labels require maintainer review.** The unreliable keyword-based auto-labeling workflow no longer assigns ownership from ambiguous issue text.
+- **Language changes preserve the active profile and session.** Activity recreation retains the exact connection, agent, session, and All Profiles browser state without replacing them with stale persisted values. The persistent connection notification also relocalizes without reconnecting. (#381)
+- **Gateway chats recover when a terminal frame is missed.** An authoritative idle state settles the active turn, retains its durable session, and reconciles history without resubmitting through fallback transport. (#365)
+- **Relay endpoint forms normalize to the correct sibling routes.** Saved base, `/ws`, and `/health` URLs resolve idempotently without producing paths such as `/relay/ws/health`; malformed or ambiguous routes still fail closed. (#380)
+
+## [Server 1.9.0] - 2026-08-21
+
+### Added
+
+- **Reconnect-delivered phone messages carry explicit backlog context.** Relay marks messages flushed from its bounded offline queue and emits one ordered completion event so compatible clients can label delayed messages and summarize the batch without generating one banner per item.
+- **Phone status reports granular Bridge capability grants.** Human-readable status and the `android_phone_status` tool distinguish permanent, timed, and unlimited capabilities while retaining the existing Android permission and safety state.
+
+## [1.11.0] - 2026-08-20
+
+### Added
+
+- **Sideload Bridge access is explicitly capability-scoped.** Read-only, read-and-confirm, and custom presets grant only selected powers for the active connection. Screen inspection and control can be allowed for a bounded period or explicitly left unlimited, and Relay status reports the resulting permanent, timed, and unlimited grants.
+
+### Changed
+
+- **The sideload Bridge screen is a summary-first access cockpit.** Agent access, unattended mode, selected Android requirements, and advanced safety controls are separated clearly while the complete permission matrix and power-user controls remain available one tap deeper.
+
+### Fixed
+
+- **Android keeps failed session resumes visible and in context.** Continuing a stored Gateway session no longer falls through to a fresh session when Hermes rejects or mis-scopes the resume. Failed turns remain error-marked and expose a composer-adjacent recovery panel with route-aware details, explicit retry/dismiss actions, and sanitized Diagnostics evidence.
+- **Software-keyboard Return inserts a newline across both common Android IME paths.** Keyboards that commit text directly and keyboards that synthesize `KEYCODE_ENTER` now keep multiline composition separate from physical-keyboard Send behavior. (#367)
+- **Cancelled answer recovery retains its Stopped status.** Empty recovery placeholders with a persistent status badge are no longer discarded during stream finalization.
+- **Android screen-on idle no longer continuously redraws the ASCII sphere.** Idle holds a stable frame while thinking, streaming, and voice states retain full-rate motion; inactive voice waveforms and closed session drawers also stop their frame loops.
+- **Android capture and audio effects release power-sensitive resources at their actual lifecycle boundaries.** Screen capture attaches its MediaProjection surface only for a requested frame, unattended Bridge wake locks release when the command finishes, and barge-in AEC/noise suppression attach to the microphone capture session instead of playback.
+- **Experimental wake-word listening reuses its PCM normalization buffer.** Continuous opt-in listening no longer allocates a new float frame for every inference call.
+
+## [1.10.0] - 2026-08-18
+
+### Added
+
+- **Android preserves composer drafts across app restarts.** Text, quote/edit context, and pending attachments remain scoped to their exact connection, profile, and session in bounded app-private no-backup storage, and successful sends remove the saved draft.
+- **Android can turn large pastes into reviewable text attachments.** The default-on Chat setting converts inserts of at least 5,000 characters into a compact attachment while preserving surrounding text; Gateway uploads the file through upstream Hermes and fallback transports retain the pasted content as text.
+- **Android renders Markdown incrementally while replies stream.** The native streaming parser retains stable message, selection, and AST identities from the first token through completion, including provisional paragraphs, lists, links, fenced code, and tables.
+
+### Fixed
+
+- **The Android software keyboard exposes Return in the multiline composer.** The dedicated composer button sends, while physical Enter, Shift+Enter, and caret-arrow behavior remain unchanged. (#367)
+- **Open chats reattach after Android returns to the foreground.** Gateway reconnect restores the visible session subscription and reconciles missed work without requiring the user to leave and reopen the conversation. (#365)
+- **Imported credentials fail closed before network or secure-state mutation.** Control characters and malformed values are rejected before header construction or encrypted-state replacement without logging credential material.
+- **Streaming follow remains stable through completion.** Deliberate scrollback stays untouched, bottom-follow uses one bounded owner, and Markdown, voice actions, timestamps, and token metadata settle without rebuilding the bubble or resetting its scroll anchor. (#341)
+
+## [1.9.1] - 2026-08-16
+
+### Added
+
+- **Android adopts Hermes-owned profile creation, shared avatars, and animated pets.** Current Gateways provide the profile roster, explicit shared/copied/isolated authentication choices, partial create outcomes, validated avatar upload/fetch/clear, and profile-scoped pet selection that follows the agent across supported Hermes clients. Older hosts retain authenticated Dashboard creation plus Relay/local presentation fallbacks, and profile deletion remains Dashboard-only.
+- **Android identifies proactive messages delivered after reconnect.** Relay marks messages flushed from its bounded offline queue, Thread bubbles label them as received “While away,” and Android shows one accessible localized summary for the completed batch.
+- **Android can create finite recurring schedules from Manage.** The native editor uses the authenticated Hermes Gateway `cron.manage` contract, optionally stops after 1–999 runs, and rejects invalid counts rather than silently creating unlimited work.
+- **Chat resets retain content-free local evidence.** New-chat and Thread transitions save a bounded app-private checkpoint for user-reviewed Diagnostics without prompts, message text, IDs, profile names, paths, URLs, media, tool payloads, secrets, or telemetry.
+- **Android surfaces host resource risk before chat state is lost.** Current Hermes Dashboard memory and disk pressure signals render as a persistent, capability-gated warning; older hosts remain unchanged and no telemetry is added.
+- **Android honors Hermes model-selection safeguards.** Every Gateway model transition, including fresh-chat and Server-default choices, now avoids raw session overrides; picks requiring cost or data-training consent show Hermes' exact warning and apply only after a confirmed second request.
+
+### Changed
+
+- **Profile identity sources are explicit in Agent Passport.** Server-owned static avatars and upstream pets follow the Hermes profile, while phone picks, Relay-host imports, phone-only animated icons, and Sphere skins remain separate local presentation choices.
+- **Interactive Gateway asks remain resolver-bound.** Android continues to use upstream clarify, approval, sudo, and secret response RPCs; connector-only prompt/reaction operations are not copied into Relay cards as a second approval protocol.
+
+### Fixed
+
+- **Shared avatar picks now persist from Android's filesystem picker.** The app accepts any image Android can decode, applies display orientation, and safely resizes or re-encodes it to the upstream PNG/JPEG/WebP and 2,000,000-byte contract. Successful writes update the local shared cache immediately, and upload failures remain visible beside the control.
+
+- **Nous-hosted Android sign-in follows the official native broker contract.** The gateway now selects its native provider exactly as Hermes Desktop does, callback attempts retain the upstream five-minute window, and post-callback failures explain whether the one-time code, hosted gateway, network, response, or secure storage prevented session creation without exposing auth material.
+- **Android edit-and-regenerate fails closed on incomplete durable history.** Mixed Gateway transcripts now require the selected message's durable row identity instead of attempting an ordinal-only rewind, while older Hermes histories with no row identities remain editable.
+- **Android fails closed when a Gateway does not confirm the selected profile.** Named-profile session creation and recovery now require Hermes to echo the exact owning profile, preventing stale or older gateways from silently running the launch profile under another agent's identity. Profile inspection also keeps read-only Gateway data available when `profiles.configure` is unsupported while disabling further write attempts without discarding drafts.
+- **Android attachment sends are bounded and fail closed.** Picked files are size-limited while streaming into the encoder, cold and queued Gateway sends upload only after the exact session is ready, and an unsupported or interrupted document upload no longer falls through to a text-only route while its file card implies delivery. Every attachment type retains the same compact collapse/expand affordance.
+
+## [0.4.0-beta.4] - 2026-08-15
+
+### Fixed
+
+- **The Windows management UI remains available while the daemon is stopped.** Missing, stale, malformed, or temporarily unavailable daemon status now resolves to an explicit stopped state instead of trapping the tray on its loading screen, so configuration, diagnostics, host management, and daemon controls remain accessible.
+
+## [1.9.0] - 2026-08-14
+
+### Added
+
+- **Android session browsing matches Hermes Desktop's recent organization model.** The primary session drawer can toggle between the active profile and all profiles, group by recency, project, status, or profile, order by supported session metrics, and narrow rows by status, project, profile, or pull-request state without collapsing duplicate IDs across profile stores. Named profiles receive stable identity-color badges with locally persisted color overrides.
+- **Android can edit current Hermes profiles through the standard Gateway.** The Profile Inspector capability-gates `profiles.describe` and `profiles.configure`, keeps Relay-only memory editing and older-Hermes fallback intact, and reports partial section saves without discarding failed drafts.
+- **Android sessions show their coding context when Hermes supplies it.** Session rows can display repository, Git branch, and the current state of the pull request created by that session while older hosts remain unchanged.
+- Android Manage can now finish host-owned backup workflows, edit or remove learning nodes with explicit recovery guidance, configure and activate memory providers, and complete profile-scoped WhatsApp QR onboarding through the authenticated upstream Dashboard contracts.
+
+### Fixed
+
+- **Android network clients shut down safely during route changes.** Replacing an authenticated Dashboard client now moves OkHttp connection-pool eviction off the main thread, preventing a live TLS socket close from crashing the app with `NetworkOnMainThreadException`. (#334)
+- **Android preserves authoritative Gateway outcomes.** Protected-file cards cannot offer forbidden persistent scopes, compression no-ops show the server result, bounded resume failures do not create context-free replacement sessions, and edit/regenerate retains durable row identities across consecutive rewinds.
+- **Android routes and uploads against live upstream truth.** Multiplex API fallback trusts `served_profiles` instead of installed profiles, and generic documents carry the Gateway-issued `@file:` reference into ordinary and queued prompts.
+- **Android clarify cards preserve upstream decision semantics.** Multi-select prompts keep independent selections and submit one exact list, while server expiry events—not an invented local deadline—retire unanswered cards.
+- **Android keeps profile management and retained automation truthful.** Custom Endpoint list and mutation routes now follow the selected Hermes profile, while completed one-shot cron jobs show their retained outcome and expose only valid Runs/Delete actions.
+- **Android and Relay recover more generated media reliably.** Android accepts upstream-valid wrapped, punctuated, adjacent, spaced, and Windows `MEDIA:` markers without consuming fenced examples, and Relay translates Docker-visible workspace, home, cache, and configured-mount paths before applying its existing credential, sandbox, and size checks.
+- **Android keeps cross-profile sessions with their owning agent.** Opening a session from All Profiles hydrates, resumes, sends, and renders with that session's profile without changing the global profile selection; New Chat from that view starts with the default profile.
+- **Android reactions and standard voice follow the active conversation.** Reactions resolve durable rows for both user and assistant messages, while Vanilla Hermes voice remains on the authenticated Gateway instead of requiring the optional API fallback.
+- **Android session navigation behaves predictably.** The drawer closes on outside taps, uses an ungrouped recent-session list by default, retains project grouping as an explicit option, and exposes secondary actions in All Profiles mode.
+
+## [0.4.0-beta.3] - 2026-08-14
+
+### Fixed
+
+- **Windows tray polling can no longer accumulate unbounded helper processes.** Grant discovery now uses lightweight local state, management refreshes are single-flight and visibility-aware, and child probes have hard timeouts, bounded output, tree cleanup, caching, and backoff. A dedicated bounded `tray.log` records sanitized operational failures without mixing them into daemon logs.
+- **Concurrent Desktop lifecycle requests cannot start duplicate daemons.** Cross-process lifecycle and runtime ownership locks serialize startup and recovery while preserving stale-owner cleanup.
+
+## [1.8.0] - 2026-08-14
+
+### Added
+
+- **Official Hermes Desktop can surface Relay through its supported runtime Plugin SDK.** The unified plugin package now includes an opt-in, profile-scoped Desktop pane for Relay status, paired devices, bridge activity, media, pairing, revocation, and remote-access management. Loading, startup, reconnects, profile changes, and updates never open it; only labeled sidebar, status-bar, or command-palette actions register and reveal the movable native pane.
+
+## [0.4.0-beta.2] - 2026-08-14
+
+### Added
+
+- **Desktop Activity now keeps inspectable local evidence.** Commands, files, devices, connection lifecycle, and computer control share a truthful event stepper with dedicated failure details; screenshot events can retain bounded local PNG evidence and open it in a larger borderless viewer. Settings controls retention as Off, 1 day, 7 days, or 30 days and shows local file usage.
+
+### Fixed
+
+- **Tunnel state stays responsive through interruption and retry.** The CLI UI distinguishes connected, reconnecting, and stopped states, exposes retry attempt/timing and a Retry now action, records connection failures and recovery in Activity, and shows compact connection cards only while the main UI is hidden.
+- **Windows CUA readiness no longer depends on the flaky whole-desktop health scan.** Hermes-Relay verifies the canonical runtime, manifest, required tools, daemon, and safe permission mode before starting structured sessions, while accessibility health remains an explicit CLI/UI diagnostic that can be rechecked without forcing the compatibility backend. This temporary workaround is scoped to the upstream fixed-timeout issue and keeps individual actions fail-closed.
+
+## [0.4.0-beta.1] - 2026-08-14
+
+### Added
+
+- **CUA Driver is the preferred Windows structured-control engine.** New local settings prefer a verified CUA runtime for window-targeted background actions, fresh snapshot tokens, and optional per-session animated agent cursors without moving the physical pointer; Windows Input is the explicit compatibility backend and backend choice is fixed for each control session. Full-display observation remains on the read-only system capture path. CLI and UI can explicitly install, check, or update the canonical CUA package after verifying the upstream release manifest and installer checksum; nothing is bundled or updated automatically, driver telemetry stays off for Hermes sessions, and activity records contain only bounded, redacted control metadata.
+
+### Fixed
+
+- **Windows bundle updates fail closed when installed processes retain a binary lock.** Setup waits for the invoking CLI, quiesces the tray and its short-lived CLI children, checks every payload extraction before writing release metadata, preserves custom install directories, and returns a failure instead of reporting a mixed-version installation.
+- **CUA readiness follows the published driver contract.** Hermes accepts the documented `ok` health state, distinguishes an installed-but-degraded runtime from a missing installation, and constructs trusted Windows installer paths consistently across verification environments.
+
+## [1.7.0] - 2026-08-13
+
+### Added
+
+- **Hermes Secure Link provides self-hosted pinned TLS ingress.** Relay, API, and Dashboard namespaces share one operator-owned TLS endpoint while retaining their native authentication boundaries, QR-carried certificate continuity, explicit rotation, and fail-closed route validation.
+- **Hermes Reach is available for explicit experimentation.** The optional self-hosted rendezvous broker carries opaque Secure Link TLS records over outbound-only connections with bounded multiplexing, hashed credentials, replay protection, persistence, revocation, and no access to Hermes payloads.
+- **Remote-access management exposes supported reachability clearly.** Dashboard status and pairing metadata distinguish Tailscale reachability, Secure Link transport protection, direct routes, and experimental Reach without presenting the broker as a replacement for authentication.
+
+### Changed
+
+- **Tailscale is the recommended remote route.** Pairing, Dashboard, documentation, and public site guidance present Tailscale as the easiest supported remote-access path; Reach remains disabled by default, advanced, and lower priority than supported routes.
+- **Relay voice custom transports follow upstream provider security options.** Relay-owned OpenAI/xAI realtime and TTS clients honor custom headers, custom CA bundles, standard CA environment precedence, and an explicitly warned development-only verification override.
+- **Voice Lab xAI sign-in uses device authorization.** The standalone login shows a verification URL and user code and polls for approval without requiring a loopback callback.
+
+### Fixed
+
+- **Phone delivery remains compatible with strict Hermes targets.** Version-tolerant parser and validator hooks retain older-host registration and exactly-once standalone delivery.
+- **Profile-owned Relay registrations stay isolated.** Current Hermes uses profile-scoped ownership and context-local profile homes while legacy hosts retain a guarded compatibility path.
+- **Phone is discoverable before its first historical session.** The Relay phone adapter publishes its configured home destination through Hermes' standard channel directory.
+
+## [0.4.0-alpha.8] - 2026-08-13
+
+### Added
+
+- **Windows management separates each Relay host from this PC.** Host detail owns identity, pairing, access, capabilities, authorized clients, re-pairing, and guarded removal; Settings owns local daemon lifecycle, startup, privilege, terminal, logs, diagnostics, updates, and Help & About.
+- **Desktop access uses clear host-scoped presets and capabilities.** Restricted, Ask Every Time, Standard, Full Access, and Custom remain explicit across commands, files, screen/input, USB, microphone, and camera controls.
+- **Activity drilldown preserves bounded execution evidence.** Overview shows the latest three events and detail views expose request, output, result, exit, duration, and truncation metadata without copying sensitive inputs.
+- **Connection presentation shows the live Agent-to-PC path.** Host selection, bidirectional packet motion, transition feedback, route details, and connection testing stay compact, responsive, and reduced-motion aware.
+
+### Changed
+
+- **Connect and disconnect remain responsive during daemon work.** Lifecycle calls and snapshot collection run outside the UI thread, transition status polls quickly without overlapping probes, and progress remains visible until authoritative daemon state arrives.
+- **Tailscale is recommended for remote access.** Secure Link and direct TLS routes remain supported, while Hermes Reach is visibly experimental and lower priority.
+
+### Fixed
+
+- **Connection tests classify legacy private routes correctly.** A saved generic role is inferred from its actual endpoint, so LAN and Tailscale routes no longer appear as Custom VPN; results include reachability, latency, security, endpoint, and route count.
+- **Ask-mode approval cards show the requested action.** A bounded preview appears in the compact card with full context and an Open in UI action.
+- **Mixed capability policies are labeled Custom.** Overview no longer claims a preset when individual capability controls differ.
+- **Tray placement follows the notification-area monitor and DPI.** Responsive popup geometry stays anchored above the tray icon across compact and high-DPI desktops.
+- **PowerShell success output is complete and self-describing.** Scalar, pipeline, JSON, native stdout/stderr, exit status, and truncation metadata survive the desktop RPC response.
+
+## [1.6.4] - 2026-08-12
+
+### Added
+
+- **Desktop tools support explicit host targeting.** Every client-routed desktop tool accepts a stable device ID or unambiguous computer name, and `/desktop/health` enumerates connected targets and their advertised tools.
+- **USB operations retain both routing scopes.** Raw USB and ADB tools use `device` to select the desktop PC, while ADB operations continue to use `serial` to select hardware attached to that PC.
+
+### Fixed
+
+- **Multiple desktop clients remain connected simultaneously.** The Relay no longer replaces the previous desktop when another heartbeat arrives; concurrent requests are bound to their selected WebSockets, responses from another PC are ignored, and an untargeted call fails closed when several desktops are online.
+- **Pairing another desktop preserves existing credentials.** Legacy placeholder device identifiers are treated as absent instead of shared ownership, preventing an unrelated PC from revoking the first desktop's session.
+
+## [1.6.3] - 2026-08-11
+
+### Fixed
+
+- **Relay diagnostics distinguish a prior clean stop from a crash.** Doctor and `/relay/info` expose only bounded clean, unclean, or unknown gateway-exit state with an optional suspected out-of-memory hint, without returning raw log evidence.
+- **Relay reconnects spread out after shared gateway restarts.** Ordinary exponential reconnect delays use full jitter while explicit reconnects and server-directed retry timing retain their exact behavior.
+
+## [0.4.0-alpha.7] - 2026-08-11
+
+### Fixed
+
+- **Installer lifecycle validation uses an isolated Windows PATH fixture.** Release smoke tests now verify add/remove cleanup against a fixed registry value and restore the runner's original value afterward, independently of the temporary profile used for session-preservation checks.
+
+## [0.4.0-alpha.6] - 2026-08-11
+
+### Fixed
+
+- **Installer cleanup validation compares the unexpanded Windows PATH.** Release smoke tests now read the raw user registry value, ensuring `%USERPROFILE%` entries are verified without temporary-profile expansion changing their apparent value.
+
+## [0.4.0-alpha.5] - 2026-08-11
+
+### Fixed
+
+- **Installer cleanup validation handles expandable Windows PATH entries.** Release smoke tests restore the original profile environment before comparing user PATH, avoiding false failures when unchanged `%USERPROFILE%` entries are expanded inside an isolated test profile.
+
+## [0.4.0-alpha.4] - 2026-08-11
+
+### Fixed
+
+- **Windows release validation waits for installer processes.** The packaged install/uninstall lifecycle smoke now captures GUI-subsystem process exit codes reliably before validating installed files, preserved sessions, registry state, and cleanup.
+
+## [0.4.0-alpha.3] - 2026-08-11
+
+### Added
+
+- **Windows tray provides focused remote-access management.** The compact host-aware popup covers connection state, per-host Ask/Trusted/Full Access, pending grant dialogs, authorized-client revocation, activity, daemon controls, and settings without adding chat, terminal, plugin, voice, or session surfaces.
+- **Desktop access policy is isolated per Hermes host.** `hermes-relay hosts` lists and selects local pairings and stores fail-closed access modes independently for each canonical relay URL.
+- **Windows CLI installations can add or open the management UI directly.** `hermes-relay ui install|open|status` and the installed UI shim provide a supported lifecycle for optional UI setup, discovery, and activation.
+
+### Changed
+
+- **Daemon connectivity no longer requires a tool grant.** Ask mode can keep an authenticated daemon connected with zero desktop tools attached; Trusted enables command/file tools with task-scoped screen/input grants, while Full Access removes those task prompts only for the selected host.
+- **Windows bundle updates preserve the desktop lifecycle.** The CLI and tray coordinate one verified installer launch, restore the daemon and UI after setup, and permit same-version UI add or repair without silently downgrading a newer CLI.
+
+### Fixed
+
+- **Background daemon start reports real readiness.** Detached startup now waits for the spawned process to authenticate and connect, and returns actionable log evidence for configuration, authentication, early-exit, and timeout failures.
+- **Local and release tray builds embed the packaged UI.** Development installs use Tauri's production protocol instead of attempting to load a missing localhost development server, and release CI exercises a silent install/uninstall lifecycle.
 - **Windows-trusted certificates work in the desktop CLI.** The packaged Windows binary and newer Node runtimes add the Windows certificate store without dropping bundled or operator-supplied roots, while TLS verification and Relay certificate pinning remain enforced.

+## [1.6.2] - 2026-08-11
+
+### Fixed
+
+- **Paired sessions use recognizable device identities.** Relay sessions preserve a client-provided hostname as the primary name, retain model and platform details, and enrich valid reconnects without requiring users to pair again.
+- **Long-lived session expiry is readable.** The Dashboard presents paired-session lifetime in days or weeks with the exact local deadline available in the detail view instead of accumulating hundreds of hours.
+
+## [Android 1.8.1] - 2026-08-09
+
+### Fixed
+
+- **Android preserves complete long-session transcripts.** API-server and profile-scoped Dashboard history reads now use explicit bounded pagination, retain compatibility with older unpaginated responses, and keep edit, retry, sharing, and recovery anchors stable beyond Hermes' latest-500 default window.
+- **Android follows authoritative Gateway turn contracts.** Submit rejections retain the server's message without silently falling through to SSE, event envelopes reconcile consistently, and edit-and-regenerate requests send the required truncation confirmation.
+
+## [Android 1.8.0] - 2026-08-09
+
+### Added
+
+- **Android chat keeps work in context and makes live turns easier to read.** Draft text, edits, quotes, and attachments stay with their connection, profile, and session; conversation search and prompt-turn navigation jump by stable message identity; message actions reveal smoothly on tap; quoted replies use linked previews without placing markup in the composer; assistant replies retain their compact high-contrast bubbles; and pending attachments support preview, removal, and accessible reordering.
+- **Android reasoning and tool activity use a quieter transcript.** Live thinking opens as an inline disclosure and settles to a collapsed Thought row, while consecutive routine reads, searches, commands, browser actions, and device actions share one live activity ticker or concise completed summary. Approvals, failures, generated media, file changes, output risks, and delegated work keep their own visible lifecycle surfaces even when ordinary tool progress is hidden.
+- **Android Profile Shelf makes agent switching immediate without mixing conversations.** The Chat header expands a compact, accessible shelf with ordered profile avatars, a subtle Server-default home badge on the resolved identity, last-session restoration, display hiding, lock controls, and one full switcher shared with Agent Passport.
+- **Android accepts shared text as a new Chat draft.** Hermes Relay now appears in the system sharesheet for text, opens the active profile in a fresh conversation, and fills the composer for review without sending automatically.
+
+### Changed
+
+- **Android appearance controls are more expressive and easier to preview.** Theme presets, accent and shape customization, imported Sphere skins, and custom pet creation share one live-preview workflow while preserving separate agent, background, and companion identities.
+
+### Fixed
+
+- **Android restores complete Gateway activity and makes settled replies speakable.** Successful Gateway turns reconcile structured persisted tool calls even when an upstream server omits live tool lifecycle events, and a configured voice can read a completed assistant reply from its message actions without requiring Voice Mode. While that narration is active, the same message actions expose Stop without cancelling an unrelated chat turn.
+- **Android chat matches standard keyboard, scrolling, and photo behavior.** Sentence capitalization is enabled, physical Enter can send or insert a newline according to a device-level setting, Ctrl/Command+Enter always submits, directional keys stay with the text caret, expanded thinking and tool content retains bottom-follow until the user scrolls away, and portrait attachments honor their EXIF orientation in previews and message viewers.
+- **Android distinguishes live-turn corrections from queued follow-ups.** The composer names its current action with visible text and accessible state, successful gateway redirects show a correction lifecycle marker, and attachment-bearing follow-ups always enter the session-owned queue because the upstream redirect operation is text-only.
+- **Android visibly explains quiet startup work without an empty chat bubble.** The full-size thinking animation now sits directly in the conversation lane with a stable reviewable status until the first answer text arrives, while recovery keeps its explicit reconnecting state.
+- **Android keeps pets and screen chrome inside safe interaction bounds.** Floating companions avoid agent identity rows and controls during scrolling, remain touchable for their menu, and settings headers respect edge-to-edge system insets.
+
+## [Android 1.7.1] - 2026-08-08
+
+### Fixed
+
+- **Android chat follows a growing live reply.** Bottom-owned conversations now observe each replacement of the streaming message list, keeping newly added lines visible while preserving the reader's position after a manual scroll away.
+- **Hosted Hermes onboarding completes through the official Dashboard sign-in path.** Android recognizes hosted account addresses, uses the system-browser native PKCE flow, and resumes the verified Dashboard session after its loopback callback.
+- **Live Android tool cards remain expandable while a run is active.** Streaming Gateway updates preserve stable card identity and merge tool arguments and result previews into the existing row, so details can be opened before the session finishes.
+- **Completed Android replies format Markdown immediately.** Live assistant text keeps its stable plain renderer only while incomplete, then the same owned row transitions to rich code blocks, lists, emphasis, and links without leaving or reopening the session.
+- **Android approval cards require an explicit labeled decision.** Reading or scrolling a guarded command, navigating away, backgrounding, recomposition, later turn activity, and card dismissal cannot submit or locally resolve it; pending requests remain bound to their owning profile and session until an explicit response or authoritative upstream expiry.
+- **Android Agent Passport controls are readable and easy to dismiss.** Safety and speed choices use full-width accessible targets with plain-language selected-state explanations, while a persistent close action and boundary-aware downward swipe make the sheet reliably dismissible without stealing nested content scrolling.
+- **Android queued messages stay with their originating chat.** Follow-ups now retain their exact connection, profile, session, run, route, attachments, and voice context across concurrent Gateway session switches instead of following whichever session is visible when a run finishes.
+- **Android model pickers reject duplicate catalog identities before rendering.** Repeated provider/model rows from cached or refreshed inventories are merged at the provider boundary, while identical model IDs under different providers remain distinct choices with provider-aware reasoning capabilities.
+- **Android session pins and archives survive app restarts.** The session drawer now reads and updates the owning Hermes profile's durable session metadata, rolls failed changes back, and makes unpinned stars clearly distinct in light theme.
+
+## [1.6.1] - 2026-08-08
+
+### Fixed
+
+- **The Dashboard plugin hands hosted Hermes connections to Android reliably.** Mobile setup exposes the canonical Dashboard address and keeps dialog focus handling contained, so system-browser authentication can return to the correct connection without disrupting the Dashboard.
+
+## [Android 1.7.0] - 2026-08-06
+
+### Added
+
+- **Android exposes provider-aware reasoning controls.** The effort drawer consumes exact upstream or optional Relay capability metadata for each provider/model identity, while unmodified or older Hermes installations retain a fail-soft standard fallback including `max` and `ultra`.
+- **Android support information is local, redacted, and reviewable.** Fatal crashes and handled failures share a bounded on-device record, Diagnostics can copy or share the exact reviewed text, and nothing is uploaded automatically.
+
+### Fixed
+
+- **Android chat chrome follows its active interaction state.** Opening the session drawer dismisses the composer keyboard, refreshed sessions keep their newest row visible, and floating pets wait for measured chat terrain, sit flush on supported rails, and treat the complete scroll-to-bottom control as forbidden space.
+- **Android pets and optional model discovery initialize quietly.** Floating companions wait for a measured overlay before taking their home position, and background API model-inventory failures retain actionable local diagnostics without interrupting chat with a generic notice.
+- **Android chat and Voice stay precisely bottom-pinned through replies, restores, and layout changes.** The active tail keeps its stable live renderer until another row takes ownership, restored sessions follow late composer and message measurement without overriding a reader, and bottom-owned transcripts settle to the exact list boundary after replies and keyboard animations instead of leaving a small hidden remainder.
+- **Android Focus voice controls remain responsive.** The modal click-through guard now sits behind the voice UI instead of consuming pointer events from the mic, close, expansion, and panel controls.
+- **Android diagnostics explain what failed and what to try next.** Relay, route, WebSocket, and API checks distinguish the saved route from the redacted request they actually attempted, name the operation, and provide targeted guidance for connection, DNS, timeout, TLS, authentication, rate-limit, and server failures.
+- **Android chat and Voice keep one render identity through recovery.** Checkpoint restore, streamed callbacks, server-ID adoption, and replay now resolve the same owned transcript row before publication, preventing recurring Compose duplicate-key crashes.
+- **Android crash reports retain actionable release context.** Reports identify the Android surface, avoid exposing hosts and credentials, migrate earlier local crash records, and release automation retains exact Play and sideload R8 mappings for retrace.
+
+## [1.6.0] - 2026-08-06
+
+### Added
+
+- **Relay supplies exact provider/model reasoning capabilities when providers expose them.** The bounded, profile-aware overlay resolves dynamic catalogs for OpenAI Codex, Copilot, LM Studio, and Ollama Cloud, keeps provider credentials on the host, and leaves unknown or unavailable catalogs on the advisory fallback.
+
 ## [Android 1.6.1] - 2026-08-03

 ### Fixed
@@ -454,7 +776,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 - **Spoken-turn badges (chat).** Voice-mode replies now carry a "Voice" chip and realtime replies a "Realtime Agent" chip — both with a speaker glyph — so spoken turns are distinguishable from typed ones in the scrollback.
 - **App themes.** A new theme picker in Settings → Appearance ships eight looks: the signature Hermes Relay brand (with full light/dark) plus ports of the Nous Hermes baselines — Hermes Teal, Nous Blue (light), Midnight, Ember, Mono, Cyberpunk, and Rosé. The whole app — brand chrome, accents, and chat background — follows the chosen theme. Light/Dark/Auto applies to themes that ship both modes; fixed-mode themes show their own complete look.
 - **Hot-swappable agent sphere.** The orb is now a pluggable "skin": an Adaptive skin that recolors to match your theme, built-in Classic / Aurora / Solar / Mono looks, and support for **user-authored skins** loaded from a small JSON spec. Each skin declares which live signals it reacts to (voice, tool bursts, activity), shown as capability badges in the picker. See `docs/sphere-spec.md`.
- **Connections separate features from routes (Android).** Connection settings now distinguish what a connection can *do* (a **Features** section) from how this phone *reaches* Hermes (a **Route** section), so you can enable Relay features over whichever transport you prefer. A plugin-provided **Secure proxy** route is surfaced alongside LAN, Tailscale, public, and custom routes. The standard direct-to-upstream path is unchanged and still needs no plugin. See `docs/plans/2026-06-18-native-secure-routes.md`.
+- **Connections separate features from routes (Android).** Connection settings now distinguish what a connection can *do* (a **Features** section) from how this phone *reaches* Hermes (a **Route** section), so you can enable Relay features over whichever transport you prefer. The optional plugin-provided **Hermes Secure Link** route is surfaced alongside LAN, Tailscale, public, and custom routes. The standard direct-to-upstream path is unchanged and still needs no plugin. See `docs/plans/2026-06-18-native-secure-routes.md`.
 - **Enhanced voice control (Gemini & xAI).** When the relay uses a Gemini or xAI voice provider, Voice Settings can now steer it: pick a Gemini voice and model and turn on expressive tone tags (with optional natural-language voice direction), or set an xAI voice with expressive speech tags. Expressive tags also apply to xAI on the streaming voice-output renderer. Standard (no-plugin) voice stays configured server-side.
 - **Voice render-path visibility.** Voice Settings shows which path is rendering speech (streaming vs. basic), and Diagnostics records it each session, making voice issues easier to troubleshoot.
 - **Agent pets — a living, swappable avatar.** The orb can be replaced with an animated "pet" that reacts to what the agent is doing: idle / thinking / writing / speaking / listening states, a distinct **working** pose during tool calls, one-shot **greet** / **celebrate** reactions, and a loop that quickens as output streams. Add or remove pets right in Settings → Appearance (no `adb` needed), with a live state preview, a playback-speed slider, and optional frame auto-stabilization; capability badges (Voice · Tools · Activity) show honestly what each pet actually reacts to. Pets are pure data — an AI authoring kit and a JSON schema let you generate one from sprite art. See `docs/pet-spec.md` and the custom-avatars guide.
@@ -193,6 +193,10 @@ This is a **public, distributed repo** — every committed file (CHANGELOG, DEVL
 ### 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.
@@ -204,6 +208,7 @@ This is a **public, distributed repo** — every committed file (CHANGELOG, DEVL
 | ----------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `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**                                              |                                                                                                                                                                                                                                                                                                     |
@@ -235,9 +240,10 @@ This is a **public, distributed repo** — every committed file (CHANGELOG, DEVL
 | **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`                             | Blocklist + destructive-verb confirmation + auto-disable timer; fails-closed on /call and /send_sms                                                                                                                                                                                                 |
-| `data/BridgeSafetyPreferences.kt`                           | DataStore for blocklist, destructive verbs, auto-disable minutes, confirmation timeout                                                                                                                                                                                                              |
-| `ui/screens/BridgeScreen.kt`                                | Bridge UI — master → permission checklist → [Advanced] → unattended → safety → activity log (v0.4.1 reorder)                                                                                                                                                                                        |
+| `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)                                                                                                                                                                           |
@@ -1,35 +1,21 @@
-# Hermes-Relay-CLI v__VERSION__
+# Hermes-Relay CLI v__VERSION__

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

-This alpha makes the desktop direction explicit: Hermes-Relay is a real CLI/TUI with an optional Windows right-click systray—not a second desktop application. The old Tauri/WebView dashboard and its embedded windows are gone. The installed CLI remains the single source of behavior for pairing, TUI, daemon management, grants, audit, diagnostics, chat, voice, and tools.
+This patch keeps the Windows management UI usable when the Relay daemon is stopped or its status cannot be read.

-**Experimental phase.** Assets are unsigned, so Windows SmartScreen and macOS Gatekeeper may warn on first launch. Standalone CLI binaries ship for Windows x64, Linux x64, and macOS x64/arm64; the optional native systray is Windows-only.
+**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, and macOS x64/arm64; the management UI is Windows-only.

 ## What's changed

-### Added
-
- **Persistent desktop-use control.** `hermes-relay computer-use status|enable|disable|cancel` stores one local preference, reports daemon privilege and active/pending grants, and can end an active task-scoped grant without relying on a GUI.
- **Headless grant review.** `hermes-relay grants` lists pending local computer-use requests and supports interactive review plus explicit `approve`, `reject`, and JSON forms for scripts.
- **Typed Relay chat option.** `chat --relay-chat` sends `chat.send` over WSS and renders typed `stream.event` v1 assistant, tool, artifact, memory, skill, and error lifecycles while preserving the existing gateway path as the default.
- **Release-parity verification.** One version contract now keeps the npm package, compiled CLI, Rust tray, lockfile, and installer metadata aligned. The Windows verification target covers TypeScript, compiled-binary smoke tests, Rust formatting/lint/check/tests, and installer packaging.
-
-### Changed
-
- **Menu-only Windows systray.** The optional tray is a small native Rust process with no application window, WebView, overlay, embedded terminal, chat view, voice view, or settings dashboard. Interactive actions open the installed CLI in a normal terminal.
- **State- and privilege-aware daemon control.** The menu reports PID-backed daemon state and User/Administrator privilege, disables invalid lifecycle actions, and requests UAC only when **Start/Restart daemon as Administrator…** is explicitly chosen. The tray itself remains unprivileged.
- **Visible desktop-use safety.** The tray shows enablement, active grant mode and expiry, warns when an Administrator control grant is active, raises a native alert for pending approvals, opens CLI grant review, and provides immediate cancellation and emergency stop.
- **Per-user Windows installation.** The default PowerShell installer downloads the checksum-verified NSIS package, installs the CLI and optional tray under `~/.hermes/bin`, adds Start-menu shortcuts and user PATH, and can start the tray at sign-in. CLI-only installation remains available with `HERMES_RELAY_INSTALL_SURFACE=cli`.
-
 ### Fixed

- **Installed-binary diagnostics.** `hermes-relay doctor` reports the physical Bun-compiled executable instead of a virtual embedded-module path, so PATH and install-directory checks describe the binary that actually launched.
- **Release guardrails.** CLI tag automation rejects version drift, tags not contained in `main`, oversized tray binaries, or a tray process that creates an application window.
+- **Stopped daemons no longer block the management UI.** Missing, stale, malformed, or temporarily unavailable daemon status falls back to an explicit stopped state while hosts, settings, activity, CLI details, diagnostics, and daemon controls continue loading normally.
+- **Starting the daemon restores live status without reopening the UI.** A valid running status continues through the same bounded, single-flight snapshot path introduced in beta.3.

 ## Install

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

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

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

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

-See the [CLI and systray guide](https://hermes-relay.dev/docs/desktop/) for installation, commands, desktop-use safety, and troubleshooting.
+See the [CLI and tray guide](https://hermes-relay.dev/docs/desktop/) for installation, access modes, grants, and troubleshooting.
@@ -17,17 +17,55 @@ That's it — no extra setup or credentials required for a debug build.
 Helper scripts for common development tasks:

 ```bash
-scripts/dev.bat build      # Build debug APK
+scripts/dev.bat build      # Build the sideload debug APK
+scripts/dev.bat compile    # Compile sideload Kotlin only
+scripts/dev.bat test-one "com.hermesandroid.relay.SomeTest"  # Run one test class
+scripts/dev.bat install-fast  # Build arm64 only + install + launch
 scripts/dev.bat release    # Build signed release APK
 scripts/dev.bat bundle     # Build release AAB for Google Play
-scripts/dev.bat run        # Build + install + launch + logcat
-scripts/dev.bat test       # Run unit tests
+scripts/dev.bat run        # Build sideload + install + launch + logcat
+scripts/dev.bat test       # Run sideload debug unit tests
 scripts/dev.bat version    # Show current version
 scripts/dev.bat relay      # Start relay server (dev, no TLS)
 ```

+### Review bundles
+
+Maintainers can produce a matched Android + Relay handoff for one pull request
+without cutting a release. Run **Actions → Build Review Bundle** with the PR
+number or an exact 40-character SHA. The short-lived artifact contains a
+side-by-side Candidate APK, Relay packages/source from the same commit,
+provenance, checksums, and install/rollback guidance.
+
+Review bundles never bump versions, create tags, upload to Play, or replace the
+stable Android app. Relay review still requires a staging Hermes instance or an
+explicit immutable snapshot/rollback window because two Relay plugins cannot
+own the same tools and hooks in one Hermes process. See
+[Review builds and release candidates](docs/review-candidates.md).
+
 Linux/macOS equivalent lives at `scripts/dev.sh`.

+### Fast Android iteration
+
+Gradle's daemon, local build cache, configuration cache, and parallel task
+execution are enabled for repeat local builds. Keep the same Gradle JVM
+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.
+
+Use the narrowest command that proves the change:
+
+1. `scripts/dev.bat compile` for a Kotlin compile check.
+2. `scripts/dev.bat test-one "<fully-qualified-class-or-pattern>"` for a focused regression.
+3. `scripts/dev.bat install-fast` when the result must run on the connected
+   arm64 phone. This passes `-Phermes.devAbi=arm64-v8a`, avoiding the x86,
+   x86_64, and armeabi-v7a native libraries in the local APK.
+4. `scripts/dev.bat prepush` before pushing Android work.
+
+`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
+universal and are unaffected unless `-Phermes.devAbi` is explicitly supplied.
+
 ## Repository Structure

 ```
@@ -51,12 +89,12 @@ The legacy `relay_server/` directory is a thin compatibility shim around `plugin

 | Component | Stack |
 |-----------|-------|
-| **Android App** | Kotlin 2.0, Jetpack Compose, Material 3, OkHttp |
+| **Android App** | Kotlin 2.4, Jetpack Compose, Material 3, OkHttp |
 | **Relay Server** | Python 3.11+, aiohttp |
 | **Serialization** | kotlinx.serialization |
-| **Build** | AGP 9, Gradle 8.13, JVM toolchain 17 |
+| **Build** | AGP 9.3.1, Gradle 9.6.1, JVM toolchain 17 |
 | **CI/CD** | GitHub Actions (lint, build, test, signed APK artifacts) |
-| **Min SDK** | 26 (Android 8.0) / Target SDK 35 |
+| **Min SDK** | 26 (Android 8.0) / Target SDK 36 |

 ## Running the Relay Locally

@@ -174,7 +212,12 @@ Release notes (`RELEASE_NOTES.md`, `app/src/main/assets/whats_new.txt`, `docs/pl
  CI in one cached Gradle invocation. Run it before pushing Android PR updates
  to catch common hosted failures without waiting for another full Actions
  cycle; hosted CI remains the exhaustive all-variant gate.
- **Android unit tests:** `scripts/dev.bat test` (runs JUnit + MockK + Compose testing)
+- **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)
+  covers the on-demand vanilla-Gateway fixture, Android instrumentation,
+  upstream conformance, and physical-device ADB certification. No contract or
+  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.
@@ -1,5 +1,399 @@
 # Hermes-Relay — Dev Log

+## 2026-08-20 — Android 1.11.0 Bridge access and lower idle power
+
+Hermes-Relay Android 1.11.0 is published from the immutable
+`android-v1.11.0` tag, with Google Play versionCode 46 submitted to the
+Production track. The release adds per-connection Bridge capability presets,
+custom grants, and explicit bounded or unlimited screen access while preserving
+the master kill switch and Android permission requirements.
+
+Stored-session resume failures now remain visible without silently changing
+conversation context, software-keyboard Return works across direct-text and
+synthesized-Enter IMEs, and cancelled recovery keeps its Stopped state. Idle
+render loops, screen-capture surfaces, audio effects, wake-word buffers, and
+unattended wake locks now follow tighter lifecycle boundaries to reduce power
+use without removing persistent Relay reachability.
+
+## 2026-08-20 — Android stored-session resume failures stay visible
+
+Android now treats a failed Gateway `session.resume` as authoritative for the
+selected stored conversation. The client no longer creates a replacement
+session and submits the continuation after a resume rejection or profile-scope
+mismatch, preventing a context-free turn from silently selecting different
+runtime state.
+
+Gateway terminal failures and pre-submit transport failures now share a
+session-scoped panel immediately above the composer. The panel keeps the failed
+transcript row intact, shows only confirmed route/model/provider identity,
+offers explicit Details, Retry, and Dismiss actions, and records bounded,
+redacted evidence in the existing Diagnostics review/share flow. No route or
+model is changed automatically.
+
+## 2026-08-18 — Android 1.10.0 chat continuity and streaming Markdown
+
+Hermes-Relay Android 1.10.0 is published from the immutable
+`android-v1.10.0` tag, with the production Play submission committed as
+versionCode 45. The release preserves exact-session composer drafts across
+restarts, converts large pastes into reviewable attachments, and keeps standard
+chat compatible with unmodified upstream Hermes.
+
+Assistant replies now render completed Markdown structures incrementally while
+holding an incomplete streaming tail stable. Stable message identity and a
+bounded bottom-follow controller prevent completion-time replacement, stacked
+scroll animations, and transcript-distance velocity from moving a reader who
+has deliberately scrolled away. Foreground reconnect reattaches the visible
+Gateway session, malformed imported credentials fail closed, and software
+keyboard Return remains distinct from the dedicated Send action.
+
+## 2026-08-17 — Android composer continuity and large-paste review
+
+Android's multiline composer now leaves the software IME action as Return while
+the dedicated trailing button sends. Physical keyboard Enter, Shift+Enter, and
+directional caret behavior retain their existing contracts.
+
+Composer drafts now persist in bounded app-private no-backup storage using
+small owner metadata plus content-addressed attachment blobs. Draft ownership
+follows the exact connection, opened session profile, session, and draft slot;
+profile and connection switches save before restoring, lifecycle stop flushes
+the latest state, and successful sends remove the saved draft.
+
+A default-on Chat setting converts a single insertion of at least 5,000
+characters into a reviewable text attachment. Preparation runs off the UI
+thread behind a visible loading card. Current Gateways send it through upstream
+`file.attach`; API-server SSE and proactive Thread paths materialize the same
+UTF-8 content into the prompt so no route silently loses the paste.
+
+## 2026-08-14 — Android 1.9.0 session identity and conversation controls
+
+Hermes-Relay Android 1.9.0 is published from the immutable
+`android-v1.9.0` tag. Multi-profile session browsing now keeps the aggregate
+drawer scope selected while transcript hydration, resume, sending, and header
+identity follow the session's owning profile. New Chat from All Profiles uses
+the default profile, and the session list starts ungrouped while retaining
+project grouping and the other desktop-style views as explicit options.
+
+Message reactions now resolve durable rows for both user and assistant
+messages. Vanilla Hermes voice remains on the authenticated Gateway instead of
+requiring the optional API fallback. Session rows can expose profile, project,
+branch, and pull-request context without crowding the chat header, secondary
+drawer actions remain available in All Profiles, and outside taps dismiss the
+drawer.
+
+## 2026-08-09 — Gateway activity recovery and chat speech
+
+Successful Android Gateway turns now reconcile against their profile-owned,
+structured session history. This recovers persisted tool calls when an upstream
+Gateway completes a turn without emitting live tool lifecycle events; assistant
+prose is never inspected for inferred activity, and the recovered calls continue
+through the existing Off, Compact, and Detailed display policy.
+
+The Speak message action now follows configured voice readiness and idle output
+state instead of active Voice Mode or presentation style. A settled assistant
+reply can therefore be read aloud directly from chat, while live or provider
+playback still prevents overlapping output. One-shot message narration owns its
+completion state outside Voice Mode and replaces Speak with Stop while active;
+stopping drains only that narration pipeline and does not cancel a chat turn
+started while the response was playing.
+
+## 2026-08-09 — Quiet reasoning and grouped tool activity
+
+Android Chat now treats reasoning and routine tools as transcript scaffolding.
+Visible live reasoning opens automatically without a tinted card, then collapses
+to a quiet Thought disclosure when it settles unless the reader has explicitly
+chosen its state. Empty reasoning remains absent and the existing first-token
+status continues to own the waiting state.
+
+Top-level routine calls retain their source order but render as consecutive
+activity runs. A live run keeps one summary and one latest-activity ticker in a
+stable footprint; a settled run becomes one collapsed summary that can disclose
+the original identity-preserving tool rows. File edits, approval/question tools,
+generated media, failures, output-risk findings, and delegated work split runs
+and retain independent surfaces. Off hides only ordinary activity runs, Compact
+uses compact disclosed rows, and Detailed preserves the full per-tool detail
+surface on demand. Expansion still yields bottom-follow ownership, and each run
+registers its measured bounds as Chat pet terrain.
+
+## 2026-08-09 — Android chat experience and attachment polish
+
+The Android composer now declares sentence capitalization and a Send IME
+action. A device-level setting chooses whether unmodified physical Enter sends
+or inserts a newline; Shift+Enter remains a newline and Ctrl/Command+Enter
+always submits. Every submit route converges on the existing live-turn owner,
+so the current gateway state still decides whether content steers the active
+turn or queues behind it. Directional focus traversal is cancelled while the
+editor owns focus so hardware arrow keys continue to move the caret and
+selection.
+
+Conversation bottom-follow now remains owned when thinking or tool details
+expand. Only an actual drag ending above the bottom yields that ownership, and
+a chat first measured while the IME is already visible now captures the same
+resize-follow state as a keyboard opened after composition.
+
+Bitmap-backed attachment surfaces now apply EXIF rotation and reflection before
+display. Attachment reads and Base64 conversion also leave the UI thread, so
+selecting a larger photo no longer performs the full ingestion path inside the
+activity-result callback.
+
+Composer drafts now belong to the stable connection, profile, and session
+identity. Text, edit context, and pending attachments restore when returning to
+a chat without persisting attachment bytes. Pending attachments expose bounded,
+orientation-aware previews plus explicit remove and reorder controls.
+
+Conversation overflow now opens transcript search with previous/next matches
+and a prompt-turn rail, both keyed to the same stable UI identity as the message
+list. Assistant prose retains the compact bubble and subtle edge treatment that
+keeps it legible above the animated chat background. Tapping a message reveals
+the existing copy, quote, speak, and edit actions with reduced-motion-aware
+expansion and accessible targets.
+
+Quotes are composer-owned structured references instead of raw blockquote text.
+The composer and sent message render a linked, highlighted author preview; the
+transport remains ordinary Markdown so unmodified Desktop and TUI clients show
+a readable quoted reply. Thinking and top-level tools continue to use their
+independent compact thought bubbles and configured compact or full tool cards,
+without an aggregate completion card. The composer also names Correction and
+Queue states with visible labels. Gateway redirects remain text-only:
+follow-ups with attachments are forced through the existing destination-owned
+queue so files cannot be left behind by a correction request.
+
+## 2026-08-08 — Standalone Android thinking status
+
+Blank streaming assistant rows now present the full-size working animation
+directly in the conversation lane above the visible `Still working…` label,
+without painting an empty assistant bubble around the status. The first answer
+token replaces that standalone state with the normal response bubble, while
+recovery retains the distinct `Reconnecting to your answer…` wording. The
+status owns one stable TalkBack description and suppresses animated child
+nodes, avoiding repeated announcements without claiming measurable progress.
+
+## 2026-08-08 — Android text-share draft handoff
+
+The shared Android manifest now advertises a `text/*` `ACTION_SEND` target for
+both app flavors. `MainActivity` accepts only non-blank single-item text shares
+and places them in a process-local, identity-fenced handoff that survives cold
+Compose initialization. Once the configured chat context settles, the app root
+navigates to Chat and delegates draft creation and composer prefill to
+`ChatViewModel`.
+
+The ViewModel reuses the existing new-chat lifecycle, preserving Gateway
+background-turn reconciliation and the active connection/profile/transport
+namespace. Composer prefills use a one-consumer conflated channel so an intent
+received before Chat composition is delivered once. Shared text is never
+routed through message sending; the user must review and submit it explicitly.
+
+## 2026-08-08 — Android Profile Shelf and profile-context identity
+
+Chat profile selection now lives in a collapsible shelf directly below the top
+app bar. The header toggles the shelf, the active capsule opens Agent Passport,
+inactive 48 dp avatars switch context, and a pinned overflow opens the same full
+switcher used by Passport. Saved ordering and hidden state drive both surfaces;
+the selected hidden profile remains disclosed, while a one-identity shelf stays
+out of the layout. Long-press actions expose inspection, Passport, profile lock,
+and hiding without adding activity or presence claims.
+
+The shelf uses the chat surface instead of a second elevated toolbar. A neutral
+active capsule, 36 dp avatar artwork inside 48 dp targets, compact spacing, and
+a contained overflow affordance keep the row visually subordinate to Chat. When
+Server default resolves to a concrete profile, that profile's avatar remains
+the identity and a small home badge discloses its default routing role.
+Local avatar lookup remains keyed to the Server-default presentation identity,
+so an image customized while that row is selected appears consistently in both
+the Chat header and shelf rather than being re-keyed to whichever explicit
+profile is currently active.
+
+The Server-default sentinel is now distinct from a profile literally named
+`default`. Profile selection restores the last compatible connection/profile/
+transport session, otherwise leaves a fresh draft. Gateway turns detach and
+reconcile in their original session, live SSE turns keep switching disabled,
+and every profile transition clears session-scoped model, provider, personality,
+reasoning, approval, Fast, and YOLO state before the destination session seeds
+its own values. Server sticky-default state is never written.
+
+## 2026-08-08 — Streaming reply tail follow
+
+Android's conversation-bottom follower now reads the current immutable message
+list from Compose state inside its long-lived layout observer. Each streamed
+replacement can therefore advance the viewport as the active bubble gains
+lines, while dragging or scrolling away still releases bottom ownership.
+
+## 2026-08-08 — Settled live replies transition to Markdown
+
+Android now releases the live plain-text renderer immediately after an
+assistant row settles. The transition retains the row's stable UI identity,
+commits the final live frame before replacing its selectable text topology,
+and anchors the same bottom-owned row during the Markdown remeasure. Readers
+who scrolled away retain their viewport, while completed code fences, lists,
+emphasis, links, and interrupted partial replies no longer require session
+navigation before rich rendering appears.
+
+## 2026-08-08 — Explicit-consent ownership for Android approvals
+
+Android no longer treats unrelated Gateway activity or a terminal display event
+as proof that an approval was resolved. Approval cards remain pending through
+scrolling, recomposition, navigation, and background restoration, and retain
+their exact connection, profile, and session ownership. Only a labeled action
+that successfully reaches `approval.respond`, an authoritative upstream expiry,
+or an explicit interrupt can retire the local request; the interrupt path stays
+visibly denied because upstream force-denies it.
+
+## 2026-08-08 — Agent Passport control and dismissal accessibility
+
+The Android Agent Passport keeps its title and explicit close action outside
+the nested content scroller. Material bottom-sheet gestures are enabled again,
+so a downward gesture scrolls long content toward its top boundary before the
+sheet receives the gesture and dismisses; backdrop and Back dismissal retain
+the same callback.
+
+Safety and speed choices now sit below their labels instead of competing for a
+narrow horizontal column. Every segment provides at least a 48 dp target,
+allows two-line labels, exposes radio-selection semantics, and states the
+meaning of the current approval, chat override, or processing-tier choice in
+plain language. The layout remains scrollable on compact heights and at larger
+font scales without moving the close action off-screen.
+
+## 2026-08-08 — Session-owned Android send queues
+
+Android follow-up queues now capture the composing connection/profile context,
+stored session, configured transport, originating run, attachments, and voice
+context as one immutable destination. Queue presentation is filtered to the
+visible session, while completion eligibility is tied to the exact run and live
+Gateway generation that owned the queue. A completion from another session or
+an older live generation cannot dispatch through the current composer route.
+
+In-flight checkpoints retain bounded queued text across process restoration.
+Attachment bytes are not copied into Preferences DataStore; an attachment queue
+that cannot be restored is rejected with a visible review-and-resend notice.
+Connection replacement and session deletion cancel their owned queues, while
+switching among concurrent Gateway sessions preserves each session's queue.
+
+## 2026-08-07 — Provider-owned model inventory identity
+
+Android now normalizes Gateway and API model inventories before publishing
+them to picker consumers. Repeated provider rows merge by canonical provider
+slug, repeated exact model IDs collapse within that provider, and capability
+metadata follows the same provider/model identity. Models intentionally offered
+by different providers remain distinct choices, even when their display labels
+and model IDs match.
+
+The searchable picker groups and keys rows by provider slug plus exact model ID
+instead of provider display text. Cached loads, dynamic refreshes, API aliases,
+and Manage inventory use the same idempotent identity rule, preventing duplicate
+catalog data from reaching keyed Compose lists without hiding valid routes.
+
+## 2026-08-05 — Restored chat bottom ownership and effort fallback clarity
+
+Opening an existing Android session now retains exact bottom ownership through
+late, non-streaming layout changes. Composer capability controls, status rows,
+and restored message content can finish measuring after history first reaches
+the footer; a session-scoped geometry observer corrects those changes without
+using a fixed delay. New-message following remains governed by the smooth
+auto-scroll setting, while a real drag, IME ownership, and the Voice dock keep
+their existing anchors.
+
+The advisory effort drawer now states that Hermes does not advertise exact
+levels for the selected model before explaining why standard options are shown.
+The wording is consistent across all shipped Android locales.
+
+## 2026-08-05 — Provider-aware reasoning effort discovery
+
+The optional Relay plugin now exposes a bearer-protected, profile-aware model
+capability overlay without requiring changes to upstream Hermes. Android merges
+that overlay with the standard `model.options` inventory using exact provider
+and model identities, while older or unpaired Relay installations continue with
+the canonical advisory fallback.
+
+Dynamic LM Studio, Ollama Cloud, and Copilot discovery is bounded by a shared
+network limiter, cached by profile, endpoint, model, and credential fingerprint,
+and fenced across refresh generations. Neither credentials nor internal cache
+scope are returned to clients. Composer controls, Agent Passport, session
+creation, and asynchronous server reconciliation share the same capability
+resolver so a displayed effort cannot silently differ from the value sent.
+
+## 2026-08-05 — Chat drawer and companion terrain ownership
+
+The Chat screen now clears composer focus when the session drawer commits to
+opening, dismissing the IME without continuously clearing focus from drawer
+search or rename fields. Drawer refreshes override keyed list anchoring only
+when the leading session identity changes, keeping the newest row visible after
+activity-based reordering.
+
+Floating companions wait for Chat's measured composer rail before publishing
+their first roaming position. Their collision footprint contains both the
+pointer target and rendered sprite, and the complete scroll-to-bottom control
+envelope is an obstacle rather than a landing perch. Supported rails add no
+visual lift, and the floating-only renderer aligns each frame's opaque bottom
+edge to its canvas baseline so transparent atlas padding cannot make pets hover;
+centered previews and message avatars remain unchanged.
+
+## 2026-08-05 — Measured pet placement and passive model sync
+
+The floating pet now remains unpublished until the app-level overlay has a
+positive measured viewport. Its initial home coordinate is therefore derived
+from the real safe bounds instead of the zero-size pre-measure bounds that
+collapsed to the top-left corner.
+
+API provider inventory remains an optional background catalog on Gateway-led
+connections. A timeout, refusal, or unavailable optional route no longer emits
+a global chat notice during initialization, reconnection, or connection-sheet
+refresh. The failure is retained as a contextual warning in local Diagnostics,
+including the operation, endpoint role, redacted stack trace, preserved network
+cause, and targeted troubleshooting guidance. Cached and Gateway-owned model
+options remain unchanged.
+
+## 2026-08-05 — Stable chat-tail completion
+
+Chat and Voice now treat the active streamed reply as the owner of its live
+renderer until a different row becomes the conversation tail. Stream
+completion retains the existing Compose subtree and list anchor; the full
+Markdown renderer is deferred until the row is no longer active or the session
+is revisited.
+
+The last-in-group timestamp occupies its final geometry from the first
+streaming frame and is only revealed at completion. Measured positive growth
+during an active stream continues to follow the bottom without replacing the
+logical anchor. Once completion layout stabilizes, a bottom-owned transcript
+settles to the exact LazyColumn boundary; proximity slop is reserved for
+retaining follow intent during motion and cannot define the final position. The
+visible footer supplies the exact remaining distance so rounding or adjacent
+layout changes cannot leave a residual forward range.
+
+IME expansion participates in that same viewport owner. A transcript already
+at the bottom advances by the measured viewport-height loss throughout the
+keyboard animation, then settles exactly after inset updates stop on both open
+and close. A transcript being read above the bottom preserves its existing
+anchor, and a real drag cancels keyboard follow immediately. Host-side coverage
+verifies renderer ownership, unchanged bubble height, exact footer settling,
+keyboard arming, viewport loss, completion/IME settlement ownership, and
+history-reading behavior.
+
+## 2026-08-05 — Focus voice input boundary repair
+
+The Focus voice presentation remains modal without installing a consuming
+pointer handler on the full overlay ancestor. Its click-through guard is now a
+behind-content sibling: empty-space gestures cannot reach the chat or drawer,
+while the mic, close, expand/collapse, and panel controls receive their full
+pointer sequence.
+
+Host-side Compose coverage injects real touch events instead of invoking
+semantic click actions. It verifies both child callback delivery and the modal
+background boundary so the two requirements cannot regress independently.
+
+## 2026-08-05 — Actionable Android connection diagnostics
+
+Android diagnostic entries now separate the configured route from the exact
+request operation and path used to test it. Relay health checks identify the
+HTTP `/health` probe that precedes a WebSocket connection, route selection
+records its Dashboard, API, or Relay probe, and WebSocket and API checks name
+their handshake or authentication stage.
+
+Known network and HTTP failure classes attach a bounded next step for refused
+listeners, DNS, routing, timeouts, TLS, credentials, rate limits, missing
+routes, and server failures. The activity list, status timeline, detail dialog,
+copy text, and GitHub issue prefill all carry the same context. Public issue
+text preserves protocol and request paths while redacting hosts, credentials,
+queries, and user information.
+
 ## 2026-08-04 — Android transcript identity ownership

 ChatHandler now owns one render identity for every published transcript row.
@@ -15,6 +409,26 @@ sequences across restore, replay, deltas, thinking, and usage updates. Voice's
 temporary transcript row now occupies an auxiliary key namespace disjoint from
 real message rows.

+## 2026-08-04 — Android reliability and support foundation
+
+Android fatal capture and centrally classified handled failures now converge on
+a versioned, allowlisted reliability record. Reports are redacted before local
+persistence, capped at 20 records with 14-day retention, written atomically,
+and correlated only with random app/report identifiers. Expected cancellation
+and permission denial remain non-reportable. The pre-existing one-file crash
+format migrates locally on first launch.
+
+Crash recovery leads with the recovery outcome and no-upload guarantee, then
+requires an explicit review before copy, share, or GitHub actions. Diagnostics
+adds an offline support-information review using the same exact redacted text.
+Android issue prefills now request the Android area while repository-wide issue
+ownership remains maintainer-reviewed, and the release workflow retains both
+variant R8 mappings for deterministic retrace.
+
+The architecture audit defers an ANR watchdog, richer allowlisted breadcrumbs,
+hashed product correlation, and OOM emergency writing until their lifecycle,
+privacy, and false-positive behavior can be validated on devices.
+
 ## 2026-08-02 — Android Russian localization

 Android now ships complete Russian catalogs for the main and sideload builds.
@@ -1,17 +1,21 @@
 # Hermes-Relay-Server v__VERSION__

-**Release Date:** August 3, 2026
+**Release Date:** August 21, 2026

-This patch makes intentional re-pairing repair the existing device record instead of accumulating duplicate Relay sessions.
+## Summary
+
+This release makes delayed phone delivery and active Bridge access easier to understand. Relay now identifies messages flushed after reconnect, emits one completion signal for the backlog, and reports permanent, timed, and unlimited phone capabilities through status surfaces.

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

-## What's changed
+## Added

-### Fixed
+- **Reconnect backlog context.** Messages flushed from the bounded offline queue carry an explicit delayed-delivery marker, followed by one ordered completion event with the delivered count.
+- **Granular phone capability status.** Relay status and `android_phone_status` report permanent, timed, and unlimited Bridge capabilities alongside existing Android permissions and safety state.

- **Re-pairing replaces stale credentials for the same device.** After the host approves a new pair, Relay revokes older sessions and refresh credentials that belong to that device before issuing the replacement.
- **Existing and unrelated sessions remain operator-controlled.** The Dashboard and `/relay revoke <token-prefix>` continue to provide explicit cleanup without treating optional Relay pairing as a requirement.
+## Changed
+
+- **Phone surfacing semantics are explicit.** Default delivery persists to Threads and notifies, Inbox delivery remains silent, and Session delivery targets an available active conversation before falling back to a notification.

 ## Install / update

@@ -70,6 +70,21 @@ an HTTPS reverse proxy. The [full walkthrough](https://hermes-relay.dev/docs/gui
 covers Windows, remote access, and dashboard authentication. You do not need to
 enable the separate API server or invent an API key for the standard path.

+For plugin-enabled setups, optional **Hermes Secure Link** presents Relay, API,
+and Dashboard routes through one pairing-pinned TLS origin. It protects traffic
+to the paired endpoint while each service keeps its own authentication; it does
+not provide reachability or independently identify the physical host. You still
+use LAN routing, Tailscale or another VPN, or an operator-managed public route
+to reach the listener. Secure Link is off by default and requires a fresh QR
+pairing after it is enabled. See the
+[remote-access guide](https://hermes-relay.dev/docs/guide/remote-access/).
+
+**Hermes Reach** is an experimental, advanced outbound-broker route. It remains
+available for development and self-hosted evaluation, but it is disabled by
+default, ordered after supported routes, and not recommended for normal remote
+access. Use Tailscale for the easiest supported remote setup, or a public TLS
+domain / Direct Secure Link when you want to own the complete network path.
+
 ### 3 · Connect and talk

 Open the app, choose **Connect to Hermes**, and enter or discover the dashboard
@@ -138,7 +153,7 @@ Full server setup, TLS, and systemd details: [docs/relay-server.md](docs/relay-s

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

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

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

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

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

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

-On Windows, the default installer adds the optional right-click-only systray: no dashboard or app window, just TUI launch, User/Administrator-aware daemon controls, pairing, local grant review, audit, diagnostics, logs, desktop-use status/cancellation, sign-in startup, and emergency stop.
+On Windows, the default installer adds the optional compact **Hermes-Relay CLI UI** tray popup for host selection and pairing, connection and daemon state, per-host Ask/Trusted/Full Access, local grant dialogs, authorized-client revocation, activity, settings, and emergency stop. It is a management surface only—chat, TUI, plugins, voice, and agent sessions remain CLI/upstream concerns.
+
+Structured Windows computer control prefers a compatible local CUA Driver
+runtime for window-targeted background actions and virtual per-session agent
+cursors. It remains behind Hermes host policy, grants, targeting, audit, and
+emergency stop; Windows input is an explicit compatibility backend. CUA is not
+bundled or updated automatically, but the local CLI/UI can explicitly install,
+check, or update its verified canonical package. It is never exposed as a raw
+remote tool surface. See the [desktop tools guide](https://hermes-relay.dev/docs/desktop/tools.html#computer-use-engines).

 - **Docs:** [CLI guide](https://hermes-relay.dev/docs/desktop/) · [`desktop/README.md`](desktop/README.md)
 - **AI-agent setup recipe:** `/hermes-relay-desktop-setup`
@@ -267,26 +290,35 @@ Already installed? The same recipe is auto-loaded as a Hermes skill — invoke `

 ```bash
 # Android: open the repo root in Android Studio, wait for Gradle sync, Run (Shift+F10).
-scripts/dev.bat build      # Build debug APK
+scripts/dev.bat build      # Build sideload debug APK
+scripts/dev.bat compile    # Compile sideload Kotlin only
+scripts/dev.bat test-one "com.hermesandroid.relay.SomeTest"  # Focused unit test
+scripts/dev.bat install-fast  # arm64 phone build + install + launch
 scripts/dev.bat release    # Build signed release APK
 scripts/dev.bat bundle     # Build release AAB for Google Play
-scripts/dev.bat run        # Build + install + launch + logcat
-scripts/dev.bat test       # Run unit tests
+scripts/dev.bat run        # Build sideload + install + launch + logcat
+scripts/dev.bat test       # Run sideload debug unit tests
 scripts/dev.bat version    # Show current version
 scripts/dev.bat relay      # Start the relay server (dev, no TLS)
 ```

+Gateway, session, streaming, reconnect, or authoritative-history changes use
+the reusable, on-demand [Gateway contract lab](docs/gateway-contract-testing.md).
+It includes deterministic protocol scenarios, current-upstream conformance,
+Android instrumentation, and opt-in physical-device certification; none of
+those lanes is scheduled automatically.
+
 ### Tech Stack

 | Component | Stack |
 |-----------|-------|
-| **Android app** | Kotlin 2.0, Jetpack Compose, Material 3, OkHttp |
+| **Android app** | Kotlin 2.4, Jetpack Compose, Material 3, OkHttp |
 | **Hermes-Relay CLI** | TypeScript, Bun-compiled native binary, Node ≥21 (source/dev), zero runtime deps |
 | **Server / plugin** | Python 3.11+, aiohttp |
 | **Serialization** | kotlinx.serialization (Android) |
-| **Build** | AGP 9, Gradle 8.13, JVM toolchain 17 (Android); `tsc` + `bun build --compile` (CLI) |
+| **Build** | AGP 9.3.1, Gradle 9.6.1, JVM toolchain 17 (Android); `tsc` + `bun build --compile` (CLI) |
 | **CI/CD** | GitHub Actions — lint, build, test, APK artifact, CLI binaries per platform |
-| **Min SDK** | 26 (Android 8.0) · Target SDK 35 |
+| **Min SDK** | 26 (Android 8.0) · Target SDK 36 |

 <details>
 <summary><b>Repository structure</b></summary>
@@ -119,19 +119,23 @@ artifacts.
 ### CLI / tray versioning

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

 | File | Purpose |
 |---|---|
 | `desktop/package.json` | canonical CLI version |
+| `desktop/.bun-version` | exact Bun compiler/runtime for standalone binaries |
 | `desktop/package-lock.json` | npm root/workspace package metadata |
 | `desktop/src/version.ts` | compiled CLI runtime version |
 | `desktop/tray/Cargo.toml` | native systray package version |
 | `desktop/tray/Cargo.lock` | locked systray package version |
+| `desktop/tray/tauri.conf.json` | tray application and bundle version |
+| `desktop/tray/package.json` | tray UI package version |
+| `desktop/tray/package-lock.json` | locked tray UI package version |

 Prepare a new CLI version on `dev` without creating a tag or npm-generated
 commit:
@@ -149,6 +153,8 @@ manually, run `npm run sync:version` before checking. `npm run verify` is the
 single Windows release-parity gate: version sync, type-check, tests, TypeScript
 build, compiled CLI smoke, and tray formatting, Clippy, check, and tests. CI runs
 the portable portions on every desktop change and the Windows tray gates separately.
+Release jobs read `desktop/.bun-version`; cross-built and Windows-built artifacts
+must not silently embed different Bun runtime versions.

 ## Branching policy

@@ -171,10 +177,11 @@ then tagging `main`. Feature completion means merged and verified on `dev`; it
 does not mean released.

 **Staging is an environment, not a branch.** Deploy an exact tested `dev` SHA or
-an immutable release-candidate tag to staging. Record that source in the Forge
-release issue/session. Never deploy a moving branch name as the source of record
-and never create a staging branch. Production deploys only immutable
-`android-v*`, `server-v*`, or `desktop-v*` tags cut from `main`.
+an immutable prerelease tag (`-alpha`, `-beta`, or `-rc.N`) cut from a
+release-prepared `dev` commit. Record that source in the Forge release
+issue/session. Never deploy a moving branch name as the source of record and
+never create a staging branch. Stable production tags are cut only from the new
+`main` tip after the approved `dev` → `main` release merge.

 ### Normal contribution and release flow

@@ -412,10 +419,17 @@ it sit alongside in `[Unreleased]`, and ship them together. A release
 is a statement to users that "this is a thing worth updating to," so
 the threshold is intent-driven, not event-driven.

-If you want to dogfood accumulated `main` state without declaring GA,
-tag a **pre-release** (`android-vX.Y.Z-rc.N`). Users can opt in via
-`hermes-relay-update --branch rc/vX.Y.Z-rc.N` without being auto-pushed
-the unstable build.
+If you want to dogfood a frozen `dev` release candidate without declaring GA,
+tag the exact release-prepared `dev` commit with a **prerelease** tag such as
+`android-vX.Y.Z-rc.N` or `server-vX.Y.Z-rc.N`. Android prereleases publish the
+side-by-side Candidate app and never upload to Play. Server prereleases publish
+opt-in packages for staging and do not automatically replace production.
+See [Review builds and release candidates](docs/review-candidates.md).
+
+For one-PR review, do not bump versions or create a tag. Run **Build Review
+Bundle** for the PR number or exact SHA. It produces one short-lived matched
+Android + Relay artifact; the Candidate app uses a separate application ID and
+the Relay package requires an explicit staging or snapshot/rollback install.

 ## Release train ownership

@@ -494,6 +508,14 @@ the new app version and a higher `appVersionCode`.
  in `app/build.gradle.kts`. Never rename the sideload APK — the
  in-app update checker matches assets by `.apk` + `sideload` in the
  name, and user-docs verify steps cite the filename.
+  The release workflow also retains
+  `app/build/outputs/mapping/{googlePlayRelease,sideloadRelease}/mapping.txt`
+  for 90 days in the `android-r8-mappings-<version>-<sha>` workflow
+  artifact. It is intentionally not a GitHub Release asset. To symbolicate an
+  in-app or sideload report, download the artifact for the exact version/SHA and
+  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/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
@@ -509,7 +531,11 @@ the new app version and a higher `appVersionCode`.
  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.
+  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.

 #### Scrub for public distribution

@@ -810,19 +836,20 @@ plugin changes from forcing an Android app `versionCode` bump.

 On every push of a tag matching `android-v*`, `.github/workflows/release-android.yml`:

-1. Verifies the stable tag resolves to a commit contained in `main` and that the
-   tag matches `appVersionName` in
+1. Verifies a stable tag resolves to a commit contained in `main`, or a
+   prerelease tag resolves to a commit contained in `dev`, and that the tag matches `appVersionName` in
   `gradle/libs.versions.toml` (mismatches fail the workflow).
 2. Runs the Android debug build and the stable sideload pairing/connection
   regression slice with explicit timeouts.
 3. Decodes `HERMES_KEYSTORE_BASE64` into `$RUNNER_TEMP/release.keystore`
   and exports `HERMES_KEYSTORE_PATH` (skipped if the secret is unset).
-4. Builds all four flavored release artifacts
+4. For stable releases, builds all four flavored release artifacts
   (`./gradlew bundleRelease assembleRelease`); only the sideload APK and
-   googlePlay AAB are attached (see §Release assets).
+   googlePlay AAB are attached. For prereleases, builds only the side-by-side
+   `sideloadCandidate` APK.
 5. Generates `SHA256SUMS.txt` covering the two attached files.
-6. Promotes the exact preflighted Production draft to `completed`; a missing
-   credential or rejected Play edit fails before public GitHub publication.
+6. For stable releases only, promotes the exact preflighted Production draft to
+   `completed`; prereleases never upload to Play.
 7. Creates a GitHub Release named `Hermes-Relay-Android v<version>` with `RELEASE_NOTES.md` as
   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.
@@ -831,8 +858,8 @@ On every push of a tag matching `android-v*`, `.github/workflows/release-android
 On every push of a tag matching `server-v*`,
 `.github/workflows/release-plugin.yml`:

-1. Verifies the tag commit is contained in `main`, validates the tag against
-   all server/plugin-owned version metadata checked by
+1. Verifies a stable tag commit is contained in `main`, or a prerelease tag is
+   contained in `dev`, then validates the tag against all server/plugin-owned version metadata checked by
   `scripts/check-plugin-version-sync.py`, and requires the matching release
   heading in `CHANGELOG.md`.
 2. Runs plugin syntax checks and the focused route/auth/session test slice.
@@ -846,9 +873,10 @@ On every push of a tag matching `desktop-v*`,
 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
 substitutes `__VERSION__` (bare, e.g. `0.3.0`) and `__TAG__` (full, e.g.
-`desktop-v0.3.0`) so the install/pin commands stay accurate. It rejects tags
-whose commit is not contained in `main`, whose version differs from
-`desktop/package.json`, or whose version has no `CHANGELOG.md` release heading.
+`desktop-v0.3.0`) so the install/pin commands stay accurate. It requires stable
+tags to be contained in `main` and prerelease tags to be contained in `dev`,
+with a version matching `desktop/package.json` and a corresponding
+`CHANGELOG.md` release heading.
 Fill its Summary and
 Added/Changed/Fixed groups at CLI release-prep and apply the §2 public scrub.
 Dashboard-only changes are covered by
@@ -1,10 +1,10 @@
-# Hermes-Relay-Android v1.6.1
+# Hermes-Relay-Android v1.12.0

-**Release Date:** August 3, 2026
+**Release Date:** August 21, 2026

 ## Download

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

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

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

 ## Summary

-This patch clarifies optional Relay recovery, restores the full session drawer, and fixes several chat and Voice regressions.
+This release adds saved custom themes and makes appearance shape consistent throughout Android. It also keeps profile and session identity intact across All Profiles navigation and language changes, recovers Gateway chats when a completion frame is missed, and accepts common Relay endpoint forms without producing invalid routes.
+
+## Added
+
+- Create up to 20 local custom themes with editable palette roles, Light or Dark ownership, saved shape, live chat preview, rename, duplicate, and delete controls.
+
+## Changed
+
+- Apply Soft, Balanced, or Sharp styling consistently across chat, settings, sheets, dialogs, terminal, voice, Bridge, and other shared surfaces.
+- Activate a session's owning agent when selecting it from All Profiles; profile locks hide that browser and reject cross-profile opens.

 ## Fixed

- Optional Relay failures stay within Relay-only surfaces, use consistent status labels, and only request re-pairing when the stored Relay credential actually needs it.
- Foreground recovery reconnects immediately after ordinary backoff, while retained credentials are described as stored details rather than an active in-memory session.
- Session history loads its 200-row drawer window through upstream-compatible 100-row pages instead of failing with HTTP 422.
- Selecting text remains stable when a streamed response changes from live text to rendered Markdown.
- Manual Voice recording waits for barge-in microphone teardown and gives a useful recovery message when the microphone is unavailable.
- New-chat coaching yields while Voice owns the composer, so it no longer covers the expanding Voice drawer.
+- Preserve the exact connection, agent, session, transcript, draft, and All Profiles state through an app-language change.
+- Relocalize the persistent connection notification without restarting the active connection.
+- Settle and reconcile active Gateway turns when the terminal completion frame was missed.
+- Normalize Relay base, `/ws`, and `/health` endpoint forms without producing duplicate route segments.

 ## Install / Verify

- App version: **1.6.1** (versionCode **38**).
- Standard Chat and Vanilla Hermes voice continue to work against unmodified upstream Hermes.
- Same-device Relay re-pair replacement requires the optional Server 1.5.1 plugin; Dashboard and `/relay revoke <token-prefix>` remain available for explicit cleanup.
+- App version: **1.12.0** (versionCode **47**).
+- Standard Chat, sessions, Manage, profile switching, custom themes, 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 is not required for standard Android chat, session continuity, themes, or Gateway recovery.
@@ -6,6 +6,94 @@ For shipped work, see `DEVLOG.md`. For architectural decisions, see `docs/decisi

 ---

+## Certify Android Gateway missing-terminal recovery on physical devices
+
+Deterministic fake-Gateway coverage now proves that a foreground turn with
+rapid deltas and tool activity can lose its WebSocket before
+`message.complete`, reactivate the exact live runtime, observe authoritative
+`running=false`, and reconcile persisted history without navigation, API
+fallback, duplicate submission, or a silent streaming latch. Complete the
+remaining hardware matrix before treating issue #365 as device-certified:
+
+On-demand contract-lab certification passed on an Android 16 SM-S938U using
+the sideload app and instrumentation APK. The embedded device test exercised
+Activity `STARTED` to `RESUMED` while streaming; the external fixture test then
+proved prompt submission, controlled socket loss, exact activation,
+authoritative HTTP history, idle settlement, and no API fallback. The ADB
+runner separately completed launch, Home/foreground, force-stop, and process
+recreation without enabling radio mutation. This is deterministic fixture
+proof, not certification against the reporter's host/device or a live provider.
+
+- Re-run long multi-turn/tool-heavy chats against current vanilla upstream on
+  the originally reported Android/device family and one Android 14+ device.
+- Exercise foreground-open chat, background/foreground, Wi-Fi/cellular loss,
+  socket replacement, queued follow-ups, profile/session switches, and process
+  recreation while capturing the content-free Gateway recovery diagnostic.
+- Confirm selection, user-owned scrollback, streaming Markdown, and follow
+  behavior remain stable while authoritative history catches up.
+
+---
+
+## Certify Android power fixes across the reported device matrix
+
+Issue #377's static estimates are not device measurements. The code now keeps
+the idle Sphere static, gates inactive waveform/drawer animation, detaches the
+MediaProjection surface between requested frames, binds AEC/NS to the capture
+session, releases unattended wake locks at command completion, and reuses the
+wake-word normalization buffer. Complete the remaining physical proof before
+assigning battery percentages or declaring the report closed:
+
+- Re-run the reported Android 13 / Pixel 4 XL workload with screen-on and
+  screen-off intervals separated, and with experimental wake listening both
+  disabled and explicitly enabled. Capture scoped CPU/thread/network/wakelock
+  evidence plus Battery Historian or Perfetto without resetting batterystats
+  unless the device owner approves the reset.
+- On Android 14+ and a foldable/rotation path, request two screenshots around a
+  geometry change and verify the existing VirtualDisplay resizes, its surface
+  is detached between requests, and the projection token is not reused.
+- On at least one device with platform AEC, run Standard and Realtime barge-in
+  through playback and confirm the effect is enabled on the AudioRecord session,
+  the microphone remains single-owner, interruption still works, and teardown
+  leaves no audio effect or capture session active.
+- Compare Wi-Fi and cellular separately. Treat radio-tail claims as unproven
+  until packet timing and mobile-radio active time reproduce them on hardware.
+
+---
+
+## Certify the official Desktop Relay plugin
+
+The unified `plugin/desktop/plugin.js` implementation is covered by source-level
+SDK contract, packaging, explicit-open, no-auto-open, close, unload, and profile
+cache-isolation tests. A physical official Hermes Desktop session is still
+required before calling the UX live-certified:
+
+- Test default and named local profiles, ordinary authenticated remote mode,
+  and SSH mode with differently named local/remote profile mapping.
+- In two full app windows, prove enabling, registration, explicit open,
+  requests, close/reopen, hot reload, and disable/unload remain window-local.
+- Prove startup, reconnect, profile change, layout restore/reset, update, and
+  background events never open or focus Relay.
+- Drag and dock the pane across native zones, close it, reopen it from all three
+  labeled actions, and verify no private-hook fallback is needed.
+- Exercise Relay running/unreachable, zero/one/multiple devices, pairing,
+  revocation, bridge activity, media, remote access, and renderer error logging
+  without exposing credentials, pairing payloads, filesystem paths, or tokens.
+
+---
+
+## Structured desktop hardware capabilities
+
+Structured access and per-host USB policy now ship with typed, serial-bound ADB
+list, shell, push, pull, install, and bounded logcat operations. Remaining work:
+- Add microphone and camera only with backend readiness detection, bounded local
+  grants, active-use indicators, audit events, and immediate cancellation.
+- Reconcile legacy `desktop_screenshot` with the task-granted computer screenshot
+  path so screen capture follows one policy.
+- Extend capability policy beyond hardware only where a typed broker provides a
+  meaningfully stronger boundary than Structured mode already provides.
+
+---
+
 ## Android Plugin Studio protocol follow-ups

 The first live declarative Plugin lane is host-local: Relay tools create bounded
@@ -24,6 +112,22 @@ multi-session protocol before treating `lifecycle=session` as an isolation claim

 ---

+## Split fast Android unit tests from resource and screenshot tests
+
+The quick-loop commands now narrow execution to the sideload debug variant and
+support one-class filtering, but all `:app` unit tests still share one Android
+test variant. That variant includes merged Android resources, gives every test
+worker a 2 GiB heap, runs on JDK 21, and enables Roborazzi recording because a
+small subset of Robolectric/screenshot tests requires those settings.
+
+Create a separate resource/screenshot test lane so pure state, parser, routing,
+and formatting tests can run as ordinary JVM tests without Android resource
+packaging. Keep golden-image recording explicit rather than applying it to all
+unit tests, preserve a CI task that runs both lanes, and benchmark cold plus
+warm focused-test latency before adopting the split.
+
+---
+
 ## Verify Android native dashboard sign-in on device

 Android now selects Custom Tab + PKCE for HTTPS gateways that advertise
@@ -893,7 +997,7 @@ Phase 1 (end-to-end spine) shipped on `Codename-11/phone-platform` — `send_mes
 - Live gateway must discover the plugin (`~/.hermes/plugins/hermes-relay` → `plugin/`) and `plugins.enabled` must include `hermes-relay` for the `phone` platform to register. Confirm `phone` appears in `hermes gateway status` with `PHONE_ENABLED=1`.
 - End-to-end: with the app paired + "Let Hermes message me" on, run `send_message target=phone text=...` (and a cron `deliver=phone`) and confirm a notification on the device. Verify 503 (no phone) and the off-by-default gates.
 - **Phase 2c reply round-trip — ✅ DONE (verified on-device 2026-06-29).** Confirmed: agent → phone notification → inline reply → drained through the relay's loopback `GET /phone/replies` (different process) → `handle_message` (`role_authorized=True`, no `PHONE_ALLOW_ALL_USERS`) → agent answer back in the *same* thread. Both fixes required (see DEVLOG / the Phase 2c bullet above).
- **FIX: cron `deliver=phone` / standalone send is broken.** Live testing: `hermes send --to phone` returns `{"error": "Unknown platform: phone"}`. The standalone (non-gateway) send path doesn't run a `kind=standalone` plugin's programmatic `ctx.register_platform`, so it never learns `phone` — only the running gateway (which loads `register()` at startup) does. The agent path (`send_message target=phone` in the gateway) works and was verified end-to-end on-device; the standalone/cron path needs the platform discoverable there too (declare it so the standalone loader picks it up, or route cron through the gateway). Until then `cron deliver=phone` won't work.
+- **Cron `deliver=phone` live certification pending.** The plugin now registers its standalone sender and enumerates the canonical phone home through the upstream adapter channel-directory hook. Re-run the device scenario above on the deployed plugin to certify scheduled delivery, including the offline queue and opt-in gates.
 - **FIX SHIPPED (2026-07-07) — installer + doctor guard against stale duplicate plugin copies; live-host verify pending.** Root cause of the 2026-06-29 round-trip failure: the gateway loader dedups discovered plugins by manifest `name`, so a second directory declaring `name: hermes-relay` (an old-installer backup copy, or a stray native install) could win the dedup and make the gateway load stale code — silently ignoring every later deploy. `plugin/doctor.py` now emits a `plugin-name-unique` warning when more than one directory under `~/.hermes/plugins/` declares the same plugin name (distinct real targets only — two links to the same target are deduped), and `install.sh` sweeps any such duplicate so only the canonical `hermes-relay` symlink survives. (Current `install.sh` already `rm -rf`s the old link rather than backing it up inside the plugins dir, so the original "back up outside the plugins dir" half is moot.) **Verify on the live host:** `hermes relay doctor` reports the `plugin-name-unique` check, and a reinstall leaves exactly one `hermes-relay` entry under `~/.hermes/plugins/`.

 ## Phone platform — usability roadmap (post device-verification, 2026-06-29)
@@ -904,9 +1008,9 @@ Phase 1 (end-to-end spine) shipped on `Codename-11/phone-platform` — `send_mes

 **Refinement (2026-06-29) — unified-session model: "Threads."** Going further on "unified surface": the agent conversation is **not a separate tab/segment** at all — it is a **source-tagged session inside the one Chat surface**, a **Thread** (`source=phone`). What makes a Thread special vs. a normal gateway chat are *session properties*, not a separate UI: (a) the agent can initiate, (b) relay `proactive` transport + relay-gated, (c) standing/named DM. **Scrollback = the gateway session store** (same read path Chat uses); **live receive = relay `proactive` push** (→ notification); **send = `proactive.reply`**. `ProactiveInboxStore` is demoted to a live-push cache + outbox (no parallel history). The Thread capability shows in the **best-path/capability UI** (relay tier, like terminal/bridge/voice) and as a clean **Threads** entry — thread-spool icon, NOT a phone glyph — pinned atop the session drawer when active; never a connection-wizard step. Degrades cleanly (no plugin → no `source=phone` sessions → Chat unchanged). **Supersedes the "separate Agent lane / 4th nav segment" sketch** and merges with the "source attribution in Chat" goal below. Keep the two "gateway" senses straight: *platform layer* (the Thread's `source`) ≠ *dashboard `/api/ws` transport* (how live bytes flow). Full re-cut: docs/decisions.md ADR 12.

- **Outbound buffering — ✅ relay-side DONE (2026-06-29).** `ProactiveChannel.push()` now queues agent→phone messages in a bounded deque (drop-oldest, 24 h TTL) when no phone is subscribed and returns `{queued: true}` (not 503); `_flush_outbound` delivers FIFO on the next subscribe (stale pruned). Inspect/cancel via `peek_outbound`/`cancel_outbound` + loopback `GET`/`DELETE /phone/outbound`. **UI surfacing of the queued state** (host-side, since the queue exists while the phone is OFFLINE): (a) ✅ **desktop CLI `relay queue` / `relay queue --clear` / `--cancel <id>` DONE (2026-06-29)** over the new endpoints (loopback-only — run on the relay host); a dashboard Relay-tab view is the optional GUI equivalent; (b) **remaining** — in the threaded agent surface, mark messages that arrived-while-away, and show the user's OWN pending replies (the Phase 3 reply queue) with a sending/Cancel affordance — that's where phone-side "queued + cancel" belongs.
+- **Outbound buffering — ✅ relay-side + arrived-while-away receive UX DONE.** `ProactiveChannel.push()` queues agent→phone messages in a bounded deque (drop-oldest, 24 h TTL) when no phone is subscribed and returns `{queued: true}`. `_flush_outbound` delivers FIFO on the next subscribe (stale pruned), marks flushed messages, and sends one batch-complete count; Android labels those Thread bubbles “While away” and shows one accessible batch summary without changing unread behavior. Inspect/cancel remains available through `peek_outbound`/`cancel_outbound`, loopback `GET`/`DELETE /phone/outbound`, and desktop `relay queue`. **Remaining:** show the user's OWN pending replies (the Phase 3 reply queue) with an honest Queued/Cancel affordance; a dashboard queue view remains optional.
 - **Threads surface (unified-session model — see ADR 12 + the Refinement above).** Build order, each shippable: **(1)** source tags in the session drawer (`source=phone` → clean **Threads** chip + thread-spool icon, NOT a phone glyph) — also delivers the "source attribution in Chat" goal; **(2)** open a Thread in Chat from its session-store history (reuse the existing message-history path); **(3)** route the live `proactive` push into the session view + notification + unread, demoting `ProactiveInboxStore` to cache/outbox; **(4)** reply from the Chat composer via `proactive.reply` + persist the user turn + local `Sending/Queued/Failed` status — **MVP**; **(5)** a **Threads capability row** in the best-path UI + a pinned **Threads** entry atop the drawer (thread-spool icon, shown only when relay-paired + opted-in) + retire `HermesInboxScreen`, re-point the notification deep-link + Settings "View messages"; **(6)** outbox/retry on reconnect; **(7)** relay `proactive.reply.ack` (honest Delivered) + `proactive.cancel`; **(8)** multi-thread `chat_id` (named/project Threads). **Verify gate before (1):** confirm the app's session-list/history path surfaces a `source=phone` session cleanly (upstream `session.list` returns all sources flat, so it should — but check whether the drawer currently filters it out). Honesty call: do NOT show "Delivered" until (7) lands (can't confirm it client-side before the ack).
-  - **Status (2026-06-29, implemented UNBUILT — verify in Studio):** **CODE-COMPLETE on `dev`:** slice **1** (drawer source tags + `ThreadSpoolGlyph` + Threads filter), **2** (open a Thread from history — free via the existing `loadSessionHistory` path), **3-parse** (carry `reply_to` on `ProactiveMessage`), **4** (composer reply in a `source=phone` session routes over `proactive.reply`; `MessageDeliveryStatus` SENDING→DELIVERED/FAILED on the bubble), **5** (Threads capability row in `SessionPathCard` + `threadsCapabilityActive` drawer wiring), **7** (relay `proactive.reply.ack` + `proactive.cancel` — 25/25 `unittest` green — and client ack handling). **DONE since (2026-06-29, built + on phone):** live **in-thread reply rendering** (an agent reply lands in the open Thread as an ASSISTANT bubble, suppressing the notification/inbox — `injectIntoThread`); **user-created named Threads** ("+ New Thread"); **retire `HermesInboxScreen`** (deleted; route + nav removed; notification tap + Settings "View messages" re-pointed to Chat; surface renamed "Hermes messages" → **"Threads"**); relay slice-7 ack/cancel **DEPLOYED** to the host so **"Delivered" is live**. **DEFERRED (reasons):** per-session **unread badge**; **outbox/retry** (needs multiplexer connection-state); **exact-Thread deep-link** from the notification (opens Chat today, not the specific thread — needs select-session-on-entry); **remove the now-orphaned `ProactiveInboxStore`** (viewer-less write-only log); **agent-initiated** named Threads (upstream `send_message` thread param). On-device verifies for the create-flow: fresh-`chat_id` auto-create, the `…:dm:<chat_id>` id form, `renameSession` on a phone session.
+  - **Status (2026-06-29, implemented UNBUILT — verify in Studio):** **CODE-COMPLETE on `dev`:** slice **1** (drawer source tags + `ThreadSpoolGlyph` + Threads filter), **2** (open a Thread from history — free via the existing `loadSessionHistory` path), **3-parse** (carry `reply_to` on `ProactiveMessage`), **4** (composer reply in a `source=phone` session routes over `proactive.reply`; `MessageDeliveryStatus` SENDING→DELIVERED/FAILED on the bubble), **5** (Threads capability row in `SessionPathCard` + `threadsCapabilityActive` drawer wiring), **7** (relay `proactive.reply.ack` + `proactive.cancel` — 25/25 `unittest` green — and client ack handling). **DONE since (2026-06-29, built + on phone):** live **in-thread reply rendering**; **user-created named Threads** ("+ New Thread"); **retire `HermesInboxScreen`**; relay slice-7 ack/cancel **DEPLOYED** to the host so **"Delivered" is live**. **DONE (2026-08-14):** notification taps survive cold start and open the exact `chat_id`; agent-initiated outbound messages appear as connection-scoped provisional Threads backed by the bounded proactive store, then promote to the real `source=phone` session after the first reply. **DEFERRED:** per-session **unread badge**; **outbox/retry** (needs multiplexer connection-state); **agent-initiated** named Threads (upstream `send_message` thread param). On-device verifies for the create-flow: fresh-`chat_id` auto-create, the `…:dm:<chat_id>` id form, `renameSession` on a phone session.
  - **User-created Threads (slice 8, Discord-style) — CODE-COMPLETE on `dev` (built + installed 2026-06-29; on-device behavior pending).** "+ New Thread" in the drawer's Threads view → name dialog → `ChatViewModel.startNewThread` mints a fresh `chat_id`; the first composer message opens it over `proactive.reply` (gateway auto-creates the `source=phone` session) → `switchToCreatedThread` polls + switches to the real session + applies the name. Existing-thread replies route by the `chat_id` parsed from the session id (`…:dm:<chat_id>`; opaque id → home fallback). **On-device verifies:** (1) a fresh-`chat_id` no-`reply_to` inbound creates a new `source=phone` session; (2) the phone session id carries the `…:dm:<chat_id>` form the client parses; (3) `renameSession` titles a phone session. **Remaining slice-8:** AGENT-initiated named Threads (the upstream `send_message` thread/chat_id param so the agent can open its own named Threads).
  - **`chat_id` not exposed by `/api/sessions` (root cause of the 2026-06-29 on-device create-flow bugs — fixed client-side).** Confirmed on the host: a phone session's `id` is a timestamp (e.g. `20260629_204755_94f391d6`); the real `chat_id` lives in the `session_key` (`agent:main:phone:dm:<chat_id>`) and a `chat_id` column — but `/api/sessions` returns **neither `chat_id` nor `session_key`**, only `source` + the timestamp `id`. So the client could not map a session ↔ its `chat_id`, which broke create-thread switch/rename + reply routing + in-thread injection. **Client workaround shipped:** find a created thread by session-list **diff** (the new `source=phone` session), keep an in-memory `sessionId → chat_id` map (learned at creation + from incoming `phone.message`s) for reply routing, and inject by source (+ learned chat_id) rather than a parsed id. **Limitation:** for a thread the app didn't create *this* session (agent-created, another device, or after an app restart) `chat_id` is unknown until a message arrives while viewing it → its replies fall back to the home channel until then. **RESOLVED via the plugin (2026-06-29, per upstream-or-plugin policy):** the relay now exposes `GET /phone/threads` (`plugin/relay/session_store.py` reads the gateway store read-only → `[{session_id, chat_id, title}]`; `server.py` `handle_phone_threads`, bearer for the app / loopback for diag; 5 unit tests). The app (`RelayHttpClient.fetchPhoneThreads` → `ConnectionViewModel.phoneThreadChatIds` on every `auth.ok` → `ChatViewModel.seedThreadChatIds`, authoritative over the learned map) now routes replies correctly for **any** Thread — incl. ones it didn't create + after restart. Deployed + verified live. **Still-nice-to-have (lower priority): the upstream PR** to add `chat_id`/`session_key` to `/api/sessions` (the standard-path proper fix; the relay route then becomes redundant + the client prefers upstream when present).
 - **Threads as named/project conversations (Discord-parity — folds into multi-thread #8).** A stable *named* `chat_id` per project = a persistent, agent-reachable project Thread (Discord named-thread parity for "persist a session for a project"). Enables: the agent **opening** a new named Thread for a background job/topic (a relay/gateway "open thread" affordance + a `send_message`-adjacent tool); cron/job updates landing in their own Thread; and replying to a Thread from any surface (desktop CLI / dashboard) since it is just a gateway session. Also evaluate per-Thread profile binding (a project Thread uses the "work" profile — ties to profile=contact).
@@ -926,7 +1030,7 @@ Phase 1 (end-to-end spine) shipped on `Codename-11/phone-platform` — `send_mes
 The gateway-platform model is the *correct + sufficient architecture* (the phone is a registered platform peer, so anything that routes to a platform — `send_message`, cron `deliver=`, channel directory, background jobs — can reach the phone). These are the concrete gaps between "architecturally a peer" and "I never open Discord":

 - **Guaranteed background delivery (the biggest gap; no push today).** Delivery is **live-WSS-only** + a 24 h relay buffer; there is **no FCM/UnifiedPush** wake-up. If the app process is dead AND not holding a socket, a message waits for the next reconnect, and the relay buffer is ephemeral (lost on relay restart). Discord/Telegram feel instant because they wake the device via push even when the app is dead. Decide a **push transport**: **UnifiedPush/ntfy** (recommended — self-hostable, no Google dependency, upstream *already* ships an `ntfy` platform, on-brand for self-hosted) vs **FCM** (simplest UX but adds Play Services + a push relay; clashes with self-hosted ethos — at most the `googlePlay` flavor) vs **persistent foreground keep-alive service** holding the relay WSS (zero new infra, like `GatewayKeepAliveService`, but battery cost + Doze-fragile). Likely: UnifiedPush primary + foreground-keepalive fallback.
- **Cron / background-job delivery is BROKEN** (already tracked above): `deliver=phone` standalone path → `Unknown platform: phone`. This is load-bearing for "receiver of crons/background jobs" — fix is required, not optional, for the replacement goal.
+- **Cron / background-job delivery needs live certification.** The standalone sender and channel-directory enumeration are implemented; certify `deliver=phone` against a deployed Relay and paired device, including reconnect delivery from the bounded offline queue.
 - **Agent-initiated multi-thread creation remains.** The app already renders N
  `source=phone` sessions, user-created Threads vary `chat_id`, and replies route
  by `chat_id` + `reply_to`. The missing parity is letting the agent open/name a
@@ -935,7 +1039,7 @@ The gateway-platform model is the *correct + sufficient architecture* (the phone
  session store; the relay buffer is only the live/offline-delivery layer, not a
  parallel history database.
 - **Profile = contact mapping (new idea, fold in).** Multiple Hermes **profiles** (distinct agent personas/configs) could each be a distinct thread *source*/"contact" — DMing different agents. Maps cleanly onto the per-thread `chat_id` + source-attribution work; lets the app feel like a contact list of agents.
- **Per-thread notification controls + deep-link (Discord-parity affordances).** Per-thread notification channels, mute/DND/quiet-hours (Phase 3 partially), and a notification that **deep-links into the exact thread** (tap → land in that conversation) so dipping in/out while multitasking is frictionless.
+- **Per-thread notification controls (Discord-parity affordances).** Exact-thread notification deep-linking is shipped. Remaining: per-thread notification channels and mute/DND/quiet-hours controls (Phase 3 partially).
 - **Agent-initiated rich content.** Agent → phone thread with **images/cards** (relay media infra + `InboundAttachmentCard`/`HermesCardBubble` already exist on the chat side — reuse). Inbound (phone → agent) reply media stays deferred (text-first), but outbound rich content is low-cost parity.
 - **In-thread "agent is working" indicator.** A typing/working state in the thread while the agent thinks/runs tools (Discord typing-dots parity) — the chat surface already has thinking indicators to reuse.

@@ -1201,8 +1305,27 @@ When the answer becomes clearer, this section becomes either an ADR in `docs/dec

 ## Smaller deferred items

+- **Certify the preferred CUA Driver backend (ADR 56).** The canonical-runtime
+  probe, bounded adapter, server-owned control-session envelope, per-session
+  grant state, local engine/status controls, telemetry-off process environment,
+  and Hermes snapshot-token primitives now exist. Before graduating the engine,
+  finish end-to-end enforcement of app/display/folder scopes and sensitive
+  pixel/accessibility denial or redaction, harden the grant-bridge ACL and nonce
+  lifecycle, and complete live Windows certification proving the physical cursor and
+  foreground app stay unchanged, stale or cross-window tokens fail, two remote
+  control sessions receive isolated animated cursors, and foreground escalation
+  never happens implicitly. Exercise revoke on grant expiry, disconnect,
+  re-pair, policy downgrade, emergency stop, Windows-session change, and daemon
+  shutdown. The explicit local CUA install/update surface now verifies upstream
+  manifest identity and installer SHA-256; add Windows publisher verification
+  when upstream signs the installer. Keep raw CUA tools, configuration,
+  recording, replay, and JavaScript outside the remote agent surface.
+  Remove the temporary Windows readiness/health split once
+  [trycua/cua#3103](https://github.com/trycua/cua/issues/3103) ships in the
+  supported CUA range; restore a mandatory health gate only if the upstream
+  probe is bounded and cannot leave UI Automation falsely busy.
 - **MediaProjection consent flow** — wired in MainActivity (2026-04-12), needs end-to-end test on a real device
- **WorkManager upgrade for auto-disable timer** — currently a coroutine `Job + delay()` in `AutoDisableWorker.kt`; documented at top of file. Upgrade when androidx.work joins the classpath
+- **WorkManager upgrade for timed screen-access expiry notification** — authority already fails closed from persisted absolute expiry after restart; the prompt notification is currently a coroutine `Job + delay()` coordinated by `BridgeSafetyManager` / `AutoDisableWorker`. Upgrade only if background notification timing becomes important after androidx.work joins the classpath.
 - **Wave 3 voice-bridge multi-turn confirmation** — currently a 5s TTS countdown with cancel; conversational confirmation is the follow-up
 - **LLM client wiring for `android_navigate`** — `_default_vision_model` is stubbed; production swap to a real Anthropic/OpenAI vision client
 - **Real screenshots of each flavor's a11y permission dialog** — for `user-docs/guide/release-tracks.md`
@@ -1258,7 +1381,7 @@ Follow-ups:
  profile/skill-aware empty-state chips and the ~40-flow recomposition hotspot at
  the top of `ChatScreen`.
 - **Pet hot-load + in-app add/remove (shipped 2026-06-20).** Pets now live-refresh: an `avatarsRefreshTick` keys the avatar `produceState` in `RelayApp`, and Appearance re-scans `pets/` on open and after in-app import/delete — no app restart. Appearance gained "Add a pet" (SAF `.zip` import via `PetImporter`, zip-slip/zip-bomb guarded + validated through `toAvatar`) and an "Installed pets" list with per-pet remove (`PetLoader.deletePet`, confirm dialog, Sphere fallback). Remaining:
-  - **Sphere-skin parity.** Skins are still process-scoped + `adb push` only — the live tick and the importer cover pets, not skins. Extend the tick to `loadUserSkins` and add a `.json` skin import if hot-loading/adding skins in-app is wanted.
+  - **Sphere-skin parity (shipped 2026-08-09).** Appearance now imports a bounded, validated declarative `.json` skin through the system picker, hot-refreshes the shared sphere registry, and selects the imported skin without an app restart.
  - `**adb push` into `Android/data` hangs on Samsung scoped storage.** Confirmed: pushing a pet pack to `/sdcard/Android/data/<pkg>/files/pets/` stalls (no bytes written) although `adb shell ls` of the dir works. In-app `.zip` import is the supported path; `/sdcard/Download` pushes fine. Consider softening `docs/pet-spec.md` + user-docs to lead with in-app import over adb.
  - **On-device import/delete smoke.** Import `/sdcard/Download/lucy.zip` via Add a pet → confirm Lucy appears, selects, and animates all states; then remove it and confirm the avatar falls back to the Sphere.
 - **Pet behavior model — richer state association (spec'd 2026-06-19, `docs/pet-spec.md` "Agent states &amp; pet behavior").** Shipped: the honesty clamp (declared reactivity ∩ `PET_RENDERER_CAPABILITIES`), the friendly `writing` alias, the `**working`/tool-use overlay** (pet-local sub-state from `toolCallBurst`; opt-in `working` clip drives both the swap and the Tools badge), the **one-shot reaction layer** (`greet`/`wake` on appear, `done`/`celebrate` on turn-finish — opt-in, play-once-then-revert, transition-derived; `ONE_SHOT_MAX_MS` backstop), and `**intensity` modulation** (opt-in `reactive.intensity` → live playback speedup ≤1.6× via `rememberUpdatedState`; un-clamps the Activity badge). Voice · Tools · Activity reactivity is now complete. Remaining:
@@ -1,5 +1,8 @@
 import java.util.Properties

+fun String.asBuildConfigString(): String =
+    "\"" + replace("\\", "\\\\").replace("\"", "\\\"") + "\""
+
 plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.plugin.compose")
@@ -7,6 +10,19 @@ plugins {
    alias(libs.plugins.play.publisher)
 }

+val supportedHermesDevAbis = setOf("arm64-v8a", "armeabi-v7a", "x86", "x86_64")
+val hermesDevAbi = providers.gradleProperty("hermes.devAbi").orNull
+val candidateKind = providers.gradleProperty("candidate.kind").orElse("review").get()
+val candidateLabel = providers.gradleProperty("candidate.label").orElse("Local review").get()
+val candidateSourceRef = providers.gradleProperty("candidate.sourceRef").orElse("local").get()
+val candidateSourceSha = providers.gradleProperty("candidate.sourceSha").orElse("unknown").get()
+hermesDevAbi?.let { requestedAbi ->
+    require(requestedAbi in supportedHermesDevAbis) {
+        "Unsupported hermes.devAbi '$requestedAbi'. Expected one of: " +
+            supportedHermesDevAbis.sorted().joinToString()
+    }
+}
+
 // Rename output artifacts to include the app version. AGP respects
 // `archivesName` for both APK (assemble*) and AAB (bundle*) outputs, so
 // this single line produces `hermes-relay-<version>-<flavor>-<buildType>`
@@ -43,8 +59,24 @@ android {

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

+        // Optional local-only fast path for device iteration. Native voice/VAD
+        // dependencies make the universal sideload APK very large, while a
+        // connected phone needs only its own ABI. Release and normal debug
+        // builds remain universal unless the developer explicitly supplies
+        // -Phermes.devAbi=<abi>.
+        hermesDevAbi?.let { requestedAbi ->
+            ndk {
+                abiFilters += requestedAbi
+            }
+        }
+
        // Feature flags — DEV_MODE enables all experimental features in debug builds
        buildConfigField("boolean", "DEV_MODE", "false")
+        buildConfigField("boolean", "CANDIDATE_BUILD", "false")
+        buildConfigField("String", "CANDIDATE_KIND", "".asBuildConfigString())
+        buildConfigField("String", "CANDIDATE_LABEL", "".asBuildConfigString())
+        buildConfigField("String", "CANDIDATE_SOURCE_REF", "".asBuildConfigString())
+        buildConfigField("String", "CANDIDATE_SOURCE_SHA", "".asBuildConfigString())
    }

    signingConfigs {
@@ -141,6 +173,18 @@ android {
                signingConfigs.getByName("debug")
            }
        }
+        create("candidate") {
+            initWith(getByName("release"))
+            applicationIdSuffix = ".candidate"
+            versionNameSuffix = "-candidate"
+            isDebuggable = false
+            matchingFallbacks += listOf("release")
+            buildConfigField("boolean", "CANDIDATE_BUILD", "true")
+            buildConfigField("String", "CANDIDATE_KIND", candidateKind.asBuildConfigString())
+            buildConfigField("String", "CANDIDATE_LABEL", candidateLabel.asBuildConfigString())
+            buildConfigField("String", "CANDIDATE_SOURCE_REF", candidateSourceRef.asBuildConfigString())
+            buildConfigField("String", "CANDIDATE_SOURCE_SHA", candidateSourceSha.asBuildConfigString())
+        }
    }

    compileOptions {
@@ -299,10 +343,13 @@ dependencies {

    // Coil 3 — async image loading for generated images in chat
    implementation(libs.coil.compose)
+    implementation(libs.coil.gif)
    implementation(libs.coil.network.okhttp)
+    implementation(libs.exifinterface)

    // QR Code scanning (ML Kit + CameraX)
    implementation(libs.mlkit.barcode)
+    implementation(libs.zxing.core)
    implementation(libs.camera.core)
    implementation(libs.camera.camera2)
    implementation(libs.camera.lifecycle)
@@ -343,14 +390,17 @@ dependencies {
    // Konsist — enforces the ADR 34 upstream/relay/shared package fence as a JUnit test
    testImplementation(libs.konsist)
    androidTestImplementation(libs.compose.ui.test.junit4)
+    // On-device vanilla-Gateway contract tests exercise the production
+    // Dashboard ticket + WebSocket stack over real loopback sockets.
+    androidTestImplementation(libs.okhttp.mockwebserver)
    debugImplementation(libs.compose.ui.tooling)
    debugImplementation(libs.compose.ui.test.manifest)

    // [POC] Roborazzi host-side screenshot rendering (src/test, Robolectric).
    // Renders real composables on the JVM at an exact canvas — no device, no
    // status bar, no clipping. See StoreScreenshotTest.
-    testImplementation("io.github.takahirom.roborazzi:roborazzi:1.70.0")
-    testImplementation("io.github.takahirom.roborazzi:roborazzi-compose:1.70.0")
+    testImplementation("io.github.takahirom.roborazzi:roborazzi:1.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")
@@ -6,8 +6,6 @@ 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.assertDoesNotExist
-import androidx.compose.ui.test.assertExists
 import androidx.compose.ui.test.junit4.createComposeRule
 import androidx.compose.ui.test.onNodeWithContentDescription
 import androidx.compose.ui.test.onNodeWithTag
@@ -121,12 +121,15 @@ class OnboardingFlowTest {
    }

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

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

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

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

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

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

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

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

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

        composeTestRule
@@ -0,0 +1,187 @@
+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.material3.Text
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.assertIsDisplayed
+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.test.platform.app.InstrumentationRegistry
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.hermesandroid.relay.data.MessageRole
+import com.hermesandroid.relay.network.upstream.ChatHandler
+import com.hermesandroid.relay.network.upstream.DashboardApiClient
+import com.hermesandroid.relay.network.upstream.GatewayChatClient
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonObject
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import java.util.concurrent.TimeUnit
+
+/**
+ * Opt-in physical-device/emulator adapter for the shared Python fixture.
+ *
+ * Pass `-e gatewayFixtureBaseUrl http://127.0.0.1:8765` after exposing the
+ * host fixture with `adb reverse`. With no argument this test alone is skipped;
+ * the embedded regression remains fully standalone.
+ */
+class GatewayExternalFixtureInstrumentedTest {
+
+    @get:Rule
+    val compose = createAndroidComposeRule<ComponentActivity>()
+
+    private var gatewayScope: CoroutineScope? = null
+    private var gatewayClient: GatewayChatClient? = null
+    private var viewModel: ChatViewModel? = null
+
+    @After
+    fun tearDown() {
+        viewModel?.updateGatewayClient(null)
+        gatewayClient?.shutdown()
+        gatewayScope?.cancel()
+    }
+
+    @Test
+    fun terminalGapActivate_externalFixtureRecoversFromAuthoritativeHttpHistory() {
+        val fixtureBaseUrl = InstrumentationRegistry.getArguments()
+            .getString(ARG_FIXTURE_BASE_URL)
+            ?.trim()
+            ?.trimEnd('/')
+        assumeTrue(
+            "Pass -e $ARG_FIXTURE_BASE_URL <url> to run the external fixture lane",
+            !fixtureBaseUrl.isNullOrBlank(),
+        )
+        requireNotNull(fixtureBaseUrl)
+
+        val okHttp = OkHttpClient.Builder()
+            .callTimeout(10, TimeUnit.SECONDS)
+            .build()
+        val initialState = readFixtureJson(okHttp, "$fixtureBaseUrl/__fixture__/state")
+        assertEquals("terminal_gap_activate", initialState["scenario"]?.jsonString())
+        assertEquals("1", initialState["remaining_turns"].toString())
+        val dashboard = DashboardApiClient(fixtureBaseUrl, okHttp)
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO).also { gatewayScope = it }
+        val gateway = GatewayChatClient(
+            initialDashboardClient = dashboard,
+            okHttpClient = okHttp,
+            callbackDispatcher = { block -> Handler(Looper.getMainLooper()).post(block) },
+            scope = scope,
+            reconnectJitterUnit = { 0.0 },
+        ).also { gatewayClient = it }
+        val handler = ChatHandler().also { it.setSessionId(STORED_SESSION_ID) }
+        val vm = ChatViewModel().also {
+            // Deliberately omit HermesApiClient: this lane has no API-server
+            // fallback surface, so a passing turn proves Gateway ownership.
+            it.initialize(null, handler)
+            it.streamingEndpoint = "gateway"
+            it.setProfileMessageLoaderWithMode { profile, sessionId, mode ->
+                dashboard.getSessionMessages(sessionId, profile, mode)
+            }
+            it.updateGatewayClient(gateway)
+            it.setChatVisible(true)
+        }.also { viewModel = it }
+
+        compose.setContent {
+            val messages by vm.messages.collectAsStateWithLifecycle()
+            val streaming by vm.isStreaming.collectAsStateWithLifecycle()
+            MaterialTheme {
+                Column(Modifier.testTag("external-contract-transcript")) {
+                    Text(
+                        text = if (streaming) "STREAMING" else "IDLE",
+                        modifier = Modifier.testTag("external-stream-state"),
+                    )
+                    messages.forEach { message ->
+                        Text(
+                            text = "${message.role.name}:${message.content}",
+                            modifier = Modifier.testTag("external-message-${message.id}"),
+                        )
+                    }
+                }
+            }
+        }
+
+        assertTrue(runBlocking { gateway.prewarmAwait(STORED_SESSION_ID) })
+        vm.sendMessage("Exercise terminal gap.")
+
+        compose.waitUntil(10_000) {
+            !handler.isStreaming.value &&
+                !gateway.hasActiveTurn() &&
+                handler.messages.value.any {
+                    it.role == MessageRole.ASSISTANT && it.content == AUTHORITATIVE_ANSWER
+                }
+        }
+
+        compose.onNodeWithTag("external-contract-transcript").assertIsDisplayed()
+        compose.onNodeWithTag("external-stream-state").assertTextEquals("IDLE")
+        compose.onAllNodesWithText("${MessageRole.ASSISTANT.name}:$AUTHORITATIVE_ANSWER")
+            .assertCountEquals(1)
+
+        val messages = handler.messages.value
+        assertEquals(
+            1,
+            messages.count {
+                it.role == MessageRole.ASSISTANT && it.content == AUTHORITATIVE_ANSWER
+            },
+        )
+        assertEquals(1, messages.count { it.role == MessageRole.USER })
+        assertFalse(messages.any { it.isStreaming || it.isThinkingStreaming })
+        assertEquals("gateway", vm.streamingEndpoint)
+
+        val evidence = readFixtureJson(okHttp, "$fixtureBaseUrl/__fixture__/evidence")
+        assertEquals("terminal_gap_activate", evidence["scenario"]?.jsonString())
+        val entries = evidence["entries"] as? JsonArray ?: JsonArray(emptyList())
+        assertEquals(1, entries.rpcCount("prompt.submit"))
+        assertEquals(1, entries.rpcCount("session.activate"))
+
+        val state = readFixtureJson(okHttp, "$fixtureBaseUrl/__fixture__/state")
+        assertEquals("terminal_gap_activate", state["scenario"]?.jsonString())
+        assertEquals("2", state["history_rows"].toString())
+    }
+
+    private fun readFixtureJson(client: OkHttpClient, url: String): JsonObject {
+        val request = Request.Builder().url(url).get().build()
+        return client.newCall(request).execute().use { response ->
+            check(response.isSuccessful) { "fixture HTTP ${response.code}" }
+            Json.parseToJsonElement(response.body.string()).jsonObject
+        }
+    }
+
+    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
+    }
+
+    private fun kotlinx.serialization.json.JsonElement.jsonString(): String? =
+        (this as? JsonPrimitive)?.contentOrNull
+
+    private companion object {
+        const val ARG_FIXTURE_BASE_URL = "gatewayFixtureBaseUrl"
+        const val STORED_SESSION_ID = "20260821_120000_fixture"
+        const val AUTHORITATIVE_ANSWER = "Persisted after the socket gap."
+    }
+}
@@ -0,0 +1,356 @@
+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.runtime.getValue
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.Modifier
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertTextEquals
+import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.hermesandroid.relay.data.MessageRole
+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 kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.put
+import okhttp3.OkHttpClient
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * On-device contract coverage for issue #365.
+ *
+ * This deliberately uses the production [GatewayChatClient], [ChatViewModel],
+ * and [ChatHandler]. [DeviceGatewayFixture] supplies only the upstream HTTP/WSS
+ * boundary, so Android main-looper dispatch and Compose collection are real.
+ */
+class GatewayForegroundRecoveryInstrumentedTest {
+
+    @get:Rule
+    val compose = createAndroidComposeRule<ComponentActivity>()
+
+    private lateinit var fixture: AndroidGatewayContractFixture
+    private lateinit var gatewayScope: CoroutineScope
+    private lateinit var gatewayClient: GatewayChatClient
+    private lateinit var handler: ChatHandler
+    private lateinit var viewModel: ChatViewModel
+    private lateinit var serverSocket: WebSocket
+
+    @Volatile
+    private var persistedHistory: List<MessageItem> = emptyList()
+
+    @Before
+    fun setUp() {
+        fixture = AndroidGatewayContractFixture()
+        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 },
+        )
+        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.setProfileMessageLoader { Result.success(persistedHistory) }
+            it.updateGatewayClient(gatewayClient)
+            it.setChatVisible(true)
+        }
+
+        compose.setContent {
+            val messages by viewModel.messages.collectAsStateWithLifecycle()
+            val streaming by viewModel.isStreaming.collectAsStateWithLifecycle()
+            MaterialTheme {
+                Column(Modifier.testTag("contract-transcript")) {
+                    Text(
+                        text = if (streaming) "STREAMING" else "IDLE",
+                        modifier = Modifier.testTag("stream-state"),
+                    )
+                    messages.forEach { message ->
+                        Text(
+                            text = "${message.role.name}:${message.content}",
+                            modifier = Modifier.testTag("message-${message.id}"),
+                        )
+                    }
+                }
+            }
+        }
+
+        assertTrue(runBlocking { gatewayClient.prewarmAwait(STORED_SESSION_ID) })
+        serverSocket = fixture.awaitServerSocket()
+        fixture.awaitRpc("session.resume")
+    }
+
+    @After
+    fun tearDown() {
+        viewModel.updateGatewayClient(null)
+        gatewayClient.shutdown()
+        gatewayScope.cancel()
+        fixture.shutdown()
+    }
+
+    @Test
+    fun terminalGapActivate_recoversForegroundTurnWithoutNavigationOrCrossSessionLeak() {
+        viewModel.sendMessage("Run a long foreground task")
+        fixture.awaitRpc("prompt.submit")
+
+        // A multiplexed Gateway shares one socket. Foreign-session events must
+        // neither render nor settle the visible turn.
+        serverSocket.send(fixture.event("message.start", null, FOREIGN_SESSION_ID))
+        serverSocket.send(
+            fixture.event(
+                "message.delta",
+                buildJsonObject { put("text", FOREIGN_ANSWER) },
+                FOREIGN_SESSION_ID,
+            ),
+        )
+        serverSocket.send(
+            fixture.event(
+                "message.complete",
+                buildJsonObject { put("text", FOREIGN_ANSWER) },
+                FOREIGN_SESSION_ID,
+            ),
+        )
+
+        serverSocket.send(fixture.event("message.start", null, LIVE_SESSION_ID))
+        serverSocket.send(
+            fixture.event(
+                "tool.start",
+                buildJsonObject {
+                    put("tool_id", "tool-foreground")
+                    put("name", "terminal")
+                },
+                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")
+        compose.onNodeWithTag("contract-transcript").assertIsDisplayed()
+        assertFalse(handler.messages.value.any { it.content.contains(FOREIGN_ANSWER) })
+
+        // Exercise the real Activity collection boundary while the turn is
+        // still live. STARTED models a covered/backgrounded activity without
+        // destroying the test host; returning to RESUMED must preserve the
+        // same turn and transcript without navigation.
+        compose.activityRule.scenario.moveToState(Lifecycle.State.STARTED)
+        compose.activityRule.scenario.moveToState(Lifecycle.State.RESUMED)
+        compose.waitUntil(5_000) { handler.isStreaming.value }
+        compose.onNodeWithTag("stream-state").assertTextEquals("STREAMING")
+
+        // The server finishes while this socket is detached. The replacement
+        // socket cannot replay message.complete; exact-session activation
+        // reports running=false and history is now authoritative.
+        persistedHistory = listOf(
+            MessageItem(
+                id = PERSISTED_ANSWER_ID,
+                sessionId = STORED_SESSION_ID,
+                role = "assistant",
+                content = JsonPrimitive(AUTHORITATIVE_ANSWER),
+            ),
+        )
+        fixture.recoveryRunning = false
+        serverSocket.close(1011, "fixture foreground gap")
+        serverSocket = fixture.awaitServerSocket()
+        fixture.awaitRpc("session.activate")
+
+        compose.waitUntil(5_000) {
+            !handler.isStreaming.value &&
+                handler.messages.value.singleOrNull()?.id == PERSISTED_ANSWER_ID
+        }
+        compose.onNodeWithTag("contract-transcript").assertIsDisplayed()
+        compose.onNodeWithTag("stream-state").assertTextEquals("IDLE")
+        compose.onNodeWithTag("message-$PERSISTED_ANSWER_ID")
+            .assertTextEquals("${MessageRole.ASSISTANT.name}:$AUTHORITATIVE_ANSWER")
+
+        val visible = handler.messages.value
+        assertEquals(1, visible.size)
+        assertEquals(AUTHORITATIVE_ANSWER, visible.single().content)
+        assertFalse(visible.single().isStreaming)
+        assertFalse(visible.any { it.content.contains(PARTIAL_ANSWER) })
+        assertFalse(visible.any { it.content.contains(FOREIGN_ANSWER) })
+        assertEquals(
+            "history catch-up must not duplicate the authoritative assistant row",
+            1,
+            compose.onAllNodesWithTag("message-$PERSISTED_ANSWER_ID").fetchSemanticsNodes().size,
+        )
+        assertEquals(
+            "the prompt must never be resubmitted during recovery",
+            1,
+            fixture.rpcCount("prompt.submit"),
+        )
+        assertEquals(
+            "the exact live session should be activated once",
+            1,
+            fixture.rpcCount("session.activate"),
+        )
+        assertEquals(0, fixture.requestsTo("/v1/chat/completions"))
+    }
+
+    private companion object {
+        const val STORED_SESSION_ID = "20260821_120000_fixture"
+        const val LIVE_SESSION_ID = "fixture-live-1"
+        const val FOREIGN_SESSION_ID = "live-foreign"
+        const val PERSISTED_ANSWER_ID = "persisted-foreground-answer"
+        const val PARTIAL_ANSWER = "Partial foreground answer"
+        const val AUTHORITATIVE_ANSWER = "Foreground task finished."
+        const val FOREIGN_ANSWER = "Wrong session content"
+    }
+}
+
+/** Minimal real-socket implementation of the vanilla Gateway contract used above. */
+internal class AndroidGatewayContractFixture {
+    val server = MockWebServer()
+    private val json = Json { ignoreUnknownKeys = true }
+    private val sockets = LinkedBlockingQueue<WebSocket>()
+    private val allSockets = ConcurrentLinkedQueue<WebSocket>()
+    private val rpcLog = ConcurrentLinkedQueue<Pair<String, JsonObject>>()
+    private val requestPaths = ConcurrentLinkedQueue<String>()
+    private val ticketCount = AtomicInteger(0)
+
+    @Volatile
+    var recoveryRunning = false
+
+    private val listener = object : WebSocketListener() {
+        override fun onOpen(webSocket: WebSocket, response: Response) {
+            sockets.add(webSocket)
+            allSockets.add(webSocket)
+            webSocket.send(event("gateway.ready", null, null))
+        }
+
+        override fun onMessage(webSocket: WebSocket, text: String) {
+            val frame = json.parseToJsonElement(text) as? JsonObject ?: return
+            val method = (frame["method"] as? JsonPrimitive)?.contentOrNull ?: return
+            val id = (frame["id"] as? JsonPrimitive)?.contentOrNull?.toLongOrNull() ?: return
+            val params = frame["params"] as? JsonObject ?: JsonObject(emptyMap())
+            rpcLog.add(method to params)
+
+            val result = when (method) {
+                "session.resume" -> sessionSnapshot("fixture-live-1")
+                "session.activate" -> sessionSnapshot(
+                    (params["session_id"] as? JsonPrimitive)?.contentOrNull ?: "fixture-live-1",
+                )
+                "prompt.submit", "session.interrupt" -> buildJsonObject { put("ok", true) }
+                else -> JsonObject(emptyMap())
+            }
+            webSocket.send(
+                buildJsonObject {
+                    put("jsonrpc", "2.0")
+                    put("id", id)
+                    put("result", result)
+                }.toString(),
+            )
+        }
+    }
+
+    init {
+        server.dispatcher = object : Dispatcher() {
+            override fun dispatch(request: RecordedRequest): MockResponse {
+                val path = request.path.orEmpty()
+                requestPaths.add(path)
+                return when {
+                    path.startsWith("/api/auth/ws-ticket") -> MockResponse()
+                        .setResponseCode(200)
+                        .setHeader("Content-Type", "application/json")
+                        .setBody(
+                            """{"ticket":"device-${ticketCount.incrementAndGet()}","ttl_seconds":30}""",
+                        )
+                    path.startsWith("/api/ws") -> MockResponse().withWebSocketUpgrade(listener)
+                    else -> MockResponse().setResponseCode(404)
+                }
+            }
+        }
+        server.start()
+    }
+
+    private fun sessionSnapshot(sessionId: String): JsonObject = buildJsonObject {
+        put("session_id", sessionId)
+        put("running", recoveryRunning)
+        put("status", if (recoveryRunning) "streaming" else "idle")
+        put("info", buildJsonObject { put("profile_name", "default") })
+    }
+
+    fun event(type: String, payload: JsonObject?, sessionId: String?): String =
+        buildJsonObject {
+            put("jsonrpc", "2.0")
+            put("method", "event")
+            put("params", buildJsonObject {
+                put("type", type)
+                payload?.let { put("payload", it) }
+                sessionId?.let { put("session_id", it) }
+            })
+        }.toString()
+
+    fun awaitServerSocket(): WebSocket =
+        sockets.poll(5, TimeUnit.SECONDS) ?: error("Gateway WebSocket did not open")
+
+    fun awaitRpc(method: String): JsonObject {
+        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
+        while (System.nanoTime() < deadline) {
+            rpcLog.firstOrNull { it.first == method }?.let { return it.second }
+            Thread.sleep(20)
+        }
+        error("Gateway RPC $method not observed; saw ${rpcLog.map { it.first }}")
+    }
+
+    fun requestsTo(path: String): Int = requestPaths.count { it.startsWith(path) }
+
+    fun rpcCount(method: String): Int = rpcLog.count { it.first == method }
+
+    fun shutdown() {
+        allSockets.forEach { socket -> runCatching { socket.close(1001, "teardown") } }
+        runCatching { server.shutdown() }
+    }
+}
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+    <application
+        android:icon="@mipmap/ic_launcher_candidate"
+        android:label="Hermes Candidate"
+        android:roundIcon="@mipmap/ic_launcher_candidate_round"
+        tools:replace="android:icon,android:label" />
+</manifest>
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/candidate_icon_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/candidate_icon_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="candidate_icon_background">#FFB300</color>
+</resources>
@@ -1 +1 @@
-Optional Relay recovery now stays in the right surfaces with clear status labels and immediate foreground retry. Session history again loads its full window through upstream-compatible paging. Streamed text selection, Voice microphone handoff, and the expanding Voice drawer are also more reliable.
+Create and save custom themes with full palette and shape controls. Shapes now apply consistently throughout the app. All Profiles sessions switch to their owning agent and survive language changes with the correct header, icon, and transcript. Gateway chats recover when a terminal frame is missed, persistent connection notifications relocalize without reconnecting, and Relay URLs normalize correctly from base, /ws, or /health forms.
@@ -1 +1 @@
-新增可在界面中漫游的 Petdex 浮动宠物、由已安装 Hermes 插件提供的安全原生页面，以及支持本地“Hey Hermes”的可选 Android 数字助理。本次更新还新增俄语，并改进语音恢复、路线切换、实时聊天稳定性和宠物移动。
+创建并保存带完整配色和形状控制的自定义主题。形状现在会一致应用到整个应用。通过“所有配置文件”选择会话时会切换到其所属智能体，并在更改语言后保留正确的标题、图标和对话内容。Gateway 漏掉终止帧时可恢复聊天，持久连接通知会随语言更新而无需重连，Relay 基础、/ws 与 /health 地址也会正确规范化。
@@ -48,6 +48,25 @@
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
+            <!-- User-mediated text handoff. The app opens a fresh Chat draft
+                 and fills the composer; it never sends from an external intent. -->
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/*" />
+            </intent-filter>
+            <!-- The loopback native-PKCE result page uses this fixed, tokenless
+                 link only to bring the installed flavor back to the foreground.
+                 MainActivity intentionally does not interpret the URI as an auth
+                 callback or navigation command. -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data
+                    android:scheme="${applicationId}"
+                    android:host="return" />
+            </intent-filter>
            <!-- Some Android OEM assistant pickers enumerate ACTION_ASSIST
                 activities in addition to VoiceInteractionService providers. -->
            <intent-filter>
@@ -101,8 +120,8 @@
        <!-- Protects user-started active turns automatically; the optional
             "Persistent connection" setting extends the same foreground
             protection to idle/background connectivity (and relay-paired
-             device features). In main so BOTH flavors ship it. specialUse
-             needs a Play Console foreground-service declaration at submission. -->
+             device features). In main so BOTH flavors ship it. Every Play
+             foreground-service type needs its matching App content declaration. -->
        <service
            android:name=".network.upstream.GatewayKeepAliveService"
            android:exported="false"
@@ -113,7 +132,8 @@
        </service>

        <!-- Experimental, explicitly user-started on-device wake-word listener.
-             Audio remains local and the service is never boot/restart started. -->
+             Audio remains local and the service is never boot/restart started.
+             The Play build's microphone type needs an App content declaration. -->
        <service
            android:name=".wake.WakeWordForegroundService"
            android:exported="false"
@@ -122,7 +142,8 @@

        <!-- User-started protection for voice capture from the system overlay.
             The service does not own AudioRecord; it keeps foreground-only
-             microphone app-ops available while Hermes is behind another app. -->
+             microphone app-ops available while Hermes is behind another app.
+             Include this use case in the Play microphone declaration. -->
        <service
            android:name=".voice.VoiceOverlayForegroundService"
            android:exported="false"
@@ -1,5 +1,258 @@
 {
 "versions": [
+  {
+   "version": "1.12.0",
+   "title": "Themes and identity that stay put",
+   "date": "2026-08-21",
+   "sections": [
+    {
+     "header": "Make the app yours",
+     "bullets": [
+      "Create and save custom themes with editable palette roles, Light or Dark ownership, shape, and a live chat preview.",
+      "Apply Soft, Balanced, or Sharp styling consistently across chat, settings, sheets, dialogs, terminal, voice, and Bridge."
+     ]
+    },
+    {
+     "header": "Keep the right agent active",
+     "bullets": [
+      "Selecting a session from All Profiles activates its owning agent with the correct header, avatar, transcript, draft, and routing.",
+      "Language changes preserve the exact active profile and session while relocalizing the persistent connection notification without reconnecting."
+     ]
+    },
+    {
+     "header": "Recover cleanly",
+     "bullets": [
+      "Settle and reconcile Gateway turns when a terminal completion frame is missed without resubmitting through fallback transport.",
+      "Normalize Relay base, /ws, and /health endpoint forms without producing duplicate route segments."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.11.0",
+   "title": "Access with clear boundaries",
+   "date": "2026-08-20",
+   "sections": [
+    {
+     "header": "Choose what Bridge can do",
+     "bullets": [
+      "Use read-only, read-and-confirm, or custom capability presets for the active connection in sideload builds.",
+      "Allow screen inspection and control for a bounded period or explicitly keep access unlimited."
+     ]
+    },
+    {
+     "header": "Recover without losing context",
+     "bullets": [
+      "Keep stored-session failures visible with route-aware details and clear retry or dismiss actions.",
+      "Insert newlines across more software keyboards and retain Stopped status when answer recovery is cancelled."
+     ]
+    },
+    {
+     "header": "Use less power while idle",
+     "bullets": [
+      "Pause invisible Sphere, waveform, and drawer animation loops when no motion is needed.",
+      "Attach capture surfaces only for requested frames and release audio or wake-lock resources at their lifecycle boundaries."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.10.0",
+   "title": "Chat that stays put",
+   "date": "2026-08-18",
+   "sections": [
+    {
+     "header": "Watch replies take shape",
+     "bullets": [
+      "Render paragraphs, lists, links, fenced code, and tables incrementally without replacing the message at completion.",
+      "Keep bottom-follow smooth while intentional scrollback remains exactly where you left it."
+     ]
+    },
+    {
+     "header": "Pick up where you left off",
+     "bullets": [
+      "Resume the visible Hermes session automatically after returning from another app.",
+      "Restore composer text, quote or edit context, and pending attachments in the correct conversation after an app restart."
+     ]
+    },
+    {
+     "header": "Review before sending",
+     "bullets": [
+      "Turn large pastes into compact text attachments while preserving compatible fallback delivery.",
+      "Use Return on the software keyboard while the dedicated composer button remains the Send action."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.9.1",
+   "title": "Profile identity that sticks",
+   "date": "2026-08-16",
+   "sections": [
+    {
+     "header": "Identity follows the right scope",
+     "bullets": [
+      "Change shared avatars from Android with automatic orientation, resizing, and safe conversion to the Hermes profile-asset contract.",
+      "Select upstream animated pets that follow the Hermes profile while phone-only animated icons, local avatar overrides, and Sphere skins stay local."
+     ]
+    },
+    {
+     "header": "Profile setup stays explicit",
+     "bullets": [
+      "Create profiles with clear shared, copied, or isolated authentication choices and see partial setup outcomes.",
+      "Named-profile sessions and profile drafts fail closed when Hermes cannot confirm their owner."
+     ]
+    },
+    {
+     "header": "Safer Gateway operations",
+     "bullets": [
+      "Attachments, rewinds, recovery, model-consent changes, and hosted sign-in now follow stricter upstream contracts.",
+      "Finite schedules, bounded reset evidence, and host resource warnings make consequential actions easier to review."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.9.0",
+   "title": "Better sessions, reactions, and voice",
+   "date": "2026-08-14",
+   "sections": [
+    {
+     "header": "Sessions keep their identity",
+     "bullets": [
+      "Browse one profile or all profiles, customize sorting and filters, and optionally group sessions by project, recency, status, or profile.",
+      "Cross-profile sessions hydrate, resume, and send with their owning agent without changing the global profile selection; New Chat in All Profiles uses the default profile."
+     ]
+    },
+    {
+     "header": "Conversation controls stay attached",
+     "bullets": [
+      "Reactions pin to durable rows on both user and assistant messages.",
+      "Vanilla Hermes voice stays on the authenticated Gateway instead of requiring the optional API fallback."
+     ]
+    },
+    {
+     "header": "Context without clutter",
+     "bullets": [
+      "Session rows show profile, project, branch, and pull-request context when Hermes supplies it, while the default view remains ungrouped.",
+      "The session drawer restores secondary actions in All Profiles and closes when you tap outside it."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.8.1",
+   "title": "Complete, reliable transcripts",
+   "date": "2026-08-09",
+   "sections": [
+    {
+     "header": "Keep long sessions complete",
+     "bullets": [
+      "Android pages explicitly through complete API-server and profile-scoped Dashboard history instead of silently stopping at Hermes' latest-500 default.",
+      "Sharing, retry, edit, and recovery retain stable transcript anchors while bounded safety limits keep unusually large reads controlled."
+     ]
+    },
+    {
+     "header": "Follow Gateway truth",
+     "bullets": [
+      "Authoritative submit rejections preserve the server's message without an unintended SSE fallback.",
+      "Gateway event envelopes and edit-and-regenerate truncation confirmation now follow current upstream contracts."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.8.0",
+   "title": "Conversations with more context",
+   "date": "2026-08-09",
+   "sections": [
+    {
+     "header": "Keep the whole turn together",
+     "bullets": [
+      "Quote, edit, search, and attach or reorder files without losing the active connection, profile, or session.",
+      "Share text from another Android app into a fresh Chat draft for review before sending."
+     ]
+    },
+    {
+     "header": "See the work without the clutter",
+     "bullets": [
+      "Live thinking settles into a compact Thought disclosure, while routine tool activity groups into concise runs.",
+      "Approvals, failures, generated media, file changes, risks, and delegated work remain clearly distinct."
+     ]
+    },
+    {
+     "header": "Switch agents, not identities",
+     "bullets": [
+      "The Profile Shelf switches agents from Chat while restoring each profile's last session.",
+      "Agent Passport model and reasoning controls remain scoped to the active session instead of rewriting server defaults."
+     ]
+    },
+    {
+     "header": "Make it yours",
+     "bullets": [
+      "Preview theme accents and shapes, Sphere skins, and pets in one Appearance workflow.",
+      "Message speech controls, pet touch targets, scrolling terrain, image rotation, and edge-to-edge settings layout are more reliable."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.7.1",
+   "title": "Safer, steadier conversations",
+   "date": "2026-08-08",
+   "sections": [
+    {
+     "header": "Chat stays with you",
+     "bullets": [
+      "Growing streamed replies stay visible while you are at the bottom, and intentional scrollback remains undisturbed.",
+      "Completed replies render Markdown immediately while live tool details remain expandable."
+     ]
+    },
+    {
+     "header": "Sessions keep their ownership",
+     "bullets": [
+      "Queued follow-ups retain their originating connection, profile, session, route, attachments, and voice context.",
+      "Session pins and archives persist across restarts, and duplicate model rows are reconciled before rendering."
+     ]
+    },
+    {
+     "header": "Safer controls and setup",
+     "bullets": [
+      "Approval cards require an explicit labeled decision, and Agent Passport safety controls are easier to read and dismiss.",
+      "Hosted Hermes setup completes through the official Dashboard system-browser sign-in flow."
+     ]
+    }
+   ]
+  },
+  {
+   "version": "1.7.0",
+   "title": "Smarter controls, steadier sessions",
+   "date": "2026-08-06",
+   "sections": [
+    {
+     "header": "Model controls fit the model",
+     "bullets": [
+      "Reasoning effort choices follow the selected provider and model when an exact supported list is available.",
+      "Unmodified Hermes and setups without the optional Relay capability overlay keep a fail-soft standard choice list."
+     ]
+    },
+    {
+     "header": "Active chats stay easy to follow",
+     "bullets": [
+      "The searchable session drawer shows which conversations are working or waiting for input.",
+      "Restored and completed chats remain bottom-pinned through late layout changes without overriding intentional scrollback.",
+      "Chat and Voice keep stable rows through recovery, and Focus Voice controls receive taps normally."
+     ]
+    },
+    {
+     "header": "Support stays private and useful",
+     "bullets": [
+      "Review locally redacted support information before choosing to copy, share, or open GitHub; nothing uploads automatically.",
+      "Connection diagnostics identify the failed operation and offer targeted guidance without exposing hosts or credentials."
+     ]
+    }
+   ]
+  },
  {
   "version": "1.6.1",
   "title": "Clearer recovery, steadier chat",
@@ -1,6 +1,8 @@
-v1.6.1 - Clearer recovery, steadier chat
+v1.12.0 - Themes and identity that stay put

-* Keep optional Relay recovery scoped to Relay surfaces with clear status labels.
-* Restore the 200-session drawer through upstream-compatible paging.
-* Stabilize streamed text selection and Voice microphone handoff.
-* Keep new-chat coaching clear of the expanding Voice drawer.
+* Create and save custom themes with full palette and shape controls.
+* Apply Soft, Balanced, or Sharp styling consistently throughout the app.
+* Switch All Profiles sessions with the correct owning agent, icon, and transcript.
+* Preserve the active profile and session through app-language changes.
+* Recover Gateway chats when a terminal completion frame is missed.
+* Accept Relay base, /ws, and /health endpoint forms without invalid routes.
@@ -7,6 +7,8 @@ import android.os.Build
 import coil3.ImageLoader
 import coil3.PlatformContext
 import coil3.SingletonImageLoader
+import coil3.gif.AnimatedImageDecoder
+import coil3.gif.GifDecoder
 import coil3.network.okhttp.OkHttpNetworkFetcherFactory
 import coil3.request.crossfade
 import com.hermesandroid.relay.bridge.UnattendedAccessManager
@@ -38,7 +40,14 @@ class HermesRelayApp : Application(), SingletonImageLoader.Factory {
     */
    override fun newImageLoader(context: PlatformContext): ImageLoader =
        ImageLoader.Builder(context)
-            .components { add(OkHttpNetworkFetcherFactory()) }
+            .components {
+                add(OkHttpNetworkFetcherFactory())
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                    add(AnimatedImageDecoder.Factory())
+                } else {
+                    add(GifDecoder.Factory())
+                }
+            }
            .crossfade(true)
            .build()

@@ -25,6 +25,8 @@ import com.hermesandroid.relay.notifications.TurnCompleteNotifier
 import com.hermesandroid.relay.notifications.InteractionRequestNotifier
 import com.hermesandroid.relay.ui.RelayApp
 import com.hermesandroid.relay.util.NavRouteRequest
+import com.hermesandroid.relay.util.SharedTextRequest
+import com.hermesandroid.relay.util.extractSharedText
 import com.hermesandroid.relay.viewmodel.ConnectionViewModel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.flow.collect
@@ -127,6 +129,7 @@ class MainActivity : AppCompatActivity() {
        // in RelayApp's NavRouteRequest collector — we just pump the request
        // into the SharedFlow here.
        consumeNavRouteIntent(intent)
+        consumeSharedTextIntent(intent)
        val consumedAssistantActivation =
            com.hermesandroid.relay.assistant.AssistantSessionProtocol.consumeActivation(
                this,
@@ -153,6 +156,7 @@ class MainActivity : AppCompatActivity() {
        // instead of onCreate. RelayApp's collector handles both cases.
        setIntent(intent)
        consumeNavRouteIntent(intent)
+        consumeSharedTextIntent(intent)
        com.hermesandroid.relay.assistant.AssistantSessionProtocol.consumeActivation(this, intent)
        // === END PHASE3-safety-rails-followup ===
    }
@@ -163,6 +167,15 @@ class MainActivity : AppCompatActivity() {
        NavRouteRequest.tryRequest(route)
    }

+    private fun consumeSharedTextIntent(intent: Intent?) {
+        val sharedText = extractSharedText(
+            action = intent?.action,
+            mimeType = intent?.type,
+            text = intent?.getCharSequenceExtra(Intent.EXTRA_TEXT),
+        ) ?: return
+        SharedTextRequest.tryRequest(sharedText)
+    }
+
    private fun configureAssistantWindow(intent: Intent?) {
        if (
            intent?.getBooleanExtra(
@@ -21,6 +21,8 @@ import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlinx.serialization.json.JsonNull
 import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.add
 import kotlinx.serialization.json.put

 /**
@@ -226,6 +228,7 @@ class BridgeStatusReporter(
        val destructiveVerbsCount = safetySnapshot?.destructiveVerbs?.size ?: 0
        val autoDisableMinutes = safetySnapshot?.autoDisableMinutes ?: 0
        val autoDisableAtMs = safetyManager?.autoDisableAtMs?.value
+        val capabilityPolicy = safetyManager?.activeCapabilityPolicy?.value

        val deviceName = Build.MODEL ?: "unknown"

@@ -281,6 +284,33 @@ class BridgeStatusReporter(
                        put("auto_disable_at_ms", autoDisableAtMs)
                    }
                })
+                put("capabilities", buildJsonObject {
+                    put("schema_version", capabilityPolicy?.schemaVersion ?: 1)
+                    put("permanent", buildJsonArray {
+                        capabilityPolicy?.permanentGrants
+                            ?.sortedBy { it.wireId }
+                            ?.forEach { add(it.wireId) }
+                    })
+                    put("timed", buildJsonObject {
+                        capabilityPolicy?.timedExpiriesMs
+                            ?.filterValues {
+                                it != com.hermesandroid.relay.bridge.BridgeCapabilityPolicy.NEVER_EXPIRES_AT_MS
+                            }
+                            ?.toSortedMap(compareBy { it.wireId })
+                            ?.forEach { (capability, expiry) ->
+                                put(capability.wireId, expiry)
+                            }
+                    })
+                    put("unlimited", buildJsonArray {
+                        capabilityPolicy?.timedExpiriesMs
+                            ?.filterValues {
+                                it == com.hermesandroid.relay.bridge.BridgeCapabilityPolicy.NEVER_EXPIRES_AT_MS
+                            }
+                            ?.keys
+                            ?.sortedBy { it.wireId }
+                            ?.forEach { add(it.wireId) }
+                    })
+                })

                // v0.4.1: unattended-access state so the agent can decide
                // upfront whether commands will reach apps with the screen
@@ -41,7 +41,7 @@ import kotlinx.coroutines.launch
 *
 * The Android system toggle in `Settings → Accessibility → Hermes-Relay` is
 * the hard switch — if it's off we never receive events. On top of that the
- * user can flip a soft master in Settings (`bridge_master_enabled`); when
+ * user can flip a soft master in Settings (`bridge_master_enabled_v2`); when
 * that's false we still run (Android requires it to stay connected) but we
 * refuse to execute commands. [isMasterEnabled] is a StateFlow the UI
 * observes and the command handler checks before dispatching actions.
@@ -61,7 +61,9 @@ class HermesAccessibilityService : AccessibilityService() {
        private const val TAG = "HermesA11yService"

        /** Master-enable DataStore key — read + toggled from Settings UI. */
-        val KEY_BRIDGE_MASTER_ENABLED = booleanPreferencesKey("bridge_master_enabled")
+        val KEY_BRIDGE_MASTER_ENABLED = booleanPreferencesKey("bridge_master_enabled_v2")
+        private val KEY_LEGACY_BRIDGE_MASTER_ENABLED =
+            booleanPreferencesKey("bridge_master_enabled")

        /**
         * Static reference to the live service instance, or null if the
@@ -92,6 +94,7 @@ class HermesAccessibilityService : AccessibilityService() {
        suspend fun setMasterEnabled(context: Context, enabled: Boolean) {
            context.applicationContext.relayDataStore.edit { prefs ->
                prefs[KEY_BRIDGE_MASTER_ENABLED] = enabled
+                prefs[KEY_LEGACY_BRIDGE_MASTER_ENABLED] = false
            }
        }
    }
@@ -15,6 +15,7 @@ import android.os.HandlerThread
 import android.util.DisplayMetrics
 import android.util.Log
 import android.view.WindowManager
+import com.hermesandroid.relay.data.RelayEndpointContract
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.sync.withLock
@@ -152,12 +153,14 @@ class ScreenCapture(
    // 13 and below but breaks the second /screenshot request on 14+.
    //
    // Fix: keep the VirtualDisplay + ImageReader + HandlerThread alive
-    // across captures, keyed by the MediaProjection instance. Rebuild only
-    // when the projection reference changes (fresh consent grant) or the
-    // dimensions change (orientation flip). The ImageReader's
-    // setOnImageAvailableListener drains the buffer continuously; each
-    // captureAndUpload() installs a one-shot [pendingCapture] callback
-    // that fires on the next frame.
+    // across captures, keyed by the MediaProjection instance. The reader
+    // surface is attached only while a request is waiting, then detached so
+    // SurfaceFlinger is not continuously mirroring into a drain-and-drop loop.
+    // Rebuild only when the projection reference changes (fresh consent
+    // grant). Orientation/size changes resize the existing VirtualDisplay and
+    // replace its detached ImageReader, preserving Android 14's single-create
+    // contract. Each captureAndUpload() installs a one-shot [pendingCapture]
+    // callback that fires on the next attached frame.
    //
    // Thread model:
    //  - `captureMutex` serializes concurrent captureAndUpload() calls
@@ -273,6 +276,7 @@ class ScreenCapture(
     */
    fun releaseCache() {
        synchronized(cacheLock) {
+            runCatching { cachedDisplay?.setSurface(null) }
            runCatching { cachedDisplay?.release() }
            runCatching { cachedReader?.close() }
            runCatching { cachedThread?.quitSafely() }
@@ -326,6 +330,7 @@ class ScreenCapture(
        }

        return try {
+            attachCaptureSurface()
            val timeoutMs = captureTimeoutMs()
            kotlinx.coroutines.withTimeout(timeoutMs) { deferred.await() }
        } catch (e: kotlinx.coroutines.TimeoutCancellationException) {
@@ -336,6 +341,24 @@ class ScreenCapture(
        } catch (t: Throwable) {
            pendingCaptureRef.compareAndSet(deferred, null)
            throw t
+        } finally {
+            detachCaptureSurface()
+        }
+    }
+
+    private fun attachCaptureSurface() {
+        synchronized(cacheLock) {
+            val display = cachedDisplay ?: throw IOException("capture display unavailable")
+            val surface = cachedReader?.surface ?: throw IOException("capture surface unavailable")
+            display.setSurface(surface)
+            Log.d(TAG, "screen capture surface attached for pending frame")
+        }
+    }
+
+    private fun detachCaptureSurface() {
+        synchronized(cacheLock) {
+            runCatching { cachedDisplay?.setSurface(null) }
+                .onFailure { Log.v(TAG, "screen capture surface detach failed: ${it.message}") }
        }
    }

@@ -350,11 +373,12 @@ class ScreenCapture(

    /**
     * Build (or reuse) the cached VirtualDisplay + ImageReader + HandlerThread
-     * for this projection. Rebuilds when:
+     * for this projection. Rebuilds the display when:
     *
     *  - The projection reference has changed (new consent grant landed)
-     *  - The captured dimensions don't match the current display (orientation
-     *    flipped, foldable opened/closed, display switched)
+     *
+     * Geometry changes resize that existing display and replace its detached
+     * consumer surface, as required for Android 14's one-display-per-token rule.
     *
     * Must be called while [captureMutex] is held so the cached fields
     * aren't racing another capture.
@@ -368,52 +392,41 @@ class ScreenCapture(
        synchronized(cacheLock) {
            val projectionChanged = cachedProjection !== projection
            val dimensionsChanged = width != cachedWidth || height != cachedHeight
-            if (!projectionChanged && !dimensionsChanged && cachedDisplay != null && cachedReader != null) {
+            val densityChanged = densityDpi != cachedDensity
+            if (!projectionChanged && !dimensionsChanged && !densityChanged &&
+                cachedDisplay != null && cachedReader != null
+            ) {
+                return
+            }
+
+            // Android 14 permits only one createVirtualDisplay() call per
+            // MediaProjection. Resize the existing display and replace only
+            // its detached consumer surface when the device geometry changes.
+            if (!projectionChanged && cachedDisplay != null && cachedThread != null) {
+                val display = cachedDisplay ?: return
+                val thread = cachedThread ?: return
+                val handler = cachedHandler ?: Handler(thread.looper)
+                display.setSurface(null)
+                runCatching { cachedReader?.close() }
+                display.resize(width, height, densityDpi)
+                cachedReader = createImageReader(width, height, handler)
+                cachedHandler = handler
+                cachedWidth = width
+                cachedHeight = height
+                cachedDensity = densityDpi
+                Log.i(TAG, "screen capture pipeline resized ${width}x$height dpi=$densityDpi")
                return
            }

            // Tear down any stale cache before building fresh.
+            runCatching { cachedDisplay?.setSurface(null) }
            runCatching { cachedDisplay?.release() }
            runCatching { cachedReader?.close() }
            runCatching { cachedThread?.quitSafely() }

            val thread = HandlerThread("HermesScreenCapture").apply { start() }
            val handler = Handler(thread.looper)
-            val reader = ImageReader.newInstance(
-                width, height, PixelFormat.RGBA_8888, MAX_IMAGES
-            )
-
-            // Persistent listener — fires on every frame the VirtualDisplay
-            // produces. If there's a pending capture request, we encode
-            // the frame and complete it; otherwise we just drain the image
-            // so the ImageReader buffer stays clear.
-            reader.setOnImageAvailableListener({ r ->
-                val waiter = pendingCaptureRef.get()
-                if (waiter == null || !waiter.isActive) {
-                    // Drain-and-drop — nobody's asking for a screenshot
-                    // right now but frames are still arriving.
-                    runCatching { r.acquireLatestImage() }.getOrNull()?.close()
-                    return@setOnImageAvailableListener
-                }
-                var image: Image? = null
-                try {
-                    image = r.acquireLatestImage()
-                        ?: return@setOnImageAvailableListener
-                    val png = imageToPngBytes(image, width, height)
-                    // Only complete the EXACT deferred we latched onto,
-                    // so a stale listener firing after supersession doesn't
-                    // resolve a new request.
-                    if (pendingCaptureRef.compareAndSet(waiter, null)) {
-                        waiter.complete(png)
-                    }
-                } catch (t: Throwable) {
-                    if (pendingCaptureRef.compareAndSet(waiter, null)) {
-                        waiter.completeExceptionally(t)
-                    }
-                } finally {
-                    runCatching { image?.close() }
-                }
-            }, handler)
+            val reader = createImageReader(width, height, handler)

            val display = try {
                projection.createVirtualDisplay(
@@ -422,7 +435,7 @@ class ScreenCapture(
                    height,
                    densityDpi,
                    DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
-                    reader.surface,
+                    null,
                    null,
                    handler,
                )
@@ -461,6 +474,38 @@ class ScreenCapture(
        }
    }

+    private fun createImageReader(width: Int, height: Int, handler: Handler): ImageReader {
+        val reader = ImageReader.newInstance(
+            width, height, PixelFormat.RGBA_8888, MAX_IMAGES,
+        )
+        // The listener receives frames only while captureFrame() has attached
+        // this reader's surface. The empty-waiter branch drains a frame already
+        // queued at the detach boundary.
+        reader.setOnImageAvailableListener({ source ->
+            val waiter = pendingCaptureRef.get()
+            if (waiter == null || !waiter.isActive) {
+                runCatching { source.acquireLatestImage() }.getOrNull()?.close()
+                return@setOnImageAvailableListener
+            }
+            var image: Image? = null
+            try {
+                image = source.acquireLatestImage()
+                    ?: return@setOnImageAvailableListener
+                val png = imageToPngBytes(image, width, height)
+                if (pendingCaptureRef.compareAndSet(waiter, null)) {
+                    waiter.complete(png)
+                }
+            } catch (t: Throwable) {
+                if (pendingCaptureRef.compareAndSet(waiter, null)) {
+                    waiter.completeExceptionally(t)
+                }
+            } finally {
+                runCatching { image?.close() }
+            }
+        }, handler)
+        return reader
+    }
+
    /**
     * Convert an [Image] from `ImageReader` into a PNG byte array. The
     * plane's `rowStride` may be wider than `width * 4` — we must crop
@@ -511,10 +556,8 @@ class ScreenCapture(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = RelayEndpointContract.parseOrNull(relayUrl)?.httpBaseUrl
+            ?: return Result.failure(IOException("Invalid relay URL"))

        val url = "$httpBase/media/upload"
        val body = MultipartBody.Builder()
@@ -70,7 +70,7 @@ import androidx.savedstate.SavedStateRegistryController
 import androidx.savedstate.SavedStateRegistryOwner
 import androidx.savedstate.setViewTreeSavedStateRegistryOwner
 import com.hermesandroid.relay.R
-import com.hermesandroid.relay.ui.theme.HermesRelayTheme
+import com.hermesandroid.relay.ui.theme.PersistedHermesRelayTheme
 import java.util.UUID
 import kotlin.math.max
 import kotlin.math.roundToInt
@@ -131,7 +131,7 @@ private class HermesVoiceInteractionSession(
        setViewTreeViewModelStoreOwner(viewOwner)
        setViewTreeSavedStateRegistryOwner(viewOwner)
        setContent {
-            HermesRelayTheme {
+            PersistedHermesRelayTheme {
                AssistantSessionSurface(
                    expanded = surfaceExpanded,
                    onExpandedChange = { surfaceExpanded = it },
@@ -52,18 +52,12 @@ import kotlin.math.max
 *
 * We configure [AudioRecord] with [MediaRecorder.AudioSource.VOICE_COMMUNICATION]
 * so the platform's voice-call AEC pipeline is in play, and additionally try
- * to attach [AcousticEchoCanceler] + [NoiseSuppressor] keyed to the ExoPlayer
- * audio session id so TTS audio is cancelled from the mic stream specifically.
+ * to attach [AcousticEchoCanceler] + [NoiseSuppressor] to the capture
+ * [AudioRecord] session. Android audio preprocessors belong to the capture
+ * path; a playback session is not a valid attachment target for AEC/NS.
 * Without AEC, the device's own speaker output would trip the VAD the moment
 * TTS started and we'd interrupt ourselves.
 *
- * The ExoPlayer audio session id is not stable at the moment we want to start
- * listening — Media3 allocates the underlying AudioTrack lazily on first
- * playback, and callers may hit [start] before that's happened (e.g. the very
- * first sentence of a turn). We poll [audioSessionIdProvider] for up to 1 s
- * before giving up on AEC and proceeding with the mic-hardware AEC alone.
- * See the `AEC_SESSION_POLL_*` constants below.
- *
 * ### Graceful degradation
 *
 * - `AudioRecord.getState() != STATE_INITIALIZED` → log WARN, emit nothing,
@@ -93,8 +87,8 @@ import kotlin.math.max
 class BargeInListener internal constructor(
    private val audioSource: AudioFrameSource,
    private val vadEngine: VadEngine,
-    private val audioSessionIdProvider: () -> Int,
    private val readerDispatcher: CoroutineDispatcher = Dispatchers.IO,
+    private val nowMsProvider: () -> Long = System::currentTimeMillis,
 ) {

    companion object {
@@ -108,12 +102,6 @@ class BargeInListener internal constructor(
         *  brief delay (GC pause, dispatcher contention). */
        private const val AUDIO_BUFFER_FRAMES = 4

-        /** ExoPlayer may return `0` for its audio session id until its
-         *  AudioTrack is first allocated (on playback start). Poll the
-         *  provider briefly before giving up on AEC and proceeding without. */
-        private const val AEC_SESSION_POLL_INTERVAL_MS = 50L
-        private const val AEC_SESSION_POLL_TIMEOUT_MS = 1_000L
-
        /**
         * Factory for the production path. Builds an [AudioRecordSource] from
         * a `Context` and wires it to the listener. The returned listener has
@@ -122,11 +110,9 @@ class BargeInListener internal constructor(
        fun create(
            context: Context,
            vadEngine: VadEngine,
-            audioSessionIdProvider: () -> Int,
        ): BargeInListener = BargeInListener(
            audioSource = AudioRecordSource(context.applicationContext),
            vadEngine = vadEngine,
-            audioSessionIdProvider = audioSessionIdProvider,
        )
    }

@@ -239,9 +225,8 @@ class BargeInListener internal constructor(
                    return@launch
                }
                Log.i(TAG, "Barge-in AudioRecord reader started")
-                // Do not block generation-phase listening while waiting for an
-                // AudioTrack session that does not exist until playback. The
-                // effects attach races harmlessly beside the reader.
+                // Effects attach beside the reader so capture can begin even
+                // on devices that reject or omit the optional preprocessors.
                effectsJob = launch { maybeAttachEffects() }

                while (isActive) {
@@ -282,7 +267,7 @@ class BargeInListener internal constructor(
                    val gated = rmsGate.observe(
                        frame = frameBuffer,
                        rawSpeech = result.probability > 0f,
-                        nowMs = System.currentTimeMillis(),
+                        nowMs = nowMsProvider(),
                        playbackGraceMs = playbackGraceMs,
                        confirmedSpeech = result.isSpeech,
                        playbackActiveOverride = playbackActiveProvider?.invoke(),
@@ -368,14 +353,12 @@ class BargeInListener internal constructor(
    }

    private suspend fun maybeAttachEffects() {
-        val sessionId = awaitNonZeroSessionId()
+        val sessionId = audioSource.audioSessionId
        if (sessionId == 0) {
            Log.i(
                TAG,
-                "AEC not attached — ExoPlayer audio session id was still 0 " +
-                    "after ${AEC_SESSION_POLL_TIMEOUT_MS}ms poll; continuing " +
-                    "without effects (mic-hardware AEC from VOICE_COMMUNICATION " +
-                    "still in play)",
+                "AEC not attached — AudioRecord capture session id is 0; " +
+                    "continuing without optional effects",
            )
            return
        }
@@ -411,20 +394,6 @@ class BargeInListener internal constructor(
        }
    }

-    private suspend fun awaitNonZeroSessionId(): Int {
-        val immediate = audioSessionIdProvider()
-        if (immediate != 0) return immediate
-
-        var waited = 0L
-        while (waited < AEC_SESSION_POLL_TIMEOUT_MS) {
-            delay(AEC_SESSION_POLL_INTERVAL_MS)
-            waited += AEC_SESSION_POLL_INTERVAL_MS
-            val id = audioSessionIdProvider()
-            if (id != 0) return id
-        }
-        return 0
-    }
-
    private fun releaseEffects() {
        aec?.let {
            runCatching { it.enabled = false }
@@ -445,6 +414,9 @@ class BargeInListener internal constructor(
     * reader coroutine.
     */
    internal interface AudioFrameSource {
+        /** Capture-session id used by Android audio preprocessors. */
+        val audioSessionId: Int
+
        /**
         * Allocate underlying native resources. Returns true on success.
         * Returning false from here short-circuits the listener without any
@@ -481,6 +453,9 @@ class BargeInListener internal constructor(
    private class AudioRecordSource(context: Context) : AudioFrameSource {
        private var record: AudioRecord? = null

+        override val audioSessionId: Int
+            get() = record?.audioSessionId ?: 0
+
        @SuppressLint("MissingPermission")
        override fun initialize(): Boolean {
            val sampleRate = 16_000
@@ -1,19 +1,28 @@
 package com.hermesandroid.relay.auth

 import android.content.Context
+import android.provider.Settings
 import android.util.Log
 import com.hermesandroid.relay.data.Connection
 import com.hermesandroid.relay.data.EndpointCandidate
+import com.hermesandroid.relay.data.BrokerEndpoint
+import com.hermesandroid.relay.data.hasHermesReach
+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.isSafeProfileUiMeta
 import com.hermesandroid.relay.network.relay.ChannelMultiplexer
 import com.hermesandroid.relay.network.relay.models.Envelope
+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.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -210,21 +219,47 @@ class AuthManager(
            tokenStoreKey: String,
            secrets: ConnectionAuthSecrets,
        ) {
+            val normalized = normalizeStoredSecrets(secrets)
            withContext(Dispatchers.IO) {
                val store = tokenStoreForBackup(context, tokenStoreKey)
-                writeOrRemove(store, KEY_SESSION_TOKEN, secrets.sessionToken)
-                writeOrRemove(store, KEY_REFRESH_TOKEN, secrets.refreshToken)
-                writeOrRemove(store, KEY_DEVICE_ID, secrets.deviceId)
-                writeOrRemove(store, KEY_API_KEY, secrets.apiKey)
+                writeOrRemove(store, KEY_SESSION_TOKEN, normalized.sessionToken)
+                writeOrRemove(store, KEY_REFRESH_TOKEN, normalized.refreshToken)
+                writeOrRemove(store, KEY_DEVICE_ID, normalized.deviceId)
+                writeOrRemove(store, KEY_API_KEY, normalized.apiKey)
                writeOrRemove(
                    store,
                    KEY_PROFILE_API_KEYS,
-                    secrets.profileApiKeys.takeIf { it.isNotEmpty() }?.let(::encodeProfileApiKeys),
+                    normalized.profileApiKeys
+                        .takeIf { it.isNotEmpty() }
+                        ?.let(::encodeProfileApiKeys),
                )
-                writeOrRemove(store, KEY_PAIRED_META, secrets.pairedSessionMetaJson)
+                writeOrRemove(store, KEY_PAIRED_META, normalized.pairedSessionMetaJson)
            }
        }

+        /** Validate a backup fully before any existing encrypted state is replaced. */
+        fun validateStoredSecrets(secrets: ConnectionAuthSecrets) {
+            normalizeStoredSecrets(secrets)
+        }
+
+        private fun normalizeStoredSecrets(secrets: ConnectionAuthSecrets): ConnectionAuthSecrets =
+            secrets.copy(
+                sessionToken = secrets.sessionToken?.let {
+                    normalizeCredentialForHeader(it, "Relay session credential")
+                }?.takeIf { it.isNotEmpty() },
+                refreshToken = secrets.refreshToken?.let {
+                    normalizeCredentialForHeader(it, "Relay refresh credential")
+                }?.takeIf { it.isNotEmpty() },
+                apiKey = secrets.apiKey?.let {
+                    normalizeCredentialForHeader(it, "API credential")
+                }?.takeIf { it.isNotEmpty() },
+                profileApiKeys = secrets.profileApiKeys
+                    .mapValues { (_, value) ->
+                        normalizeCredentialForHeader(value, "Profile API credential")
+                    }
+                    .filterValues { it.isNotEmpty() },
+            )
+
        private fun tokenStoreForBackup(
            context: Context,
            tokenStoreKey: String,
@@ -280,6 +315,7 @@ class AuthManager(
                    ?: return@mapNotNull null
                val model = obj["model"]?.jsonPrimitive?.contentOrNull
                    ?: "unknown"
+                val provider = obj["provider"]?.jsonPrimitive?.contentOrNull.orEmpty()
                val description = obj["description"]?.jsonPrimitive?.contentOrNull
                    ?: ""
                val systemMessage = obj["system_message"]?.jsonPrimitive?.contentOrNull
@@ -299,9 +335,15 @@ class AuthManager(
                    ?.jsonPrimitive?.intOrNull
                val apiServerKeyPresent = obj["api_server_key_present"]
                    ?.jsonPrimitive?.booleanOrNull ?: false
+                val isDefault = obj["is_default"]?.jsonPrimitive?.booleanOrNull ?: false
+                val hasAvatar = obj["has_avatar"]?.jsonPrimitive?.booleanOrNull ?: false
+                val uiMeta = (obj["ui_meta"] as? JsonObject)
+                    ?.takeIf(::isSafeProfileUiMeta)
+                    ?: JsonObject(emptyMap())
                Profile(
                    name = name,
                    model = model,
+                    provider = provider,
                    description = description,
                    systemMessage = systemMessage,
                    gatewayRunning = gatewayRunning,
@@ -312,6 +354,9 @@ class AuthManager(
                    apiServerHost = apiServerHost,
                    apiServerPort = apiServerPort,
                    apiServerKeyPresent = apiServerKeyPresent,
+                    isDefault = isDefault,
+                    hasAvatar = hasAvatar,
+                    uiMeta = uiMeta,
                )
            }
        }
@@ -557,6 +602,12 @@ class AuthManager(
     * Either way, we leave the previously-persisted list untouched.
     */
    private var pendingEndpoints: List<EndpointCandidate>? = null
+    private var activeEndpointProvider: () -> EndpointCandidate? = { null }
+
+    /** Bind auth.ok route credentials to the transport that actually carried them. */
+    fun setActiveEndpointProvider(provider: () -> EndpointCandidate?) {
+        activeEndpointProvider = provider
+    }

    /**
     * Server-advertised agent profiles from the `auth.ok` payload's
@@ -584,6 +635,8 @@ class AuthManager(
     */
    private val _apiKeyPresent = MutableStateFlow(false)
    val apiKeyPresent: StateFlow<Boolean> = _apiKeyPresent.asStateFlow()
+    private val _apiKeyError = MutableStateFlow<String?>(null)
+    val apiKeyError: StateFlow<String?> = _apiKeyError.asStateFlow()

    init {
        // Register as system channel handler for auth messages
@@ -603,19 +656,40 @@ class AuthManager(
                val s = store()
                val existingToken = s.getString(KEY_SESSION_TOKEN)
                if (existingToken != null) {
-                    _authState.value = AuthState.Paired(existingToken)
-                    _currentPairedSession.value = loadStoredMetadata(existingToken)
-                    Log.i(
-                        TAG,
-                        "init: hydrated existing session_token=${existingToken.take(8)}… " +
-                            "→ authState=Paired (stale-at-startup unless this is a real continuous session)"
-                    )
+                    runCatching {
+                        normalizeCredentialForHeader(existingToken, "Relay session credential")
+                            .also { require(it.isNotEmpty()) }
+                    }.onSuccess { normalized ->
+                        if (normalized != existingToken) s.putString(KEY_SESSION_TOKEN, normalized)
+                        _authState.value = AuthState.Paired(normalized)
+                        _currentPairedSession.value = loadStoredMetadata(normalized)
+                        Log.i(TAG, "init: hydrated existing session credential")
+                    }.onFailure {
+                        _authState.value = AuthState.Failed(
+                            "Saved Relay credential is malformed. Re-pair this connection.",
+                        )
+                        Log.w(TAG, "init: rejected malformed saved Relay credential")
+                    }
                } else {
                    Log.i(TAG, "init: no stored session_token → authState stays Unpaired")
                }
                // Converge the plain api-key-present hint with the decrypted
                // truth (also repairs a hint that predates legacy migration).
-                recordApiKeyHint(!s.getString(KEY_API_KEY).isNullOrBlank())
+                val storedApiKey = s.getString(KEY_API_KEY)
+                if (storedApiKey != null) {
+                    runCatching {
+                        normalizeCredentialForHeader(storedApiKey, "API credential")
+                            .also { require(it.isNotEmpty()) }
+                    }.onSuccess { normalized ->
+                        if (normalized != storedApiKey) s.putString(KEY_API_KEY, normalized)
+                        _apiKeyError.value = null
+                    }.onFailure {
+                        _apiKeyError.value =
+                            "Saved API credential is malformed. Replace or clear it."
+                        Log.w(TAG, "init: rejected malformed saved API credential")
+                    }
+                }
+                recordApiKeyHint(!storedApiKey.isNullOrBlank())
            }
        }
    }
@@ -631,7 +705,7 @@ class AuthManager(
        val now = System.currentTimeMillis() / 1000L
        val defaults = PairedSession(
            token = token,
-            deviceName = android.os.Build.MODEL,
+            deviceName = relayDeviceName(),
            expiresAt = null,
            grants = emptyMap(),
            transportHint = null,
@@ -651,7 +725,7 @@ class AuthManager(
            val transportHint = obj["transport_hint"]?.jsonPrimitive?.contentOrNull
            val firstSeen = obj["first_seen"]?.jsonPrimitive?.longOrNull ?: now
            val deviceName = obj["device_name"]?.jsonPrimitive?.contentOrNull
-                ?: android.os.Build.MODEL
+                ?: relayDeviceName()

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

+    private fun JsonObjectBuilder.putRelayDeviceIdentity() {
+        val model = android.os.Build.MODEL.orEmpty().ifBlank { "Android device" }
+        val deviceName = relayDeviceName()
+        put("device_name", deviceName)
+        put("device_hostname", deviceName)
+        put("device_model", model)
+        put("device_platform", "Android ${android.os.Build.VERSION.RELEASE}")
+        put("client_surface", "android")
+        put("device_form_factor", "phone")
+    }
+
+    private fun relayDeviceName(): String {
+        val configured = runCatching {
+            Settings.Global.getString(context.contentResolver, "device_name")
+        }.getOrNull()?.trim().orEmpty()
+        return configured.ifBlank {
+            android.os.Build.MODEL.orEmpty().ifBlank { "Android device" }
+        }
+    }
+
    /**
     * Send auth envelope when connection is established.
     *
@@ -772,10 +866,20 @@ class AuthManager(
            val deviceId = getDeviceId()
            val payload = when (currentState) {
                is AuthState.Paired -> {
-                    val refreshToken = store().getString(KEY_REFRESH_TOKEN)
+                    val refreshToken = store().getString(KEY_REFRESH_TOKEN)?.let { raw ->
+                        runCatching {
+                            normalizeCredentialForHeader(raw, "Relay refresh credential")
+                        }.getOrElse {
+                            _authState.value = AuthState.Failed(
+                                "Saved Relay credential is malformed. Re-pair this connection.",
+                            )
+                            Log.w(TAG, "authenticate: rejected malformed refresh credential")
+                            return@launch
+                        }
+                    }
                    Log.i(
                        TAG,
-                        "authenticate: sending session_token (state=Paired, token=${currentState.token.take(8)}…, " +
+                        "authenticate: sending saved session credential (state=Paired, " +
                            "refresh=${!refreshToken.isNullOrBlank()})"
                    )
                    buildJsonObject {
@@ -784,7 +888,7 @@ class AuthManager(
                            put("refresh_token", refreshToken)
                        }
                        put("device_id", deviceId)
-                        put("device_name", android.os.Build.MODEL)
+                        putRelayDeviceIdentity()
                        putRelayClientSupports()
                    }
                }
@@ -800,7 +904,7 @@ class AuthManager(
                    buildJsonObject {
                        put("pairing_code", codeToSend)
                        put("device_id", deviceId)
-                        put("device_name", android.os.Build.MODEL)
+                        putRelayDeviceIdentity()
                        putRelayClientSupports()
                        pendingTtlSeconds?.let { put("ttl_seconds", it) }
                        pendingGrants?.let { grants ->
@@ -963,10 +1067,26 @@ class AuthManager(

    // --- API Key storage (for direct Hermes API Server auth) ---

-    suspend fun getApiKey(): String? = store().getString(KEY_API_KEY)
+    suspend fun getApiKey(): String? {
+        val raw = store().getString(KEY_API_KEY) ?: return null
+        return runCatching {
+            normalizeCredentialForHeader(raw, "API credential")
+                .takeIf { it.isNotEmpty() }
+        }.onSuccess {
+            _apiKeyError.value = null
+        }.onFailure {
+            _apiKeyError.value = "Saved API credential is malformed. Replace or clear it."
+            Log.w(TAG, "getApiKey: rejected malformed saved API credential")
+        }.getOrNull()
+    }

    suspend fun setApiKey(key: String) {
-        val trimmed = key.trim()
+        val trimmed = runCatching {
+            normalizeCredentialForHeader(key, "API credential")
+        }.getOrElse {
+            _apiKeyError.value = "API credentials must be a single line."
+            throw it
+        }
        val s = store()
        if (trimmed.isBlank()) {
            s.remove(KEY_API_KEY)
@@ -975,11 +1095,13 @@ class AuthManager(
            s.putString(KEY_API_KEY, trimmed)
            recordApiKeyHint(true)
        }
+        _apiKeyError.value = null
    }

    suspend fun clearApiKey() {
        store().remove(KEY_API_KEY)
        recordApiKeyHint(false)
+        _apiKeyError.value = null
    }

    suspend fun getProfileApiKey(profileName: String): String? =
@@ -991,7 +1113,7 @@ class AuthManager(
        profileApiKeysMutex.withLock {
            val tokenStore = store()
            val keys = decodeProfileApiKeys(tokenStore.getString(KEY_PROFILE_API_KEYS)).toMutableMap()
-            val normalizedKey = key.trim()
+            val normalizedKey = normalizeCredentialForHeader(key, "Profile API credential")
            if (normalizedKey.isBlank()) keys.remove(normalizedProfile)
            else keys[normalizedProfile] = normalizedKey
            if (keys.isEmpty()) tokenStore.remove(KEY_PROFILE_API_KEYS)
@@ -1010,7 +1132,10 @@ class AuthManager(
        scope.launch {
            try {
                val payload = envelope.payload
-                val token = payload["session_token"]?.jsonPrimitive?.contentOrNull
+                val token = payload["session_token"]?.jsonPrimitive?.contentOrNull?.let { raw ->
+                    normalizeCredentialForHeader(raw, "Relay session credential")
+                        .takeIf { it.isNotEmpty() }
+                }

                if (token == null) {
                    Log.w(
@@ -1021,18 +1146,20 @@ class AuthManager(
                }

                if (token != null) {
+                    applyBrokerRouteCredential(payload)
                    val s = store()
                    s.putString(KEY_SESSION_TOKEN, token)
                    val refreshToken = payload["refresh_token"]
                        ?.jsonPrimitive
                        ?.contentOrNull
-                        ?.takeIf { it.isNotBlank() }
+                        ?.let { normalizeCredentialForHeader(it, "Relay refresh credential") }
+                        ?.takeIf { it.isNotEmpty() }
                    if (refreshToken != null) {
                        s.putString(KEY_REFRESH_TOKEN, refreshToken)
                        Log.i(TAG, "handleAuthOk: stored rotated refresh token")
                    }
                    _authState.value = AuthState.Paired(token)
-                    Log.i(TAG, "handleAuthOk: Paired(token=${token.take(8)}…)")
+                    Log.i(TAG, "handleAuthOk: paired with server-issued session credential")
                    // Per-connection signal for socket-scoped consumers (e.g.
                    // re-sending proactive.subscribe). Fires on every auth.ok.
                    _authOkEvents.tryEmit(Unit)
@@ -1066,7 +1193,7 @@ class AuthManager(

                    val paired = PairedSession(
                        token = token,
-                        deviceName = android.os.Build.MODEL,
+                        deviceName = relayDeviceName(),
                        expiresAt = expiresAt,
                        grants = grantsMap,
                        transportHint = transportHint,
@@ -1125,10 +1252,56 @@ class AuthManager(
                // handler is exactly why the broken `_sessionLabels` parser
                // (stringifying object entries) sat undetected for so long.
                Log.w(TAG, "auth.ok parse failed: ${e.message}", e)
+                if (e is InvalidCredentialException) {
+                    _authState.value = AuthState.Failed(
+                        "Relay returned a malformed credential. Re-pair this connection.",
+                    )
+                }
            }
        }
    }

+    private suspend fun applyBrokerRouteCredential(payload: JsonObject) {
+        val active = activeEndpointProvider()?.takeIf { it.hasHermesReach() } ?: return
+        val current = active.broker ?: return
+        // Fresh pairing is scoped by pendingEndpoints; reconnect rotation is
+        // accepted only by this connection-scoped AuthManager's live session.
+        if (pendingEndpoints == null && _authState.value !is AuthState.Paired) return
+        val credential = payload["route_credential"] as? JsonObject ?: return
+        if (credential["kind"]?.jsonPrimitive?.contentOrNull != "broker_route") return
+        val brokerUrl = credential["broker_url"]?.jsonPrimitive?.contentOrNull ?: return
+        val hostId = credential["host_id"]?.jsonPrimitive?.contentOrNull ?: return
+        if (!sameBrokerAuthority(brokerUrl, current.url) || hostId != current.hostId) {
+            Log.w(TAG, "Ignoring broker route credential that does not match the active paired route")
+            return
+        }
+        val replacement = BrokerEndpoint(
+            url = current.url,
+            protocolVersion = current.protocolVersion,
+            hostId = current.hostId,
+            credentialKind = "route",
+            token = credential["token"]?.jsonPrimitive?.contentOrNull?.let {
+                runCatching {
+                    normalizeCredentialForHeader(it, "Hermes Reach credential")
+                }.getOrElse {
+                    Log.w(TAG, "Ignoring malformed Hermes Reach route credential")
+                    return
+                }
+            } ?: return,
+            expiresAt = credential["expires_at"]?.jsonPrimitive?.longOrNull,
+        )
+        val validated = active.copy(broker = replacement).takeIf { it.hasHermesReach() } ?: return
+        val deviceId = getDeviceId()
+        val source = pendingEndpoints
+            ?: PairingPreferences.getDeviceEndpoints(context, deviceId).first()
+        val updated = replaceHermesReachCredential(source, current, validated)
+        if (updated == source) return
+        if (pendingEndpoints != null) pendingEndpoints = updated
+        else PairingPreferences.setDeviceEndpoints(context, deviceId, updated)
+        Log.i(TAG, "Accepted a durable Hermes Reach route credential for the active paired route")
+    }
+
+
    private fun handleAuthFail(envelope: Envelope) {
        try {
            val rawReason = envelope.payload["reason"]?.jsonPrimitive?.contentOrNull
@@ -90,12 +90,28 @@ class CertPinStore(private val context: Context) {
        if (pins.isEmpty()) return CertificatePinner.DEFAULT
        val builder = CertificatePinner.Builder()
        for ((hostPort, pin) in pins) {
-            val host = hostPort.substringBefore(':')
+            val host = hostPort.substringBeforeLast(':')
            builder.add(host, pin)
        }
        return builder.build()
    }

+    /**
+     * Build a pinner for one exact URL authority. CertificatePinner keys by
+     * hostname only, so adding every stored host:port entry to one client
+     * accidentally lets a pin learned on one port govern another port.
+     */
+    fun buildPinnerSnapshotFor(url: String): CertificatePinner {
+        val hostPort = hostPortFromUrl(url) ?: return CertificatePinner.DEFAULT
+        val pin = getPinsBlocking()[hostPort] ?: return CertificatePinner.DEFAULT
+        val host = runCatching { URI(url.trim()).host }.getOrNull()
+            ?.takeIf { it.isNotBlank() }
+            ?: return CertificatePinner.DEFAULT
+        return CertificatePinner.Builder()
+            .add(host, pin)
+            .build()
+    }
+
    /**
     * Record a pin for a host. Called from the WebSocket listener's `onOpen`
     * when we have a successful connection and can read the peer certs from
@@ -74,6 +74,14 @@ data class PairedDeviceInfo(
    val deviceName: String = "",
    @SerialName("device_id")
    val deviceId: String = "",
+    @SerialName("device_model")
+    val deviceModel: String = "",
+    @SerialName("device_platform")
+    val devicePlatform: String = "",
+    @SerialName("client_surface")
+    val clientSurface: String = "",
+    @SerialName("device_form_factor")
+    val deviceFormFactor: String = "",
    @SerialName("created_at")
    val createdAt: Double? = null,
    @SerialName("last_seen")
@@ -15,25 +15,22 @@ import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.ContextCompat
 import com.hermesandroid.relay.MainActivity
 import com.hermesandroid.relay.R
-import com.hermesandroid.relay.accessibility.HermesAccessibilityService

 /**
 * Phase 3 — safety-rails `bridge-safety-rails`
 *
- * Canonical "turn the bridge off after idle" unit of work. Not a real
+ * Canonical timed-screen-expiry notification unit. Not a real
 * `androidx.work.CoroutineWorker` — the project intentionally does not
 * depend on androidx.work — but its shape mirrors one exactly: a single
 * suspend [run] method that performs the work and returns.
 *
 * Why this pattern instead of dropping a WorkManager dep:
- *  - Auto-disable is a pure in-memory decision: the toggle lives in our
- *    own DataStore, no inter-process scheduling is required.
+ *  - Capability expiry is persisted as absolute wall-clock timestamps;
+ *    the in-process job exists only to prune promptly and notify.
 *  - Android's AlarmManager / WorkManager are needed when the work must
- *    survive process death. For bridge, process death already implies
- *    the service is disconnected and the master toggle re-evaluates
- *    fresh on the next launch. So a coroutine-owned `delay` does it.
- *  - Every command reschedules the timer, so the idle window is always
- *    reset against wall clock. No drift concerns.
+ *    survive process death. Authorization itself does survive because the
+ *    command boundary compares persisted expiry with the current clock.
+ *  - Only timed screen inspection/control commands reset the timer.
 *
 * When WorkManager is added later (say, if notif-listener needs background-posted
 * notifications on a schedule), this file is a natural upgrade point:
@@ -51,17 +48,10 @@ class AutoDisableWorker(private val context: Context) {
    }

    /**
-     * Execute the auto-disable: flip the master toggle off and post a
-     * one-shot "bridge paused" notification. Idempotent — safe to call
-     * twice (the second call just re-writes the same DataStore value
-     * and overrides the existing notification).
+     * Post a one-shot notification after timed screen authority is revoked.
+     * Idempotent — a repeated call replaces the existing notification.
     */
    suspend fun run() {
-        try {
-            HermesAccessibilityService.setMasterEnabled(context, false)
-        } catch (t: Throwable) {
-            Log.w(TAG, "run: failed to flip master toggle", t)
-        }
        postNotification()
    }

@@ -92,8 +82,7 @@ class AutoDisableWorker(private val context: Context) {
            .setContentTitle(context.getString(R.string.bridge_notification_auto_disabled_title))
            .setContentText(context.getString(R.string.bridge_notification_auto_disabled_body))
            .setStyle(NotificationCompat.BigTextStyle().bigText(
-                "Hermes bridge was idle for too long, so device control has been turned off " +
-                    "automatically. Open the Bridge tab to turn it back on if you still need it."
+                context.getString(R.string.bridge_notification_auto_disabled_body)
            ))
            .setContentIntent(tapPending)
            .setAutoCancel(true)
@@ -115,7 +104,7 @@ class AutoDisableWorker(private val context: Context) {
            CHANNEL_NAME,
            NotificationManager.IMPORTANCE_DEFAULT,
        ).apply {
-            description = "Fires once when the bridge auto-disables after being idle."
+            description = "Fires once when timed Bridge screen access expires after idle."
            setShowBadge(false)
        }
        nm.createNotificationChannel(channel)
@@ -0,0 +1,113 @@
+package com.hermesandroid.relay.bridge
+
+import kotlinx.serialization.Serializable
+
+/** Stable, auditable authority groups for every phone-side Bridge command. */
+@Serializable
+enum class BridgeCapability(val wireId: String, val timed: Boolean) {
+    DEVICE_INFO("device_info", false),
+    CONTACTS_READ("contacts_read", false),
+    LOCATION_READ("location_read", false),
+    CLIPBOARD_READ("clipboard_read", false),
+    CLIPBOARD_WRITE("clipboard_write", false),
+    MEDIA_CONTROL("media_control", false),
+    COMMUNICATIONS("communications", false),
+    OUTBOUND_SHARING("outbound_sharing", false),
+    SCREEN_INSPECTION("screen_inspection", true),
+    SCREEN_CONTROL("screen_control", true),
+}
+
+enum class BridgeCapabilityGrant { EXEMPT, PERMANENT, TIMED }
+
+data class BridgeCommandAuthority(
+    val capability: BridgeCapability? = null,
+    val grant: BridgeCapabilityGrant,
+)
+
+/**
+ * Closed command registry. Authorization is resolved from both path and HTTP
+ * method so method-split commands such as clipboard read/write cannot share a
+ * grant accidentally. Unknown paths and method combinations return null and
+ * must be denied by the command boundary.
+ *
+ * Composite Python tools (android_navigate/android_macro) do not get a broad
+ * grant: every primitive route they dispatch is checked here independently.
+ */
+object BridgeCommandRegistry {
+    private data class Key(val method: String, val path: String)
+
+    private fun permanent(capability: BridgeCapability) =
+        BridgeCommandAuthority(capability, BridgeCapabilityGrant.PERMANENT)
+
+    private fun timed(capability: BridgeCapability) =
+        BridgeCommandAuthority(capability, BridgeCapabilityGrant.TIMED)
+
+    private val exempt = BridgeCommandAuthority(grant = BridgeCapabilityGrant.EXEMPT)
+
+    private val routes: Map<Key, BridgeCommandAuthority> = buildMap {
+        fun route(method: String, path: String, authority: BridgeCommandAuthority) {
+            put(Key(method, path), authority)
+        }
+
+        route("GET", "/ping", exempt)
+        route("POST", "/setup", exempt)
+        route("POST", "/wait", exempt)
+
+        route("GET", "/current_app", permanent(BridgeCapability.DEVICE_INFO))
+        route("GET", "/get_apps", permanent(BridgeCapability.DEVICE_INFO))
+        route("GET", "/apps", permanent(BridgeCapability.DEVICE_INFO))
+        route("POST", "/search_contacts", permanent(BridgeCapability.CONTACTS_READ))
+        route("GET", "/location", permanent(BridgeCapability.LOCATION_READ))
+        route("GET", "/clipboard", permanent(BridgeCapability.CLIPBOARD_READ))
+        route("POST", "/clipboard", permanent(BridgeCapability.CLIPBOARD_WRITE))
+        route("POST", "/media", permanent(BridgeCapability.MEDIA_CONTROL))
+        route("POST", "/call", permanent(BridgeCapability.COMMUNICATIONS))
+        route("POST", "/send_sms", permanent(BridgeCapability.COMMUNICATIONS))
+        route("POST", "/share_media", permanent(BridgeCapability.OUTBOUND_SHARING))
+        route("POST", "/send_mms", permanent(BridgeCapability.OUTBOUND_SHARING))
+
+        listOf("/screen", "/screenshot", "/screen_hash", "/events").forEach {
+            route("GET", it, timed(BridgeCapability.SCREEN_INSPECTION))
+        }
+        listOf("/find_nodes", "/describe_node", "/diff_screen", "/events/stream").forEach {
+            route("POST", it, timed(BridgeCapability.SCREEN_INSPECTION))
+        }
+
+        listOf(
+            "/tap", "/tap_text", "/long_press", "/type", "/swipe", "/drag",
+            "/scroll", "/press_key", "/open_app", "/return_to_hermes",
+            "/send_intent", "/broadcast",
+        ).forEach { route("POST", it, timed(BridgeCapability.SCREEN_CONTROL)) }
+    }
+
+    fun resolve(path: String, method: String): BridgeCommandAuthority? =
+        routes[Key(method.trim().uppercase(), path.trim())]
+
+    fun registeredRoutes(): Set<Pair<String, String>> =
+        routes.keys.mapTo(linkedSetOf()) { it.method to it.path }
+}
+
+@Serializable
+data class BridgeCapabilityPolicy(
+    val schemaVersion: Int = CURRENT_SCHEMA_VERSION,
+    val permanentGrants: Set<BridgeCapability> = emptySet(),
+    val timedExpiriesMs: Map<BridgeCapability, Long> = emptyMap(),
+) {
+    companion object {
+        const val CURRENT_SCHEMA_VERSION = 1
+        /** Explicit sentinel for a user-selected "Until turned off" lease. */
+        const val NEVER_EXPIRES_AT_MS: Long = Long.MAX_VALUE
+    }
+
+    fun allows(capability: BridgeCapability, nowMs: Long): Boolean =
+        if (capability.timed) {
+            (timedExpiriesMs[capability] ?: 0L) > nowMs
+        } else {
+            capability in permanentGrants
+        }
+
+    fun expiryFor(capability: BridgeCapability): Long? = timedExpiriesMs[capability]
+
+    fun isUnlimited(capability: BridgeCapability): Boolean =
+        timedExpiriesMs[capability] == NEVER_EXPIRES_AT_MS
+}
@@ -4,6 +4,7 @@ import android.content.Context
 import android.util.Log
 import com.hermesandroid.relay.data.BridgeSafetyPreferencesRepository
 import com.hermesandroid.relay.data.BridgeSafetySettings
+import com.hermesandroid.relay.data.BridgeCapabilityPolicyRepository
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -14,6 +15,8 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
@@ -25,8 +28,8 @@ import java.util.concurrent.atomic.AtomicLong
 /**
 * Phase 3 — safety-rails `bridge-safety-rails`
 *
- * Central enforcement point for Tier 5 safety: per-app blocklist, destructive
- * verb confirmation, and idle-based auto-disable. Owned as a singleton-per-
+ * Central enforcement point for Tier 5 safety: connection-scoped capabilities,
+ * per-app blocklist, destructive confirmation, and timed screen access. Owned as a singleton-per-
 * process by [ConnectionViewModel] and injected into [BridgeCommandHandler].
 *
 * # Integration surface
@@ -47,9 +50,9 @@ import java.util.concurrent.atomic.AtomicLong
 *    reacts, which is exactly the UX we want (the server sees a slow
 *    response, not a denial race).
 *
- *  - [rescheduleAutoDisable] — every accepted command bumps the idle timer
- *    forward; after [BridgeSafetySettings.autoDisableMinutes] of silence
- *    the master toggle flips off and a one-shot notification fires.
+ *  - [rescheduleAutoDisable] — accepted timed screen commands bump the idle
+ *    expiry forward; after [BridgeSafetySettings.autoDisableMinutes] of
+ *    silence only timed screen authority is revoked and a notification fires.
 *    [cancelAutoDisable] cancels the pending timer (called when the master
 *    toggle flips off manually, so we don't race the timer against the
 *    user).
@@ -71,15 +74,14 @@ import java.util.concurrent.atomic.AtomicLong
 * The Android app does not depend on androidx.work. [AutoDisableWorker]
 * documents the canonical pattern, but the live path is a coroutine
 * `Job` owned by this manager, delayed by the configured minutes. This is
- * acceptable because we are the in-memory owner of the master-toggle flow
- * — no inter-process or cross-restart scheduling is needed. On process
- * death the master toggle is simply evaluated fresh from DataStore, and
- * any command not explicitly sent within the idle window never actually
- * happens because the app isn't running.
+ * acceptable because authorization stores an absolute expiry in DataStore.
+ * After process death or reconnect, the command boundary compares that expiry
+ * to wall clock and denies stale authority even if the notification job did not run.
 */
 class BridgeSafetyManager(
    context: Context,
    private val scope: CoroutineScope,
+    private val activeConnectionId: StateFlow<String?>,
 ) {
    companion object {
        private const val TAG = "BridgeSafetyMgr"
@@ -94,10 +96,14 @@ class BridgeSafetyManager(
         */
        fun peek(): BridgeSafetyManager? = INSTANCE

-        fun install(context: Context, scope: CoroutineScope): BridgeSafetyManager {
+        fun install(
+            context: Context,
+            scope: CoroutineScope,
+            activeConnectionId: StateFlow<String?>,
+        ): BridgeSafetyManager {
            val existing = INSTANCE
            if (existing != null) return existing
-            val created = BridgeSafetyManager(context.applicationContext, scope)
+            val created = BridgeSafetyManager(context.applicationContext, scope, activeConnectionId)
            INSTANCE = created
            return created
        }
@@ -105,6 +111,10 @@ class BridgeSafetyManager(

    private val appContext: Context = context.applicationContext
    private val prefsRepo = BridgeSafetyPreferencesRepository(appContext)
+    private val capabilityRepo = BridgeCapabilityPolicyRepository(appContext)
+    private val _activeCapabilityPolicy = MutableStateFlow(BridgeCapabilityPolicy())
+    val activeCapabilityPolicy: StateFlow<BridgeCapabilityPolicy> =
+        _activeCapabilityPolicy.asStateFlow()

    /** Latest settings snapshot — UI + checks read this via [settings]. */
    private val _settings = MutableStateFlow(BridgeSafetySettings())
@@ -140,12 +150,12 @@ class BridgeSafetyManager(
    private val pendingConfirmations = ConcurrentHashMap<Long, PendingConfirmation>()
    private val nextRequestId = AtomicLong(0L)

-    /** Coroutine job that fires auto-disable after idle. */
+    /** Coroutine job that prunes timed screen authority after idle. */
    @Volatile
    private var autoDisableJob: Job? = null

    /**
-     * Remaining time (epoch millis) for the current auto-disable job, or
+     * Remaining time (epoch millis) for current timed screen authority, or
     * null when idle. BridgeSafetySummaryCard reads this as a countdown.
     */
    private val _autoDisableAtMs = MutableStateFlow<Long?>(null)
@@ -167,6 +177,100 @@ class BridgeSafetyManager(
                trustedHydrated = true
            }
        }
+        scope.launch {
+            activeConnectionId.collectLatest { connectionId ->
+                schedulePersistedExpiry(connectionId)
+                capabilityRepo.policy(connectionId).collect { policy ->
+                    _activeCapabilityPolicy.value = policy
+                }
+            }
+        }
+    }
+
+    data class CapabilityAuthorization(
+        val allowed: Boolean,
+        val authority: BridgeCommandAuthority? = null,
+        val errorCode: String? = null,
+    )
+
+    fun capabilityPolicy(connectionId: String?): Flow<BridgeCapabilityPolicy> =
+        capabilityRepo.policy(connectionId)
+
+    suspend fun authorizeCapability(
+        path: String,
+        method: String,
+        nowMs: Long = System.currentTimeMillis(),
+    ): CapabilityAuthorization {
+        val authority = BridgeCommandRegistry.resolve(path, method)
+            ?: return CapabilityAuthorization(false, errorCode = "unknown_bridge_command")
+        if (authority.grant == BridgeCapabilityGrant.EXEMPT) {
+            return CapabilityAuthorization(true, authority)
+        }
+        val connectionId = activeConnectionId.value
+            ?: return CapabilityAuthorization(false, authority, "bridge_policy_unbound")
+        val capability = authority.capability
+            ?: return CapabilityAuthorization(false, authority, "bridge_policy_invalid")
+        val policy = capabilityRepo.snapshot(connectionId)
+        return if (policy.allows(capability, nowMs)) {
+            CapabilityAuthorization(true, authority)
+        } else {
+            CapabilityAuthorization(
+                false,
+                authority,
+                if (capability.timed) "bridge_capability_expired" else "bridge_capability_denied",
+            )
+        }
+    }
+
+    suspend fun setPermanentCapability(
+        connectionId: String?,
+        capability: BridgeCapability,
+        allowed: Boolean,
+    ) {
+        capabilityRepo.setPermanent(connectionId, capability, allowed)
+    }
+
+    suspend fun replacePermanentCapabilities(
+        connectionId: String?,
+        capabilities: Set<BridgeCapability>,
+    ) {
+        capabilityRepo.replacePermanent(connectionId, capabilities)
+    }
+
+    suspend fun setTimedCapability(
+        connectionId: String?,
+        capability: BridgeCapability,
+        allowed: Boolean,
+    ) {
+        if (!allowed) {
+            capabilityRepo.revoke(connectionId, capability)
+            if (capability == BridgeCapability.SCREEN_CONTROL) {
+                prefsRepo.setUnattendedAccessEnabled(false)
+            }
+            schedulePersistedExpiry(connectionId)
+            return
+        }
+        val fireAt = System.currentTimeMillis() + currentSettings().autoDisableMinutes * 60_000L
+        capabilityRepo.grantTimed(connectionId, capability, fireAt)
+        schedulePersistedExpiry(connectionId)
+    }
+
+    suspend fun replaceTimedCapabilities(
+        connectionId: String?,
+        capabilities: Set<BridgeCapability>,
+        durationMinutes: Int,
+        unlimited: Boolean = false,
+    ) {
+        val fireAt = if (unlimited) {
+            BridgeCapabilityPolicy.NEVER_EXPIRES_AT_MS
+        } else {
+            System.currentTimeMillis() + durationMinutes * 60_000L
+        }
+        capabilityRepo.replaceTimed(connectionId, capabilities, fireAt)
+        if (BridgeCapability.SCREEN_CONTROL !in capabilities) {
+            prefsRepo.setUnattendedAccessEnabled(false)
+        }
+        schedulePersistedExpiry(connectionId)
    }

    // ── Blocklist ────────────────────────────────────────────────────────
@@ -307,26 +411,35 @@ class BridgeSafetyManager(
        pending.deferred.complete(allowed)
    }

-    // ── Auto-disable timer ───────────────────────────────────────────────
+    // ── Timed screen-access expiry ──────────────────────────────────────

    /**
-     * Cancel any pending timer and arm a fresh one. Called on every accepted
-     * bridge command — an actively-used bridge never auto-disables.
+     * Refresh active timed grants and arm their shared idle expiry. Permanent
+     * capability activity never calls this method.
     */
    fun rescheduleAutoDisable() {
+        val connectionId = activeConnectionId.value ?: return
        val minutes = _settings.value.autoDisableMinutes
-        val delayMs = minutes * 60_000L
-        val fireAt = System.currentTimeMillis() + delayMs
+        val fireAt = System.currentTimeMillis() + minutes * 60_000L
        autoDisableJob?.cancel()
-        _autoDisableAtMs.value = fireAt
-
        autoDisableJob = (scope + SupervisorJob()).launch {
            try {
+                val snapshot = capabilityRepo.snapshot(connectionId)
+                val nowMs = System.currentTimeMillis()
+                val finite = snapshot.timedExpiriesMs.filterValues {
+                    it != BridgeCapabilityPolicy.NEVER_EXPIRES_AT_MS && it > nowMs
+                }
+                if (finite.isEmpty()) {
+                    _autoDisableAtMs.value = null
+                    return@launch
+                }
+                capabilityRepo.refreshActiveTimed(connectionId, fireAt)
+                _autoDisableAtMs.value = fireAt
+                val delayMs = (fireAt - System.currentTimeMillis()).coerceAtLeast(0L)
                delay(delayMs)
-                Log.i(TAG, "Auto-disable fired after $minutes min of idle")
-                // Hand off to the canonical worker so both code paths look
-                // identical from a behavioral standpoint (notification +
-                // master-toggle flip).
+                Log.i(TAG, "Timed Bridge capabilities expired after $minutes min of idle")
+                capabilityRepo.pruneExpired(connectionId, System.currentTimeMillis())
+                clearUnattendedIfControlEnded(connectionId)
                AutoDisableWorker(appContext).run()
            } catch (_: Throwable) {
                // Cancellation is expected on reschedule — swallow quietly.
@@ -342,6 +455,48 @@ class BridgeSafetyManager(
        _autoDisableAtMs.value = null
    }

+    fun revokeTimedCapabilities() {
+        val connectionId = activeConnectionId.value ?: return
+        cancelAutoDisable()
+        scope.launch {
+            capabilityRepo.revokeTimed(connectionId)
+            prefsRepo.setUnattendedAccessEnabled(false)
+        }
+    }
+
+    private suspend fun schedulePersistedExpiry(connectionId: String?) {
+        autoDisableJob?.cancel()
+        val policy = capabilityRepo.snapshot(connectionId)
+        val nextExpiry = policy.timedExpiriesMs.values
+            .filter { it != BridgeCapabilityPolicy.NEVER_EXPIRES_AT_MS }
+            .maxOrNull()
+        if (nextExpiry == null) {
+            _autoDisableAtMs.value = null
+            return
+        }
+        if (nextExpiry <= System.currentTimeMillis()) {
+            capabilityRepo.pruneExpired(connectionId, System.currentTimeMillis())
+            clearUnattendedIfControlEnded(connectionId)
+            _autoDisableAtMs.value = null
+            return
+        }
+        _autoDisableAtMs.value = nextExpiry
+        autoDisableJob = (scope + SupervisorJob()).launch {
+            delay((nextExpiry - System.currentTimeMillis()).coerceAtLeast(0L))
+            capabilityRepo.pruneExpired(connectionId, System.currentTimeMillis())
+            clearUnattendedIfControlEnded(connectionId)
+            AutoDisableWorker(appContext).run()
+            if (activeConnectionId.value == connectionId) _autoDisableAtMs.value = null
+        }
+    }
+
+    private suspend fun clearUnattendedIfControlEnded(connectionId: String?) {
+        val policy = capabilityRepo.snapshot(connectionId)
+        if (!policy.allows(BridgeCapability.SCREEN_CONTROL, System.currentTimeMillis())) {
+            prefsRepo.setUnattendedAccessEnabled(false)
+        }
+    }
+
    // ── Internals ────────────────────────────────────────────────────────

    /**
@@ -242,11 +242,9 @@ object UnattendedAccessManager {
     * returns [WakeOutcome.Success] / [SuccessNoKeyguardChange] /
     * [KeyguardBlocked] depending on the dismiss attempt outcome.
     *
-     * The wake lock auto-releases via the platform's 30s timeout — we
-     * don't release explicitly per call because the bridge command may
-     * take several gestures to complete and we want one continuous
-     * wake-up, not a stutter. [release] is provided for the master
-     * toggle off path.
+     * The caller must pair each successful acquire with [releaseAfterAction].
+     * The platform's 30s timeout remains a crash/stall backstop, not the normal
+     * lifetime. Nested or concurrent commands share the ref-counted lock.
     *
     * # Compatibility shim
     *
@@ -300,6 +298,22 @@ object UnattendedAccessManager {
        return requestDismiss()
    }

+    /** Release one command's ownership without disturbing concurrent actions. */
+    fun releaseAfterAction() {
+        synchronized(countLock) {
+            if (lockCount <= 0) return
+            lockCount -= 1
+            if (lockCount == 0) {
+                val lock = wakeLock ?: return
+                try {
+                    if (lock.isHeld) lock.release()
+                } catch (t: Throwable) {
+                    Log.w(TAG, "wakeLock.release threw: ${t.message}")
+                }
+            }
+        }
+    }
+
    /**
     * Synchronous keyguard dismiss attempt. Returns:
     *  - [WakeOutcome.SuccessNoKeyguardChange] when there's no keyguard
@@ -3,10 +3,10 @@ package com.hermesandroid.relay.data
 /**
 * Shared profile/personality display and request identity helpers.
 *
- * A null profile name is the app's explicit "Server default" state. The
- * relay also advertises the root Hermes config as a synthetic profile named
- * "default"; for request/session identity that row is an alias of server
- * default so it does not split chat, voice, or session scope.
+ * A null profile name is the app's explicit "Server default" state. It is
+ * intentionally distinct from a real profile whose name is literally
+ * `default`: the former follows the server's sticky default, while the latter
+ * explicitly addresses the root profile.
 */
 object AgentDisplay {
    const val SERVER_DEFAULT_PROFILE_KEY: String = "__server_default__"
@@ -16,17 +16,16 @@ object AgentDisplay {
        "hermes agent",
    )

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

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

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

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

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

    /**
     * The profile name that owns chat sessions for the current UI selection.
     *
-     * [selectedProfileName] is null (or the synthetic `default` alias) for the
-     * "Server default" row. That UI sentinel must remain distinct from the
+     * [selectedProfileName] is null for the "Server default" row. That UI
+     * sentinel must remain distinct from the
     * server's sticky active profile: a dashboard launched under the root home
     * may still report `active=victor`, in which case upstream Gateway and
     * dashboard session calls must explicitly target `victor`. The resolved
@@ -0,0 +1,89 @@
+package com.hermesandroid.relay.data
+
+import android.content.Context
+import androidx.datastore.preferences.core.floatPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
+import com.hermesandroid.relay.ui.theme.AppFont
+import com.hermesandroid.relay.ui.theme.AppThemes
+import com.hermesandroid.relay.ui.theme.AppearanceShape
+import com.hermesandroid.relay.ui.theme.normalizeAccentHex
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.json.Json
+
+internal data class PersistedAppearance(
+    val themePreference: String = "auto",
+    val appThemeId: String = AppThemes.DEFAULT_ID,
+    val accentHex: String? = null,
+    val shapeId: String = AppearanceShape.DEFAULT.id,
+    val appFontId: String = AppFont.DEFAULT.id,
+    val fontScale: Float = 1.0f,
+    val customTheme: CustomThemePreset? = null,
+)
+
+internal object AppearancePreferences {
+    val themeKey = stringPreferencesKey("theme")
+    val appThemeKey = stringPreferencesKey("app_theme")
+    val accentKey = stringPreferencesKey("appearance_accent")
+    val shapeKey = stringPreferencesKey("appearance_shape")
+    val appFontKey = stringPreferencesKey("app_font")
+    val fontScaleKey = floatPreferencesKey("font_scale")
+    val customThemesKey = stringPreferencesKey("custom_theme_presets")
+
+    private val json = Json { ignoreUnknownKeys = true }
+    private val serializer = ListSerializer(CustomThemePreset.serializer())
+
+    fun state(context: Context): Flow<PersistedAppearance> = context.applicationContext.relayDataStore.data
+        .map { preferences ->
+            val customThemes = decodeCustomThemes(preferences[customThemesKey])
+            val requestedThemeId = preferences[appThemeKey]
+            val customTheme = CustomThemePreset.idFromAppTheme(requestedThemeId)
+                ?.let { id -> customThemes.firstOrNull { it.id == id } }
+            PersistedAppearance(
+                themePreference = preferences[themeKey]
+                    ?.takeIf { it == "auto" || it == "light" || it == "dark" }
+                    ?: "auto",
+                appThemeId = customTheme?.appThemeId ?: AppThemes.byId(requestedThemeId).id,
+                accentHex = normalizeAccentHex(preferences[accentKey]),
+                shapeId = AppearanceShape.fromId(preferences[shapeKey]).id,
+                appFontId = AppFont.byId(preferences[appFontKey]).id,
+                fontScale = (preferences[fontScaleKey] ?: 1.0f).coerceIn(0.85f, 1.3f),
+                customTheme = customTheme,
+            )
+        }
+
+    fun shape(context: Context): Flow<String> = state(context).map { it.shapeId }
+
+    fun customThemes(context: Context): Flow<List<CustomThemePreset>> =
+        context.applicationContext.relayDataStore.data.map { decodeCustomThemes(it[customThemesKey]) }
+
+    fun decodeCustomThemes(raw: String?): List<CustomThemePreset> = raw
+        ?.let { runCatching { json.decodeFromString(serializer, it) }.getOrNull() }
+        .orEmpty()
+        .mapNotNull { it.normalized() }
+        .distinctBy { it.id }
+        .take(CustomThemePreset.MAX_PRESETS)
+
+    fun encodeCustomThemes(themes: List<CustomThemePreset>): String = json.encodeToString(
+        serializer,
+        themes.mapNotNull { it.normalized() }
+            .distinctBy { it.id }
+            .take(CustomThemePreset.MAX_PRESETS),
+    )
+
+    fun upsertCustomTheme(
+        current: List<CustomThemePreset>,
+        preset: CustomThemePreset,
+    ): List<CustomThemePreset>? {
+        val normalized = preset.normalized() ?: return null
+        val safeCurrent = current.mapNotNull { it.normalized() }
+            .distinctBy { it.id }
+            .take(CustomThemePreset.MAX_PRESETS)
+        val existingIndex = safeCurrent.indexOfFirst { it.id == normalized.id }
+        if (existingIndex < 0 && safeCurrent.size >= CustomThemePreset.MAX_PRESETS) return null
+        return safeCurrent.toMutableList().apply {
+            if (existingIndex >= 0) set(existingIndex, normalized) else add(normalized)
+        }
+    }
+}
@@ -0,0 +1,182 @@
+package com.hermesandroid.relay.data
+
+import android.content.Context
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import com.hermesandroid.relay.bridge.BridgeCapability
+import com.hermesandroid.relay.bridge.BridgeCapabilityPolicy
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import java.io.File
+import java.util.UUID
+
+/** Connection-scoped Bridge authority. Missing, malformed, or future schemas deny all. */
+class BridgeCapabilityPolicyRepository(private val context: Context) {
+    companion object {
+        private val KEY_POLICIES = stringPreferencesKey("bridge_capability_policies_v1")
+    }
+
+    @Serializable
+    private data class StoredPolicies(
+        val schemaVersion: Int = BridgeCapabilityPolicy.CURRENT_SCHEMA_VERSION,
+        val installId: String = "",
+        val byConnection: Map<String, BridgeCapabilityPolicy> = emptyMap(),
+    )
+
+    private val json = Json { ignoreUnknownKeys = true; encodeDefaults = true }
+    private val installId: String = localInstallId(context)
+
+    fun policy(connectionId: String?): Flow<BridgeCapabilityPolicy> =
+        context.relayDataStore.data.map { prefs ->
+            readPolicies(prefs[KEY_POLICIES])[connectionId.normalizedPolicyKey()]
+                ?.takeIf { it.schemaVersion == BridgeCapabilityPolicy.CURRENT_SCHEMA_VERSION }
+                ?: BridgeCapabilityPolicy()
+        }
+
+    suspend fun snapshot(connectionId: String?): BridgeCapabilityPolicy =
+        policy(connectionId).first()
+
+    suspend fun setPermanent(connectionId: String?, capability: BridgeCapability, allowed: Boolean) {
+        require(!capability.timed) { "Timed capabilities require an expiry" }
+        update(connectionId) { current ->
+            current.copy(
+                permanentGrants = if (allowed) {
+                    current.permanentGrants + capability
+                } else {
+                    current.permanentGrants - capability
+                },
+            )
+        }
+    }
+
+    suspend fun replacePermanent(
+        connectionId: String?,
+        capabilities: Set<BridgeCapability>,
+    ) {
+        require(capabilities.none { it.timed }) { "Timed capabilities require an expiry" }
+        update(connectionId) { current -> current.copy(permanentGrants = capabilities) }
+    }
+
+    suspend fun grantTimed(
+        connectionId: String?,
+        capability: BridgeCapability,
+        expiresAtMs: Long,
+        nowMs: Long = System.currentTimeMillis(),
+    ) {
+        require(capability.timed) { "Permanent capabilities do not accept an expiry" }
+        update(connectionId) { current ->
+            current.copy(
+                timedExpiriesMs = (
+                    current.timedExpiriesMs.filterValues { it > nowMs }.keys + capability
+                )
+                    .associateWith { expiresAtMs },
+            )
+        }
+    }
+
+    suspend fun revoke(connectionId: String?, capability: BridgeCapability) {
+        update(connectionId) { current ->
+            current.copy(
+                permanentGrants = current.permanentGrants - capability,
+                timedExpiriesMs = current.timedExpiriesMs - capability,
+            )
+        }
+    }
+
+    suspend fun revokeTimed(connectionId: String?) {
+        update(connectionId) { it.copy(timedExpiriesMs = emptyMap()) }
+    }
+
+    suspend fun replaceTimed(
+        connectionId: String?,
+        capabilities: Set<BridgeCapability>,
+        expiresAtMs: Long,
+    ) {
+        require(capabilities.all { it.timed }) { "Permanent capabilities cannot be timed" }
+        update(connectionId) { current ->
+            current.copy(timedExpiriesMs = capabilities.associateWith { expiresAtMs })
+        }
+    }
+
+    suspend fun refreshActiveTimed(connectionId: String?, expiresAtMs: Long) {
+        update(connectionId) { current ->
+            current.copy(
+                timedExpiriesMs = current.timedExpiriesMs.mapNotNull { (capability, currentExpiry) ->
+                    when {
+                        currentExpiry == BridgeCapabilityPolicy.NEVER_EXPIRES_AT_MS ->
+                            capability to currentExpiry
+                        currentExpiry > System.currentTimeMillis() -> capability to expiresAtMs
+                        else -> null
+                    }
+                }.toMap(),
+            )
+        }
+    }
+
+    suspend fun pruneExpired(connectionId: String?, nowMs: Long) {
+        update(connectionId) { current ->
+            current.copy(timedExpiriesMs = current.timedExpiriesMs.filterValues { it > nowMs })
+        }
+    }
+
+    suspend fun clearConnection(connectionId: String) {
+        val key = connectionId.normalizedPolicyKey()
+        context.relayDataStore.edit { prefs ->
+            val current = readPolicies(prefs[KEY_POLICIES]).toMutableMap()
+            current.remove(key)
+            prefs[KEY_POLICIES] = json.encodeToString(
+                StoredPolicies(installId = installId, byConnection = current),
+            )
+        }
+    }
+
+    private suspend fun update(
+        connectionId: String?,
+        transform: (BridgeCapabilityPolicy) -> BridgeCapabilityPolicy,
+    ) {
+        val key = connectionId.normalizedPolicyKey()
+        context.relayDataStore.edit { prefs ->
+            val current = readPolicies(prefs[KEY_POLICIES]).toMutableMap()
+            current[key] = transform(current[key] ?: BridgeCapabilityPolicy())
+            prefs[KEY_POLICIES] = json.encodeToString(
+                StoredPolicies(installId = installId, byConnection = current),
+            )
+        }
+    }
+
+    private fun readPolicies(raw: String?): Map<String, BridgeCapabilityPolicy> {
+        if (raw.isNullOrBlank()) return emptyMap()
+        val stored = runCatching { json.decodeFromString<StoredPolicies>(raw) }.getOrNull()
+            ?: return emptyMap()
+        if (stored.schemaVersion != BridgeCapabilityPolicy.CURRENT_SCHEMA_VERSION ||
+            stored.installId != installId
+        ) return emptyMap()
+        return stored.byConnection
+    }
+
+    private fun String?.normalizedPolicyKey(): String =
+        this?.trim()?.takeIf { it.isNotEmpty() } ?: "__unbound__"
+
+    private fun localInstallId(context: Context): String {
+        val file = File(context.noBackupFilesDir, "bridge-policy-install-id")
+        return runCatching {
+            if (file.isFile) {
+                file.readText().trim().takeIf { it.isNotEmpty() }
+            } else {
+                null
+            } ?: UUID.randomUUID().toString().also { id ->
+                file.parentFile?.mkdirs()
+                file.writeText(id)
+            }
+        }.getOrElse {
+            // An unavailable no-backup fence must never make restored grants
+            // usable. This process-only value causes every persisted read to
+            // mismatch and therefore deny.
+            "unavailable-${UUID.randomUUID()}"
+        }
+    }
+}
@@ -70,7 +70,11 @@ data class BridgeSettings(
 class BridgePreferencesRepository(private val context: Context) {

    companion object {
-        private val KEY_MASTER_ENABLED = booleanPreferencesKey("bridge_master_enabled")
+        // v2 is deliberately separate. Older APKs know only the legacy key
+        // and therefore remain disabled after a downgrade instead of treating
+        // the new granular grants as blanket authority.
+        private val KEY_MASTER_ENABLED = booleanPreferencesKey("bridge_master_enabled_v2")
+        private val KEY_LEGACY_MASTER_ENABLED = booleanPreferencesKey("bridge_master_enabled")
        private val KEY_ACTIVITY_LOG = stringPreferencesKey("bridge_activity_log")

        /** Hard cap on persisted entries. See file-level KDoc for rationale. */
@@ -99,7 +103,10 @@ class BridgePreferencesRepository(private val context: Context) {
    }

    suspend fun setMasterEnabled(enabled: Boolean) {
-        context.relayDataStore.edit { it[KEY_MASTER_ENABLED] = enabled }
+        context.relayDataStore.edit {
+            it[KEY_MASTER_ENABLED] = enabled
+            it[KEY_LEGACY_MASTER_ENABLED] = false
+        }
    }

    /**
@@ -29,10 +29,9 @@ import kotlinx.serialization.json.Json
 *    appear in `/tap_text` or `/type` payloads. Seeded with a set of verbs
 *    that carry irreversible or high-stakes consequences. Editable.
 *
- *  - [autoDisableMinutes] — idle timeout after which the master toggle
- *    auto-flips to false. Rescheduled on every command so an active agent
- *    never triggers it; a runaway agent that stops sending commands for
- *    this long loses bridge access automatically.
+ *  - [autoDisableMinutes] — idle timeout for timed screen inspection and
+ *    control grants. Only accepted timed commands refresh it; permanent
+ *    read/action grants neither expire nor keep screen authority alive.
 *
 *  - [statusOverlayEnabled] — opt-in floating-dot indicator (like the
 *    screen-recording red dot) that's visible while bridge is active.
@@ -0,0 +1,24 @@
+package com.hermesandroid.relay.data
+
+import com.hermesandroid.relay.BuildConfig
+
+/** Immutable provenance embedded into side-by-side review and RC builds. */
+object CandidateBuild {
+    val isCandidate: Boolean get() = BuildConfig.CANDIDATE_BUILD
+    val kind: String get() = BuildConfig.CANDIDATE_KIND.ifBlank { "review" }
+    val label: String get() = BuildConfig.CANDIDATE_LABEL.ifBlank { "Local review" }
+    val sourceRef: String get() = BuildConfig.CANDIDATE_SOURCE_REF.ifBlank { "local" }
+    val sourceSha: String get() = BuildConfig.CANDIDATE_SOURCE_SHA.ifBlank { "unknown" }
+    val shortSha: String get() = sourceSha.take(12)
+
+    val heading: String
+        get() = when (kind.lowercase()) {
+            "rc", "release-candidate" -> "RELEASE CANDIDATE"
+            else -> "REVIEW CANDIDATE"
+        }
+
+    val provenance: String
+        get() = listOf(label, shortSha)
+            .filter { it.isNotBlank() && it != "unknown" }
+            .joinToString(" · ")
+}
@@ -0,0 +1,492 @@
+package com.hermesandroid.relay.data
+
+import java.io.File
+import java.io.FileOutputStream
+import java.security.MessageDigest
+import java.util.Base64
+import java.util.WeakHashMap
+import java.nio.file.AtomicMoveNotSupportedException
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+
+/**
+ * Immutable owner of one composer draft.
+ *
+ * Callers must supply stable ids rather than display labels. [sessionId] may be
+ * a server id or a stable client-generated id for a not-yet-created session.
+ * [draftId] separates the primary composer from any future named draft slot.
+ */
+data class ChatComposerDraftKey(
+    val connectionId: String,
+    val profileId: String,
+    val sessionId: String,
+    val draftId: String = PRIMARY_DRAFT_ID,
+) {
+    init {
+        require(connectionId.isNotBlank()) { "connectionId must not be blank" }
+        require(profileId.isNotBlank()) { "profileId must not be blank" }
+        require(sessionId.isNotBlank()) { "sessionId must not be blank" }
+        require(draftId.isNotBlank()) { "draftId must not be blank" }
+    }
+
+    companion object {
+        const val PRIMARY_DRAFT_ID = "primary"
+        const val DEFAULT_PROFILE_ID = "default"
+    }
+}
+
+/** Message references associated with composer content. */
+data class ChatComposerDraftContext(
+    val quotedMessageId: String? = null,
+    val editingMessageId: String? = null,
+) {
+    internal fun normalized(): ChatComposerDraftContext = copy(
+        quotedMessageId = quotedMessageId?.takeIf(String::isNotBlank),
+        editingMessageId = editingMessageId?.takeIf(String::isNotBlank),
+    )
+}
+
+/**
+ * Complete restorable state for one composer.
+ *
+ * Selection offsets use the same start-inclusive/end-exclusive convention as
+ * Compose text fields. The store clamps them whenever the text changes so a
+ * restored selection can never address outside the restored string.
+ */
+data class ChatComposerDraft(
+    val text: String = "",
+    val selectionStart: Int = text.length,
+    val selectionEnd: Int = selectionStart,
+    val context: ChatComposerDraftContext = ChatComposerDraftContext(),
+    val attachments: List<Attachment> = emptyList(),
+) {
+    val isEmpty: Boolean
+        get() = text.isEmpty() &&
+            context.quotedMessageId == null &&
+            context.editingMessageId == null &&
+            attachments.isEmpty()
+
+    internal fun normalized(): ChatComposerDraft {
+        val normalizedStart = selectionStart.coerceIn(0, text.length)
+        val normalizedEnd = selectionEnd.coerceIn(0, text.length)
+        return copy(
+            selectionStart = minOf(normalizedStart, normalizedEnd),
+            selectionEnd = maxOf(normalizedStart, normalizedEnd),
+            context = context.normalized(),
+            attachments = attachments.toList(),
+        )
+    }
+}
+
+/**
+ * Session-owned composer state.
+ *
+ * This store is deliberately memory-only: outbound [Attachment.content] can
+ * contain large Base64 payloads and must not enter Preferences DataStore. Keep
+ * one instance in the chat owner (normally its ViewModel) so drafts survive
+ * navigation and Activity recreation. Process death starts with empty drafts;
+ * a future durable implementation should persist URI grants, not attachment
+ * bytes.
+ */
+interface ChatComposerDraftStore {
+    fun observe(key: ChatComposerDraftKey): Flow<ChatComposerDraft>
+    suspend fun snapshot(key: ChatComposerDraftKey): ChatComposerDraft
+    suspend fun save(key: ChatComposerDraftKey, draft: ChatComposerDraft)
+    suspend fun update(
+        key: ChatComposerDraftKey,
+        transform: (ChatComposerDraft) -> ChatComposerDraft,
+    )
+    suspend fun remove(key: ChatComposerDraftKey)
+    suspend fun removeSession(connectionId: String, profileId: String, sessionId: String)
+    suspend fun clear()
+}
+
+class InMemoryChatComposerDraftStore : ChatComposerDraftStore {
+    private val drafts = MutableStateFlow<Map<ChatComposerDraftKey, ChatComposerDraft>>(emptyMap())
+
+    override fun observe(key: ChatComposerDraftKey): Flow<ChatComposerDraft> =
+        drafts
+            .map { it[key] ?: ChatComposerDraft() }
+            .distinctUntilChanged()
+
+    override suspend fun snapshot(key: ChatComposerDraftKey): ChatComposerDraft =
+        drafts.value[key] ?: ChatComposerDraft()
+
+    override suspend fun save(key: ChatComposerDraftKey, draft: ChatComposerDraft) {
+        synchronized(drafts) {
+            val normalized = draft.normalized()
+            drafts.value = if (normalized.isEmpty) {
+                drafts.value - key
+            } else {
+                drafts.value + (key to normalized)
+            }
+        }
+    }
+
+    override suspend fun update(
+        key: ChatComposerDraftKey,
+        transform: (ChatComposerDraft) -> ChatComposerDraft,
+    ) {
+        save(key, transform(snapshot(key)))
+    }
+
+    override suspend fun remove(key: ChatComposerDraftKey) {
+        synchronized(drafts) {
+            drafts.value = drafts.value - key
+        }
+    }
+
+    override suspend fun removeSession(connectionId: String, profileId: String, sessionId: String) {
+        synchronized(drafts) {
+            drafts.value = drafts.value.filterKeys { key ->
+                key.connectionId != connectionId ||
+                    key.profileId != profileId ||
+                    key.sessionId != sessionId
+            }
+        }
+    }
+
+    override suspend fun clear() {
+        synchronized(drafts) {
+            drafts.value = emptyMap()
+        }
+    }
+}
+
+/**
+ * App-private durable composer storage.
+ *
+ * The caller supplies a directory under `noBackupFilesDir`: drafts survive
+ * process death and ordinary app exits but never enter Android cloud backup.
+ * Metadata stays small JSON while attachment bytes are content-addressed blobs,
+ * so typing does not repeatedly rewrite Base64 payloads.
+ */
+class PersistentChatComposerDraftStore(
+    private val root: File,
+) : ChatComposerDraftStore {
+    private val mutex = Mutex()
+    private val updates = MutableSharedFlow<ChatComposerDraftKey>(extraBufferCapacity = 64)
+    private val json = Json { ignoreUnknownKeys = true; encodeDefaults = true }
+    private val draftsDir = File(root, "drafts")
+    private val blobsDir = File(root, "blobs")
+    private val contentBlobIds = WeakHashMap<String, String>()
+
+    override fun observe(key: ChatComposerDraftKey): Flow<ChatComposerDraft> = flow {
+        emit(snapshot(key))
+        emitAll(
+            updates
+                .filter { it == key }
+                .map { snapshot(key) }
+                .distinctUntilChanged(),
+        )
+    }.distinctUntilChanged()
+
+    override suspend fun snapshot(key: ChatComposerDraftKey): ChatComposerDraft = withContext(Dispatchers.IO) {
+        mutex.withLock { readDraft(key) }
+    }
+
+    override suspend fun save(key: ChatComposerDraftKey, draft: ChatComposerDraft) {
+        withContext(Dispatchers.IO) {
+            mutex.withLock {
+                val normalized = draft.normalized()
+                if (normalized.isEmpty) {
+                    draftFile(key).delete()
+                } else {
+                    ensureDirectories()
+                    val persisted = normalized.toPersisted(key)
+                    atomicWrite(
+                        draftFile(key),
+                        json.encodeToString(PersistedDraft.serializer(), persisted)
+                            .toByteArray(Charsets.UTF_8),
+                    )
+                }
+                pruneAndCollect(except = key)
+            }
+        }
+        updates.tryEmit(key)
+    }
+
+    override suspend fun update(
+        key: ChatComposerDraftKey,
+        transform: (ChatComposerDraft) -> ChatComposerDraft,
+    ) {
+        withContext(Dispatchers.IO) {
+            mutex.withLock {
+                val normalized = transform(readDraft(key)).normalized()
+                if (normalized.isEmpty) {
+                    draftFile(key).delete()
+                } else {
+                    ensureDirectories()
+                    atomicWrite(
+                        draftFile(key),
+                        json.encodeToString(
+                            PersistedDraft.serializer(),
+                            normalized.toPersisted(key),
+                        ).toByteArray(Charsets.UTF_8),
+                    )
+                }
+                pruneAndCollect(except = key)
+            }
+        }
+        updates.tryEmit(key)
+    }
+
+    override suspend fun remove(key: ChatComposerDraftKey) {
+        withContext(Dispatchers.IO) {
+            mutex.withLock {
+                draftFile(key).delete()
+                collectOrphanBlobs()
+            }
+        }
+        updates.tryEmit(key)
+    }
+
+    override suspend fun removeSession(connectionId: String, profileId: String, sessionId: String) {
+        val removed = mutableListOf<ChatComposerDraftKey>()
+        withContext(Dispatchers.IO) {
+            mutex.withLock {
+                draftFiles().forEach { file ->
+                    val persisted = readPersisted(file) ?: return@forEach
+                    val key = persisted.key.toDomain()
+                    if (
+                        key.connectionId == connectionId &&
+                        key.profileId == profileId &&
+                        key.sessionId == sessionId
+                    ) {
+                        file.delete()
+                        removed += key
+                    }
+                }
+                collectOrphanBlobs()
+            }
+        }
+        removed.forEach(updates::tryEmit)
+    }
+
+    override suspend fun clear() {
+        withContext(Dispatchers.IO) {
+            mutex.withLock {
+                root.listFiles().orEmpty().forEach(File::deleteRecursively)
+                contentBlobIds.clear()
+            }
+        }
+    }
+
+    private fun ChatComposerDraft.toPersisted(key: ChatComposerDraftKey): PersistedDraft =
+        PersistedDraft(
+            key = PersistedKey.from(key),
+            text = text,
+            selectionStart = selectionStart,
+            selectionEnd = selectionEnd,
+            quotedMessageId = context.quotedMessageId,
+            editingMessageId = context.editingMessageId,
+            attachments = attachments.mapNotNull(::persistAttachment),
+            savedAtEpochMs = System.currentTimeMillis(),
+        )
+
+    private fun persistAttachment(attachment: Attachment): PersistedAttachment? {
+        val rawBytes = attachment.composerRawText
+            ?.takeIf { attachment.isLargePaste }
+            ?.toByteArray(Charsets.UTF_8)
+        val cachedBlobId = if (rawBytes == null) contentBlobIds[attachment.content] else null
+        val cachedBlob = cachedBlobId?.let { File(blobsDir, "$it.blob") }
+        if (cachedBlobId != null && cachedBlob?.exists() == true) {
+            return attachment.toPersistedAttachment(cachedBlobId)
+        }
+        val bytes = rawBytes
+            ?: runCatching { Base64.getDecoder().decode(attachment.content) }.getOrNull()
+            ?: return null
+        if (bytes.isEmpty()) return null
+        val blobId = sha256(bytes)
+        val blob = File(blobsDir, "$blobId.blob")
+        if (!blob.exists()) atomicWrite(blob, bytes)
+        if (rawBytes == null) contentBlobIds[attachment.content] = blobId
+        return attachment.toPersistedAttachment(blobId)
+    }
+
+    private fun Attachment.toPersistedAttachment(blobId: String): PersistedAttachment =
+        PersistedAttachment(
+            contentType = contentType,
+            blobId = blobId,
+            fileName = fileName,
+            fileSize = fileSize,
+            sensitive = sensitive,
+            isLargePaste = isLargePaste,
+            composerId = composerId,
+        )
+
+    private fun readDraft(key: ChatComposerDraftKey): ChatComposerDraft {
+        val persisted = readPersisted(draftFile(key)) ?: return ChatComposerDraft()
+        if (persisted.key.toDomain() != key) return ChatComposerDraft()
+        return ChatComposerDraft(
+            text = persisted.text,
+            selectionStart = persisted.selectionStart,
+            selectionEnd = persisted.selectionEnd,
+            context = ChatComposerDraftContext(
+                quotedMessageId = persisted.quotedMessageId,
+                editingMessageId = persisted.editingMessageId,
+            ),
+            attachments = persisted.attachments.mapNotNull { attachment ->
+                val blob = File(blobsDir, "${attachment.blobId}.blob")
+                val bytes = runCatching { blob.readBytes() }.getOrNull()
+                    ?.takeIf(ByteArray::isNotEmpty) ?: return@mapNotNull null
+                val content = Base64.getEncoder().encodeToString(bytes)
+                contentBlobIds[content] = attachment.blobId
+                Attachment(
+                    contentType = attachment.contentType,
+                    content = content,
+                    fileName = attachment.fileName,
+                    fileSize = attachment.fileSize ?: bytes.size.toLong(),
+                    sensitive = attachment.sensitive,
+                    isLargePaste = attachment.isLargePaste,
+                    composerId = attachment.composerId,
+                )
+            },
+        ).normalized()
+    }
+
+    private fun readPersisted(file: File): PersistedDraft? = runCatching {
+        json.decodeFromString(PersistedDraft.serializer(), file.readText(Charsets.UTF_8))
+    }.getOrNull()
+
+    private fun pruneAndCollect(except: ChatComposerDraftKey) {
+        val exceptFile = draftFile(except)
+        val candidates = draftFiles()
+            .filterNot { it == exceptFile }
+            .sortedBy(File::lastModified)
+        candidates
+            .take((draftFiles().size - MAX_DRAFTS).coerceAtLeast(0))
+            .forEach { it.delete() }
+        collectOrphanBlobs()
+        for (oldest in candidates) {
+            if (blobsDir.listFiles().orEmpty().sumOf(File::length) <= MAX_BLOB_BYTES) break
+            if (oldest.exists()) {
+                oldest.delete()
+                collectOrphanBlobs()
+            }
+        }
+    }
+
+    private fun collectOrphanBlobs() {
+        val referenced = draftFiles()
+            .mapNotNull(::readPersisted)
+            .flatMap { draft -> draft.attachments.map(PersistedAttachment::blobId) }
+            .toSet()
+        blobsDir.listFiles().orEmpty()
+            .filter { it.isFile && it.extension == "blob" && it.nameWithoutExtension !in referenced }
+            .forEach(File::delete)
+    }
+
+    private fun ensureDirectories() {
+        check(draftsDir.exists() || draftsDir.mkdirs()) { "Could not create composer draft directory" }
+        check(blobsDir.exists() || blobsDir.mkdirs()) { "Could not create composer blob directory" }
+    }
+
+    private fun draftFiles(): List<File> = draftsDir.listFiles().orEmpty()
+        .filter { it.isFile && it.extension == "json" }
+
+    private fun draftFile(key: ChatComposerDraftKey): File =
+        File(draftsDir, "${sha256(key.storageIdentity().toByteArray(Charsets.UTF_8))}.json")
+
+    private fun atomicWrite(target: File, bytes: ByteArray) {
+        target.parentFile?.let { parent ->
+            check(parent.exists() || parent.mkdirs()) { "Could not create composer storage directory" }
+        }
+        val temporary = File(target.parentFile, ".${target.name}.${System.nanoTime()}.tmp")
+        try {
+            FileOutputStream(temporary).use { output ->
+                output.write(bytes)
+                output.fd.sync()
+            }
+            try {
+                Files.move(
+                    temporary.toPath(),
+                    target.toPath(),
+                    StandardCopyOption.ATOMIC_MOVE,
+                    StandardCopyOption.REPLACE_EXISTING,
+                )
+            } catch (_: AtomicMoveNotSupportedException) {
+                Files.move(
+                    temporary.toPath(),
+                    target.toPath(),
+                    StandardCopyOption.REPLACE_EXISTING,
+                )
+            }
+        } finally {
+            temporary.delete()
+        }
+    }
+
+    private fun ChatComposerDraftKey.storageIdentity(): String =
+        listOf(connectionId, profileId, sessionId, draftId).joinToString("\u0000")
+
+    private fun sha256(bytes: ByteArray): String = MessageDigest.getInstance("SHA-256")
+        .digest(bytes)
+        .joinToString("") { byte -> "%02x".format(byte) }
+
+    companion object {
+        private const val MAX_DRAFTS = 64
+        private const val MAX_BLOB_BYTES = 128L * 1024L * 1024L
+    }
+}
+
+@Serializable
+private data class PersistedDraft(
+    val key: PersistedKey,
+    val text: String,
+    val selectionStart: Int,
+    val selectionEnd: Int,
+    val quotedMessageId: String? = null,
+    val editingMessageId: String? = null,
+    val attachments: List<PersistedAttachment> = emptyList(),
+    val savedAtEpochMs: Long,
+)
+
+@Serializable
+private data class PersistedKey(
+    val connectionId: String,
+    val profileId: String,
+    val sessionId: String,
+    val draftId: String,
+) {
+    fun toDomain(): ChatComposerDraftKey = ChatComposerDraftKey(
+        connectionId = connectionId,
+        profileId = profileId,
+        sessionId = sessionId,
+        draftId = draftId,
+    )
+
+    companion object {
+        fun from(key: ChatComposerDraftKey): PersistedKey = PersistedKey(
+            connectionId = key.connectionId,
+            profileId = key.profileId,
+            sessionId = key.sessionId,
+            draftId = key.draftId,
+        )
+    }
+}
+
+@Serializable
+private data class PersistedAttachment(
+    val contentType: String,
+    val blobId: String,
+    val fileName: String? = null,
+    val fileSize: Long? = null,
+    val sensitive: Boolean = false,
+    val isLargePaste: Boolean = false,
+    val composerId: String? = null,
+)
@@ -0,0 +1,61 @@
+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.booleanPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+
+/** Phone-local behavior for a physical keyboard's unmodified Enter key. */
+enum class PhysicalKeyboardEnterBehavior(val storedValue: String) {
+    SendMessage("send_message"),
+    InsertNewline("insert_newline"),
+    ;
+
+    companion object {
+        fun fromStoredValue(value: String?): PhysicalKeyboardEnterBehavior =
+            entries.firstOrNull { it.storedValue == value } ?: SendMessage
+    }
+}
+
+/** Device-level chat input preferences shared by every Hermes profile. */
+class ChatInputPreferencesRepository(
+    private val dataStore: DataStore<Preferences>,
+) {
+    constructor(context: Context) : this(context.relayDataStore)
+
+    companion object {
+        internal val KEY_PHYSICAL_KEYBOARD_ENTER =
+            stringPreferencesKey("physical_keyboard_enter_behavior")
+        internal val KEY_CONVERT_LARGE_PASTES =
+            booleanPreferencesKey("convert_large_pastes_to_attachments")
+    }
+
+    val physicalKeyboardEnterBehavior: Flow<PhysicalKeyboardEnterBehavior> = dataStore.data
+        .map { preferences ->
+            PhysicalKeyboardEnterBehavior.fromStoredValue(
+                preferences[KEY_PHYSICAL_KEYBOARD_ENTER],
+            )
+        }
+        .distinctUntilChanged()
+
+    val convertLargePastesToAttachments: Flow<Boolean> = dataStore.data
+        .map { preferences -> preferences[KEY_CONVERT_LARGE_PASTES] ?: true }
+        .distinctUntilChanged()
+
+    suspend fun setPhysicalKeyboardEnterBehavior(behavior: PhysicalKeyboardEnterBehavior) {
+        dataStore.edit { preferences ->
+            preferences[KEY_PHYSICAL_KEYBOARD_ENTER] = behavior.storedValue
+        }
+    }
+
+    suspend fun setConvertLargePastesToAttachments(enabled: Boolean) {
+        dataStore.edit { preferences ->
+            preferences[KEY_CONVERT_LARGE_PASTES] = enabled
+        }
+    }
+}
@@ -0,0 +1,44 @@
+package com.hermesandroid.relay.data
+
+import java.util.Base64
+
+const val LARGE_PASTE_THRESHOLD_CHARS = 5_000
+
+data class TextTransportAttachments(
+    val message: String,
+    val attachments: List<Attachment>,
+)
+
+fun largePasteAttachment(text: String, composerId: String? = null): Attachment {
+    val bytes = text.toByteArray(Charsets.UTF_8)
+    return Attachment(
+        contentType = "text/plain; charset=utf-8",
+        content = Base64.getEncoder().encodeToString(bytes),
+        fileName = "pasted-text.txt",
+        fileSize = bytes.size.toLong(),
+        isLargePaste = true,
+        composerId = composerId,
+    )
+}
+
+fun prepareTextTransportAttachments(
+    message: String,
+    attachments: List<Attachment>,
+): TextTransportAttachments {
+    val largePastes = attachments.filter(Attachment::isLargePaste)
+    if (largePastes.isEmpty()) return TextTransportAttachments(message, attachments)
+
+    val materialized = largePastes.mapNotNull { attachment ->
+        runCatching {
+            val text = String(Base64.getDecoder().decode(attachment.content), Charsets.UTF_8)
+            val name = attachment.fileName?.takeIf(String::isNotBlank) ?: "pasted text"
+            "--- $name ---\n$text"
+        }.getOrNull()
+    }
+    return TextTransportAttachments(
+        message = (listOf(message) + materialized)
+            .filter(String::isNotBlank)
+            .joinToString("\n\n"),
+        attachments = attachments.filterNot(Attachment::isLargePaste),
+    )
+}
@@ -112,12 +112,11 @@ data class ChatMessage(
     */
    val clientOnly: Boolean = false,
    /**
-     * Delivery state for a message the user sends into an agent **Thread** over
-     * the relay proactive channel ([com.hermesandroid.relay.viewmodel.ChatViewModel]
-     * routes `source=phone` sessions here instead of the normal chat send).
-     * `SENDING` until the relay acks (`proactive.reply.ack`) → `DELIVERED`;
-     * `FAILED` on a send error. Null for ordinary chat messages — those render
-     * no status affix.
+     * Delivery state for a user-authored message. Agent **Thread** replies use
+     * `SENDING` until the relay acks (`proactive.reply.ack`) → `DELIVERED`,
+     * with `FAILED` on a send error. Ordinary chat may additionally use
+     * `QUEUED` and `STEERED` to make active-turn routing visible. Null keeps the
+     * legacy behavior of rendering no status affix.
     */
    val deliveryStatus: MessageDeliveryStatus? = null,
    /**
@@ -142,6 +141,18 @@ data class ChatMessage(
     * through `copy`, while [id] remains the authoritative lookup/wire id.
     */
    val uiKey: String = id,
+    /**
+     * Durable Gateway transcript row identity for rewind/edit-regenerate.
+     * This is server-owned and can change after a truncating rewrite; it is
+     * never used as a Compose key or synthesized client-side.
+     */
+    val rowId: Long? = null,
+    /**
+     * Durable iOS-style tapbacks attached to this server message. Hermes keeps
+     * one reaction per author in the message's display metadata; the UI also
+     * updates this list optimistically while a reaction write is in flight.
+     */
+    val reactions: List<MessageReaction> = emptyList(),
    /**
     * Mixture-of-Agents advisor responses surfaced during the live turn.
     * Unavailable advisors retain only neutral state, never their raw failure
@@ -151,6 +162,29 @@ data class ChatMessage(
    val moaReferences: List<MoaReference> = emptyList(),
 )

+data class MessageReaction(
+    val emoji: String,
+    val author: String,
+    /** Epoch seconds, matching the Gateway/Desktop contract. */
+    val at: Double,
+)
+
+/** Apply Hermes' one-reaction-per-author, re-tap-to-retract semantics. */
+internal fun applyMessageReaction(
+    reactions: List<MessageReaction>,
+    emoji: String?,
+    author: String = "user",
+    at: Double = System.currentTimeMillis() / 1000.0,
+): List<MessageReaction> {
+    val previous = reactions.firstOrNull { it.author == author }
+    val withoutAuthor = reactions.filterNot { it.author == author }
+    return if (emoji.isNullOrBlank() || previous?.emoji == emoji) {
+        withoutAuthor
+    } else {
+        withoutAuthor + MessageReaction(emoji = emoji, author = author, at = at)
+    }
+}
+
 data class MoaReference(
    val index: Int,
    val count: Int?,
@@ -294,7 +328,13 @@ data class Attachment(
     * existing outbound/inbound call site stays valid and unflagged media
     * renders exactly as before.
     */
-    val sensitive: Boolean = false
+    val sensitive: Boolean = false,
+    /** Local composer metadata; never serialized onto the Hermes wire. */
+    val isLargePaste: Boolean = false,
+    /** Stable id for an asynchronous composer preparation; never sent to Hermes. */
+    val composerId: String? = null,
+    /** Raw UTF-8 text retained only while a large-paste attachment is preparing. */
+    val composerRawText: String? = null,
 ) {
    val isImage: Boolean get() = contentType.startsWith("image/")

@@ -367,12 +407,20 @@ data class ToolCall(
     * header can render without a separate lane registry.
     */
    val taskLabel: String? = null,
+    /** Live upstream child id used by subagent.steer while this lane runs. */
+    val subagentId: String? = null,
    /** Deterministic non-low output risk reported by upstream for this call. */
    val outputRisk: String? = null,
    /** Human-readable deterministic findings; rendered as untrusted metadata. */
    val outputRiskFindings: List<String> = emptyList(),
    /** Upstream removed sensitive spans before emitting the findings. */
    val outputRiskRedacted: Boolean = false,
+    /**
+     * Stable UI identity retained when a generating placeholder adopts its
+     * gateway tool ID. This keeps per-card interaction state attached to the
+     * logical call across streaming reconciliation and list updates.
+     */
+    val uiKey: String = id ?: "$name:$startedAt",
 )

 enum class MessageRole {
@@ -382,21 +430,28 @@ enum class MessageRole {
 }

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

 data class ChatSession(
    val sessionId: String,
    val title: String?,
    val model: String?,
    val messageCount: Int = 0,
+    val inputTokens: Int = 0,
+    val outputTokens: Int = 0,
+    val actualCostUsd: Double? = null,
+    val estimatedCostUsd: Double? = null,
+    val isActive: Boolean = false,
    val updatedAt: Long = 0L,
    val startedAt: Long = 0L,
    val lastActivityAt: Long = 0L,
@@ -409,7 +464,24 @@ data class ChatSession(
    val source: String? = null,
    /** Server reports a persisted session runtime/model binding. */
    val hasModelConfig: Boolean = false,
+    /** Durable upstream session metadata, scoped by the owning connection/profile DB. */
+    val pinned: Boolean = false,
+    val archived: Boolean = false,
+    /** Optional newer-upstream workspace context; absent on legacy/API-only hosts. */
+    val workingDirectory: String? = null,
+    val gitBranch: String? = null,
+    val gitRepoRoot: String? = null,
+    val pullRequestNumber: Int? = null,
+    val pullRequestUrl: String? = null,
+    val pullRequestState: String? = null,
+    val pullRequestDraft: Boolean = false,
 ) {
+    val totalTokens: Int
+        get() = inputTokens + outputTokens
+
+    val costUsd: Double
+        get() = actualCostUsd ?: estimatedCostUsd ?: 0.0
+
    val activityTimestamp: Long
        get() = firstPositive(lastActivityAt, updatedAt, startedAt)

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

+@Serializable
+data class ChatQueuedMessageCheckpoint(
+    val id: String,
+    val text: String,
+    val transport: String,
+    val ownerRunId: String,
+    val interfaceContextPrompt: String? = null,
+    /** Attachment bytes are intentionally not copied into Preferences DataStore. */
+    val hadAttachments: Boolean = false,
+)
+
@Serializable
 data class ChatTurnUserCheckpoint(
    val id: String,
@@ -117,6 +129,7 @@ data class ChatTurnAskCheckpoint(
    val requestId: String? = null,
    val text: String,
    val choices: List<String>? = null,
+    val multiSelect: Boolean = false,
    val smartDenied: Boolean = false,
    val envVar: String? = null,
    val timeoutSeconds: Int,
@@ -14,6 +14,9 @@ data class DashboardConnectionStatus(
    val gatewayTicketAvailable: Boolean? = null,
    val message: String? = null,
    val gatewayMode: String? = null,
+    /** Profiles positively advertised by the live multiplex gateway. */
+    val servedProfiles: List<String> = emptyList(),
+    /** Installed profiles reported by the dashboard; never routing authority. */
    val profiles: List<String> = emptyList(),
 )

@@ -134,7 +137,7 @@ data class Connection(
         * than to crash).
         */
        fun extractDefaultLabel(apiServerUrl: String): String =
-            extractHost(apiServerUrl) ?: apiServerUrl
+            extractHost(apiServerUrl)?.let(::defaultLabelFromHost) ?: apiServerUrl

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

        private fun extractHost(url: String): String? = try {
@@ -63,12 +63,8 @@ fun EndpointCandidate?.isEncryptedOverlayRoute(isTailscaleDetected: Boolean): Bo
    val hint = security.orEmpty().lowercase()
    return r == "tailscale" ||
        (isTailscaleDetected && hint.contains("tailscale")) ||
-        r == "plugin_proxy" ||
-        r == "plugin-proxy" ||
-        hasSecureProxy() ||
        hint.contains("wireguard") ||
-        hint.contains("https") ||
-        hint.contains("tls")
+        (!hasSecureProxy() && (hint.contains("https") || hint.contains("tls")))
 }

 /** Human label for the overlay mechanism encrypting a route. */
@@ -78,7 +74,6 @@ fun EndpointCandidate?.overlayMechanism(isTailscaleDetected: Boolean): String {
    val hint = security.orEmpty().lowercase()
    return when {
        r == "tailscale" || (isTailscaleDetected && hint.contains("tailscale")) -> "Tailscale"
-        r == "plugin_proxy" || r == "plugin-proxy" || hasSecureProxy() -> "Proxy"
        hint.contains("wireguard") -> "WireGuard"
        hint.contains("https") || hint.contains("tls") -> "TLS"
        else -> "Encrypted"
@@ -92,7 +87,10 @@ fun classifySurfaceSecurity(
    activeEndpoint: EndpointCandidate?,
    isTailscaleDetected: Boolean,
 ): SurfaceSecurity {
+    val secureLinkProtected = activeEndpoint.secureLinkProtects(label, url)
    val (kind, mechanism) = when {
+        secureLinkProtected -> SurfaceSecurityKind.Tls to
+            if (activeEndpoint?.hasHermesReach() == true) "Hermes Reach" else "Hermes Secure Link"
        isTlsUrl(url) -> SurfaceSecurityKind.Tls to "TLS"
        activeEndpoint.isEncryptedOverlayRoute(isTailscaleDetected) ->
            SurfaceSecurityKind.Overlay to activeEndpoint.overlayMechanism(isTailscaleDetected)
@@ -101,6 +99,33 @@ fun classifySurfaceSecurity(
    return SurfaceSecurity(label = label, kind = kind, mechanism = mechanism, url = url)
 }

+private fun EndpointCandidate?.secureLinkProtects(label: String, url: String): Boolean {
+    val candidate = this ?: return false
+    val routes = candidate.proxy?.takeIf { candidate.hasSecureProxy() }
+        ?.let { proxy ->
+            val base = proxy.url.trim().trimEnd('/')
+            Triple(
+                "$base/dashboard",
+                "$base/api",
+                "wss://${base.substringAfter("://")}/relay/ws",
+            )
+        } ?: return false
+    val normalized = url.trim().trimEnd('/')
+    val service = when (label) {
+        "Chat & Manage" -> "dashboard"
+        "API / sessions" -> "api"
+        "Relay tools" -> "relay"
+        else -> return false
+    }
+    if (service !in candidate.secureLinkServices()) return false
+    val expected = when (service) {
+        "dashboard" -> routes.first
+        "api" -> routes.second
+        else -> routes.third
+    }
+    return normalized.equals(expected, ignoreCase = true)
+}
+
 /**
 * Roll up the per-surface verdicts into one connection-level [ConnectionSecurity].
 * Pure + side-effect free so it is unit-testable without Android.
@@ -45,12 +45,13 @@ object ConnectionValidation {
        kind = "API server URL",
    )

-    /** Relay URL must be ws:// or wss:// with a host. */
-    fun validateRelayUrl(raw: String): String? = validateUrl(
-        raw = raw,
-        allowedSchemes = setOf("ws", "wss"),
-        kind = "relay URL",
-    )
+    /** Relay URL may identify its base, WebSocket route, or health route. */
+    fun validateRelayUrl(raw: String): String? {
+        if (raw.isBlank()) return "relay URL can't be blank"
+        return runCatching { RelayEndpointContract.parse(raw) }
+            .exceptionOrNull()
+            ?.message
+    }

    /** Dashboard/Gateway URL must be HTTP(S) when configured. */
    fun validateDashboardUrl(raw: String): String? = validateOptionalUrl(
@@ -67,11 +68,8 @@ object ConnectionValidation {
    )

    /** A blank Relay URL means Relay-only power features are not configured. */
-    fun validateOptionalRelayUrl(raw: String): String? = validateOptionalUrl(
-        raw = raw,
-        allowedSchemes = setOf("ws", "wss"),
-        kind = "relay URL",
-    )
+    fun validateOptionalRelayUrl(raw: String): String? =
+        if (raw.isBlank()) null else validateRelayUrl(raw)

    /**
     * Validate the independently optional connection surfaces. A connection
@@ -114,7 +112,7 @@ object ConnectionValidation {
            val legacyExactMatch =
                (apiServerUrl.isNotBlank() || relayUrl.isNotBlank()) &&
                    urlsEqual(c.apiServerUrl, apiServerUrl) &&
-                    urlsEqual(c.relayUrl, relayUrl)
+                    relayUrlsEqual(c.relayUrl, relayUrl)
            val candidateDashboard = dashboardUrl
                ?.takeIf { it.isNotBlank() }
                ?: Connection.deriveDefaultDashboardUrl(apiServerUrl)
@@ -133,6 +131,12 @@ object ConnectionValidation {
    private fun urlsEqual(first: String, second: String): Boolean =
        first.trim().trimEnd('/').equals(second.trim().trimEnd('/'), ignoreCase = true)

+    private fun relayUrlsEqual(first: String, second: String): Boolean {
+        val left = RelayEndpointContract.parseOrNull(first)?.webSocketUrl ?: return urlsEqual(first, second)
+        val right = RelayEndpointContract.parseOrNull(second)?.webSocketUrl ?: return urlsEqual(first, second)
+        return left.equals(right, ignoreCase = true)
+    }
+
    private fun validateUrl(raw: String, allowedSchemes: Set<String>, kind: String): String? {
        val trimmed = raw.trim()
        if (trimmed.isEmpty()) return "$kind can't be blank"
@@ -0,0 +1,52 @@
+package com.hermesandroid.relay.data
+
+import com.hermesandroid.relay.ui.theme.AppearanceShape
+import com.hermesandroid.relay.ui.theme.normalizeAccentHex
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class CustomThemePreset(
+    val id: String,
+    val name: String,
+    val mode: String,
+    val backgroundHex: String,
+    val surfaceHex: String,
+    val accentHex: String,
+    val textHex: String,
+    val shapeId: String = AppearanceShape.DEFAULT.id,
+) {
+    val appThemeId: String get() = "$APP_THEME_PREFIX$id"
+    val isDark: Boolean get() = mode != MODE_LIGHT
+
+    fun normalized(): CustomThemePreset? {
+        val normalizedId = id.trim().take(64).takeIf { it.matches(ID_PATTERN) } ?: return null
+        val normalizedName = name.trim().replace(WHITESPACE, " ").take(MAX_NAME_LENGTH)
+            .takeIf(String::isNotBlank) ?: return null
+        return copy(
+            id = normalizedId,
+            name = normalizedName,
+            mode = if (mode == MODE_LIGHT) MODE_LIGHT else MODE_DARK,
+            backgroundHex = normalizeAccentHex(backgroundHex) ?: return null,
+            surfaceHex = normalizeAccentHex(surfaceHex) ?: return null,
+            accentHex = normalizeAccentHex(accentHex) ?: return null,
+            textHex = normalizeAccentHex(textHex) ?: return null,
+            shapeId = AppearanceShape.fromId(shapeId).id,
+        )
+    }
+
+    companion object {
+        const val APP_THEME_PREFIX = "custom:"
+        const val MODE_LIGHT = "light"
+        const val MODE_DARK = "dark"
+        const val MAX_PRESETS = 20
+        const val MAX_NAME_LENGTH = 24
+
+        private val ID_PATTERN = Regex("[A-Za-z0-9_-]+")
+        private val WHITESPACE = Regex("\\s+")
+
+        fun idFromAppTheme(appThemeId: String?): String? = appThemeId
+            ?.takeIf { it.startsWith(APP_THEME_PREFIX) }
+            ?.removePrefix(APP_THEME_PREFIX)
+            ?.takeIf(String::isNotBlank)
+    }
+}
@@ -172,6 +172,11 @@ class DataManager(

    suspend fun restoreConnectionBackup(backup: AppBackup) {
        val store = connectionStore ?: return
+        // Validate every credential before deleting or replacing any current
+        // encrypted state. A malformed/hostile backup fails atomically.
+        backup.connectionSecrets.forEach { secret ->
+            AuthManager.validateStoredSecrets(secret.auth)
+        }
        deleteSensitivePreferenceFiles()
        store.replaceConnections(
            connections = backup.connections,
@@ -45,8 +45,13 @@ data class EndpointCandidate(
    val relay: RelayEndpoint? = null,
    val dashboard: DashboardEndpoint? = null,
    val proxy: ProxyEndpoint? = null,
+    /** Optional outbound rendezvous carrying the pinned [proxy] byte stream. */
+    val broker: BrokerEndpoint? = null,
    val security: String? = null,
    val recommended: Boolean = false,
+    val experimental: Boolean = false,
+    @SerialName("display_name")
+    val displayName: String? = null,
 )

 /**
@@ -110,6 +115,27 @@ data class ProxyEndpoint(
    val transportHint: String? = null,
    @SerialName("pin_sha256")
    val pinSha256: String? = null,
+    /** Independently authenticated services carried by this pinned origin. */
+    val surfaces: List<String> = listOf("relay"),
+)
+
+/**
+ * Hermes Reach rendezvous metadata from an operator-reviewed pairing payload.
+ * The token authenticates only this broker route; Hermes service credentials
+ * remain inside the QR-pinned Secure Link TLS connection.
+ */
+@Serializable
+data class BrokerEndpoint(
+    val url: String,
+    @SerialName("protocol_version")
+    val protocolVersion: Int = 1,
+    @SerialName("host_id")
+    val hostId: String,
+    @SerialName("credential_kind")
+    val credentialKind: String,
+    val token: String,
+    @SerialName("expires_at")
+    val expiresAt: Long? = null,
 )

 /**
@@ -123,7 +149,7 @@ data class ProxyEndpoint(
 */
 fun EndpointCandidate.isKnownRole(): Boolean {
    return when (role.lowercase()) {
-        "lan", "tailscale", "public", "plugin_proxy", "plugin-proxy", "https" -> true
+        "lan", "tailscale", "public", "plugin_proxy", "plugin-proxy", "outbound_broker", "https" -> true
        else -> false
    }
 }
@@ -146,7 +172,8 @@ fun EndpointCandidate.displayLabel(): String {
            "Public"
        }
        "https" -> "HTTPS"
-        "plugin_proxy", "plugin-proxy" -> "Plugin proxy"
+        "plugin_proxy", "plugin-proxy" -> "Hermes Secure Link"
+        "outbound_broker", "broker", "relay_broker" -> "Hermes Reach · Experimental"
        else -> "Custom VPN ($role)"
    }
 }
@@ -177,7 +204,69 @@ fun EndpointCandidate.routeAuthority(): String? {
 }

 fun EndpointCandidate.hasSecureProxy(): Boolean =
-    proxy?.url?.startsWith("https://", ignoreCase = true) == true ||
-        proxy?.url?.startsWith("wss://", ignoreCase = true) == true ||
-        role.equals("plugin_proxy", ignoreCase = true) ||
-        role.equals("plugin-proxy", ignoreCase = true)
+    proxy?.isValidPinnedProxy() == true
+
+/** Product-facing service inventory; wire identifiers remain unchanged. */
+fun EndpointCandidate.secureLinkServices(): List<String> =
+    if (!hasSecureProxy()) emptyList() else proxy.orEmptySurfaces()
+
+fun EndpointCandidate.secureLinkCoversAllServices(): Boolean =
+    secureLinkServices().containsAll(listOf("relay", "api", "dashboard"))
+
+fun EndpointCandidate.presentationRouteUrl(): String? =
+    broker?.url?.takeIf { hasHermesReach() } ?: proxy?.url?.takeIf { hasSecureProxy() } ?: primaryRouteUrl()
+
+fun EndpointCandidate.hasHermesReach(): Boolean =
+    role.lowercase() in setOf("outbound_broker", "broker", "relay_broker") &&
+        broker?.isValidHermesReach() == true && hasSecureProxy()
+
+fun BrokerEndpoint.isValidHermesReach(): Boolean {
+    if (protocolVersion != 1 || !hostId.isCanonicalBase64Url(16) || !token.isCanonicalBase64Url(32)) return false
+    if (credentialKind !in setOf("bootstrap", "route")) return false
+    if (credentialKind == "bootstrap" && expiresAt?.let { it <= System.currentTimeMillis() / 1000L } == true) return false
+    val uri = runCatching { URI(url.trim()) }.getOrNull() ?: return false
+    if (!uri.scheme.equals("wss", ignoreCase = true) || uri.host.isNullOrBlank()) return false
+    if (!uri.rawUserInfo.isNullOrBlank() || uri.rawQuery != null || uri.rawFragment != null) return false
+    return uri.rawPath.orEmpty().let { it.isEmpty() || it == "/" || it == "/v1/connect" }
+}
+
+private fun String.isCanonicalBase64Url(byteCount: Int): Boolean {
+    if (isBlank() || '=' in this) return false
+    val decoded = runCatching { java.util.Base64.getUrlDecoder().decode(this) }.getOrNull() ?: return false
+    return decoded.size == byteCount &&
+        java.util.Base64.getUrlEncoder().withoutPadding().encodeToString(decoded) == this
+}
+
+/** Exact host locator + broker authority replacement; never crosses devices. */
+internal fun replaceHermesReachCredential(
+    source: List<EndpointCandidate>,
+    expected: BrokerEndpoint,
+    replacement: EndpointCandidate,
+): List<EndpointCandidate> = source.map { candidate ->
+    if (candidate.broker?.hostId == expected.hostId &&
+        sameBrokerAuthority(candidate.broker.url, expected.url)
+    ) replacement else candidate
+}
+
+internal fun sameBrokerAuthority(left: String, right: String): Boolean = runCatching {
+    val a = URI(left.trim())
+    val b = URI(right.trim())
+    fun port(uri: URI) = if (uri.port > 0) uri.port else 443
+    a.scheme.equals("wss", true) && b.scheme.equals("wss", true) &&
+        a.host.equals(b.host, true) && port(a) == port(b) &&
+        a.rawPath.orEmpty().trimEnd('/') == b.rawPath.orEmpty().trimEnd('/')
+}.getOrDefault(false)
+
+private fun ProxyEndpoint?.orEmptySurfaces(): List<String> = this?.surfaces.orEmpty()
+    .map { it.trim().lowercase() }
+    .filter { it in setOf("relay", "api", "dashboard") }
+    .distinct()
+
+fun ProxyEndpoint.isValidPinnedProxy(): Boolean {
+    val uri = runCatching { URI(url.trim().trimEnd('/')) }.getOrNull() ?: return false
+    if (!uri.scheme.equals("https", ignoreCase = true) || uri.host.isNullOrBlank()) return false
+    if (!uri.rawUserInfo.isNullOrBlank() || uri.rawQuery != null || uri.rawFragment != null) return false
+    if (uri.rawPath.orEmpty().let { it.isNotEmpty() && it != "/" }) return false
+    val pin = pinSha256?.trim()?.removePrefix("sha256/") ?: return false
+    return runCatching { java.util.Base64.getDecoder().decode(pin).size == 32 }.getOrDefault(false)
+}
@@ -139,5 +139,5 @@ object BuildFlavor {
            GOOGLE_PLAY -> "Google Play"
            SIDELOAD -> "Sideload"
            else -> current.ifBlank { "Unknown" }
-        }
+        } + if (CandidateBuild.isCandidate) " Candidate" else ""
 }
@@ -2,6 +2,8 @@ package com.hermesandroid.relay.data

 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json

 /**
 * A rich content card emitted inline in an assistant message via the
@@ -117,6 +119,8 @@ data class HermesCardInput(
    val kind: String,
    /** Quick-answer chips (clarify). Empty = no chip row. */
    val choices: List<String> = emptyList(),
+    /** Choices toggle independently and require an explicit submit. */
+    val multiSelect: Boolean = false,
    /** Render the inline free-text mini field under the chips. */
    val allowFreeText: Boolean = false,
    /** Password-style field: masked glyphs + reveal toggle (secret/sudo). */
@@ -124,7 +128,7 @@ data class HermesCardInput(
    /** Submit is a 650ms hold-to-confirm press-fill instead of a tap (sudo). */
    val holdToConfirm: Boolean = false,
    /**
-     * Wall-clock expiry for timed asks (sudo 120s, clarify/secret 300s).
+     * Wall-clock expiry for asks with an advertised deadline.
     * The renderer shows a countdown footer (Amber under 30s) and
     * self-collapses to "Expired — not granted" past it. Null = no timeout
     * (approval is session-scoped).
@@ -155,6 +159,10 @@ data class HermesCardInput(
    }
 }

+/** Exact JSON-array wire value expected by upstream multi-select clarify. */
+internal fun encodeClarifyMultiSelectAnswer(values: List<String>): String =
+    Json.encodeToString(values.map(String::trim).filter(String::isNotEmpty).distinct())
+
 /**
 * A label/value row inside a card. [value] is rendered as markdown so the
 * agent can embed emphasis, inline code, or links.
@@ -34,6 +34,10 @@ data class ProactiveInboxEntry(
     * field).
     */
    val chatId: String? = null,
+    /** Owning saved connection. Null only for entries written by older builds. */
+    val connectionId: String? = null,
+    /** Relay proved this row came from its bounded offline queue. */
+    val arrivedWhileAway: Boolean = false,
 )

 private val Context.proactiveInboxStore: DataStore<Preferences> by
@@ -49,10 +53,10 @@ private const val MAX_ENTRIES = 100
 * newest-first, deduped by id (so a re-delivered message doesn't double up), and
 * capped at [MAX_ENTRIES]. Survives app restart.
 *
- * Demoted (2026-06-29): the agent conversation now lives as a Thread in Chat (the
- * gateway session is the durable history), so the in-app inbox view is retired.
- * This store is only fed for messages NOT shown in an open Thread; it currently
- * has no viewer and is fully retireable — see TODO.
+ * Demoted (2026-06-29): once a phone gateway session exists, it is the durable
+ * history. Outbound agent messages arrive before that session exists, so this
+ * bounded store also backs the provisional Thread until the user's first reply
+ * promotes it to a real `source=phone` session.
 */
 class ProactiveInboxRepository(private val context: Context) {

@@ -0,0 +1,125 @@
+package com.hermesandroid.relay.data
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.ImageDecoder
+import android.net.Uri
+import android.os.Build
+import java.io.ByteArrayOutputStream
+import kotlin.math.roundToInt
+
+internal fun profileAvatarMime(bytes: ByteArray): String? = when {
+    bytes.size >= 8 && bytes.copyOfRange(0, 8).contentEquals(
+        byteArrayOf(0x89.toByte(), 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a),
+    ) -> "image/png"
+    bytes.size >= 3 && bytes[0] == 0xff.toByte() && bytes[1] == 0xd8.toByte() &&
+        bytes[2] == 0xff.toByte() -> "image/jpeg"
+    bytes.size >= 12 && bytes.copyOfRange(0, 4).contentEquals("RIFF".toByteArray()) &&
+        bytes.copyOfRange(8, 12).contentEquals("WEBP".toByteArray()) -> "image/webp"
+    else -> null
+}
+
+/**
+ * Convert any image Android can decode into the small static format accepted by
+ * upstream `profiles.set_asset`. ImageDecoder applies camera EXIF orientation
+ * and downsamples before allocating the bitmap on current Android releases.
+ */
+internal fun prepareProfileAvatar(
+    context: Context,
+    uri: Uri,
+    maxBytes: Int,
+): ByteArray? {
+    val original = runCatching {
+        context.contentResolver.openInputStream(uri)?.use { input ->
+            val output = ByteArrayOutputStream(minOf(maxBytes + 1, 64 * 1024))
+            val buffer = ByteArray(16 * 1024)
+            while (output.size() <= maxBytes) {
+                val read = input.read(buffer)
+                if (read < 0) break
+                output.write(buffer, 0, read)
+            }
+            output.toByteArray()
+        }
+    }.getOrNull()
+    if (original != null && original.size <= maxBytes && profileAvatarMime(original) != null) {
+        return original
+    }
+
+    val bitmap = decodeProfileAvatar(context, uri) ?: return null
+    return try {
+        encodeProfileAvatar(bitmap, maxBytes)
+    } finally {
+        bitmap.recycle()
+    }
+}
+
+private fun decodeProfileAvatar(context: Context, uri: Uri): Bitmap? = runCatching {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        ImageDecoder.decodeBitmap(ImageDecoder.createSource(context.contentResolver, uri)) { decoder, info, _ ->
+            decoder.allocator = ImageDecoder.ALLOCATOR_SOFTWARE
+            val width = info.size.width
+            val height = info.size.height
+            val longest = maxOf(width, height)
+            if (longest > PROFILE_AVATAR_MAX_DIMENSION) {
+                val scale = PROFILE_AVATAR_MAX_DIMENSION.toFloat() / longest
+                decoder.setTargetSize(
+                    (width * scale).roundToInt().coerceAtLeast(1),
+                    (height * scale).roundToInt().coerceAtLeast(1),
+                )
+            }
+        }
+    } else {
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, bounds) }
+        var sample = 1
+        while (maxOf(bounds.outWidth, bounds.outHeight) / sample > PROFILE_AVATAR_MAX_DIMENSION) sample *= 2
+        context.contentResolver.openInputStream(uri)?.use {
+            BitmapFactory.decodeStream(it, null, BitmapFactory.Options().apply { inSampleSize = sample })
+        }
+    }
+}.getOrNull()
+
+internal fun encodeProfileAvatar(bitmap: Bitmap, maxBytes: Int): ByteArray? {
+    var working = bitmap.scaledToFit(PROFILE_AVATAR_MAX_DIMENSION)
+    var ownsWorking = working !== bitmap
+    try {
+        while (true) {
+            val format = if (working.hasAlpha()) Bitmap.CompressFormat.PNG else Bitmap.CompressFormat.JPEG
+            val qualities = if (format == Bitmap.CompressFormat.PNG) intArrayOf(100) else intArrayOf(92, 82, 72, 62)
+            for (quality in qualities) {
+                val encoded = ByteArrayOutputStream().use { output ->
+                    if (!working.compress(format, quality, output)) null else output.toByteArray()
+                }
+                if (encoded != null && encoded.size <= maxBytes) return encoded
+            }
+            if (maxOf(working.width, working.height) <= PROFILE_AVATAR_MIN_DIMENSION) return null
+            val next = Bitmap.createScaledBitmap(
+                working,
+                (working.width * 0.75f).roundToInt().coerceAtLeast(1),
+                (working.height * 0.75f).roundToInt().coerceAtLeast(1),
+                true,
+            )
+            if (ownsWorking) working.recycle()
+            working = next
+            ownsWorking = true
+        }
+    } finally {
+        if (ownsWorking) working.recycle()
+    }
+}
+
+private fun Bitmap.scaledToFit(maxDimension: Int): Bitmap {
+    val longest = maxOf(width, height)
+    if (longest <= maxDimension) return this
+    val scale = maxDimension.toFloat() / longest
+    return Bitmap.createScaledBitmap(
+        this,
+        (width * scale).roundToInt().coerceAtLeast(1),
+        (height * scale).roundToInt().coerceAtLeast(1),
+        true,
+    )
+}
+
+private const val PROFILE_AVATAR_MAX_DIMENSION = 1024
+private const val PROFILE_AVATAR_MIN_DIMENSION = 128
@@ -2,6 +2,35 @@ package com.hermesandroid.relay.data

 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+
+internal fun isSafeProfileUiMeta(meta: JsonObject): Boolean {
+    if (meta.toString().toByteArray(Charsets.UTF_8).size > 65_536) return false
+    fun containsEmbeddedAsset(value: String): Boolean {
+        val compact = value.trim()
+        return compact.startsWith("data:image/", ignoreCase = true) ||
+            compact.startsWith("iVBORw0KGgo") || // PNG
+            compact.startsWith("/9j/") || // JPEG
+            compact.startsWith("UklGR") || // RIFF/WebP
+            compact.startsWith("R0lGOD") || // GIF
+            compact.startsWith("UEsDB") // ZIP/pet archive
+    }
+    fun safe(element: JsonElement): Boolean = when (element) {
+        is JsonObject -> element.size <= 128 && element.all { (key, value) ->
+            key.length <= 128 && safe(value)
+        }
+        is JsonArray -> element.size <= 128 && element.all(::safe)
+        is JsonPrimitive -> {
+            val value = element.contentOrNull
+            value == null || (value.length <= 4_096 && !containsEmbeddedAsset(value))
+        }
+    }
+    return safe(meta)
+}

 /**
 * An agent profile advertised by a Hermes server in its `auth.ok` payload.
@@ -56,6 +85,7 @@ import kotlinx.serialization.Serializable
 data class Profile(
    val name: String,
    val model: String,
+    val provider: String = "",
    val description: String = "",
    @SerialName("system_message")
    val systemMessage: String? = null,
@@ -75,6 +105,12 @@ data class Profile(
    val apiServerPort: Int? = null,
    @SerialName("api_server_key_present")
    val apiServerKeyPresent: Boolean = false,
+    @SerialName("is_default")
+    val isDefault: Boolean = false,
+    @SerialName("has_avatar")
+    val hasAvatar: Boolean = false,
+    @SerialName("ui_meta")
+    val uiMeta: JsonObject = JsonObject(emptyMap()),
 ) {
    val hasIsolatedApi: Boolean
        get() = !apiServerUrl.isNullOrBlank()
@@ -4,13 +4,15 @@ 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.booleanPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map

 /**
- * Local-only per-profile agent icons — the visual twin of [ProfileDisplayAliasStore].
+ * Per-profile icon cache. Local fallback paths and Hermes-owned avatar cache
+ * paths use separate keys so syncing either side never silently overwrites the other.
 *
 * Stores a **file path** to an image that was copied into app storage (not a SAF
 * content URI, so it survives without a persistable-permission grant). Like the
@@ -25,6 +27,8 @@ class ProfileIconStore(

    companion object {
        private const val PREFIX = "profile_icon__"
+        private const val SERVER_PREFIX = "profile_avatar_server__"
+        private const val LOCAL_OVERRIDE_PREFIX = "profile_icon_override__"

        private fun keyName(connectionId: String, profileName: String?): String =
            "$PREFIX${connectionId}__${AgentDisplay.profileSessionKey(profileName)}"
@@ -34,6 +38,20 @@ class ProfileIconStore(

        private fun connectionPrefix(connectionId: String): String =
            "$PREFIX${connectionId}__"
+
+        private fun serverKeyFor(connectionId: String, profileName: String) =
+            stringPreferencesKey("$SERVER_PREFIX${connectionId}__${AgentDisplay.profileSessionKey(profileName)}")
+
+        private fun serverConnectionPrefix(connectionId: String): String =
+            "$SERVER_PREFIX${connectionId}__"
+
+        private fun localOverrideKeyFor(connectionId: String, profileName: String?) =
+            booleanPreferencesKey(
+                "$LOCAL_OVERRIDE_PREFIX${connectionId}__${AgentDisplay.profileSessionKey(profileName)}",
+            )
+
+        private fun localOverrideConnectionPrefix(connectionId: String): String =
+            "$LOCAL_OVERRIDE_PREFIX${connectionId}__"
    }

    suspend fun setIcon(connectionId: String, profileName: String?, path: String?) {
@@ -52,11 +70,39 @@ class ProfileIconStore(
        return dataStore.data.map { prefs -> prefs[key] }
    }

+    suspend fun setServerAvatar(connectionId: String, profileName: String, path: String?) {
+        dataStore.edit { prefs ->
+            val key = serverKeyFor(connectionId, profileName)
+            if (path.isNullOrBlank()) prefs.remove(key) else prefs[key] = path
+        }
+    }
+
+    fun serverAvatarFlow(connectionId: String, profileName: String): Flow<String?> {
+        val key = serverKeyFor(connectionId, profileName)
+        return dataStore.data.map { prefs -> prefs[key] }
+    }
+
+    suspend fun setLocalOverride(connectionId: String, profileName: String?, enabled: Boolean) {
+        dataStore.edit { prefs ->
+            val key = localOverrideKeyFor(connectionId, profileName)
+            if (enabled) prefs[key] = true else prefs.remove(key)
+        }
+    }
+
+    fun localOverrideFlow(connectionId: String, profileName: String?): Flow<Boolean> {
+        val key = localOverrideKeyFor(connectionId, profileName)
+        return dataStore.data.map { prefs -> prefs[key] ?: false }
+    }
+
    suspend fun clearConnection(connectionId: String) {
-        val prefix = connectionPrefix(connectionId)
+        val prefixes = listOf(
+            connectionPrefix(connectionId),
+            serverConnectionPrefix(connectionId),
+            localOverrideConnectionPrefix(connectionId),
+        )
        dataStore.edit { prefs ->
            prefs.asMap().keys
-                .filter { it.name.startsWith(prefix) }
+                .filter { key -> prefixes.any(key.name::startsWith) }
                .forEach { prefs.remove(it) }
        }
    }
@@ -66,5 +112,11 @@ class ProfileIconStore(
    }
 }

+internal fun preferredProfileIcon(
+    server: String?,
+    local: String?,
+    useLocalOverride: Boolean,
+): String? = if (useLocalOverride && !local.isNullOrBlank()) local else server ?: local
+
 internal val Context.profileIconsDataStore: DataStore<Preferences>
        by preferencesDataStore(name = "profile_icons")
@@ -136,3 +136,154 @@ data class ProfileMemoryUpdateResponse(
    @SerialName("bytes_written")
    val bytesWritten: Long,
 )
+
+/** Authoritative upstream `profiles.describe` snapshot. */
+data class GatewayProfileDescription(
+    val name: String,
+    val description: String,
+    val soul: String,
+    val provider: String,
+    val model: String,
+    val skills: List<GatewayProfileSkill>,
+    val toolsets: List<GatewayProfileToolset>,
+    val toolsetsPinned: Boolean,
+)
+
+data class GatewayProfileSkill(val name: String, val enabled: Boolean)
+
+data class GatewayProfileToolset(
+    val name: String,
+    val description: String,
+    val toolCount: Int,
+    val enabled: Boolean,
+)
+
+enum class GatewayProfileSection(val wireName: String) {
+    Description("description"),
+    Soul("soul"),
+    Model("model"),
+    Skills("skills"),
+    Toolsets("toolsets"),
+    McpServers("mcp_servers"),
+    UiMeta("ui_meta"),
+}
+
+/** Null leaves a section unchanged; empty lists retain upstream replace semantics. */
+data class GatewayProfilePatch(
+    val description: String? = null,
+    val soul: String? = null,
+    val provider: String? = null,
+    val model: String? = null,
+    val disabledSkills: List<String>? = null,
+    val enabledToolsets: List<String>? = null,
+    val enabledMcpServers: List<String>? = null,
+    /** Small interoperable preferences only; binary assets belong in profiles.set_asset. */
+    val uiMeta: JsonObject? = null,
+) {
+    val requestedSections: Set<GatewayProfileSection>
+        get() = buildSet {
+            if (description != null) add(GatewayProfileSection.Description)
+            if (soul != null) add(GatewayProfileSection.Soul)
+            if (provider != null && model != null) add(GatewayProfileSection.Model)
+            if (disabledSkills != null) add(GatewayProfileSection.Skills)
+            if (enabledToolsets != null) add(GatewayProfileSection.Toolsets)
+            if (enabledMcpServers != null) add(GatewayProfileSection.McpServers)
+            if (uiMeta != null) add(GatewayProfileSection.UiMeta)
+        }
+}
+
+enum class GatewayProfileAuthChoice {
+    /** Share the launch profile's refreshable OAuth/token store; copy static environment keys. */
+    Shared,
+
+    /** Copy the current credential snapshot into a separate profile-owned store. */
+    Copied,
+
+    /** Copy no credentials or provider defaults. */
+    Isolated,
+}
+
+data class GatewayProfileCreateRequest(
+    val name: String,
+    val description: String? = null,
+    val cloneFrom: String? = null,
+    val cloneAll: Boolean = false,
+    val noSkills: Boolean = false,
+    val soul: String? = null,
+    val model: String? = null,
+    val provider: String? = null,
+    val authChoice: GatewayProfileAuthChoice = GatewayProfileAuthChoice.Shared,
+)
+
+data class GatewayProfileCreateResult(
+    val name: String,
+    val soulWritten: Boolean,
+    val modelSet: Boolean,
+    val mirroredEnvironment: Boolean,
+    val mirroredAuth: String?,
+    val modelInherited: Boolean,
+    val voiceMirrored: Boolean,
+) {
+    fun partialMessages(request: GatewayProfileCreateRequest): List<String> = buildList {
+        if (!request.soul.isNullOrBlank() && !soulWritten) add("SOUL was not saved")
+        if (!request.model.isNullOrBlank() && !modelSet) add("model was not saved")
+        if (request.authChoice == GatewayProfileAuthChoice.Shared && mirroredAuth != "shared") {
+            add("shared sign-in was not confirmed")
+        }
+        if (
+            request.authChoice == GatewayProfileAuthChoice.Copied &&
+            !mirroredEnvironment && mirroredAuth != "true"
+        ) {
+            add("no credential source was copied")
+        }
+    }
+}
+
+data class GatewayProfileAsset(
+    val data: ByteArray,
+    val mime: String,
+)
+
+class GatewayProfileManagementUnsupportedException(
+    operation: String,
+) : Exception("$operation is not supported by this gateway")
+
+data class GatewayProfileConfigureResult(
+    val requested: Set<GatewayProfileSection>,
+    val applied: Set<GatewayProfileSection>,
+) {
+    val failed: Set<GatewayProfileSection> get() = requested - applied
+}
+
+interface GatewayProfileEditorClient {
+    suspend fun describeProfile(profileName: String): Result<GatewayProfileDescription>
+    suspend fun configureProfile(
+        profileName: String,
+        patch: GatewayProfilePatch,
+    ): Result<GatewayProfileConfigureResult>
+}
+
+class GatewayProfileEditorUnsupportedException : Exception(
+    "Profile editing is not supported by this gateway",
+)
+
+/** Relay fallback retained for older gateways and Relay-only memory files. */
+interface LegacyProfileInspectorClient {
+    suspend fun fetchConfig(profileName: String): Result<ProfileConfigResponse>
+    suspend fun fetchSkills(profileName: String): Result<ProfileSkillsResponse>
+    suspend fun fetchSoul(profileName: String): Result<ProfileSoulResponse>
+    suspend fun fetchMemory(profileName: String): Result<ProfileMemoryResponse>
+    suspend fun updateSoul(profileName: String, content: String): Result<ProfileSoulUpdateResponse>
+    suspend fun updateMemoryEntry(
+        profileName: String,
+        filename: String,
+        content: String,
+    ): Result<ProfileMemoryUpdateResponse>
+    suspend fun updateSkillToggle(skillName: String, enabled: Boolean): Result<RelaySkillToggleResult>
+    suspend fun probeSkillToggleSupported(): Boolean
+}
+
+sealed interface RelaySkillToggleResult {
+    data object Ok : RelaySkillToggleResult
+    data object NotImplemented : RelaySkillToggleResult
+}
@@ -9,6 +9,7 @@ import androidx.datastore.preferences.preferencesDataStore
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.builtins.MapSerializer
 import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.json.Json

@@ -16,6 +17,8 @@ import kotlinx.serialization.json.Json
 data class ProfilePresentation(
    val order: List<String> = emptyList(),
    val hidden: Set<String> = emptySet(),
+    /** Local-only named-profile accent overrides, stored as normalized RGB hex. */
+    val colors: Map<String, String> = emptyMap(),
 )

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

 class ProfilePresentationStore(
@@ -58,14 +66,17 @@ class ProfilePresentationStore(

    private val json = Json { ignoreUnknownKeys = true }
    private val listSerializer = ListSerializer(String.serializer())
+    private val mapSerializer = MapSerializer(String.serializer(), String.serializer())

    private fun orderKey(connectionId: String) = stringPreferencesKey("order_$connectionId")
    private fun hiddenKey(connectionId: String) = stringPreferencesKey("hidden_$connectionId")
+    private fun colorsKey(connectionId: String) = stringPreferencesKey("colors_$connectionId")

    fun presentationFlow(connectionId: String): Flow<ProfilePresentation> = dataStore.data.map { prefs ->
        ProfilePresentation(
            order = decode(prefs[orderKey(connectionId)]),
            hidden = decode(prefs[hiddenKey(connectionId)]).toSet(),
+            colors = decodeMap(prefs[colorsKey(connectionId)]),
        )
    }

@@ -77,10 +88,18 @@ class ProfilePresentationStore(
        dataStore.edit { it[hiddenKey(connectionId)] = json.encodeToString(listSerializer, hidden.sorted()) }
    }

+    suspend fun setColors(connectionId: String, colors: Map<String, String>) {
+        dataStore.edit {
+            if (colors.isEmpty()) it.remove(colorsKey(connectionId))
+            else it[colorsKey(connectionId)] = json.encodeToString(mapSerializer, colors.toSortedMap())
+        }
+    }
+
    suspend fun clear(connectionId: String) {
        dataStore.edit {
            it.remove(orderKey(connectionId))
            it.remove(hiddenKey(connectionId))
+            it.remove(colorsKey(connectionId))
        }
    }

@@ -93,6 +112,12 @@ class ProfilePresentationStore(
    } else {
        runCatching { json.decodeFromString(listSerializer, raw) }.getOrDefault(emptyList())
    }
+
+    private fun decodeMap(raw: String?): Map<String, String> = if (raw == null) {
+        emptyMap()
+    } else {
+        runCatching { json.decodeFromString(mapSerializer, raw) }.getOrDefault(emptyMap())
+    }
 }

 internal val Context.profilePresentationDataStore: DataStore<Preferences>
@@ -0,0 +1,86 @@
+package com.hermesandroid.relay.data
+
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import java.net.URI
+
+/** Canonical Relay routes derived from one operator- or pairing-supplied URL. */
+data class RelayEndpoints(
+    val httpBaseUrl: String,
+    val webSocketBaseUrl: String,
+    val webSocketUrl: String,
+    val healthUrl: String,
+)
+
+/**
+ * Parses the accepted Relay URL forms and derives every route from one base.
+ *
+ * The input may identify the route base, its terminal `/ws` endpoint, or its
+ * terminal `/health` endpoint, using either HTTP(S) or WS(S). The final
+ * `ws`/`health` segment is removed before both canonical routes are rebuilt,
+ * which makes the operation idempotent and preserves reverse-proxy prefixes.
+ */
+object RelayEndpointContract {
+    private val encodedAmbiguousPathByte = Regex("%(?:2e|2f|5c)", RegexOption.IGNORE_CASE)
+
+    fun parseOrNull(raw: String?): RelayEndpoints? = runCatching { parse(raw) }.getOrNull()
+
+    fun parse(raw: String?): RelayEndpoints {
+        val input = raw?.trim()?.takeIf { it.isNotEmpty() }
+            ?: throw IllegalArgumentException("Relay URL is empty")
+        val uri = runCatching { URI(input) }.getOrElse {
+            throw IllegalArgumentException("Relay URL is malformed")
+        }
+        val sourceScheme = uri.scheme?.lowercase()
+        val secure = when (sourceScheme) {
+            "https", "wss" -> true
+            "http", "ws" -> false
+            else -> throw IllegalArgumentException("Relay URL must use HTTP(S) or WS(S)")
+        }
+        if (uri.host.isNullOrBlank() || uri.rawAuthority.isNullOrBlank() || uri.isOpaque) {
+            throw IllegalArgumentException("Relay URL has no valid host")
+        }
+        if (uri.rawUserInfo != null) {
+            throw IllegalArgumentException("Relay URL must not contain user info")
+        }
+        if (uri.rawQuery != null || uri.rawFragment != null) {
+            throw IllegalArgumentException("Relay URL must not contain a query or fragment")
+        }
+        if (uri.port == 0 || uri.port > 65_535) {
+            throw IllegalArgumentException("Relay URL has an invalid port")
+        }
+
+        val rawPath = uri.rawPath.orEmpty()
+        if ('\\' in rawPath || "//" in rawPath || encodedAmbiguousPathByte.containsMatchIn(rawPath)) {
+            throw IllegalArgumentException("Relay URL contains an ambiguous path")
+        }
+        val trimmedPath = rawPath.trimEnd('/')
+        val pathSegments = trimmedPath.split('/').filter { it.isNotEmpty() }
+        if (pathSegments.any { it == "." || it == ".." }) {
+            throw IllegalArgumentException("Relay URL contains a relative path segment")
+        }
+        val baseSegments = if (pathSegments.lastOrNull() in setOf("ws", "health")) {
+            pathSegments.dropLast(1)
+        } else {
+            pathSegments
+        }
+        val basePath = baseSegments.joinToString(separator = "/", prefix = "/")
+            .takeUnless { it == "/" }
+            .orEmpty()
+        val httpScheme = if (secure) "https" else "http"
+        val webSocketScheme = if (secure) "wss" else "ws"
+        val httpBase = "$httpScheme://${uri.rawAuthority}$basePath"
+        val webSocketBase = "$webSocketScheme://${uri.rawAuthority}$basePath"
+        val webSocket = "$webSocketBase/ws"
+        val health = "$httpBase/health"
+
+        if (httpBase.toHttpUrlOrNull() == null || health.toHttpUrlOrNull() == null) {
+            throw IllegalArgumentException("Relay URL is malformed")
+        }
+        return RelayEndpoints(
+            httpBaseUrl = httpBase,
+            webSocketBaseUrl = webSocketBase,
+            webSocketUrl = webSocket,
+            healthUrl = health,
+        )
+    }
+}
@@ -0,0 +1,7 @@
+package com.hermesandroid.relay.data
+
+/** Live activity surfaced beside a session without conflating it with selection. */
+enum class SessionActivityState {
+    Working,
+    NeedsInput,
+}
@@ -3,6 +3,8 @@ package com.hermesandroid.relay.diagnostics
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import com.hermesandroid.relay.reliability.ReliabilityCenter
+import com.hermesandroid.relay.reliability.ReliabilityRedactor

 enum class DiagnosticCategory(val label: String) {
    Api("API"),
@@ -25,7 +27,16 @@ data class DiagnosticLogEntry(
    val severity: DiagnosticSeverity,
    val title: String,
    val detail: String? = null,
+    /** Human-readable action that produced this event, not merely its subsystem. */
+    val operation: String? = null,
    val endpointRole: String? = null,
+    /** User/configuration-facing route before protocol/path normalization. */
+    val configuredUrl: String? = null,
+    /** Exact sanitized URL attempted on the wire, including the diagnostic path. */
+    val requestUrl: String? = null,
+    /** Concrete next troubleshooting step for failures with a known interpretation. */
+    val suggestion: String? = null,
+    /** Legacy single-URL field retained for diagnostics that have not needed split context. */
    val url: String? = null,
    val elapsedMs: Long? = null,
    /**
@@ -34,7 +45,11 @@ data class DiagnosticLogEntry(
     * the detail view shows this. Null for non-error / manually-recorded entries.
     */
    val stacktrace: String? = null,
-)
+) {
+    /** Best route for mode inference and compact list rendering. */
+    val primaryUrl: String?
+        get() = configuredUrl ?: requestUrl ?: url
+}

 /**
 * Current health of a single subsystem on the Diagnostics status timeline.
@@ -81,19 +96,29 @@ object DiagnosticsLog {
        severity: DiagnosticSeverity = DiagnosticSeverity.Info,
        title: String,
        detail: String? = null,
+        operation: String? = null,
        endpointRole: String? = null,
+        configuredUrl: String? = null,
+        requestUrl: String? = null,
+        suggestion: String? = null,
        url: String? = null,
        elapsedMs: Long? = null,
        stacktrace: String? = null,
    ) {
+        val safeConfiguredUrl = sanitizeUrl(configuredUrl)
+        val safeRequestUrl = sanitizeUrl(requestUrl)
        val entry = DiagnosticLogEntry(
            timestampMs = System.currentTimeMillis(),
            category = category,
            severity = severity,
            title = clean(title) ?: title.take(MAX_TEXT_LENGTH),
            detail = clean(detail),
+            operation = clean(operation),
            endpointRole = clean(endpointRole),
-            url = sanitizeUrl(url),
+            configuredUrl = safeConfiguredUrl,
+            requestUrl = safeRequestUrl,
+            suggestion = clean(suggestion),
+            url = if (safeConfiguredUrl == null && safeRequestUrl == null) sanitizeUrl(url) else null,
            elapsedMs = elapsedMs,
            stacktrace = redactTrace(stacktrace),
        )
@@ -121,20 +146,40 @@ object DiagnosticsLog {
        title: String,
        detail: String? = null,
        throwable: Throwable? = null,
+        operation: String? = null,
        endpointRole: String? = null,
+        configuredUrl: String? = null,
+        requestUrl: String? = null,
+        suggestion: String? = null,
        url: String? = null,
        elapsedMs: Long? = null,
+        reliabilityContext: String? = null,
    ) {
        record(
            category = category,
            severity = DiagnosticSeverity.Error,
            title = title,
            detail = detail ?: throwable?.message,
+            operation = operation,
            endpointRole = endpointRole,
+            configuredUrl = configuredUrl,
+            requestUrl = requestUrl,
+            suggestion = suggestion,
            url = url,
            elapsedMs = elapsedMs,
            stacktrace = throwable?.let { stackTraceText(it) },
        )
+        if (throwable != null) {
+            runCatching {
+                ReliabilityCenter.recordHandled(
+                    title = title,
+                    detail = detail ?: throwable.message,
+                    throwable = throwable,
+                    context = reliabilityContext,
+                    routeRole = endpointRole,
+                )
+            }
+        }
    }

    private fun stackTraceText(t: Throwable): String =
@@ -167,10 +212,8 @@ object DiagnosticsLog {
            val prefix = noQuery.substring(0, schemeEnd + 3)
            val rest = noQuery.substring(schemeEnd + 3)
            val slash = rest.indexOf('/').let { if (it < 0) rest.length else it }
-            val authority = rest.substring(0, slash)
            val path = rest.substring(slash)
-            val safeAuthority = authority.substringAfterLast('@')
-            prefix + safeAuthority + path
+            prefix + "[host]" + path
        } else {
            noQuery
        }
@@ -197,7 +240,7 @@ object DiagnosticsLog {
     */
    private fun redactTrace(value: String?): String? {
        val trimmed = value?.trim()?.takeIf { it.isNotBlank() } ?: return null
-        val redacted = redact(trimmed)
+        val redacted = ReliabilityRedactor.redact(trimmed, MAX_TRACE_LENGTH)
        return if (redacted.length > MAX_TRACE_LENGTH) {
            redacted.take(MAX_TRACE_LENGTH) + "\n… (truncated)"
        } else {
@@ -205,8 +248,5 @@ object DiagnosticsLog {
        }
    }

-    private fun redact(value: String): String =
-        value.replace(Regex("""(?i)(bearer|token|api[_-]?key|session[_-]?token)\s*[:=]\s*\S+""")) {
-            "${it.groupValues[1]}=[hidden]"
-        }
+    private fun redact(value: String): String = ReliabilityRedactor.redact(value, MAX_TRACE_LENGTH)
 }
@@ -0,0 +1,42 @@
+package com.hermesandroid.relay.diagnostics
+
+import java.net.ConnectException
+import java.net.NoRouteToHostException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+import javax.net.ssl.SSLException
+
+/**
+ * Maps network failure classes to narrow, truthful next steps.
+ *
+ * These messages are diagnostic guidance, not recovery behavior: callers still
+ * own retries, routing, and authentication. Walking the cause chain preserves
+ * useful classification when OkHttp or a coroutine boundary wraps the socket
+ * exception in a higher-level failure.
+ */
+object NetworkDiagnosticGuidance {
+    fun forThrowable(throwable: Throwable, target: String): String? {
+        val causes = generateSequence(throwable as Throwable?) { it.cause }.take(12).toList()
+        return when {
+            causes.any { it is ConnectException } ->
+                "Verify $target is running and listening on the configured host and port."
+            causes.any { it is UnknownHostException } ->
+                "Verify the configured hostname resolves from this device."
+            causes.any { it is NoRouteToHostException } ->
+                "Verify the device has a network path to the configured host."
+            causes.any { it is SocketTimeoutException } ->
+                "Check network routing or firewall rules between this device and $target."
+            causes.any { it is SSLException } ->
+                "Verify the TLS scheme, certificate, and trust configuration for $target."
+            else -> null
+        }
+    }
+
+    fun forHttpStatus(statusCode: Int, target: String): String? = when (statusCode) {
+        401, 403 -> "Verify the configured $target credentials or pair the device again."
+        404 -> "Verify this URL points to the expected $target route and version."
+        429 -> "Wait for the server's backoff period before retrying."
+        in 500..599 -> "Check the $target server logs for the failing request."
+        else -> null
+    }
+}
@@ -258,6 +258,7 @@ class BridgeCommandHandler(

    private val pendingActivities =
        java.util.concurrent.ConcurrentHashMap<String, PendingActivity>()
+    private val unattendedWakeRequests = java.util.concurrent.ConcurrentHashMap.newKeySet<String>()
    // === END v0.4.1 polish ===

    private val json = Json {
@@ -302,6 +303,8 @@ class BridgeCommandHandler(
                        put("error", t.message ?: "unknown executor error")
                    }
                )
+            } finally {
+                releaseUnattendedWake(requestId)
            }
        }
    }
@@ -396,6 +399,8 @@ class BridgeCommandHandler(
                errorCode = "dispatch_exception",
                resultJson = null,
            )
+        } finally {
+            releaseUnattendedWake(requestId)
        }

        val resultJson = sink.get()
@@ -421,6 +426,54 @@ class BridgeCommandHandler(
        method: String,
        body: JsonObject,
    ) {
+        // Resolve path + method through the closed capability registry before
+        // any wake, confirmation, event read, executor, or run-tracker effect.
+        val registeredAuthority =
+            com.hermesandroid.relay.bridge.BridgeCommandRegistry.resolve(path, method)
+        val capabilityAuthorization = when {
+            registeredAuthority == null -> BridgeSafetyManager.CapabilityAuthorization(
+                allowed = false,
+                errorCode = "unknown_bridge_command",
+            )
+            !BuildFlavor.isSideload && registeredAuthority.grant !=
+                com.hermesandroid.relay.bridge.BridgeCapabilityGrant.EXEMPT ->
+                BridgeSafetyManager.CapabilityAuthorization(
+                    allowed = false,
+                    authority = registeredAuthority,
+                    errorCode = "device_control_sideload_only",
+                )
+            registeredAuthority.grant ==
+                com.hermesandroid.relay.bridge.BridgeCapabilityGrant.EXEMPT ->
+                BridgeSafetyManager.CapabilityAuthorization(true, registeredAuthority)
+            else -> safetyManager?.authorizeCapability(path, method)
+                ?: BridgeSafetyManager.CapabilityAuthorization(
+                    allowed = false,
+                    authority = registeredAuthority,
+                    errorCode = "bridge_policy_unavailable",
+                )
+        }
+        if (!capabilityAuthorization.allowed) {
+            return respond(
+                requestId,
+                403,
+                buildJsonObject {
+                    put(
+                        "error",
+                        if (capabilityAuthorization.errorCode == "device_control_sideload_only") {
+                            "Device Control is not included in the Google Play build."
+                        } else {
+                            "Bridge capability is not granted for this connection."
+                        },
+                    )
+                    put("error_code", capabilityAuthorization.errorCode ?: "bridge_capability_denied")
+                    capabilityAuthorization.authority?.capability?.let {
+                        put("capability", it.wireId)
+                    }
+                    put("required_action", "Review Bridge > Safety & capabilities on the phone")
+                },
+            )
+        }
+
        // === v0.4.1 polish: keep auto-return idle timer alive ===
        // Any non-polling bridge command during a run is evidence the
        // agent is still working — reset BridgeRunTracker's idle timer
@@ -475,44 +528,6 @@ class BridgeCommandHandler(
            return
        }

-        // === PHASE3-event-stream: B1 android_events read-only polling ===
-        // /events is a read-only peek at the EventStore ring buffer. The
-        // buffer lives in our own process so there's no safety gate —
-        // the agent already opted into streaming via /events/stream
-        // which IS gated. This mirrors the /ping early-return path so
-        // polling works even when the service is transiently unbound.
-        if (path == "/events") {
-            val limitRaw = body["limit"]?.jsonPrimitive?.content?.toIntOrNull() ?: 50
-            val limit = limitRaw.coerceIn(1, EventStore.MAX_ENTRIES)
-            val since = body["since"]?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
-            val entries = EventStore.recent(limit = limit, since = since)
-            val arr: JsonArray = buildJsonArray {
-                for (e in entries) {
-                    add(
-                        buildJsonObject {
-                            put("timestamp", e.timestamp)
-                            put("event_type", e.eventType)
-                            e.packageName?.let { put("package_name", it) }
-                            e.className?.let { put("class_name", it) }
-                            e.text?.let { put("text", it) }
-                            e.contentDescription?.let { put("content_description", it) }
-                            put("source", e.source)
-                        }
-                    )
-                }
-            }
-            respond(
-                requestId, 200,
-                buildJsonObject {
-                    put("entries", arr)
-                    put("count", entries.size)
-                    put("streaming", EventStore.isStreaming)
-                }
-            )
-            return
-        }
-        // === END PHASE3-event-stream ===
-
        // /setup exists on the relay as a legacy bridge HTTP route, but
        // android_setup() in plugin/tools/android_tool.py is host-side
        // only (it just writes ANDROID_BRIDGE_TOKEN to ~/.hermes/.env)
@@ -576,10 +591,7 @@ class BridgeCommandHandler(
                }
            )

-        if (!service.isMasterEnabled() &&
-            path != "/current_app" &&
-            path != "/return_to_hermes"
-        ) {
+        if (!service.isMasterEnabled()) {
            // Crystal-clear error text + structured error_code. Bailey hit
            // 2026-04-15: when the phone was paired + a11y granted but
            // master toggle flipped off, the agent read the shorter
@@ -649,9 +661,13 @@ class BridgeCommandHandler(
            }
        }

-        // Reschedule the idle auto-disable timer on every accepted
-        // command. Safe to call even when no timer is currently armed.
-        safetyManager?.rescheduleAutoDisable()
+        // Permanent capabilities never keep screen control armed. Only an
+        // accepted timed inspection/control command refreshes the timer.
+        if (capabilityAuthorization.authority?.grant ==
+            com.hermesandroid.relay.bridge.BridgeCapabilityGrant.TIMED
+        ) {
+            safetyManager?.rescheduleAutoDisable()
+        }
        // === END PHASE3-safety-rails ===

        // === v0.4.1 unattended-access wake + keyguard dismiss ===
@@ -673,6 +689,9 @@ class BridgeCommandHandler(
        if (!isReadOnlyRoute) {
            val outcome = runCatching { UnattendedAccessManager.acquireForAction() }
                .getOrDefault(UnattendedAccessManager.WakeOutcome.Disabled)
+            if (outcome != UnattendedAccessManager.WakeOutcome.Disabled) {
+                unattendedWakeRequests += requestId
+            }
            if (outcome == UnattendedAccessManager.WakeOutcome.KeyguardBlocked) {
                respond(
                    requestId, 423,
@@ -705,6 +724,30 @@ class BridgeCommandHandler(
        val executor = service.actionExecutor

        when (path) {
+            "/events" -> {
+                val limitRaw = body["limit"]?.jsonPrimitive?.content?.toIntOrNull() ?: 50
+                val limit = limitRaw.coerceIn(1, EventStore.MAX_ENTRIES)
+                val since = body["since"]?.jsonPrimitive?.content?.toLongOrNull() ?: 0L
+                val entries = EventStore.recent(limit = limit, since = since)
+                val arr: JsonArray = buildJsonArray {
+                    for (e in entries) {
+                        add(buildJsonObject {
+                            put("timestamp", e.timestamp)
+                            put("event_type", e.eventType)
+                            e.packageName?.let { put("package_name", it) }
+                            e.className?.let { put("class_name", it) }
+                            e.text?.let { put("text", it) }
+                            e.contentDescription?.let { put("content_description", it) }
+                            put("source", e.source)
+                        })
+                    }
+                }
+                respond(requestId, 200, buildJsonObject {
+                    put("entries", arr)
+                    put("count", entries.size)
+                    put("streaming", EventStore.isStreaming)
+                })
+            }
            "/current_app" -> respond(
                requestId, 200,
                buildJsonObject {
@@ -2417,6 +2460,12 @@ class BridgeCommandHandler(
        }
        multiplexer.send(envelope)
    }
+
+    private fun releaseUnattendedWake(requestId: String) {
+        if (unattendedWakeRequests.remove(requestId)) {
+            UnattendedAccessManager.releaseAfterAction()
+        }
+    }
 }

 // LocalDispatchResult moved to network.shared (ADR 34 fence): it is a passive
@@ -10,14 +10,18 @@ import android.util.Log
 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.primaryRouteUrl
 import com.hermesandroid.relay.data.PairingPreferences
+import com.hermesandroid.relay.network.shared.pluginProxyRoutesOrNull
 import com.hermesandroid.relay.diagnostics.DiagnosticCategory
 import com.hermesandroid.relay.diagnostics.DiagnosticSeverity
 import com.hermesandroid.relay.diagnostics.DiagnosticsLog
+import com.hermesandroid.relay.diagnostics.NetworkDiagnosticGuidance
 import com.hermesandroid.relay.network.relay.models.Envelope
 import com.hermesandroid.relay.network.shared.EndpointResolver
 import com.hermesandroid.relay.network.shared.EndpointSurface
+import com.hermesandroid.relay.network.shared.fullJitterDelayMs
 import com.hermesandroid.relay.network.shutdownOffMainThread
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -75,6 +79,9 @@ internal fun buildRelayRequestOrNull(url: String): Request? =
        null
    }

+private fun EndpointCandidate.relayWebSocketUrl(): String? =
+    pluginProxyRoutesOrNull()?.relayWebSocketUrl ?: relay?.url
+
 class ConnectionManager(
    private val multiplexer: ChannelMultiplexer,
    /**
@@ -138,6 +145,12 @@ class ConnectionManager(
     * non-null — the manager falls back to the single-URL path.
     */
    private val deviceIdProvider: (suspend () -> String?)? = null,
+    /** Random source for ordinary reconnect full-jitter; exact backoffs never use it. */
+    private val reconnectJitterUnit: () -> Double = { kotlin.random.Random.nextDouble() },
+    /** Exact-authority pinned client for a plugin-proxy WSS URL. */
+    private val proxyClientProvider: ((String) -> OkHttpClient?)? = null,
+    /** Test seam for observing lifecycle teardown without opening a socket. */
+    private val okHttpClientFactory: (() -> OkHttpClient)? = null,
 ) {
    private val supervisorJob = SupervisorJob()
    private val scope = CoroutineScope(supervisorJob + Dispatchers.IO)
@@ -147,7 +160,8 @@ class ConnectionManager(
        encodeDefaults = true
    }

-    private fun buildClient(): OkHttpClient {
+    private fun buildClient(url: String? = null): OkHttpClient {
+        okHttpClientFactory?.let { return it() }
        val builder = OkHttpClient.Builder()
            // OkHttp's 10s default connectTimeout is LAN-tuned; a Tailscale
            // DERP-relayed cold-start handshake can exceed it, and a failed
@@ -161,7 +175,9 @@ class ConnectionManager(
        // that wipes a pin would still be subject to the pre-wipe rules.
        certPinStore?.let { store ->
            try {
-                builder.certificatePinner(store.buildPinnerSnapshot())
+                builder.certificatePinner(
+                    url?.let(store::buildPinnerSnapshotFor) ?: store.buildPinnerSnapshot(),
+                )
            } catch (e: Exception) {
                Log.w(TAG, "CertificatePinner build failed: ${e.message}")
                builder.certificatePinner(CertificatePinner.DEFAULT)
@@ -220,10 +236,12 @@ class ConnectionManager(
    // Endpoints card in Settings.
    private val _activeEndpoint = MutableStateFlow<EndpointCandidate?>(null)
    val activeEndpoint: StateFlow<EndpointCandidate?> = _activeEndpoint.asStateFlow()
+    private val _activeApiEndpoint = MutableStateFlow<EndpointCandidate?>(null)
+    val activeApiEndpoint: StateFlow<EndpointCandidate?> = _activeApiEndpoint.asStateFlow()

    /** Relay-only winner, deliberately separate from the standard route. */
-    @Volatile
-    private var activeRelayEndpoint: EndpointCandidate? = null
+    private val _activeRelayEndpoint = MutableStateFlow<EndpointCandidate?>(null)
+    val activeRelayEndpoint: StateFlow<EndpointCandidate?> = _activeRelayEndpoint.asStateFlow()

    /**
     * Manual role override. When non-null, the resolver's output is replaced
@@ -344,11 +362,14 @@ class ConnectionManager(
        // behavior for freshly-upgraded installs and for v1/v2 QRs where
        // the synthesized list just collapses to the same URL anyway.
        scope.launch {
-            val resolved = resolveBestEndpointSafe(EndpointSurface.Standard)
+            val resolved = resolveBestEndpointSafe(EndpointSurface.Dashboard)
+                ?: resolveBestEndpointSafe(EndpointSurface.Standard)
+            val apiResolved = resolveBestEndpointSafe(EndpointSurface.Api)
            val relayResolved = resolveBestEndpointSafe(EndpointSurface.Relay)
-            val resolvedRelayUrl = relayResolved?.relay?.url?.takeIf { it.isNotBlank() }
+            val resolvedRelayUrl = relayResolved?.relayWebSocketUrl()?.takeIf { it.isNotBlank() }
            val targetUrl = resolvedRelayUrl ?: url.takeIf { it.isNotBlank() }
-            activeRelayEndpoint = relayResolved
+            _activeRelayEndpoint.value = relayResolved
+            _activeApiEndpoint.value = apiResolved
            if (resolved != null) {
                _activeEndpoint.value = resolved
                Log.i(TAG, "connect: standard resolver picked role=${resolved.role} " +
@@ -375,7 +396,7 @@ class ConnectionManager(
                Log.i(
                    TAG,
                    "connect: relay resolver picked role=${relayRoute.role} " +
-                        "url=${relayRoute.relay?.url}",
+                        "url=${relayRoute.relayWebSocketUrl()}",
                )
            }
            if (targetUrl != null) {
@@ -433,7 +454,22 @@ class ConnectionManager(
        replaceReason: String = "Relay socket replaced",
        preserveReconnectBackoff: Boolean = false,
    ) {
-        val isInsecure = url.startsWith("ws://") && !url.startsWith("wss://")
+        val endpoints = RelayEndpointContract.parseOrNull(url)
+        if (endpoints == null) {
+            Log.e(TAG, "Invalid Relay URL")
+            DiagnosticsLog.record(
+                category = DiagnosticCategory.Relay,
+                severity = DiagnosticSeverity.Error,
+                title = context?.getString(R.string.conn_diag_url_invalid) ?: "Relay socket URL invalid",
+                detail = "Malformed or unsafe Relay URL",
+                operation = "Open Relay WebSocket",
+                configuredUrl = url,
+                suggestion = "Use a Relay URL with no credentials, query, or fragment.",
+            )
+            return
+        }
+        val normalized = endpoints.webSocketUrl
+        val isInsecure = normalized.startsWith("ws://", ignoreCase = true)
        if (isInsecure && !_insecureMode.value) {
            Log.e(TAG, "Blocked ws:// connection — insecure mode is disabled. Use wss:// or enable insecure mode in Settings.")
            DiagnosticsLog.record(
@@ -441,27 +477,12 @@ class ConnectionManager(
                severity = DiagnosticSeverity.Error,
                title = context?.getString(R.string.conn_diag_socket_blocked) ?: "Relay socket blocked",
                detail = "ws:// is disabled",
-                url = url,
+                operation = "Open Relay WebSocket",
+                configuredUrl = url,
+                suggestion = "Use wss:// or explicitly allow plain ws:// for a trusted LAN or VPN.",
            )
            return
        }
-        if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
-            Log.e(TAG, "Invalid URL scheme — must start with ws:// or wss://")
-            DiagnosticsLog.record(
-                category = DiagnosticCategory.Relay,
-                severity = DiagnosticSeverity.Error,
-                title = context?.getString(R.string.conn_diag_url_invalid) ?: "Relay socket URL invalid",
-                detail = "URL must start with ws:// or wss://",
-                url = url,
-            )
-            return
-        }
-
-        // Normalize: append /ws if the user gave us a bare host:port with no
-        // path. The relay routes the WebSocket handler at /ws; a bare URL
-        // hits the HTTP root and comes back as 404 Not Found during the
-        // upgrade handshake. We still accept an explicit path if present.
-        val normalized = normalizeRelayUrl(url)
        if (isRelayRateLimitBackoffActive(
                rateLimitBackoffUntilMs,
                SystemClock.elapsedRealtime(),
@@ -488,14 +509,18 @@ class ConnectionManager(
                category = DiagnosticCategory.Relay,
                severity = DiagnosticSeverity.Warning,
                title = context?.getString(R.string.conn_diag_opening_insecure) ?: "Opening insecure relay socket",
-                url = normalized,
+                operation = "Open Relay WebSocket",
+                configuredUrl = url,
+                requestUrl = normalized,
            )
        } else {
            DiagnosticsLog.record(
                category = DiagnosticCategory.Relay,
                severity = DiagnosticSeverity.Info,
                title = context?.getString(R.string.conn_diag_opening_socket) ?: "Opening relay socket",
-                url = normalized,
+                operation = "Open Relay WebSocket",
+                configuredUrl = url,
+                requestUrl = normalized,
            )
        }

@@ -522,7 +547,8 @@ class ConnectionManager(
     * for any reason we don't block the connect loop forever.
     */
    suspend fun resolveBestEndpoint(): EndpointCandidate? =
-        resolveBestEndpointSafe(EndpointSurface.Standard)
+        resolveBestEndpointSafe(EndpointSurface.Dashboard)
+            ?: resolveBestEndpointSafe(EndpointSurface.Standard)

    private suspend fun resolveBestEndpointSafe(
        surface: EndpointSurface,
@@ -600,7 +626,9 @@ class ConnectionManager(
    suspend fun probeAndReconnectNow(): EndpointCandidate? {
        endpointResolver?.clearCache()
        val current = serverUrl
-        val resolved = resolveBestEndpointSafe(EndpointSurface.Standard)
+        val resolved = resolveBestEndpointSafe(EndpointSurface.Dashboard)
+            ?: 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
@@ -609,8 +637,9 @@ class ConnectionManager(
            return _activeEndpoint.value
        }
        _activeEndpoint.value = resolved
-        if (relayResolved != null) activeRelayEndpoint = relayResolved
-        val targetUrl = relayResolved?.relay?.url ?: current ?: return resolved
+        _activeApiEndpoint.value = apiResolved
+        if (relayResolved != null) _activeRelayEndpoint.value = relayResolved
+        val targetUrl = relayResolved?.relayWebSocketUrl() ?: current ?: return resolved
        val normalizedTarget = normalizeRelayUrl(targetUrl)
        // Reconnect when the winner changed, and also when the socket is
        // stale/disconnected on the same winner. The latter makes the
@@ -647,7 +676,9 @@ class ConnectionManager(
     */
    suspend fun refreshActiveEndpoint(clearProbeCache: Boolean = false): EndpointCandidate? {
        if (clearProbeCache) endpointResolver?.clearCache()
-        val resolved = resolveBestEndpointSafe(EndpointSurface.Standard)
+        val resolved = resolveBestEndpointSafe(EndpointSurface.Dashboard)
+            ?: 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
@@ -656,6 +687,7 @@ class ConnectionManager(
            return _activeEndpoint.value
        }
        _activeEndpoint.value = resolved
+        _activeApiEndpoint.value = apiResolved
        return resolved
    }

@@ -672,7 +704,7 @@ class ConnectionManager(
    fun getManualRoleOverride(): String? = _manualRoleOverride.value

    private fun markActiveRelayEndpointUnreachable(reason: String) {
-        val active = activeRelayEndpoint ?: return
+        val active = _activeRelayEndpoint.value ?: return
        endpointResolver?.markUnreachable(active, EndpointSurface.Relay)
        Log.i(TAG, "marked endpoint role=${active.role} unreachable ($reason)")
    }
@@ -698,7 +730,9 @@ class ConnectionManager(
            // manages its own cache (clear + markUnreachable) and passes false.
            if (wipeCache) endpointResolver.clearCache()
            val current = serverUrl
-            val resolved = resolveBestEndpointSafe(EndpointSurface.Standard)
+            val resolved = resolveBestEndpointSafe(EndpointSurface.Dashboard)
+                ?: 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
@@ -735,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
@@ -744,8 +779,8 @@ class ConnectionManager(
            // the swap path never re-checked it.)
            if (!shouldReconnect) return@launch
            val relayResolved = resolveBestEndpointSafe(EndpointSurface.Relay)
-            if (relayResolved != null) activeRelayEndpoint = relayResolved
-            val relayUrl = relayResolved?.relay?.url?.takeIf { it.isNotBlank() }
+            if (relayResolved != null) _activeRelayEndpoint.value = relayResolved
+            val relayUrl = relayResolved?.relayWebSocketUrl()?.takeIf { it.isNotBlank() }
                ?: return@launch
            if (isRelayRateLimitBackoffActive(
                    rateLimitBackoffUntilMs,
@@ -850,21 +885,8 @@ class ConnectionManager(
        }
    }

-    private fun normalizeRelayUrl(url: String): String {
-        // Strip scheme to reason about the path portion cheaply.
-        val schemeEnd = url.indexOf("://")
-        if (schemeEnd < 0) return url
-        val afterScheme = url.substring(schemeEnd + 3)
-        val pathStart = afterScheme.indexOf('/')
-        return if (pathStart < 0) {
-            // No path at all — append /ws
-            "$url/ws"
-        } else {
-            val path = afterScheme.substring(pathStart)
-            // Empty or root path — append ws
-            if (path == "/" || path.isEmpty()) "${url.trimEnd('/')}/ws" else url
-        }
-    }
+    private fun normalizeRelayUrl(url: String): String =
+        RelayEndpointContract.parseOrNull(url)?.webSocketUrl ?: url

    fun disconnect() {
        shouldReconnect = false
@@ -890,7 +912,8 @@ class ConnectionManager(
        // the ViewModel on the next connection load.
        _manualRoleOverride.value = null
        _activeEndpoint.value = null
-        activeRelayEndpoint = null
+        _activeApiEndpoint.value = null
+        _activeRelayEndpoint.value = null
        reconnectState.reset()
    }

@@ -970,7 +993,18 @@ class ConnectionManager(
        // Every new socket starts unauthenticated — the send-gate stays closed
        // (auth frame excepted) until this socket's own auth.ok arrives.
        authenticated = false
-        client = buildClient()
+        val isPluginProxyUrl = _activeRelayEndpoint.value?.pluginProxyRoutesOrNull()
+            ?.relayWebSocketUrl
+            ?.equals(url, ignoreCase = true) == true
+        client = if (isPluginProxyUrl) {
+            proxyClientProvider?.invoke(url) ?: run {
+                Log.e(TAG, "Pinned plugin proxy client unavailable — refusing generic TLS fallback")
+                _connectionState.value = ConnectionState.Disconnected
+                return
+            }
+        } else {
+            buildClient(url)
+        }

        val request = buildRelayRequestOrNull(url)
        if (request == null) {
@@ -985,7 +1019,9 @@ class ConnectionManager(
                severity = DiagnosticSeverity.Error,
                title = "Invalid relay URL",
                detail = "The relay address could not be parsed; re-pair to refresh it.",
-                url = url,
+                operation = "Build Relay WebSocket request",
+                configuredUrl = url,
+                suggestion = "Edit or re-pair the Relay route to replace the invalid address.",
            )
            authenticated = false
            _connectionState.value = ConnectionState.Disconnected
@@ -1018,7 +1054,8 @@ class ConnectionManager(
                    category = DiagnosticCategory.Relay,
                    severity = DiagnosticSeverity.Info,
                    title = context?.getString(R.string.conn_diag_connected) ?: "Relay socket connected",
-                    url = url,
+                    operation = "Relay WebSocket handshake",
+                    requestUrl = url,
                )

                // TOFU: record the peer cert fingerprint if we don't have one
@@ -1079,7 +1116,9 @@ class ConnectionManager(
                    severity = DiagnosticSeverity.Warning,
                    title = context?.getString(R.string.conn_diag_closed) ?: "Relay socket closed",
                    detail = "code=$code reason=$reason",
-                    url = url,
+                    operation = "Relay WebSocket session",
+                    requestUrl = url,
+                    suggestion = if (code == 1000) null else "Check the Relay server logs for the matching close code and reason.",
                )
                authenticated = false
                _connectionState.value = ConnectionState.Disconnected
@@ -1102,7 +1141,11 @@ class ConnectionManager(
                        t.message,
                        code?.let { "HTTP $it" },
                    ).joinToString(": "),
-                    url = url,
+                    operation = "Relay WebSocket handshake",
+                    requestUrl = url,
+                    suggestion = code?.let {
+                        NetworkDiagnosticGuidance.forHttpStatus(it, "Relay")
+                    } ?: NetworkDiagnosticGuidance.forThrowable(t, "Relay"),
                )
                lastUpgradeResponseCode = code
                if (response == null) {
@@ -1195,8 +1238,9 @@ class ConnectionManager(
                SLOW_POLL_BACKOFF_MS
            }
            else -> {
-                val ms = (BASE_BACKOFF_MS * (1L shl minOf(reconnectAttempt - 1, 4)))
+                val capMs = (BASE_BACKOFF_MS * (1L shl minOf(reconnectAttempt - 1, 4)))
                    .coerceAtMost(MAX_BACKOFF_MS)
+                val ms = fullJitterDelayMs(capMs, reconnectJitterUnit())
                DiagnosticsLog.record(
                    category = DiagnosticCategory.Relay,
                    severity = DiagnosticSeverity.Info,
@@ -1218,7 +1262,7 @@ class ConnectionManager(
            // during the retry window).
            if (shouldReconnect && reconnectGate()) {
                val resolved = resolveBestEndpointSafe(EndpointSurface.Relay)
-                val targetUrl = resolved?.relay?.url
+                val targetUrl = resolved?.relayWebSocketUrl()
                if (resolved != null) {
                    // Mirror scheduleNetworkReResolve: clear the sustained-loss
                    // latch on a successful resolve so a later transient miss
@@ -1226,7 +1270,7 @@ class ConnectionManager(
                    // in onLost's grace job but can be cleared on EITHER success
                    // edge — network-callback or relay-timer.)
                    sustainedLossDeclared = false
-                    activeRelayEndpoint = resolved
+                    _activeRelayEndpoint.value = resolved
                }
                if (targetUrl != null && normalizeRelayUrl(targetUrl) != url) {
                    Log.i(TAG, "scheduleReconnect: switching $url → ${normalizeRelayUrl(targetUrl)}")
@@ -5,7 +5,9 @@ import android.util.Log
 import com.hermesandroid.relay.network.relay.models.Envelope
 import com.hermesandroid.relay.notifications.ProactiveMessageNotifier
 import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.booleanOrNull
 import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.intOrNull
 import kotlinx.serialization.json.jsonPrimitive

 /**
@@ -50,7 +52,7 @@ class ProactiveMessageHandler(
    /** Sink for the dedicated Hermes inbox (Phase 2a) — the always-present log. */
    private val toInbox: ((ProactiveMessage) -> Unit)? = null,
    /** Sink for injecting into the active chat session (Phase 2b). */
-    var toSession: ((ProactiveMessage) -> Unit)? = null,
+    var toSession: ((ProactiveMessage) -> Boolean)? = null,
    /**
     * Sink for the relay's per-reply ack (`proactive.reply.ack`) — lets the
     * chat layer settle a Thread reply bubble from SENDING → DELIVERED. Wired
@@ -61,11 +63,13 @@ class ProactiveMessageHandler(
    /**
     * Show an inbound message inline in the Chat **Thread** it belongs to, when
     * that Thread is currently open. Returns true if it was shown there — in
-     * which case the message is NOT also notified or added to the inbox (you're
-     * already looking at the conversation). The unified-Threads counterpart of
+     * which case the message is persisted but not also notified (you're already
+     * looking at the conversation). The unified-Threads counterpart of
     * [toSession]; wired after construction.
     */
    var injectIntoThread: ((ProactiveMessage) -> Boolean)? = null,
+    /** One callback per completed queued-message flush, never per message. */
+    var onBacklogDelivered: ((Int) -> Unit)? = null,
 ) {

    fun onMessage(envelope: Envelope) {
@@ -80,6 +84,10 @@ class ProactiveMessageHandler(
            }
            // Subscribe ack — informational; nothing to do client-side.
            "proactive.subscribed" -> Log.d(TAG, "proactive subscribe acked")
+            "proactive.backlog.complete" -> {
+                val count = envelope.payload["count"]?.jsonPrimitive?.intOrNull ?: 0
+                if (count > 0) onBacklogDelivered?.invoke(count)
+            }
            // Per-reply ack — settle the matching Thread reply bubble (the
            // `client_msg_id` is the id the app stamped on its own reply).
            "proactive.reply.ack" -> {
@@ -94,24 +102,28 @@ 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) {
-        // Unified Threads: if this message belongs to the Thread currently open
-        // in Chat, render it inline there and STOP — no notification, no inbox
-        // entry (you're already looking at the conversation).
-        if (injectIntoThread?.invoke(msg) == true) return
-        // Otherwise the inbox is the durable log of agent-initiated messages and
-        // the surfacing hint selects the additional surface.
+        // 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.
        when (msg.surfacing?.lowercase()) {
-            "inbox" -> { /* inbox only — already recorded above */ }
+            "inbox" -> {
+                injectIntoThread?.invoke(msg)
+            }
            "session" -> {
-                val sink = toSession
-                // Legacy explicit "inject into active session" path; if no sink
-                // (or no active chat) fall back to a notification so it isn't
-                // silently missed (the inbox copy already exists either way).
-                if (sink != null) sink.invoke(msg) else notify(msg)
+                val delivered = injectIntoThread?.invoke(msg) == true ||
+                    toSession?.invoke(msg) == true
+                if (!delivered) notify(msg)
            }
            // null / "default" / "notification" / anything unrecognized.
-            else -> notify(msg)
+            else -> {
+                injectIntoThread?.invoke(msg)
+                notify(msg)
+            }
        }
    }

@@ -136,6 +148,7 @@ class ProactiveMessageHandler(
            surfacing = payload["surfacing"]?.jsonPrimitive?.contentOrNull,
            sentAt = payload["sent_at"]?.jsonPrimitive?.contentOrNull?.toLongOrNull(),
            replyTo = payload["reply_to"]?.jsonPrimitive?.contentOrNull,
+            arrivedWhileAway = payload["queued_delivery"]?.jsonPrimitive?.booleanOrNull == true,
        )
    }

@@ -157,4 +170,6 @@ data class ProactiveMessage(
    val sentAt: Long?,
    /** Id of the message this one answers, if any (server threading hint). */
    val replyTo: String? = null,
+    /** True only when Relay explicitly marked this as a reconnect queue flush. */
+    val arrivedWhileAway: Boolean = false,
 )
@@ -4,13 +4,16 @@ import android.content.Context
 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.diagnostics.DiagnosticCategory
 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.withContext
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.contentOrNull
@@ -57,8 +60,15 @@ class RelayHttpClient(
    private val context: Context? = null,
 ) {

+    private fun relayHttpBaseOrNull(url: String): String? =
+        RelayEndpointContract.parseOrNull(url)?.httpBaseUrl
+
    companion object {
        private const val TAG = "RelayHttpClient"
+        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
+        private const val MAX_MODEL_CAPABILITY_PROFILE_CHARS = 128
        private val sessionsJson = Json {
            ignoreUnknownKeys = true
            isLenient = true
@@ -174,10 +184,8 @@ class RelayHttpClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))
        val url = try {
            "$httpBase/chat/image-activity".toHttpUrl().newBuilder()
                .addQueryParameter("profile", profile)
@@ -241,10 +249,8 @@ class RelayHttpClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        val url = "$httpBase/media/$token".toHttpUrlOrNull()
            ?: return@withContext Result.failure(
@@ -293,10 +299,10 @@ class RelayHttpClient(
                Result.success(FetchedMedia(contentType, bytes, fileName, sensitive))
            }
        } catch (e: IOException) {
-            Log.w(TAG, "fetchMedia failed for $token: ${e.message}")
+            Log.w(TAG, "fetchMedia failed: ${e.message}")
            Result.failure(e)
        } catch (e: Exception) {
-            Log.w(TAG, "fetchMedia unexpected error for $token: ${e.message}")
+            Log.w(TAG, "fetchMedia unexpected error: ${e.message}")
            Result.failure(e)
        }
    }
@@ -338,10 +344,8 @@ class RelayHttpClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        // Build the URL via OkHttp's HttpUrl builder so query-param encoding
        // handles paths with slashes, spaces, and non-ASCII characters
@@ -436,10 +440,8 @@ class RelayHttpClient(
                )
            }

-            val httpBase = relayUrl
-                .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-                .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-                .trimEnd('/')
+            val httpBase = relayHttpBaseOrNull(relayUrl)
+                ?: return@withContext Result.failure(IOException("Invalid relay URL"))
            val profile = profileName?.trim()?.ifBlank { null } ?: "default"
            val url = try {
                "$httpBase/api/profiles".toHttpUrl().newBuilder()
@@ -537,10 +539,8 @@ class RelayHttpClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        val url = try {
            "$httpBase/context/injected".toHttpUrl()
@@ -629,10 +629,8 @@ class RelayHttpClient(
                IllegalStateException("Relay not paired — session token missing")
            )
        }
-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))
        val url = try {
            "$httpBase/phone/threads".toHttpUrl()
        } catch (e: IllegalArgumentException) {
@@ -710,6 +708,37 @@ class RelayHttpClient(
        @SerialName("age_seconds") val ageSeconds: Int? = null,
    )

+    @Serializable
+    data class ModelCapabilityRequestRow(
+        val provider: String,
+        val model: String,
+    )
+
+    @Serializable
+    data class ModelCapabilitiesRequest(
+        @SerialName("schema_version") val schemaVersion: Int = 1,
+        val profile: String? = null,
+        val refresh: Boolean = false,
+        val models: List<ModelCapabilityRequestRow>,
+    )
+
+    @Serializable
+    data class ModelCapabilityRow(
+        val provider: String,
+        val model: String,
+        val reasoning: Boolean? = null,
+        @SerialName("reasoning_efforts") val reasoningEfforts: List<String> = emptyList(),
+        @SerialName("reasoning_efforts_exact") val reasoningEffortsExact: Boolean = false,
+        val source: String = "",
+    )
+
+    @Serializable
+    data class ModelCapabilitiesResponse(
+        @SerialName("schema_version") val schemaVersion: Int = 1,
+        @SerialName("contract_version") val contractVersion: String = "",
+        val capabilities: List<ModelCapabilityRow> = emptyList(),
+    )
+
    /** Fetch the installed plugin/protocol/profile capability contract. */
    suspend fun fetchRelayInfo(): Result<RelayInfo?> = withContext(Dispatchers.IO) {
        val relayUrl = relayUrlProvider()?.trim().orEmpty()
@@ -717,10 +746,8 @@ class RelayHttpClient(
        if (relayUrl.isEmpty() || token.isNullOrBlank()) {
            return@withContext Result.failure(IllegalStateException("Relay is not configured and paired"))
        }
-        val base = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val base = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))
        val url = try { "$base/relay/info".toHttpUrl() } catch (e: IllegalArgumentException) {
            return@withContext Result.failure(IOException("Invalid relay URL: ${e.message}"))
        }
@@ -743,6 +770,62 @@ class RelayHttpClient(
        }
    }

+    /** Optional provider/model reasoning overlay; 404 and no pairing are fail-soft. */
+    suspend fun fetchModelCapabilities(
+        models: List<ModelCapabilityRequestRow>,
+        profile: String? = null,
+        refresh: Boolean = false,
+    ): Result<ModelCapabilitiesResponse?> = withContext(Dispatchers.IO) {
+        val boundedModels = models
+            .asSequence()
+            .map {
+                ModelCapabilityRequestRow(
+                    it.provider.trim().take(MAX_MODEL_CAPABILITY_PROVIDER_CHARS),
+                    it.model.trim().take(MAX_MODEL_CAPABILITY_MODEL_CHARS),
+                )
+            }
+            .filter { it.provider.isNotEmpty() && it.model.isNotEmpty() }
+            .distinct()
+            .take(MAX_MODEL_CAPABILITY_ROWS)
+            .toList()
+        if (boundedModels.isEmpty()) return@withContext Result.success(null)
+        val relayUrl = relayUrlProvider()?.trim().orEmpty()
+        val token = sessionTokenProvider()
+        if (relayUrl.isEmpty() || token.isNullOrBlank()) return@withContext Result.success(null)
+        val base = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.success(null)
+        val url = runCatching { "$base/relay/model-capabilities".toHttpUrl() }.getOrElse {
+            return@withContext Result.success(null)
+        }
+        val payload = ModelCapabilitiesRequest(
+            profile = profile?.trim()?.take(MAX_MODEL_CAPABILITY_PROFILE_CHARS)
+                ?.takeIf { it.isNotEmpty() },
+            refresh = refresh,
+            models = boundedModels,
+        )
+        val request = Request.Builder()
+            .url(url)
+            .post(sessionsJson.encodeToString(payload).toRequestBody("application/json".toMediaType()))
+            .header("Authorization", "Bearer $token")
+            .header("Accept", "application/json")
+            .build()
+        try {
+            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}"))
+                    val body = response.body?.string().orEmpty()
+                    val parsed = body.takeIf { it.isNotBlank() }?.let {
+                        sessionsJson.decodeFromString(ModelCapabilitiesResponse.serializer(), it)
+                    }
+                    if (parsed?.schemaVersion != 1) Result.success(null) else Result.success(parsed)
+                }
+        } catch (e: Exception) {
+            Log.w(TAG, "fetchModelCapabilities failed: ${e.message}")
+            Result.failure(e)
+        }
+    }
+
    /**
     * Ask the relay whether a newer plugin release is available — it compares its
     * installed version against the latest `plugin-v*` GitHub release (cached an
@@ -763,10 +846,8 @@ class RelayHttpClient(
                IllegalStateException("Relay not paired — session token missing")
            )
        }
-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))
        val url = try {
            "$httpBase/relay/update-check".toHttpUrl()
        } catch (e: IllegalArgumentException) {
@@ -849,10 +930,8 @@ class RelayHttpClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        val url = "$httpBase/sessions".toHttpUrlOrNull()
            ?: return@withContext Result.failure(
@@ -932,10 +1011,8 @@ class RelayHttpClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        val url = try {
            "$httpBase/sessions/".toHttpUrl().newBuilder()
@@ -1026,10 +1103,8 @@ class RelayHttpClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        val url = try {
            "$httpBase/sessions/".toHttpUrl().newBuilder()
@@ -1139,32 +1214,30 @@ class RelayHttpClient(
        logSuccess: Boolean = true,
    ): Result<RelayHealth> = withContext(Dispatchers.IO) {
        val trimmed = relayUrl.trim()
+        val operation = "Relay health probe before WebSocket connection"
        if (trimmed.isEmpty()) {
            return@withContext Result.failure(
                IllegalArgumentException("Relay URL is empty")
            )
        }

-        val httpBase = trimmed
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
        val startedAtMs = System.currentTimeMillis()
-
-        val url = try {
-            "$httpBase/health".toHttpUrl()
-        } catch (e: IllegalArgumentException) {
+        val endpoints = RelayEndpointContract.parseOrNull(trimmed)
+        if (endpoints == null) {
            DiagnosticsLog.record(
                category = DiagnosticCategory.Relay,
                severity = DiagnosticSeverity.Error,
                title = context?.getString(R.string.http_diag_url_invalid) ?: "Relay URL invalid",
-                detail = e.message,
-                url = relayUrl,
+                detail = "Malformed or unsafe Relay URL",
+                operation = operation,
+                configuredUrl = relayUrl,
+                suggestion = "Enter a Relay URL with no credentials, query, or fragment.",
            )
            return@withContext Result.failure(
-                IOException("Invalid relay URL: ${e.message}")
+                IOException("Invalid relay URL")
            )
        }
+        val url = endpoints.healthUrl.toHttpUrl()

        // Fast-timeout client — we don't want Save & Test to hang the UI
        // for 10 seconds on a dead URL.
@@ -1180,6 +1253,7 @@ class RelayHttpClient(
            .get()
            .header("Accept", "application/json")
            .build()
+        val requestUrl = request.url.toString()

        try {
            fastClient.newCall(request).execute().use { response ->
@@ -1189,8 +1263,11 @@ class RelayHttpClient(
                        severity = DiagnosticSeverity.Warning,
                        title = context?.getString(R.string.http_diag_health_failed) ?: "Relay health failed",
                        detail = "HTTP ${response.code}",
-                        url = httpBase,
+                        operation = operation,
+                        configuredUrl = trimmed,
+                        requestUrl = requestUrl,
                        elapsedMs = System.currentTimeMillis() - startedAtMs,
+                        suggestion = NetworkDiagnosticGuidance.forHttpStatus(response.code, "Relay"),
                    )
                    return@withContext Result.failure(
                        IOException("Relay responded HTTP ${response.code}")
@@ -1203,8 +1280,11 @@ class RelayHttpClient(
                        severity = DiagnosticSeverity.Warning,
                        title = context?.getString(R.string.http_diag_health_failed) ?: "Relay health failed",
                        detail = "Empty response",
-                        url = httpBase,
+                        operation = operation,
+                        configuredUrl = trimmed,
+                        requestUrl = requestUrl,
                        elapsedMs = System.currentTimeMillis() - startedAtMs,
+                        suggestion = "Verify this route points to a Hermes-Relay server and inspect its logs.",
                    )
                    return@withContext Result.failure(
                        IOException("Relay returned an empty response")
@@ -1220,8 +1300,11 @@ class RelayHttpClient(
                        severity = DiagnosticSeverity.Warning,
                        title = context?.getString(R.string.http_diag_health_failed) ?: "Relay health failed",
                        detail = "Non-JSON response",
-                        url = httpBase,
+                        operation = operation,
+                        configuredUrl = trimmed,
+                        requestUrl = requestUrl,
                        elapsedMs = System.currentTimeMillis() - startedAtMs,
+                        suggestion = "Verify this route points to a Hermes-Relay server rather than another HTTP service.",
                    )
                    return@withContext Result.failure(
                        IOException("Relay returned non-JSON: ${e.message ?: "parse error"}")
@@ -1234,8 +1317,11 @@ class RelayHttpClient(
                        severity = DiagnosticSeverity.Warning,
                        title = context?.getString(R.string.http_diag_health_failed) ?: "Relay health failed",
                        detail = "status=${status ?: "missing"}",
-                        url = httpBase,
+                        operation = operation,
+                        configuredUrl = trimmed,
+                        requestUrl = requestUrl,
                        elapsedMs = System.currentTimeMillis() - startedAtMs,
+                        suggestion = "Check the Relay service health and server logs.",
                    )
                    return@withContext Result.failure(
                        IOException("Relay reports status=${status ?: "missing"} (expected 'ok')")
@@ -1248,8 +1334,11 @@ class RelayHttpClient(
                        severity = DiagnosticSeverity.Warning,
                        title = context?.getString(R.string.http_diag_health_failed) ?: "Relay health failed",
                        detail = "Missing version field",
-                        url = httpBase,
+                        operation = operation,
+                        configuredUrl = trimmed,
+                        requestUrl = requestUrl,
                        elapsedMs = System.currentTimeMillis() - startedAtMs,
+                        suggestion = "Verify this route points to a current Hermes-Relay server.",
                    )
                    return@withContext Result.failure(
                        IOException("Response doesn't look like a hermes-relay — missing 'version' field")
@@ -1265,7 +1354,9 @@ class RelayHttpClient(
                        severity = DiagnosticSeverity.Info,
                        title = context?.getString(R.string.http_diag_health_ok) ?: "Relay health ok",
                        detail = "version=$version clients=$clients sessions=$sessions",
-                        url = httpBase,
+                        operation = operation,
+                        configuredUrl = trimmed,
+                        requestUrl = requestUrl,
                        elapsedMs = System.currentTimeMillis() - startedAtMs,
                    )
                }
@@ -1278,8 +1369,11 @@ class RelayHttpClient(
                severity = DiagnosticSeverity.Warning,
                title = context?.getString(R.string.http_diag_health_timeout) ?: "Relay health timeout",
                detail = "No HTTP response in 3s",
-                url = httpBase,
+                operation = operation,
+                configuredUrl = trimmed,
+                requestUrl = requestUrl,
                elapsedMs = System.currentTimeMillis() - startedAtMs,
+                suggestion = NetworkDiagnosticGuidance.forThrowable(e, "Relay"),
            )
            Result.failure(IOException("Relay is not responding (3s timeout)"))
        } catch (e: java.net.ConnectException) {
@@ -1289,8 +1383,11 @@ class RelayHttpClient(
                severity = DiagnosticSeverity.Error,
                title = context?.getString(R.string.http_diag_conn_refused) ?: "Relay connection refused",
                detail = e.message,
-                url = httpBase,
+                operation = operation,
+                configuredUrl = trimmed,
+                requestUrl = requestUrl,
                elapsedMs = System.currentTimeMillis() - startedAtMs,
+                suggestion = NetworkDiagnosticGuidance.forThrowable(e, "Relay"),
            )
            Result.failure(IOException("Connection refused — is the relay running on this URL?"))
        } catch (e: IOException) {
@@ -1300,8 +1397,11 @@ class RelayHttpClient(
                severity = DiagnosticSeverity.Warning,
                title = context?.getString(R.string.http_diag_health_failed) ?: "Relay health failed",
                detail = e.message ?: "Network error",
-                url = httpBase,
+                operation = operation,
+                configuredUrl = trimmed,
+                requestUrl = requestUrl,
                elapsedMs = System.currentTimeMillis() - startedAtMs,
+                suggestion = NetworkDiagnosticGuidance.forThrowable(e, "Relay"),
            )
            Result.failure(IOException("Network error: ${e.message ?: "unreachable"}"))
        } catch (e: Exception) {
@@ -1311,8 +1411,11 @@ class RelayHttpClient(
                severity = DiagnosticSeverity.Error,
                title = context?.getString(R.string.http_diag_health_failed) ?: "Relay health failed",
                detail = e.message ?: e.javaClass.simpleName,
-                url = httpBase,
+                operation = operation,
+                configuredUrl = trimmed,
+                requestUrl = requestUrl,
                elapsedMs = System.currentTimeMillis() - startedAtMs,
+                suggestion = NetworkDiagnosticGuidance.forThrowable(e, "Relay"),
            )
            Result.failure(e)
        }
@@ -7,6 +7,9 @@ import com.hermesandroid.relay.data.ProfileSkillsResponse
 import com.hermesandroid.relay.data.ProfileSoulResponse
 import com.hermesandroid.relay.data.ProfileSoulUpdateResponse
 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 kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.SerializationException
@@ -48,7 +51,10 @@ class RelayProfileInspectorClient(
    private val okHttpClient: OkHttpClient,
    private val relayUrlProvider: () -> String?,
    private val sessionTokenProvider: suspend () -> String?,
-) {
+) : LegacyProfileInspectorClient {
+
+    private fun relayHttpBaseOrNull(url: String): String? =
+        RelayEndpointContract.parseOrNull(url)?.httpBaseUrl

    companion object {
        private const val TAG = "RelayProfileInspector"
@@ -79,19 +85,19 @@ class RelayProfileInspectorClient(


    /** Fetch `GET /api/profiles/{name}/config`. */
-    suspend fun fetchConfig(profileName: String): Result<ProfileConfigResponse> =
+    override suspend fun fetchConfig(profileName: String): Result<ProfileConfigResponse> =
        get(profileName, "config", ProfileConfigResponse.serializer())

    /** Fetch `GET /api/profiles/{name}/skills`. */
-    suspend fun fetchSkills(profileName: String): Result<ProfileSkillsResponse> =
+    override suspend fun fetchSkills(profileName: String): Result<ProfileSkillsResponse> =
        get(profileName, "skills", ProfileSkillsResponse.serializer())

    /** Fetch `GET /api/profiles/{name}/soul`. */
-    suspend fun fetchSoul(profileName: String): Result<ProfileSoulResponse> =
+    override suspend fun fetchSoul(profileName: String): Result<ProfileSoulResponse> =
        get(profileName, "soul", ProfileSoulResponse.serializer())

    /** Fetch `GET /api/profiles/{name}/memory`. */
-    suspend fun fetchMemory(profileName: String): Result<ProfileMemoryResponse> =
+    override suspend fun fetchMemory(profileName: String): Result<ProfileMemoryResponse> =
        get(profileName, "memory", ProfileMemoryResponse.serializer())

    /**
@@ -108,7 +114,7 @@ class RelayProfileInspectorClient(
     * would be a protocol violation; we send empty-string for an empty
     * SOUL.
     */
-    suspend fun updateSoul(
+    override suspend fun updateSoul(
        profileName: String,
        content: String,
    ): Result<ProfileSoulUpdateResponse> = withContext(Dispatchers.IO) {
@@ -137,7 +143,7 @@ class RelayProfileInspectorClient(
     * Used for both creating a new memory entry (the relay writes the
     * file if missing) and updating an existing entry.
     */
-    suspend fun updateMemoryEntry(
+    override suspend fun updateMemoryEntry(
        profileName: String,
        filename: String,
        content: String,
@@ -189,10 +195,8 @@ class RelayProfileInspectorClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        val encodedName = URLEncoder.encode(profileName, "UTF-8").replace("+", "%20")

@@ -270,10 +274,10 @@ class RelayProfileInspectorClient(
     * server" snackbar and ghost out the toggle. When the real
     * implementation lands server-side, this method needs no change.
     */
-    suspend fun updateSkillToggle(
+    override suspend fun updateSkillToggle(
        skillName: String,
        enabled: Boolean,
-    ): Result<SkillToggleResult> = withContext(Dispatchers.IO) {
+    ): Result<RelaySkillToggleResult> = withContext(Dispatchers.IO) {
        val relayUrl = relayUrlProvider()?.trim().orEmpty()
        if (relayUrl.isEmpty()) {
            return@withContext Result.failure(
@@ -287,10 +291,8 @@ class RelayProfileInspectorClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        val url = try {
            "$httpBase/api/skills/toggle".toHttpUrl()
@@ -319,8 +321,8 @@ class RelayProfileInspectorClient(
        try {
            okHttpClient.newCall(request).execute().use { response ->
                when (response.code) {
-                    in 200..299 -> Result.success(SkillToggleResult.Ok)
-                    501 -> Result.success(SkillToggleResult.NotImplemented)
+                    in 200..299 -> Result.success(RelaySkillToggleResult.Ok)
+                    501 -> Result.success(RelaySkillToggleResult.NotImplemented)
                    401, 403 -> Result.failure(
                        IOException("Unauthorized — re-pair with the relay")
                    )
@@ -348,15 +350,13 @@ class RelayProfileInspectorClient(
     * "not implemented" and any 2xx as "supported". The relay serves
     * OPTIONS via aiohttp's CORS handling by default.
     */
-    suspend fun probeSkillToggleSupported(): Boolean = withContext(Dispatchers.IO) {
+    override suspend fun probeSkillToggleSupported(): Boolean = withContext(Dispatchers.IO) {
        val relayUrl = relayUrlProvider()?.trim().orEmpty()
        if (relayUrl.isEmpty()) return@withContext false
        val sessionToken = sessionTokenProvider() ?: return@withContext false

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext false

        val url = try {
            "$httpBase/api/skills/toggle".toHttpUrl()
@@ -402,11 +402,6 @@ class RelayProfileInspectorClient(
     * answered 501 — not implemented yet" without inventing magic
     * error strings.
     */
-    sealed class SkillToggleResult {
-        data object Ok : SkillToggleResult()
-        data object NotImplemented : SkillToggleResult()
-    }
-
    /**
     * Best-effort pull of a `detail` or `error` string out of a relay
     * 400 body. Falls back to the first 120 chars of the payload when
@@ -448,10 +443,8 @@ class RelayProfileInspectorClient(
            )
        }

-        val httpBase = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
+        val httpBase = relayHttpBaseOrNull(relayUrl)
+            ?: return@withContext Result.failure(IOException("Invalid relay URL"))

        // Percent-encode the profile name for splicing into the path —
        // profile names are typically ASCII identifiers but nothing
@@ -6,6 +6,7 @@ import com.hermesandroid.relay.R
 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 kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -2616,13 +2617,7 @@ class RelayVoiceClient(
    private fun resolveHttpBase(): String? {
        val relayUrl = relayUrlProvider()?.trim().orEmpty()
        if (relayUrl.isEmpty()) return null
-        val normalized = relayUrl
-            .replace(Regex("^wss://", RegexOption.IGNORE_CASE), "https://")
-            .replace(Regex("^ws://", RegexOption.IGNORE_CASE), "http://")
-            .trimEnd('/')
-        // Reject a malformed base up front so callers' url("$base/…") can't throw
-        // IllegalArgumentException on the IO dispatcher (relay half of #131).
-        return if (normalized.toHttpUrlOrNull() != null) normalized else null
+        return RelayEndpointContract.parseOrNull(relayUrl)?.httpBaseUrl
    }

    private fun resolveWebSocketBase(): String? {
@@ -2633,10 +2628,7 @@ class RelayVoiceClient(
    private fun toWebSocketBase(relayUrl: String?): String? {
        val trimmed = relayUrl?.trim().orEmpty()
        if (trimmed.isEmpty()) return null
-        return trimmed
-            .replace(Regex("^https://", RegexOption.IGNORE_CASE), "wss://")
-            .replace(Regex("^http://", RegexOption.IGNORE_CASE), "ws://")
-            .trimEnd('/')
+        return RelayEndpointContract.parseOrNull(trimmed)?.webSocketBaseUrl
    }

    private suspend fun resolveBearerToken(): String? {
@@ -0,0 +1,41 @@
+package com.hermesandroid.relay.network.shared
+
+import okhttp3.Request
+import java.io.IOException
+
+/** Secret-free failure raised before OkHttp sees a malformed credential. */
+class InvalidCredentialException internal constructor(message: String) : IOException(message)
+
+/**
+ * Normalize only harmless surrounding horizontal whitespace. Credentials are
+ * otherwise single-line visible ASCII: embedded whitespace, CR/LF, controls,
+ * and non-ASCII input are rejected instead of repaired or logged.
+ */
+fun normalizeCredentialForHeader(raw: String, label: String): String {
+    val normalized = raw.trim(' ', '\t')
+    if (normalized.any { it < '!' || it > '~' }) {
+        throw InvalidCredentialException(
+            "Invalid $label — enter or import a single-line value.",
+        )
+    }
+    return normalized
+}
+
+fun Request.Builder.bearerAuthorization(
+    rawCredential: String,
+    label: String,
+): Request.Builder {
+    val credential = normalizeCredentialForHeader(rawCredential, label)
+    if (credential.isEmpty()) return this
+    return header("Authorization", "Bearer $credential")
+}
+
+fun Request.Builder.credentialHeader(
+    name: String,
+    rawCredential: String,
+    label: String,
+): Request.Builder {
+    val credential = normalizeCredentialForHeader(rawCredential, label)
+    if (credential.isEmpty()) return this
+    return header(name, credential)
+}
@@ -4,11 +4,13 @@ import android.content.Context
 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.primaryRouteUrl
 import com.hermesandroid.relay.data.routeAuthority
 import com.hermesandroid.relay.diagnostics.DiagnosticCategory
 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.TimeoutCancellationException
 import kotlinx.coroutines.async
@@ -54,6 +56,8 @@ data class RouteProbeOutcome(
 */
 enum class EndpointSurface {
    Standard,
+    Dashboard,
+    Api,
    Relay,
 }

@@ -108,6 +112,8 @@ class EndpointResolver(
     * expected path for plain JVM tests.
     */
    private val context: Context? = null,
+    /** Route-aware client for pinned plugin proxy probes. */
+    private val clientForCandidate: ((EndpointCandidate) -> OkHttpClient?)? = null,
 ) {

    /**
@@ -195,8 +201,13 @@ class EndpointResolver(
            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 ->
-                    routeAuthority(candidate.relay?.url).orEmpty()
+                    candidate.pluginProxyRoutesOrNull()?.authority
+                        ?: routeAuthority(candidate.relay?.url).orEmpty()
            }
            return "${surface.name.lowercase()}|${candidate.role}|$authority"
        }
@@ -238,11 +249,16 @@ class EndpointResolver(
        val eligible = candidates.filter { probeTarget(it, surface) != null }
        if (eligible.isEmpty()) return null

-        // Strict priority: sort ascending so priority-0 lands first. Grouping
-        // preserves emitted order within a priority class (DNS SRV parity).
-        val groups = eligible.groupBy { it.priority }.toSortedMap()
+        // Supported routes always run before experimental routes. Priority is
+        // strict inside each stability tier, so Reach remains available as a
+        // 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 groups = (supported.groupBy { it.priority }.toSortedMap().values +
+            experimental.groupBy { it.priority }.toSortedMap().values)

-        for ((priority, group) in groups) {
+        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) {
@@ -353,6 +369,12 @@ class EndpointResolver(
        surface: EndpointSurface,
    ): Boolean {
        val startedAtMs = clock()
+        val operation = when (surface) {
+            EndpointSurface.Standard -> "Dashboard or API route health probe"
+            EndpointSurface.Dashboard -> "Dashboard route health probe"
+            EndpointSurface.Api -> "API route health probe"
+            EndpointSurface.Relay -> "Relay route health probe"
+        }
        val target = probeTarget(candidate, surface)
        val url = target?.requestUrl?.toHttpUrlOrNull()
            ?: run {
@@ -362,13 +384,15 @@ class EndpointResolver(
                    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,
-                    url = candidate.primaryRouteUrl(),
+                    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 = httpClient.newBuilder()
+        val fastClient = (clientForCandidate?.invoke(candidate) ?: httpClient).newBuilder()
            .connectTimeout(PROBE_TIMEOUT_MS, TimeUnit.MILLISECONDS)
            .readTimeout(PROBE_TIMEOUT_MS, TimeUnit.MILLISECONDS)
            .writeTimeout(PROBE_TIMEOUT_MS, TimeUnit.MILLISECONDS)
@@ -397,9 +421,16 @@ class EndpointResolver(
                            severity = if (ok) DiagnosticSeverity.Info else DiagnosticSeverity.Warning,
                            title = probeTitle,
                            detail = if (ok) null else "HTTP ${resp.code}",
+                            operation = operation,
                            endpointRole = candidate.role,
-                            url = target.baseUrl,
+                            configuredUrl = target.baseUrl,
+                            requestUrl = target.requestUrl,
                            elapsedMs = clock() - startedAtMs,
+                            suggestion = if (ok) {
+                                null
+                            } else {
+                                NetworkDiagnosticGuidance.forHttpStatus(resp.code, surface.diagnosticTarget())
+                            },
                        )
                        recordOutcome(
                            candidate,
@@ -415,9 +446,12 @@ class EndpointResolver(
                        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,
-                        url = target.baseUrl,
+                        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
@@ -428,9 +462,12 @@ class EndpointResolver(
                    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,
-                    url = target.baseUrl,
+                    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
@@ -441,10 +478,13 @@ class EndpointResolver(
                    category = DiagnosticCategory.Endpoint,
                    severity = DiagnosticSeverity.Warning,
                    title = context?.getString(R.string.endpoint_diag_probe_failed) ?: "Endpoint probe failed",
-                    detail = e.javaClass.simpleName,
+                    detail = humanProbeFailure(e),
+                    operation = operation,
                    endpointRole = candidate.role,
-                    url = target.baseUrl,
+                    configuredUrl = target.baseUrl,
+                    requestUrl = target.requestUrl,
                    elapsedMs = clock() - startedAtMs,
+                    suggestion = NetworkDiagnosticGuidance.forThrowable(e, surface.diagnosticTarget()),
                )
                recordOutcome(candidate, surface, reachable = false, detail = humanProbeFailure(e))
                false
@@ -457,6 +497,29 @@ class EndpointResolver(
        candidate: EndpointCandidate,
        surface: EndpointSurface,
    ): ProbeTarget? {
+        if (surface == EndpointSurface.Dashboard) {
+            candidate.pluginProxyRoutesOrNull()?.dashboardBaseUrl?.let { base ->
+                return ProbeTarget(base, "$base/api/status", "/dashboard/api/status")
+            }
+            candidate.dashboard?.url?.trim()?.trimEnd('/')?.takeIf { it.isNotBlank() }?.let { base ->
+                return ProbeTarget(base, "$base/api/status", "/api/status")
+            }
+            return null
+        }
+        if (surface == EndpointSurface.Api) {
+            candidate.pluginProxyRoutesOrNull()?.apiBaseUrl?.let { base ->
+                return ProbeTarget(base, "$base/health", "/api/health")
+            }
+            candidate.api?.url?.let { base -> return ProbeTarget(base, "$base/health", "/health") }
+            return null
+        }
+        if (surface == EndpointSurface.Relay) candidate.pluginProxyRoutesOrNull()?.let { proxy ->
+            return ProbeTarget(
+                baseUrl = proxy.relayHttpUrl,
+                requestUrl = "${proxy.relayHttpUrl}/health",
+                path = "/relay/health",
+            )
+        }
        if (surface == EndpointSurface.Relay) {
            return relayProbeTarget(candidate)
        }
@@ -486,26 +549,24 @@ class EndpointResolver(
    private fun relayProbeTarget(candidate: EndpointCandidate): ProbeTarget? {
        candidate.relay?.url
            ?.trim()
-            ?.trimEnd('/')
            ?.takeIf { it.isNotBlank() }
            ?.let { relayUrl ->
-                val httpBase = when {
-                    relayUrl.startsWith("ws://", ignoreCase = true) ->
-                        "http://${relayUrl.substringAfter("://")}"
-                    relayUrl.startsWith("wss://", ignoreCase = true) ->
-                        "https://${relayUrl.substringAfter("://")}"
-                    else -> return null
-                }
+                val endpoints = RelayEndpointContract.parseOrNull(relayUrl) ?: return null
                return ProbeTarget(
-                    baseUrl = relayUrl,
-                    requestUrl = "$httpBase/health",
-                    path = "/health",
+                    baseUrl = endpoints.webSocketUrl,
+                    requestUrl = endpoints.healthUrl,
+                    path = endpoints.healthUrl.toHttpUrlOrNull()?.encodedPath ?: return null,
                )
            }

        return null
    }

+    internal fun probeRequestUrlForTest(
+        candidate: EndpointCandidate,
+        surface: EndpointSurface,
+    ): String? = probeTarget(candidate, surface)?.requestUrl
+
    /**
     * Map a probe exception to a short, actionable string for the Routes
     * card. The TLS case is the headline: a route saved with `https://`
@@ -521,6 +582,13 @@ class EndpointResolver(
        else -> e.javaClass.simpleName
    }

+    private fun EndpointSurface.diagnosticTarget(): String = when (this) {
+        EndpointSurface.Standard -> "Dashboard or API server"
+        EndpointSurface.Dashboard -> "Dashboard"
+        EndpointSurface.Api -> "API server"
+        EndpointSurface.Relay -> "Relay"
+    }
+
    /**
     * Mark [candidate] unreachable without re-probing. Called from
     * `ConnectionManager`'s `NetworkCallback.onLost` so the next resolve()
@@ -61,7 +61,7 @@ object HermesLanDiscovery {
            .callTimeout(PROBE_TIMEOUT_MS * 2, TimeUnit.MILLISECONDS)
            .build()

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

    private fun probeHost(
@@ -133,8 +135,7 @@ object HermesLanDiscovery {
                val body = response.body.string().take(2_048)
                expectedBody(body, contentType)
            }
-        } catch (e: Exception) {
-            Log.d(TAG, "probe failed url=$url type=${e.javaClass.simpleName}")
+        } catch (_: Exception) {
            false
        }
    }
@@ -0,0 +1,402 @@
+package com.hermesandroid.relay.network.shared
+
+import com.hermesandroid.relay.data.EndpointCandidate
+import com.hermesandroid.relay.data.isValidHermesReach
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import okio.ByteString
+import java.io.IOException
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.net.Socket
+import java.net.SocketAddress
+import java.net.SocketException
+import java.net.URI
+import java.security.SecureRandom
+import java.util.Base64
+import java.util.ArrayDeque
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import javax.net.SocketFactory
+
+private const val REACH_PROTOCOL_VERSION = 1
+private const val REACH_MAX_FRAME_BYTES = 1024 * 1024
+internal const val REACH_MAX_QUEUED_FRAMES = 32
+internal const val REACH_MAX_QUEUED_BYTES = 8 * 1024 * 1024
+private const val REACH_MATCH_TIMEOUT_MS = 10_000L
+
+/**
+ * Connection metadata for Hermes Reach's outer WSS rendezvous.
+ *
+ * This is deliberately transport-only. The inner HTTPS/WSS origin and its
+ * pairing-authenticated SPKI pin continue to be owned by [PluginProxyRoutes],
+ * so broker reachability can never weaken Secure Link trust.
+ */
+data class HermesReachRoute(
+    val brokerUrl: String,
+    val hostId: String,
+    val credentialKind: String,
+    val token: String,
+) {
+    fun tunnelUrlOrNull(): String? {
+        if (hostId.isBlank() || token.isBlank()) return null
+        if (credentialKind !in setOf("bootstrap", "route")) return null
+        val uri = runCatching { URI(brokerUrl.trim()) }.getOrNull() ?: return null
+        if (!uri.scheme.equals("wss", ignoreCase = true) || uri.host.isNullOrBlank()) return null
+        if (!uri.rawUserInfo.isNullOrBlank() || uri.rawQuery != null || uri.rawFragment != null) return null
+        if (uri.rawPath.orEmpty().let { it.isNotEmpty() && it != "/" && it != "/v1/connect" }) return null
+        val authority = buildString {
+            append(if (':' in uri.host) "[${uri.host}]" else uri.host)
+            if (uri.port > 0 && uri.port != 443) append(":${uri.port}")
+        }
+        return "wss://$authority/v1/connect"
+    }
+}
+
+fun EndpointCandidate.hermesReachRouteOrNull(): HermesReachRoute? {
+    val metadata = broker?.takeIf { it.isValidHermesReach() } ?: return null
+    if (pluginProxyRoutesOrNull() == null) return null
+    return HermesReachRoute(
+        brokerUrl = metadata.url,
+        hostId = metadata.hostId,
+        credentialKind = metadata.credentialKind,
+        token = metadata.token,
+    )
+}
+
+/** Build the pinned inner Secure Link client over an outer Hermes Reach WSS. */
+fun buildHermesReachClient(
+    baseBuilder: OkHttpClient.Builder,
+    outerClient: OkHttpClient,
+    candidate: EndpointCandidate,
+    sessionTokenProvider: () -> String?,
+    includeRelaySessionHeader: Boolean = true,
+): OkHttpClient? {
+    val secureLink = candidate.pluginProxyRoutesOrNull() ?: return null
+    val reach = candidate.hermesReachRouteOrNull() ?: return null
+    return buildPluginProxyClient(
+        baseBuilder = baseBuilder,
+        routes = secureLink,
+        sessionTokenProvider = sessionTokenProvider,
+        includeRelaySessionHeader = includeRelaySessionHeader,
+        rawSocketFactory = HermesReachSocketFactory(outerClient, reach),
+    )
+}
+
+@Serializable
+private data class ReachRegistration(
+    val type: String = "register",
+    @SerialName("protocol_version") val protocolVersion: Int = REACH_PROTOCOL_VERSION,
+    val role: String = "client",
+    @SerialName("host_id") val hostId: String,
+    @SerialName("connection_id") val connectionId: String,
+    @SerialName("credential_kind") val credentialKind: String,
+    val token: String,
+)
+
+@Serializable
+private data class ReachControl(
+    val type: String? = null,
+    @SerialName("protocol_version") val protocolVersion: Int? = null,
+    @SerialName("stream_id") val streamId: String? = null,
+    val code: String? = null,
+)
+
+internal object HermesReachHandshake {
+    private val json = Json {
+        ignoreUnknownKeys = false
+        encodeDefaults = true
+    }
+
+    fun registration(route: HermesReachRoute, connectionId: String): String = json.encodeToString(
+        ReachRegistration(
+            hostId = route.hostId,
+            connectionId = connectionId,
+            credentialKind = route.credentialKind,
+            token = route.token,
+        ),
+    )
+
+    fun validateMatched(payload: String): String? {
+        val control = runCatching { json.decodeFromString<ReachControl>(payload) }
+            .getOrElse { return "Hermes Reach returned an invalid match response" }
+        if (control.type == "error") {
+            return "Hermes Reach rejected the route (${control.code ?: "unknown"})"
+        }
+        val streamIdValid = control.streamId?.let(::isCanonicalId) == true
+        if (control.type != "matched" ||
+            control.protocolVersion != REACH_PROTOCOL_VERSION ||
+            !streamIdValid
+        ) {
+            return "Hermes Reach returned a mismatched route response"
+        }
+        return null
+    }
+
+    private fun isCanonicalId(value: String): Boolean {
+        if (value.isBlank() || '=' in value) return false
+        val decoded = runCatching { Base64.getUrlDecoder().decode(value) }.getOrNull() ?: return false
+        return decoded.size == 16 && Base64.getUrlEncoder().withoutPadding().encodeToString(decoded) == value
+    }
+}
+
+/**
+ * Raw socket factory that carries bytes through Hermes Reach. OkHttp layers
+ * the normal Secure Link TLS socket factory over the returned socket, so SNI,
+ * hostname verification, and the QR SPKI pin all apply to the inner endpoint.
+ */
+class HermesReachSocketFactory(
+    private val outerClient: OkHttpClient,
+    private val route: HermesReachRoute,
+) : SocketFactory() {
+    init {
+        require(route.tunnelUrlOrNull() != null) { "Invalid Hermes Reach route" }
+    }
+
+    override fun createSocket(): Socket = HermesReachSocket(outerClient, route)
+
+    override fun createSocket(host: String?, port: Int): Socket =
+        createSocket().apply { connect(InetSocketAddress(host, port)) }
+
+    override fun createSocket(host: String?, port: Int, localHost: InetAddress?, localPort: Int): Socket =
+        createSocket().apply {
+            if (localHost != null) bind(InetSocketAddress(localHost, localPort))
+            connect(InetSocketAddress(host, port))
+        }
+
+    override fun createSocket(host: InetAddress?, port: Int): Socket =
+        createSocket().apply { connect(InetSocketAddress(host, port)) }
+
+    override fun createSocket(
+        address: InetAddress?,
+        port: Int,
+        localAddress: InetAddress?,
+        localPort: Int,
+    ): Socket = createSocket().apply {
+        if (localAddress != null) bind(InetSocketAddress(localAddress, localPort))
+        connect(InetSocketAddress(address, port))
+    }
+}
+
+private class HermesReachSocket(
+    private val outerClient: OkHttpClient,
+    private val route: HermesReachRoute,
+) : Socket() {
+    private val inbound = ReachInputStream()
+    private val matchLatch = CountDownLatch(1)
+    private val connectionId = randomConnectionId()
+    @Volatile private var matchError: IOException? = null
+    @Volatile private var webSocket: WebSocket? = null
+    @Volatile private var connected = false
+    @Volatile private var closed = false
+    @Volatile private var matched = false
+    @Volatile private var remote: InetSocketAddress? = null
+    private var readTimeoutMs: Int = 0
+
+    private val outbound = object : OutputStream() {
+        override fun write(value: Int) = write(byteArrayOf(value.toByte()))
+
+        override fun write(bytes: ByteArray, offset: Int, length: Int) {
+            if (length == 0) return
+            if (!matched || closed) throw SocketException("Hermes Reach tunnel is not open")
+            var cursor = offset
+            var remaining = length
+            while (remaining > 0) {
+                val count = minOf(remaining, REACH_MAX_FRAME_BYTES)
+                val accepted = webSocket?.send(ByteString.of(*bytes.copyOfRange(cursor, cursor + count))) == true
+                if (!accepted) throw SocketException("Hermes Reach could not queue tunnel bytes")
+                cursor += count
+                remaining -= count
+            }
+        }
+    }
+
+    override fun connect(endpoint: SocketAddress?) = connect(endpoint, REACH_MATCH_TIMEOUT_MS.toInt())
+
+    override fun connect(endpoint: SocketAddress?, timeout: Int) {
+        if (connected) throw SocketException("Socket is already connected")
+        if (closed) throw SocketException("Socket is closed")
+        remote = endpoint as? InetSocketAddress
+            ?: throw SocketException("Hermes Reach requires an internet socket target")
+        val request = Request.Builder().url(requireNotNull(route.tunnelUrlOrNull())).build()
+        webSocket = outerClient.newWebSocket(request, listener)
+        val waitMs = minOf(
+            timeout.takeIf { it > 0 }?.toLong() ?: REACH_MATCH_TIMEOUT_MS,
+            REACH_MATCH_TIMEOUT_MS,
+        )
+        if (!matchLatch.await(waitMs, TimeUnit.MILLISECONDS)) {
+            closeWithError(IOException("Hermes Reach host match timed out"))
+        }
+        matchError?.let { throw it }
+        if (!matched) throw IOException("Hermes Reach closed before matching the host")
+        connected = true
+    }
+
+    private val listener = object : WebSocketListener() {
+        override fun onOpen(webSocket: WebSocket, response: Response) {
+            val registration = HermesReachHandshake.registration(route, connectionId)
+            if (!webSocket.send(registration)) {
+                closeWithError(IOException("Hermes Reach registration could not be sent"))
+            }
+        }
+
+        override fun onMessage(webSocket: WebSocket, text: String) {
+            if (matched) {
+                closeWithError(IOException("Hermes Reach sent text after matching"))
+                return
+            }
+            HermesReachHandshake.validateMatched(text)?.let { message ->
+                closeWithError(IOException(message))
+                return
+            }
+            matched = true
+            matchLatch.countDown()
+        }
+
+        override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+            if (!matched) {
+                closeWithError(IOException("Hermes Reach sent bytes before matching"))
+                return
+            }
+            if (bytes.size > REACH_MAX_FRAME_BYTES) {
+                closeWithError(IOException("Hermes Reach frame exceeds 1 MiB"))
+                return
+            }
+            if (!inbound.offer(bytes.toByteArray())) {
+                closeWithError(IOException("Hermes Reach receive queue exceeded its safe limit"))
+            }
+        }
+
+        override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
+            webSocket.close(code, null)
+        }
+
+        override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+            if (!matched) matchError = IOException("Hermes Reach closed before matching the host")
+            closed = true
+            inbound.close(matchError)
+            matchLatch.countDown()
+        }
+
+        override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+            closeWithError(IOException("Hermes Reach connection failed", t))
+        }
+    }
+
+    private fun closeWithError(error: IOException) {
+        matchError = error
+        closed = true
+        webSocket?.cancel()
+        inbound.close(error)
+        matchLatch.countDown()
+    }
+
+    override fun getInputStream(): InputStream {
+        if (!connected || closed) throw SocketException("Hermes Reach tunnel is not open")
+        inbound.readTimeoutMs = readTimeoutMs
+        return inbound
+    }
+
+    override fun getOutputStream(): OutputStream {
+        if (!connected || closed) throw SocketException("Hermes Reach tunnel is not open")
+        return outbound
+    }
+
+    override fun close() {
+        if (closed) return
+        closed = true
+        webSocket?.close(1000, null)
+        inbound.close(null)
+        matchLatch.countDown()
+    }
+
+    override fun isConnected(): Boolean = connected
+    override fun isClosed(): Boolean = closed
+    override fun getRemoteSocketAddress(): SocketAddress? = remote
+    override fun getInetAddress(): InetAddress? = remote?.address
+    override fun getPort(): Int = remote?.port ?: 0
+    override fun setSoTimeout(timeout: Int) { readTimeoutMs = timeout }
+    override fun getSoTimeout(): Int = readTimeoutMs
+    override fun setTcpNoDelay(on: Boolean) = Unit
+    override fun getTcpNoDelay(): Boolean = true
+    override fun setKeepAlive(on: Boolean) = Unit
+    override fun getKeepAlive(): Boolean = true
+    override fun setReuseAddress(on: Boolean) = Unit
+    override fun getReuseAddress(): Boolean = false
+}
+
+internal class ReachInputStream : InputStream() {
+    private val chunks = ArrayDeque<ByteArray>()
+    private var offset = 0
+    private var queuedBytes = 0
+    private var terminalError: IOException? = null
+    private var closed = false
+    @Volatile var readTimeoutMs: Int = 0
+
+    @Synchronized
+    fun offer(bytes: ByteArray): Boolean {
+        if (closed) return false
+        if (chunks.size >= REACH_MAX_QUEUED_FRAMES || queuedBytes + bytes.size > REACH_MAX_QUEUED_BYTES) {
+            return false
+        }
+        chunks.addLast(bytes)
+        queuedBytes += bytes.size
+        (this as java.lang.Object).notifyAll()
+        return true
+    }
+
+    @Synchronized
+    fun close(error: IOException?) {
+        if (closed) return
+        closed = true
+        terminalError = error
+        (this as java.lang.Object).notifyAll()
+    }
+
+    override fun read(): Int {
+        val one = ByteArray(1)
+        return if (read(one, 0, 1) < 0) -1 else one[0].toInt() and 0xff
+    }
+
+    @Synchronized
+    override fun read(target: ByteArray, targetOffset: Int, length: Int): Int {
+        if (length == 0) return 0
+        val started = System.nanoTime()
+        while (chunks.isEmpty() && !closed) {
+            val waitMs = if (readTimeoutMs > 0) {
+                val elapsed = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - started)
+                (readTimeoutMs - elapsed).coerceAtLeast(0)
+            } else 0L
+            if (readTimeoutMs > 0 && waitMs == 0L) throw java.net.SocketTimeoutException("Hermes Reach read timed out")
+            (this as java.lang.Object).wait(if (readTimeoutMs > 0) waitMs else 0L)
+        }
+        if (chunks.isEmpty()) {
+            terminalError?.let { throw it }
+            return -1
+        }
+        val chunk = chunks.first()
+        val count = minOf(length, chunk.size - offset)
+        chunk.copyInto(target, targetOffset, offset, offset + count)
+        offset += count
+        queuedBytes -= count
+        if (offset == chunk.size) {
+            chunks.remove(chunk)
+            offset = 0
+        }
+        return count
+    }
+}
+
+private fun randomConnectionId(): String {
+    val bytes = ByteArray(16).also(SecureRandom()::nextBytes)
+    return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes)
+}
@@ -0,0 +1,149 @@
+package com.hermesandroid.relay.network.shared
+
+import com.hermesandroid.relay.data.EndpointCandidate
+import com.hermesandroid.relay.data.ProxyEndpoint
+import com.hermesandroid.relay.data.isValidPinnedProxy
+import okhttp3.CertificatePinner
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import java.net.URI
+import java.security.KeyStore
+import java.security.MessageDigest
+import java.security.SecureRandom
+import java.security.cert.CertificateException
+import java.security.cert.X509Certificate
+import javax.net.ssl.SSLContext
+import javax.net.ssl.TrustManagerFactory
+import javax.net.ssl.X509TrustManager
+import javax.net.SocketFactory
+
+/** Runtime endpoints exposed beneath one plugin-owned pinned-TLS origin. */
+data class PluginProxyRoutes(
+    val authority: String,
+    val host: String,
+    val port: Int,
+    val relayHttpUrl: String,
+    val relayWebSocketUrl: String,
+    val apiBaseUrl: String?,
+    val dashboardBaseUrl: String?,
+    val pinSha256: String,
+)
+
+/**
+ * Resolve and validate the pairing-advertised proxy contract. Invalid or
+ * incomplete advertisements are never treated as secure routes.
+ */
+fun ProxyEndpoint.toPluginProxyRoutesOrNull(): PluginProxyRoutes? {
+    if (!isValidPinnedProxy()) return null
+    val base = url.trim().trimEnd('/')
+    val uri = runCatching { URI(base) }.getOrNull() ?: return null
+    if (!uri.scheme.equals("https", ignoreCase = true)) return null
+    val host = uri.host?.lowercase()?.takeIf { it.isNotBlank() } ?: return null
+    if (!uri.rawUserInfo.isNullOrBlank() || uri.rawQuery != null || uri.rawFragment != null) return null
+    val rawPath = uri.rawPath.orEmpty()
+    if (rawPath.isNotEmpty() && rawPath != "/") return null
+    val port = if (uri.port > 0) uri.port else 443
+    val pin = pinSha256!!.trim()
+    val authority = "$host:$port"
+    val wsBase = "wss://${formatHost(host)}${if (port == 443) "" else ":$port"}$rawPath"
+        .trimEnd('/')
+    val surfaces = surfaces.map(String::lowercase).toSet()
+    return PluginProxyRoutes(
+        authority = authority,
+        host = host,
+        port = port,
+        relayHttpUrl = "$base/relay",
+        relayWebSocketUrl = "$wsBase/relay/ws",
+        apiBaseUrl = "$base/api".takeIf { "api" in surfaces },
+        dashboardBaseUrl = "$base/dashboard".takeIf { "dashboard" in surfaces },
+        pinSha256 = pin,
+    )
+}
+
+fun EndpointCandidate.pluginProxyRoutesOrNull(): PluginProxyRoutes? =
+    proxy?.toPluginProxyRoutesOrNull()
+
+private fun formatHost(host: String): String = if (':' in host) "[$host]" else host
+
+/**
+ * Build a client that trusts the system normally, plus exactly the
+ * pairing-advertised SPKI for this proxy. The authority guard keeps a pin
+ * scoped to host *and port*; OkHttp's CertificatePinner alone is host-only.
+ */
+fun buildPluginProxyClient(
+    baseBuilder: OkHttpClient.Builder,
+    routes: PluginProxyRoutes,
+    sessionTokenProvider: () -> String?,
+    includeRelaySessionHeader: Boolean = true,
+    rawSocketFactory: SocketFactory? = null,
+): OkHttpClient {
+    val expectedHost = routes.host
+    val expectedPort = routes.port
+    val systemTrust = systemTrustManager()
+    val pinnedTrust = PinnedOrSystemTrustManager(systemTrust, routes.pinSha256)
+    val sslContext = SSLContext.getInstance("TLS").apply {
+        init(null, arrayOf(pinnedTrust), SecureRandom())
+    }
+
+    if (rawSocketFactory != null) baseBuilder.socketFactory(rawSocketFactory)
+    return baseBuilder
+        .sslSocketFactory(sslContext.socketFactory, pinnedTrust)
+        .certificatePinner(
+            CertificatePinner.Builder().add(expectedHost, routes.pinSha256).build(),
+        )
+        .addNetworkInterceptor(Interceptor { chain ->
+            val requestUrl = chain.request().url
+            if (!requestUrl.host.equals(expectedHost, ignoreCase = true) ||
+                requestUrl.port != expectedPort
+            ) {
+                throw java.io.IOException("Pinned proxy redirect left its paired authority")
+            }
+            val token = sessionTokenProvider().takeIf { includeRelaySessionHeader }
+                ?.takeIf { it.isNotBlank() }
+            val request = if (token != null) {
+                chain.request().newBuilder()
+                    .credentialHeader(
+                        "X-Hermes-Relay-Session",
+                        token,
+                        "Relay session credential",
+                    )
+                    .build()
+            } else {
+                chain.request()
+            }
+            chain.proceed(request)
+        })
+        .build()
+}
+
+private fun systemTrustManager(): X509TrustManager {
+    val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
+    factory.init(null as KeyStore?)
+    return factory.trustManagers.filterIsInstance<X509TrustManager>().single()
+}
+
+private class PinnedOrSystemTrustManager(
+    private val system: X509TrustManager,
+    private val expectedPin: String,
+) : X509TrustManager {
+    override fun checkClientTrusted(chain: Array<out X509Certificate>?, authType: String?) =
+        system.checkClientTrusted(chain, authType)
+
+    override fun checkServerTrusted(chain: Array<out X509Certificate>?, authType: String?) {
+        val certificates = chain?.takeIf { it.isNotEmpty() }
+            ?: throw CertificateException("Proxy supplied no certificate chain")
+        val systemAccepted = runCatching { system.checkServerTrusted(chain, authType) }.isSuccess
+        if (systemAccepted) return
+
+        val leaf = certificates.first()
+        leaf.checkValidity()
+        val actual = "sha256/" + java.util.Base64.getEncoder().encodeToString(
+            MessageDigest.getInstance("SHA-256").digest(leaf.publicKey.encoded),
+        )
+        if (!MessageDigest.isEqual(actual.toByteArray(), expectedPin.toByteArray())) {
+            throw CertificateException("Plugin proxy certificate does not match the paired pin")
+        }
+    }
+
+    override fun getAcceptedIssuers(): Array<X509Certificate> = system.acceptedIssuers
+}
--- a/Show More
+++ b/Show More