test(plugins): cover catalog CLI surface and plugin validation

Behavior contracts for catalog-name install resolution (ref pin + sidecar), custom-URL banner, --allow-removed wiring, catalog-pin updates, list annotations, live-index fetch/fallback/TTL cache, search/browse/info rendering, doctor, argparse dispatch, and the validate checks incl. undeclared-capability diffs, crash containment, and built-in tool collisions.
feat(plugins): catalog CLI surface — search/browse/info/install/update/doctor
2026-07-22 08:14:51 -07:00 · 2026-07-22 08:14:51 -07:00 · 2026-07-22 08:14:51 -07:00 · 2026-07-22 08:14:51 -07:00 · 2026-07-22 07:30:55 -07:00 · 2026-07-22 07:30:55 -07:00
429 changed files with 8468 additions and 43912 deletions
@@ -97,6 +97,9 @@ packaging/
 plans/
 .plans/

+# ACP registry manifest (icon + agent.json) — not consumed at runtime
+acp_registry/
+
 # Repo-level dotfiles that are git-only or dev-tooling config
 .env.example
 .envrc
@@ -39,9 +39,6 @@ outputs:
  ci_review:
    description: Require CI-sensitive file review label.
    value: ${{ steps.classify.outputs.ci_review }}
-  ci_review_files:
-    description: JSON list of CI-sensitive files changed by the pull request.
-    value: ${{ steps.classify.outputs.ci_review_files }}

 runs:
  using: composite
@@ -5,32 +5,24 @@ description: >-
  5,000 req/hr per installation (vs 1,000 for the default GITHUB_TOKEN)
  and are scoped to the App's installation permissions, not a user account.

-  Callers must source App credentials from a protected, main-only environment.
-  Never pass an App private key to a pull_request job, a local action, or a
-  reusable workflow resolved from an untrusted PR ref. The fallback keeps a
-  trusted caller functional when its protected environment is misconfigured.
+  Falls back to the built-in GITHUB_TOKEN when APP_CLIENT_ID is not set —
+  this happens on fork PRs where repo secrets are unavailable. The fallback
+  ensures classification, timings, and review comments still work on
+  forks (with the lower GITHUB_TOKEN rate limit).

-  Composite actions cannot access contexts directly, so callers pass the
-  public vars.APP_CLIENT_ID and protected secrets.APP_PRIVATE_KEY as inputs.
-  When the private key is empty, the fallback fires.
+  Composite actions cannot access the secrets context directly, so the
+  calling workflow must pass secrets.APP_CLIENT_ID and secrets.APP_PRIVATE_KEY
+  as inputs. When both are empty (fork PRs), the fallback fires.

 inputs:
  client-id:
-    description: GitHub App Client ID. Pass vars.APP_CLIENT_ID from the calling workflow.
+    description: GitHub App Client ID. Pass secrets.APP_CLIENT_ID from the calling workflow.
    required: false
    default: ''
  private-key:
    description: GitHub App private key PEM. Pass secrets.APP_PRIVATE_KEY from the calling workflow.
    required: false
    default: ''
-  owner:
-    description: GitHub App installation owner. Empty scopes the token to the current repository.
-    required: false
-    default: ''
-  repositories:
-    description: Comma- or newline-separated repositories to scope within the installation owner.
-    required: false
-    default: ''

 outputs:
  token:
@@ -59,8 +51,6 @@ runs:
      with:
        client-id: ${{ inputs.client-id }}
        private-key: ${{ inputs.private-key }}
-        owner: ${{ inputs.owner }}
-        repositories: ${{ inputs.repositories }}

    - name: Fall back to GITHUB_TOKEN
      id: fallback
@@ -9,10 +9,6 @@ name: CI
 # definitions, matrices, and concurrency settings. They no longer have
 # ``push:`` / ``pull_request:`` triggers of their own — everything flows
 # through this file.
-#
-# SECURITY: this workflow runs PR-controlled actions, workflows, and code.
-# Do not add ``secrets: inherit`` or GitHub App credentials here. Trusted
-# main-only automation uses protected environments in its own workflows.

 on:
  pull_request:
@@ -50,15 +46,22 @@ jobs:
      docker_meta: ${{ steps.classify.outputs.docker_meta }}
      mcp_catalog: ${{ steps.classify.outputs.mcp_catalog }}
      ci_review: ${{ steps.classify.outputs.ci_review }}
-      ci_review_files: ${{ steps.classify.outputs.ci_review_files }}
      event_name: ${{ github.event_name }}
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Get GitHub App token
+        id: app-token
+        uses: ./.github/actions/get-app-token
+        with:
+          client-id: ${{ secrets.APP_CLIENT_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
      - name: Detect affected areas
        id: classify
        uses: ./.github/actions/detect-changes
        with:
-          github-token: ${{ github.token }}
+          # The get-app-token composite action falls back to GITHUB_TOKEN
+          # on fork PRs where APP_ID is unavailable.
+          github-token: ${{ steps.app-token.outputs.token }}

  # ─────────────────────────────────────────────────────────────────────
  # Lane-gated sub-workflows. Each runs in parallel after detect finishes.
@@ -71,6 +74,7 @@ jobs:
    uses: ./.github/workflows/tests.yml
    with:
      slice_count: 8
+    secrets: inherit

  lint:
    name: Python lints
@@ -79,12 +83,14 @@ jobs:
    uses: ./.github/workflows/lint.yml
    with:
      event_name: ${{ needs.detect.outputs.event_name }}
+    secrets: inherit

  js-tests:
    name: JS & TS checks
    needs: detect
    if: needs.detect.outputs.frontend == 'true'
    uses: ./.github/workflows/js-tests.yml
+    secrets: inherit

  e2e-desktop:
    name: Desktop E2E
@@ -97,44 +103,48 @@ jobs:
    needs: detect
    if: needs.detect.outputs.site == 'true'
    uses: ./.github/workflows/docs-site-checks.yml
+    secrets: inherit

  history-check:
    name: Deny unrelated histories
    needs: detect
    if: needs.detect.outputs.event_name == 'pull_request'
    uses: ./.github/workflows/history-check.yml
+    secrets: inherit

  contributor-check:
    name: Check contributors
    needs: detect
    if: needs.detect.outputs.python == 'true'
    uses: ./.github/workflows/contributor-check.yml
+    secrets: inherit

  uv-lockfile:
    name: Check uv.lock
    needs: detect
    uses: ./.github/workflows/uv-lockfile-check.yml
+    secrets: inherit

  lockfile-diff:
    name: package-lock.json diff
    needs: detect
    if: needs.detect.outputs.event_name == 'pull_request' && needs.detect.outputs.npm_lock == 'true'
    uses: ./.github/workflows/lockfile-diff.yml
+    secrets: inherit

  docker-lint:
    name: Lint Docker scripts
    needs: detect
    if: needs.detect.outputs.docker_meta == 'true'
    uses: ./.github/workflows/docker-lint.yml
+    secrets: inherit

  docker:
    name: Build&Test Docker image
    needs: detect
-    # Trusted main pushes run docker.yml directly so its container-publish
-    # environment secrets never cross this reusable-workflow call. PR runs
-    # remain build/test-only and secret-free.
-    if: needs.detect.outputs.event_name == 'pull_request' && (needs.detect.outputs.python == 'true' || needs.detect.outputs.frontend == 'true' || needs.detect.outputs.docker_meta == 'true')
+    if: needs.detect.outputs.python == 'true' || needs.detect.outputs.frontend == 'true' || needs.detect.outputs.docker_meta == 'true'
    uses: ./.github/workflows/docker.yml
+    secrets: inherit

  supply-chain:
    name: Supply-chain scan
@@ -153,13 +163,14 @@ jobs:
    uses: ./.github/workflows/review-labels.yml
    with:
      ci_review: ${{ needs.detect.outputs.ci_review == 'true' }}
-      ci_review_files: ${{ needs.detect.outputs.ci_review_files }}
      mcp_catalog: ${{ needs.detect.outputs.mcp_catalog == 'true' }}
      supply_chain: ${{ needs.supply-chain.outputs.critical_findings == 'true' }}
+    secrets: inherit

  osv-scanner:
    name: OSV scan
    uses: ./.github/workflows/osv-scanner.yml
+    secrets: inherit

  # ─────────────────────────────────────────────────────────────────────
  # Live-updating PR review comment.
@@ -169,21 +180,19 @@ jobs:
  # whatever results are available, and upserts it via the
  # ``<!-- hermes-ci-review-bot -->`` marker.
  #
-  # When the visible job set goes quiet, the poller waits 10 seconds and polls
-  # once more so downstream jobs created by an aggregate gate get included.
+  # The poller exits when all non-infra jobs are completed (or on
+  # timeout). ci-timings' review_status is picked up automatically when
+  # its artifact becomes available — the poller downloads and merges it.
  # ─────────────────────────────────────────────────────────────────────
  comment-live:
    name: CI review comment (live)
-    needs: [detect, review-labels, lockfile-diff, supply-chain, osv-scanner, uv-lockfile, history-check, contributor-check, e2e-desktop]
+    needs: [detect, review-labels, lockfile-diff, supply-chain, osv-scanner, uv-lockfile, history-check, contributor-check]
    if: always() && github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork != true
    runs-on: ubuntu-latest
    timeout-minutes: 40
    steps:
      - name: Checkout code
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          ref: ${{ github.event.repository.default_branch }}
-          persist-credentials: false

      - name: Run live comment poller
        env:
@@ -304,8 +313,8 @@ jobs:
  # report with a gantt chart + per-step breakdown. The report is uploaded
  # as an artifact and a markdown summary is written to $GITHUB_STEP_SUMMARY.
  #
-  # The live comment poller can read the standalone review-status artifact
-  # after the HTML report is uploaded, so its link points straight at that report.
+  # The live comment poller picks up ci-timings' completion automatically —
+  # it reads review-status.json from the artifact when the job finishes.
  # ─────────────────────────────────────────────────────────────────────
  ci-timings:
    name: CI timing report
@@ -317,6 +326,13 @@ jobs:
      - name: Checkout code
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

+      - name: Get GitHub App token
+        id: app-token
+        uses: ./.github/actions/get-app-token
+        with:
+          client-id: ${{ secrets.APP_CLIENT_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
      - name: Restore baseline cache (PR only)
        if: github.event_name == 'pull_request'
        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
@@ -330,52 +346,38 @@ jobs:

      - name: Collect timings and generate report
        env:
-          GITHUB_TOKEN: ${{ github.token }}
+          # Forks get no repo secrets (AUTOFIX_BOT_PAT is empty); fall back to
+          # the built-in read-only token so the timings API read still works
+          # there instead of hard-failing this advisory job on every fork PR.
+          # The get-app-token composite action falls back to GITHUB_TOKEN
+          # on fork PRs where APP_ID is unavailable.
+          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
        run: |
          python3 scripts/ci/timings_report.py \
            --baseline ci-timings-baseline.json \
            --output ci-timings-report.html \
            --json-out ci-timings.json \
-            --summary-out ci-timings-summary.md
+            --summary-out ci-timings-summary.md \
+            --review-status-out review-status.json

-      - name: Upload HTML report
+      - name: Upload HTML report + review status
        # Advisory report — artifact-service blips must not fail the job.
        continue-on-error: true
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
-        id: ci-timings-html
+        id: ci-timings-artifact
        with:
          name: ci-timings-report
-          path: ci-timings-report.html
-          retention-days: 14
-
-      - name: Build linked review status
-        if: hashFiles('ci-timings.json') != ''
-        env:
-          CI_TIMINGS_REPORT_URL: ${{ steps.ci-timings-html.outputs.artifact-url }}
-        run: |
-          python3 scripts/ci/timings_report.py \
-            --from-json ci-timings.json \
-            --baseline ci-timings-baseline.json \
-            --review-status-out review-status.json \
-            --review-status-only
-
-      - name: Upload review status
-        if: hashFiles('review-status.json') != ''
-        continue-on-error: true
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
-        with:
-          name: ci-timings-review-status
-          path: review-status.json
+          path: |
+            ci-timings-report.html
+            review-status.json
          retention-days: 14

      - name: Output summary
        env:
-          REPORT_URL: ${{ steps.ci-timings-html.outputs.artifact-url}}
+          REPORT_URL: ${{ steps.ci-timings-artifact.outputs.artifact-url}}
        run: |
-          {
-            echo "# CI Timing report"
-            echo "[View the full interactive report]($REPORT_URL)"
-          } >> "$GITHUB_STEP_SUMMARY"
+          echo "# CI Timing report" >> "$GITHUB_STEP_SUMMARY"
+          echo "[View the full interactive report]($REPORT_URL)" >> "$GITHUB_STEP_SUMMARY"
          cat ci-timings-summary.md >> "$GITHUB_STEP_SUMMARY"

      - name: Save baseline cache (main only)
@@ -60,7 +60,7 @@ jobs:
        id: app-token
        uses: ./.github/actions/get-app-token
        with:
-          client-id: ${{ vars.APP_CLIENT_ID }}
+          client-id: ${{ secrets.APP_CLIENT_ID }}
          private-key: ${{ secrets.APP_PRIVATE_KEY }}

      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020  # v4
@@ -1,15 +1,8 @@
 name: Docker Build, Test, and Publish

 on:
-  # Trusted main pushes run this workflow directly so environment-scoped
-  # Docker Hub secrets are resolved by the top-level workflow, never across
-  # a reusable-workflow boundary.
-  push:
-    branches: [main]
  release:
    types: [published]
-  # CI calls this only for untrusted PR build/test coverage. Those runs never
-  # reach the protected publish or merge jobs below.
  workflow_call:

 permissions:
@@ -27,9 +20,7 @@ env:
  IMAGE_NAME: nousresearch/hermes-agent

 jobs:
-  # Build and test the image for each architecture. This job runs PR code,
-  # so it must remain secret-free. Publishing happens in the separate,
-  # protected publish job after these tests pass.
+  # Build, test, and optionally push the image for each architecture.
  build:
    if: github.repository == 'NousResearch/hermes-agent'
    strategy:
@@ -71,6 +62,49 @@ jobs:
          cache-from: ${{ matrix.cache-from }}
          cache-to: ${{ (github.event_name != 'pull_request') && matrix.cache-to || '' }}

+      - name: Log in to Docker Hub
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main' || github.event_name == 'release'
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      # Push by digest only (no tag).  The merge job assembles the
+      # tagged manifest list.  `push-by-digest=true` is docker's recommended
+      # pattern for multi-runner multi-platform builds.
+      - name: Push ${{ matrix.arch }} by digest
+        id: push
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main' || github.event_name == 'release'
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: .
+          file: Dockerfile
+          platforms: ${{ matrix.platform }}
+          labels: |
+            org.opencontainers.image.revision=${{ github.sha }}
+          build-args: |
+            HERMES_GIT_SHA=${{ github.sha }}
+          outputs: type=image,name=${{ env.IMAGE_NAME }},push-by-digest=true,name-canonical=true,push=true
+          cache-from: ${{ matrix.cache-from }}
+          cache-to: ${{ matrix.cache-to }}
+
+      # Write the digest to a file and upload it as an artifact so the
+      # merge job can stitch both per-arch digests into a manifest list.
+      - name: Export digest
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main' || github.event_name == 'release'
+        run: |
+          mkdir -p /tmp/digests
+          digest="${{ steps.push.outputs.digest }}"
+          touch "/tmp/digests/${digest#sha256:}"
+
+      - name: Upload digest artifact
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main' || github.event_name == 'release'
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        with:
+          name: digest-${{ matrix.arch }}
+          path: /tmp/digests/*
+          if-no-files-found: error
+          retention-days: 1

      # Run the docker-integration test suite against the freshly-built
      # image already loaded into the local daemon (`:test`).
@@ -113,74 +147,6 @@ jobs:
        run: |
          scripts/run_tests.sh tests/docker/ --file-timeout 600

-  # ---------------------------------------------------------------------------
-  # Rebuild and push each architecture only after the unprivileged build/test
-  # matrix passes. This job is the sole Docker Hub credential boundary.
-  # ---------------------------------------------------------------------------
-  publish:
-    if: github.repository == 'NousResearch/hermes-agent' && (github.event_name == 'push' && github.ref == 'refs/heads/main' || github.event_name == 'release')
-    needs: [build]
-    environment: container-publish
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - arch: amd64
-            runner: ubuntu-latest
-            platform: linux/amd64
-            cache-from: type=gha,scope=docker-amd64
-            cache-to: type=gha,mode=max,scope=docker-amd64
-          - arch: arm64
-            runner: ubuntu-24.04-arm
-            platform: linux/arm64
-            cache-from: type=gha,scope=docker-arm64
-            cache-to: type=gha,mode=max,scope=docker-arm64
-    runs-on: ${{ matrix.runner }}
-    timeout-minutes: 30
-    steps:
-      - name: Checkout trusted source
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      # Push by digest only (no tag). The merge job assembles the tagged
-      # manifest list after both architecture publishers complete.
-      - name: Push ${{ matrix.arch }} by digest
-        id: push
-        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
-        with:
-          context: .
-          file: Dockerfile
-          platforms: ${{ matrix.platform }}
-          labels: |
-            org.opencontainers.image.revision=${{ github.sha }}
-          build-args: |
-            HERMES_GIT_SHA=${{ github.sha }}
-          outputs: type=image,name=${{ env.IMAGE_NAME }},push-by-digest=true,name-canonical=true,push=true
-          cache-from: ${{ matrix.cache-from }}
-          cache-to: ${{ matrix.cache-to }}
-
-      - name: Export digest
-        run: |
-          mkdir -p /tmp/digests
-          digest="${{ steps.push.outputs.digest }}"
-          touch "/tmp/digests/${digest#sha256:}"
-
-      - name: Upload digest artifact
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
-        with:
-          name: digest-${{ matrix.arch }}
-          path: /tmp/digests/*
-          if-no-files-found: error
-          retention-days: 1
-
  # ---------------------------------------------------------------------------
  # Stitch both per-arch digests into a single tagged multi-arch manifest.
  # This is a registry-side operation — no building, no layer re-push —
@@ -192,9 +158,8 @@ jobs:
  merge:
    if: github.repository == 'NousResearch/hermes-agent' && (github.event_name == 'push' && github.ref == 'refs/heads/main' || github.event_name == 'release')
    runs-on: ubuntu-latest
-    needs: [publish]
+    needs: [build]
    timeout-minutes: 10
-    environment: container-publish
    steps:
      - name: Download digests
        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
@@ -2,10 +2,6 @@ name: E2E Desktop

 on:
  workflow_call:
-    outputs:
-      review_status:
-        description: Screenshot and visual-diff status for the CI review comment.
-        value: ${{ jobs.e2e.outputs.review_status }}

 permissions:
  contents: read
@@ -19,8 +15,6 @@ jobs:
    name: Playwright E2E (Linux)
    runs-on: ubuntu-latest
    timeout-minutes: 20
-    outputs:
-      review_status: ${{ steps.review-status.outputs.review_status }}
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

@@ -64,8 +58,7 @@ jobs:
          command: uv sync --locked --python 3.11 --extra all --extra dev

      # ── Build desktop app ─────────────────────────────────────────────
-      # The Playwright step below runs `npm run build` before testing so
-      # dist/ is always fresh — no separate build step needed here.
+      - run: npm run --prefix apps/desktop build

      # ── Restore visual baseline screenshots from main ──────────────────
      # Baselines are generated on main (via --update-snapshots) and cached.
@@ -86,18 +79,16 @@ jobs:
      # xvfb runs at a fixed 1280x1024 screen so the 1220x800 Electron
      # window always has a consistent viewport for screenshot comparison.
      # On main, we run with --update-snapshots to generate baselines.
-      # `npm run test:e2e` builds dist/ as a pretest hook so the renderer
-      # is always fresh — no separate build step needed.
      - name: Run Playwright E2E tests
        working-directory: apps/desktop
        run: |
          if [ "${{ github.ref_name }}" = "main" ]; then
            echo "On main — generating/updating baseline screenshots"
-            npm run build && xvfb-run -a --server-args="-screen 0 1280x1024x24" \
+            xvfb-run -a --server-args="-screen 0 1280x1024x24" \
              npx playwright test --reporter=list --update-snapshots
          else
            echo "On PR — comparing against cached baselines"
-            npm run build && xvfb-run -a --server-args="-screen 0 1280x1024x24" \
+            xvfb-run -a --server-args="-screen 0 1280x1024x24" \
              npx playwright test --reporter=list
          fi
        env:
@@ -152,38 +143,6 @@ jobs:
          overwrite: true
          if-no-files-found: ignore

-      - name: Build screenshot review status
-        id: review-status
-        if: always()
-        working-directory: apps/desktop
-        env:
-          RESULTS_URL: ${{ steps.upload-results.outputs.artifact-url }}
-        run: |
-          python3 ../../scripts/ci/e2e_screenshot_status.py \
-            --results-dir test-results \
-            --manifest-output /tmp/e2e-screenshot-manifest.json \
-            --evidence-dir /tmp/e2e-evidence \
-            --artifact-url "$RESULTS_URL" \
-            --output /tmp/e2e-review-status.json
-          {
-            echo 'review_status<<__E2E_REVIEW_STATUS__'
-            cat /tmp/e2e-review-status.json
-            echo '__E2E_REVIEW_STATUS__'
-          } >> "$GITHUB_OUTPUT"
-
-      # The trusted workflow_run publisher consumes only this flat, bounded
-      # artifact. It turns selected images into GitHub attachment URLs; it
-      # never checks out or runs this PR's code.
-      - name: Upload inline E2E evidence
-        if: always() && github.ref_name != 'main'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: e2e-evidence-${{ github.sha }}
-          path: /tmp/e2e-evidence
-          retention-days: 14
-          overwrite: true
-          if-no-files-found: error
-
      # ── Generate step summary with visual diff info ───────────────────
      # Parse the JSON report + scan for diff images, then post a summary
      # to the GitHub Actions step output so reviewers can see what changed
@@ -197,50 +156,49 @@ jobs:
          RESULTS_URL: ${{ steps.upload-results.outputs.artifact-url }}
          DIFFS_URL: ${{ steps.upload-diffs.outputs.artifact-url }}
        run: |
-          {
-          echo "## Desktop E2E — Visual Diff Report"
-          echo ""
+          echo "## Desktop E2E — Visual Diff Report" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"

          # Count diff images (playwright writes *-diff.png on mismatch)
          DIFF_COUNT=$(find test-results -name '*-diff.png' 2>/dev/null | wc -l)
          ACTUAL_COUNT=$(find test-results -name '*-actual.png' 2>/dev/null | wc -l)

          if [ "$DIFF_COUNT" -eq 0 ]; then
-            echo "✅ All $ACTUAL_COUNT screenshot(s) matched their baselines (or no baselines existed yet)."
+            echo "✅ All $ACTUAL_COUNT screenshot(s) matched their baselines (or no baselines existed yet)." >> "$GITHUB_STEP_SUMMARY"
          else
-            echo "📸 **$DIFF_COUNT of $ACTUAL_COUNT screenshot(s) differ from baseline:**"
-            echo ""
-            echo "| Test | Diff | Actual | Expected |"
-            echo "|------|------|--------|----------|"
+            echo "📸 **$DIFF_COUNT of $ACTUAL_COUNT screenshot(s) differ from baseline:**" >> "$GITHUB_STEP_SUMMARY"
+            echo "" >> "$GITHUB_STEP_SUMMARY"
+            echo "| Test | Diff | Actual | Expected |" >> "$GITHUB_STEP_SUMMARY"
+            echo "|------|------|--------|----------|" >> "$GITHUB_STEP_SUMMARY"

            # List each diff image with a link to the artifact
            for diff in $(find test-results -name '*-diff.png' 2>/dev/null | sort); do
-              base=${diff%-diff.png}
+              base=$(echo "$diff" | sed 's/-diff\.png$//')
              test_name=$(basename "$base")
-              echo "| $test_name | [diff]($diff) | [actual](${base}-actual.png) | [expected](${base}-expected.png) |"
+              echo "| $test_name | [diff]($diff) | [actual](${base}-actual.png) | [expected](${base}-expected.png) |" >> "$GITHUB_STEP_SUMMARY"
            done
          fi

-          echo ""
-          echo "📥 **Artifacts:**"
-          echo ""
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "📥 **Artifacts:**" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
          if [ -n "$RESULTS_URL" ]; then
-            echo "- [playwright-test-results]($RESULTS_URL) — all screenshots (actual + expected + diff) + traces"
+            echo "- [playwright-test-results]($RESULTS_URL) — all screenshots (actual + expected + diff) + traces" >> "$GITHUB_STEP_SUMMARY"
          fi
          if [ -n "$REPORT_URL" ]; then
-            echo "- [playwright-report]($REPORT_URL) — interactive HTML report"
+            echo "- [playwright-report]($REPORT_URL) — interactive HTML report" >> "$GITHUB_STEP_SUMMARY"
          fi
          if [ -n "$DIFFS_URL" ]; then
-            echo "- [visual-diffs]($DIFFS_URL) — just the diffed screenshots (small, fast to review)"
+            echo "- [visual-diffs]($DIFFS_URL) — just the diffed screenshots (small, fast to review)" >> "$GITHUB_STEP_SUMMARY"
          fi
-          echo ""
-          echo "**To update baselines:** merge to main (baselines auto-update on main runs) or run \`npx playwright test --update-snapshots\` locally."
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "**To update baselines:** merge to main (baselines auto-update on main runs) or run \`npx playwright test --update-snapshots\` locally." >> "$GITHUB_STEP_SUMMARY"

          # Also parse the JSON report for pass/fail counts
          if [ -f playwright-report/results.json ]; then
-            echo ""
-            echo "### Test Results"
-            echo ""
+            echo "" >> "$GITHUB_STEP_SUMMARY"
+            echo "### Test Results" >> "$GITHUB_STEP_SUMMARY"
+            echo "" >> "$GITHUB_STEP_SUMMARY"
            node -e "
              const r = require('./playwright-report/results.json');
              const stats = r.stats || {};
@@ -250,6 +208,5 @@ jobs:
              console.log('| ❌ Failed | ' + (stats.unexpected || 0) + ' |');
              console.log('| ⏭️ Skipped | ' + (stats.skipped || 0) + ' |');
              console.log('| 🔄 Flaky | ' + (stats.flaky || 0) + ' |');
-            " 2>/dev/null || true
+            " >> "$GITHUB_STEP_SUMMARY" 2>/dev/null || true
          fi
-          } >> "$GITHUB_STEP_SUMMARY"
@@ -122,7 +122,6 @@ jobs:
    if: needs.generate-patch.outputs.has-fixes == 'true'
    runs-on: ubuntu-latest
    timeout-minutes: 15
-    environment: trusted-automation
    permissions:
      contents: write # needed to push to bot/js-autofix
      pull-requests: write # needed for PR creation + auto-merge
@@ -133,7 +132,7 @@ jobs:
        id: app-token
        uses: ./.github/actions/get-app-token
        with:
-          client-id: ${{ vars.APP_CLIENT_ID }}
+          client-id: ${{ secrets.APP_CLIENT_ID }}
          private-key: ${{ secrets.APP_PRIVATE_KEY }}

      - name: Download patch
@@ -48,9 +48,6 @@ jobs:
        --lockfile=uv.lock
        --lockfile=package-lock.json
        --lockfile=website/package-lock.json
-      # The upstream reusable workflow uploads this exact file under its
-      # fixed artifact name, which the wrapper downloads below.
-      results-file-name: osv-results.sarif
      fail-on-vuln: false

  emit-status:
@@ -67,7 +64,7 @@ jobs:
      - name: Download SARIF result
        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
        with:
-          name: OSV Scanner SARIF file
+          name: osv-results
          path: /tmp/osv-results
        continue-on-error: true

@@ -1,71 +0,0 @@
-name: Publish E2E evidence
-
-# This runs only from the default branch after CI completes. It intentionally
-# checks out main, never the PR ref, and treats the downloaded artifact as
-# untrusted input before uploading validated GitHub attachments.
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-
-permissions:
-  actions: read
-  contents: read
-  pull-requests: write
-
-concurrency:
-  group: publish-e2e-evidence-${{ github.event.workflow_run.id }}
-  cancel-in-progress: false
-
-jobs:
-  publish:
-    name: Publish inline E2E evidence
-    if: github.event.workflow_run.event == 'pull_request'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    environment: gh-image
-    steps:
-      - name: Check out trusted publisher
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          ref: ${{ github.event.repository.default_branch }}
-          persist-credentials: false
-
-      # v1.2.0 resolves to 44f4b93ecbbe22de6c45fa2f62f519aee564ca8c.
-      - name: Install gh-image
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: gh extension install drogers0/gh-image --pin v1.2.0
-
-      - name: Download and attach evidence
-        env:
-          GH_TOKEN: ${{ github.token }}
-          GITHUB_TOKEN: ${{ github.token }}
-          GH_SESSION_TOKEN: ${{ secrets.GH_IMAGE_SESSION_TOKEN }}
-          SOURCE_REPO: ${{ github.repository }}
-          SOURCE_RUN_ID: ${{ github.event.workflow_run.id }}
-        run: |
-          set -euo pipefail
-
-          PR_NUMBER=$(gh api "repos/$SOURCE_REPO/actions/runs/$SOURCE_RUN_ID" --jq '.pull_requests[0].number // empty')
-          if [ -z "$PR_NUMBER" ]; then
-            echo "No pull request is associated with CI run $SOURCE_RUN_ID."
-            exit 0
-          fi
-
-          ARTIFACT_NAME=$(gh api "repos/$SOURCE_REPO/actions/runs/$SOURCE_RUN_ID/artifacts" \
-            --jq '.artifacts[] | select(.expired == false and (.name | startswith("e2e-evidence-"))) | .name' \
-            | python3 -c 'import sys; print(next(iter(sys.stdin), "").strip())')
-          if [ -z "$ARTIFACT_NAME" ]; then
-            echo "No E2E evidence artifact was produced for CI run $SOURCE_RUN_ID."
-            exit 0
-          fi
-
-          EVIDENCE_DIR="$RUNNER_TEMP/e2e-evidence"
-          mkdir -p "$EVIDENCE_DIR"
-          gh run download "$SOURCE_RUN_ID" --repo "$SOURCE_REPO" --name "$ARTIFACT_NAME" --dir "$EVIDENCE_DIR"
-
-          python3 scripts/ci/publish_e2e_evidence.py \
-            --evidence-dir "$EVIDENCE_DIR" \
-            --source-repo "$SOURCE_REPO" \
-            --pr-number "$PR_NUMBER"
@@ -23,10 +23,6 @@ on:
        description: Whether CI-sensitive files (eslint config, workflows, actions) changed.
        type: boolean
        default: false
-      ci_review_files:
-        description: JSON list of CI-sensitive files changed by the pull request.
-        type: string
-        default: '[]'
      mcp_catalog:
        description: Whether the MCP catalog / installer changed.
        type: boolean
@@ -82,25 +78,18 @@ jobs:
        id: build-status
        env:
          CI_REVIEW: ${{ inputs.ci_review }}
-          CI_REVIEW_FILES: ${{ inputs.ci_review_files }}
          MCP_CATALOG: ${{ inputs.mcp_catalog }}
          SUPPLY_CHAIN: ${{ inputs.supply_chain }}
          LABEL_PRESENT: ${{ steps.label-check.outputs.ci_reviewed }}
-          REPO_URL: ${{ github.server_url }}/${{ github.repository }}
-          BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
        run: |
          set -euo pipefail
          args=()
          if [ "$CI_REVIEW" = "true" ]; then args+=(--ci-review); fi
-          args+=(--ci-review-files "$CI_REVIEW_FILES")
          if [ "$MCP_CATALOG" = "true" ]; then args+=(--mcp-catalog); fi
          if [ "$SUPPLY_CHAIN" = "true" ]; then args+=(--supply-chain); fi
          if [ "$LABEL_PRESENT" = "true" ]; then args+=(--label-present); fi

-          python3 scripts/ci/emit_review_status.py "${args[@]}" \
-            --repo-url "$REPO_URL" --base-sha "$BASE_SHA" --head-sha "$HEAD_SHA" \
-            --output "$GITHUB_OUTPUT"
+          python3 scripts/ci/emit_review_status.py "${args[@]}" --output "$GITHUB_OUTPUT"

      - name: Fail on missing label
        if: steps.label-check.outputs.ci_reviewed != 'true'
@@ -21,7 +21,6 @@ jobs:
    if: github.repository == 'NousResearch/hermes-agent'
    runs-on: ubuntu-latest
    timeout-minutes: 10
-    environment: trusted-automation
    steps:
      - name: Probe live index
        id: probe
@@ -114,7 +113,7 @@ jobs:
        id: app-token
        uses: ./.github/actions/get-app-token
        with:
-          client-id: ${{ vars.APP_CLIENT_ID }}
+          client-id: ${{ secrets.APP_CLIENT_ID }}
          private-key: ${{ secrets.APP_PRIVATE_KEY }}

      - name: Open issue on degraded / failed probe
@@ -21,7 +21,6 @@ jobs:
    if: github.repository == 'NousResearch/hermes-agent'
    runs-on: ubuntu-latest
    timeout-minutes: 15
-    environment: trusted-automation
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

@@ -29,7 +28,7 @@ jobs:
        id: app-token
        uses: ./.github/actions/get-app-token
        with:
-          client-id: ${{ vars.APP_CLIENT_ID }}
+          client-id: ${{ secrets.APP_CLIENT_ID }}
          private-key: ${{ secrets.APP_PRIVATE_KEY }}

      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -61,13 +60,12 @@ jobs:
    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
    runs-on: ubuntu-latest
    timeout-minutes: 15
-    environment: trusted-automation
    steps:
      - name: Get GitHub App token
        id: app-token
        uses: ./.github/actions/get-app-token
        with:
-          client-id: ${{ vars.APP_CLIENT_ID }}
+          client-id: ${{ secrets.APP_CLIENT_ID }}
          private-key: ${{ secrets.APP_PRIVATE_KEY }}
      - name: Trigger Deploy Site workflow
        env:
@@ -65,11 +65,17 @@ jobs:
        with:
          fetch-depth: 0

+      - name: Get GitHub App token
+        id: app-token
+        uses: ./.github/actions/get-app-token
+        with:
+          client-id: ${{ secrets.APP_CLIENT_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
      - name: Scan diff for critical patterns
        id: scan
        env:
-          GH_TOKEN: ${{ github.token }}
-          CI_REVIEWED: ${{ contains(github.event.pull_request.labels.*.name, 'ci-reviewed') }}
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
        run: |
          set -euo pipefail

@@ -87,7 +93,7 @@ jobs:
          # --- .pth files (auto-execute on Python startup) ---
          # The exact mechanism used in the litellm supply chain attack:
          # https://github.com/BerriAI/litellm/issues/24512
-          PTH_FILES=$(git diff --diff-filter=d --name-only "$BASE"..."$HEAD" | grep '\.pth$' || true)
+          PTH_FILES=$(git diff --name-only "$BASE"..."$HEAD" | grep '\.pth$' || true)
          if [ -n "$PTH_FILES" ]; then
            FINDINGS="${FINDINGS}
          ### 🚨 CRITICAL: .pth file added or modified
@@ -135,11 +141,8 @@ jobs:
          # auto-loaded by the interpreter via site.py. Any nested file with the
          # same name (e.g. hermes_cli/setup.py — the CLI setup wizard) is unrelated
          # and produced false positives that trained reviewers to ignore the scanner.
-          SETUP_HITS=$(git diff --diff-filter=d --name-only "$BASE"..."$HEAD" | grep -E '^(setup\.py|setup\.cfg|sitecustomize\.py|usercustomize\.py|__init__\.pth)$' || true)
-          # A maintainer-applied ci-reviewed label records the manual review
-          # required for intentional changes to an install hook. The scanner
-          # still blocks every unreviewed addition or modification.
-          if [ -n "$SETUP_HITS" ] && [ "$CI_REVIEWED" != "true" ]; then
+          SETUP_HITS=$(git diff --name-only "$BASE"..."$HEAD" | grep -E '^(setup\.py|setup\.cfg|sitecustomize\.py|usercustomize\.py|__init__\.pth)$' || true)
+          if [ -n "$SETUP_HITS" ]; then
            FINDINGS="${FINDINGS}
          ### 🚨 CRITICAL: Install-hook file added or modified
          These files can execute code during package installation or interpreter startup.
@@ -215,6 +215,11 @@ jobs:
        # re-download, keeping the persisted cache small and fast to restore.
        run: uv cache prune --ci

+      - name: Packaged-wheel i18n smoke test
+        run: |
+          source .venv/bin/activate
+          python -m pytest -m integration tests/test_wheel_locales_e2e.py -v
+
      - name: Run e2e tests
        run: |
          source .venv/bin/activate
@@ -0,0 +1,188 @@
+name: Publish to PyPI
+
+# Triggered by CalVer tag pushes from scripts/release.py (e.g. v2026.5.15)
+# Can also be triggered manually from the Actions tab as an escape hatch.
+on:
+  push:
+    tags:
+      - "v20*" # CalVer tags: v2026.5.15, v2026.5.15.2, etc.
+  workflow_dispatch:
+    inputs:
+      confirm_tag:
+        description: "Tag to publish (e.g. v2026.5.15). Must already exist."
+        required: true
+        type: string
+
+# Restrict default token to read-only; each job escalates as needed.
+permissions:
+  contents: read
+
+# Prevent overlapping publishes (e.g. two same-day tags pushed quickly).
+concurrency:
+  group: pypi-publish
+  cancel-in-progress: false
+
+jobs:
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+          # On workflow_dispatch, check out the confirmed tag.
+          ref: ${{ inputs.confirm_tag || github.ref }}
+          fetch-tags: true
+
+      - name: Validate tag exists
+        if: github.event_name == 'workflow_dispatch'
+        run: |
+          if ! git tag -l "${{ inputs.confirm_tag }}" | grep -q .; then
+            echo "::error::Tag '${{ inputs.confirm_tag }}' does not exist in the repo"
+            exit 1
+          fi
+
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.13"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # 8.2.0
+
+      - name: Set up Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: "22"
+
+      - name: Build web dashboard
+        uses: ./.github/actions/retry
+        with:
+          command: npm ci
+          working-directory: web
+
+      - name: Compile web dashboard
+        run: npm run build
+        working-directory: web
+
+      - name: Build TUI bundle
+        uses: ./.github/actions/retry
+        with:
+          command: npm ci
+          working-directory: ui-tui
+
+      - name: Compile TUI bundle
+        run: npm run build
+        working-directory: ui-tui
+
+      - name: Bundle TUI into hermes_cli
+        run: |
+          mkdir -p hermes_cli/tui_dist
+          cp ui-tui/dist/entry.js hermes_cli/tui_dist/entry.js
+
+      - name: Verify frontend assets exist
+        run: |
+          test -f hermes_cli/web_dist/index.html || { echo "ERROR: web_dist not built"; exit 1; }
+          test -f hermes_cli/tui_dist/entry.js || { echo "ERROR: tui_dist not built"; exit 1; }
+
+      - name: Bundle install scripts into wheel
+        run: |
+          mkdir -p hermes_cli/scripts
+          cp scripts/install.sh hermes_cli/scripts/install.sh
+          cp scripts/install.ps1 hermes_cli/scripts/install.ps1
+
+      - name: Build wheel and sdist
+        run: uv build --sdist --wheel
+
+      - name: Upload distribution artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    environment:
+      name: pypi
+      url: https://pypi.org/p/hermes-agent
+    permissions:
+      id-token: write # OIDC trusted publishing
+
+    steps:
+      - name: Download distribution artifacts
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
+        with:
+          skip-existing: true
+
+  sign:
+    name: Sign and attach to GitHub Release
+    # Only runs on tag pushes — release.py creates the GitHub Release,
+    # and workflow_dispatch won't have a matching release to attach to.
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: publish
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: write # attach assets to the existing release
+      id-token: write # sigstore signing
+
+    steps:
+      - name: Download distribution artifacts
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Get GitHub App token
+        id: app-token
+        uses: ./.github/actions/get-app-token
+        with:
+          client-id: ${{ secrets.APP_CLIENT_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+      - name: Wait for GitHub Release to exist
+        env:
+          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
+        # release.py creates the GitHub Release after pushing the tag,
+        # but this workflow starts from the tag push — wait for it.
+        run: |
+          for i in $(seq 1 30); do
+            if gh release view "$GITHUB_REF_NAME" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+              echo "Release $GITHUB_REF_NAME found"
+              exit 0
+            fi
+            echo "Waiting for release... ($i/30)"
+            sleep 10
+          done
+          echo "::warning::Release $GITHUB_REF_NAME not found after 5 minutes — skipping signature upload"
+          echo "skip_sign=true" >> "$GITHUB_ENV"
+
+      - name: Sign with Sigstore
+        if: env.skip_sign != 'true'
+        uses: sigstore/gh-action-sigstore-python@04cffa1d795717b140764e8b640de88853c92acc # v3.3.0
+        with:
+          inputs: >-
+            ./dist/*.tar.gz
+            ./dist/*.whl
+
+      - name: Attach signed artifacts to GitHub Release
+        if: env.skip_sign != 'true'
+        env:
+          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
+        # release.py already created the GitHub Release — just upload
+        # the Sigstore signatures alongside the existing assets.
+        run: >-
+          gh release upload
+          "$GITHUB_REF_NAME" dist/*.sigstore.json
+          --repo "$GITHUB_REPOSITORY"
+          --clobber
@@ -150,11 +150,6 @@ docs/superpowers/*
 .update-incomplete
 .update-incomplete.lock

-# Installer-written method stamp in the managed checkout root (scripts/install.sh).
-# Runtime metadata only — never a code change. Ignore so `git status` stays clean
-# and `hermes update`'s untracked autostash does not treat it as a local edit (#66189 / #54855).
-/.install_method
-
 # Tool Search live-test harness output — non-deterministic model transcripts,
 # regenerated by scripts/tool_search_livetest.py. Never an artifact of the repo.
 scripts/out/
@@ -174,4 +169,3 @@ apps/desktop/demo/
 # PR body is the archive. See the hermes-agent-dev skill's
 # pr-infographic-workflow reference (storage rule + lapse #8 / #COMMIT-1).
 infographic/
-native/fts5_cjk/*.so
@@ -0,0 +1,14 @@
+graft skills
+graft optional-skills
+graft optional-mcps
+graft hermes_cli/web_dist
+graft locales
+# Bundled plugin manifests (plugin.yaml / plugin.yml). Without these the
+# PluginManager scan (hermes_cli/plugins.py) finds zero plugins on installs
+# built from the sdist (e.g. Homebrew, downstream packagers). package-data
+# below covers the wheel; this covers the sdist. See #34034 / #28149.
+recursive-include plugins plugin.yaml plugin.yml
+# Gateway assets include images plus YAML catalogs such as status_phrases.yaml.
+recursive-include gateway/assets *
+global-exclude __pycache__
+global-exclude *.py[cod]
@@ -190,7 +190,7 @@ def _run_setup_browser(assume_yes: bool = False) -> int:
    """Bootstrap agent-browser + Chromium.

    Routes through dep_ensure -> install.{sh,ps1} --ensure, sharing code
-    with the runtime lazy installer.
+    with ``hermes postinstall`` and the runtime lazy installer.

    Returns 0 on success, 1 on failure.
    """
@@ -74,10 +74,6 @@ from acp_adapter.permissions import make_approval_callback
 from acp_adapter.provenance import session_provenance_meta
 from acp_adapter.session import SessionManager, SessionState, _expand_acp_enabled_toolsets
 from acp_adapter.tools import build_tool_complete, build_tool_start
-from agent.context_compressor import (
-    COMPRESSED_SUMMARY_METADATA_KEY,
-    ContextCompressor,
-)
 from tools.approval import (
    reset_hermes_interactive_context,
    set_hermes_interactive_context,
@@ -973,49 +969,11 @@ class HermesACPAgent(acp.Agent):
                return text
        return ""

-    @staticmethod
-    def _history_summary_meta(message: dict[str, Any], text: str) -> dict[str, Any] | None:
-        """Build the ``_meta`` payload for a replayed compaction summary.
-
-        Compaction summaries are persisted as ordinary history messages —
-        standalone handoffs under ``role="user"`` OR ``role="assistant"``
-        (the compressor picks whichever role keeps alternation valid), and
-        merge-into-tail messages where the summary is appended after the
-        first preserved tail message's real content. Without a wire flag,
-        ACP frontends render all of these as ordinary turns.
-
-        Two distinct keys under ``_meta.hermes`` (ACP's extensibility
-        channel), so clients cannot accidentally hide real content:
-
-        * ``compactionSummary: true`` — the entire chunk is the handoff
-          summary. Safe to restyle or collapse wholesale.
-        * ``containsCompactionSummary: true`` — a merged-tail message: real
-          preserved turn content followed by the summary. Clients may style
-          it, but collapsing the whole chunk would hide the preserved
-          content, hence the separate key.
-
-        Detection honors the in-process ``_compressed_summary`` flag and
-        falls back to content classification, so it also works for a
-        DB-reloaded session that lost the in-memory flag.
-        """
-        kind = ContextCompressor.classify_summary_content(text)
-        if kind is None and message.get(COMPRESSED_SUMMARY_METADATA_KEY):
-            # Flagged in-process but content didn't classify (e.g. future
-            # prefix drift): treat as a standalone summary — the flag is only
-            # ever set on summary-bearing messages.
-            kind = "standalone"
-        if kind == "standalone":
-            return {"hermes": {"compactionSummary": True}}
-        if kind == "merged":
-            return {"hermes": {"containsCompactionSummary": True}}
-        return None
-
    @staticmethod
    def _history_message_update(
        *,
        role: str,
        text: str,
-        field_meta: dict[str, Any] | None = None,
    ) -> UserMessageChunk | AgentMessageChunk | None:
        """Build an ACP history replay update for a user/assistant message."""
        block = TextContentBlock(type="text", text=text)
@@ -1023,13 +981,11 @@ class HermesACPAgent(acp.Agent):
            return UserMessageChunk(
                session_update="user_message_chunk",
                content=block,
-                field_meta=field_meta,
            )
        if role == "assistant":
            return AgentMessageChunk(
                session_update="agent_message_chunk",
                content=block,
-                field_meta=field_meta,
            )
        return None

@@ -1100,11 +1056,7 @@ class HermesACPAgent(acp.Agent):
            if role == "user":
                text = self._history_message_text(message)
                if text:
-                    update = self._history_message_update(
-                        role=role,
-                        text=text,
-                        field_meta=self._history_summary_meta(message, text),
-                    )
+                    update = self._history_message_update(role=role, text=text)
                    if update is not None and not await _send(update):
                        return
                continue
@@ -1116,11 +1068,7 @@ class HermesACPAgent(acp.Agent):

                text = self._history_message_text(message)
                if text:
-                    update = self._history_message_update(
-                        role=role,
-                        text=text,
-                        field_meta=self._history_summary_meta(message, text),
-                    )
+                    update = self._history_message_update(role=role, text=text)
                    if update is not None and not await _send(update):
                        return

@@ -1270,19 +1218,12 @@ class HermesACPAgent(acp.Agent):
            with state.runtime_lock:
                if state.is_running and state.current_prompt_text:
                    state.interrupted_prompt_text = state.current_prompt_text
-                # Publish cancellation and hard-stop the agent before another
-                # prompt can acquire this lock and mistake the turn for
-                # redirectable work.
-                state.cancel_event.set()
-                try:
-                    if getattr(state, "agent", None) and hasattr(state.agent, "interrupt"):
-                        state.agent.interrupt()
-                except Exception:
-                    logger.debug(
-                        "Failed to interrupt ACP session %s",
-                        session_id,
-                        exc_info=True,
-                    )
+            state.cancel_event.set()
+            try:
+                if getattr(state, "agent", None) and hasattr(state.agent, "interrupt"):
+                    state.agent.interrupt()
+            except Exception:
+                logger.debug("Failed to interrupt ACP session %s", session_id, exc_info=True)
            logger.info("Cancelled session %s", session_id)

    async def fork_session(
@@ -1411,26 +1352,6 @@ class HermesACPAgent(acp.Agent):
            elif rewrite_idle:
                user_text = steer_text
                user_content = steer_text
-        elif (
-            text_only_prompt
-            and isinstance(user_content, str)
-            and not user_text.startswith("/")
-        ):
-            # Some ACP clients implement "stop and send" as two protocol calls:
-            # cancel the active prompt, then submit plain correction text. Keep
-            # the cancelled request attached so deictic follow-ups ("not that
-            # file") still have an explicit target.
-            interrupted_prompt = ""
-            with state.runtime_lock:
-                if not state.is_running and state.interrupted_prompt_text:
-                    interrupted_prompt = state.interrupted_prompt_text
-                    state.interrupted_prompt_text = ""
-            if interrupted_prompt:
-                user_text = (
-                    f"{interrupted_prompt}\n\n"
-                    f"User correction/guidance after interrupt: {user_text}"
-                )
-                user_content = user_text

        # Intercept slash commands — handle locally without calling the LLM.
        # Slash commands are text-only; if the client included images/resources,
@@ -1445,54 +1366,23 @@ class HermesACPAgent(acp.Agent):
                    await self._send_usage_update(state)
                return PromptResponse(stop_reason="end_turn")

-        # If the client sends another regular text prompt while this ACP session
-        # is running, route it through the core active-turn redirect. Rich media
-        # and older runtimes retain the proven next-turn queue fallback.
-        redirected = False
-        queued_depth: int | None = None
+        # If Zed sends another regular prompt while the same ACP session is
+        # still running, queue it instead of racing two AIAgent loops against
+        # the same state.history. /steer and /queue are handled above and can
+        # land immediately.
        with state.runtime_lock:
            if state.is_running:
-                if (
-                    text_only_prompt
-                    and isinstance(user_content, str)
-                    and getattr(
-                        state.agent,
-                        "_supports_active_turn_redirect",
-                        False,
+                queued_text = user_text or "[Image attachment]"
+                state.queued_prompts.append(queued_text)
+                depth = len(state.queued_prompts)
+                if self._conn:
+                    update = acp.update_agent_message_text(
+                        f"Queued for the next turn. ({depth} queued)"
                    )
-                    is True
-                    and hasattr(state.agent, "redirect")
-                ):
-                    try:
-                        redirected = bool(state.agent.redirect(user_content))
-                    except Exception:
-                        logger.debug(
-                            "ACP active-turn redirect failed for %s",
-                            session_id,
-                            exc_info=True,
-                        )
-                if not redirected:
-                    queued_text = user_text or "[Image attachment]"
-                    state.queued_prompts.append(queued_text)
-                    queued_depth = len(state.queued_prompts)
-            else:
-                state.is_running = True
-                state.current_prompt_text = user_text or "[Image attachment]"
-
-        if redirected:
-            if self._conn:
-                update = acp.update_agent_message_text(
-                    "Redirected the active turn with your correction."
-                )
-                await self._conn.session_update(session_id, update)
-            return PromptResponse(stop_reason="end_turn")
-        if queued_depth is not None:
-            if self._conn:
-                update = acp.update_agent_message_text(
-                    f"Queued for the next turn. ({queued_depth} queued)"
-                )
-                await self._conn.session_update(session_id, update)
-            return PromptResponse(stop_reason="end_turn")
+                    await self._conn.session_update(session_id, update)
+                return PromptResponse(stop_reason="end_turn")
+            state.is_running = True
+            state.current_prompt_text = user_text or "[Image attachment]"

        logger.info("Prompt on session %s: %s", session_id, user_text[:100])

@@ -2021,10 +1911,7 @@ class HermesACPAgent(acp.Agent):
                lines.append(f"Compression threshold: ~{threshold_tokens:,} tokens")

        if getattr(agent, "compression_enabled", True) is False:
-            lines.append(
-                "Auto-compaction is disabled (compression.enabled: false); "
-                "/compress still compresses manually."
-            )
+            lines.append("Compression is disabled for this agent.")
        else:
            lines.append("Tip: run /compress to compress manually before the threshold.")

@@ -2051,9 +1938,8 @@ class HermesACPAgent(acp.Agent):
            return "Nothing to compress — conversation is empty."
        try:
            agent = state.agent
-            # No compression_enabled gate: the flag disables *automatic*
-            # compaction only; manual /compress must keep working (matches
-            # the CLI /compress and gateway handlers).
+            if not getattr(agent, "compression_enabled", True):
+                return "Context compression is disabled for this agent."
            if not hasattr(agent, "_compress_context"):
                return "Context compression not available for this agent."

@@ -2078,7 +1964,6 @@ class HermesACPAgent(acp.Agent):
                    getattr(agent, "_cached_system_prompt", "") or "",
                    approx_tokens=approx_tokens,
                    task_id=state.session_id,
-                    force=True,
                )
            finally:
                agent._session_db = original_session_db
@@ -0,0 +1,16 @@
+{
+  "id": "hermes-agent",
+  "name": "Hermes Agent",
+  "version": "0.19.0",
+  "description": "Self-improving open-source AI agent by Nous Research with ACP editor integration, persistent memory, skills, and rich tool support.",
+  "repository": "https://github.com/NousResearch/hermes-agent",
+  "website": "https://hermes-agent.nousresearch.com/docs/user-guide/features/acp",
+  "authors": ["Nous Research"],
+  "license": "MIT",
+  "distribution": {
+    "uvx": {
+      "package": "hermes-agent[acp]==0.19.0",
+      "args": ["hermes-acp"]
+    }
+  }
+}
@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16" fill="none">
+  <path d="M8 1.5v13" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+  <path d="M8 3.25c-2.35-1.4-4.7-.95-6.25.35 1.85-.2 3.8.2 5.55 1.55" stroke="currentColor" stroke-width="1.1" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M8 3.25c2.35-1.4 4.7-.95 6.25.35-1.85-.2-3.8.2-5.55 1.55" stroke="currentColor" stroke-width="1.1" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M8 13.25c-2.3-1-3.05-2.65-1.35-4.15-2 .8-2.35 2.95-.35 4" stroke="currentColor" stroke-width="1.1" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M8 13.25c2.3-1 3.05-2.65 1.35-4.15 2 .8 2.35 2.95.35 4" stroke="currentColor" stroke-width="1.1" stroke-linecap="round" stroke-linejoin="round"/>
+  <circle cx="8" cy="1.8" r="1.1" fill="currentColor"/>
+</svg>
@@ -701,18 +701,6 @@ def redeem_codex_reset_credit(
    remaining = max(0, available - 1)
    plural = "s" if remaining != 1 else ""
    if code == "reset":
-        # The redeemed reset restores the account's quota upstream — lift any
-        # persisted pool cooldowns so Hermes doesn't keep the credential
-        # frozen behind the now-stale ``last_error_reset_at`` (issue #43747).
-        try:
-            from hermes_cli.auth import clear_codex_pool_quota_cooldowns
-
-            clear_codex_pool_quota_cooldowns()
-        except Exception:
-            logger.debug(
-                "Failed to clear Codex pool cooldowns after reset redemption",
-                exc_info=True,
-            )
        return CodexResetRedeemResult(
            status="reset",
            message=(
@@ -720,8 +720,6 @@ def init_agent(
    agent._execution_thread_id: int | None = None  # Set at run_conversation() start
    agent._interrupt_thread_signal_pending = False
    agent._client_lock = threading.RLock()
-    agent._model_request_active = threading.Event()
-    agent._supports_active_turn_redirect = True

    # /steer mechanism — inject a user note into the next tool result
    # without interrupting the agent. Unlike interrupt(), steer() does
@@ -733,13 +731,6 @@ def init_agent(
    agent._pending_steer: Optional[str] = None
    agent._pending_steer_lock = threading.Lock()

-    # Active-turn redirect mechanism. A regular follow-up sent while the model
-    # is generating is different from a hard /stop: preserve the valid turn
-    # prefix, cancel only the in-flight model request, and rebuild its tail with
-    # the correction. The loop drains this slot at a role-safe boundary.
-    agent._pending_redirect: Optional[str] = None
-    agent._pending_redirect_lock = threading.Lock()
-
    # Concurrent-tool worker thread tracking.  `_execute_tool_calls_concurrent`
    # runs each tool on its own ThreadPoolExecutor worker — those worker
    # threads have tids distinct from `_execution_thread_id`, so
@@ -906,12 +897,6 @@ def init_agent(
    agent._stream_writer_tls = threading.local()
    agent._stream_writer_dropped = 0

-    # Displayed reasoning text streamed during the current model response,
-    # captured only when a surface consumed it via a reasoning callback. Used
-    # by active-turn redirect to checkpoint what the user actually saw without
-    # ever persisting hidden provider reasoning.
-    agent._current_streamed_reasoning_text = ""
-
    # Optional current-turn user-message override used when the API-facing
    # user message intentionally differs from the persisted transcript
    # (e.g. CLI voice mode adds a temporary prefix for the live call only).
@@ -1854,18 +1839,6 @@ def init_agent(
        }
    else:
        compression_model_thresholds = {}
-    # Absolute token cap: when set, compression triggers at the lower of
-    # the ratio-based threshold and this absolute count. Clamped to the
-    # model's context length at apply-time so a cap above the window is
-    # a no-op (ratio-based threshold wins).
-    compression_threshold_tokens = _compression_cfg.get("threshold_tokens")
-    if compression_threshold_tokens is not None:
-        try:
-            compression_threshold_tokens = int(compression_threshold_tokens)
-            if compression_threshold_tokens <= 0:
-                compression_threshold_tokens = None
-        except (TypeError, ValueError):
-            compression_threshold_tokens = None
    # In-place compaction: when True, compress_context() rewrites the message
    # list + rebuilds the system prompt WITHOUT rotating the session id (no
    # parent_session_id chain, no `name #N` renumber). See #38763 and
@@ -1884,12 +1857,6 @@ def init_agent(
            codex_app_server_auto_compaction,
        )
        codex_app_server_auto_compaction = "native"
-    # Opt-in idle compaction: compact a session up front when it resumes after
-    # this many seconds of inactivity (0 = disabled). Time-based, so it
-    # complements the size-based threshold above. Consumed by build_turn_context().
-    compression_idle_compact_after_seconds = max(
-        0, int(_compression_cfg.get("idle_compact_after_seconds", 0))
-    )

    # Read optional explicit context_length override for the auxiliary
    # compression model. Custom endpoints often cannot report this via
@@ -2304,7 +2271,6 @@ def init_agent(
            abort_on_summary_failure=compression_abort_on_summary_failure,
            max_tokens=agent.max_tokens,
            model_thresholds=compression_model_thresholds,
-            threshold_tokens_cap=compression_threshold_tokens,
        )
    _bind_session_state = getattr(agent.context_compressor, "bind_session_state", None)
    if callable(_bind_session_state):
@@ -2316,9 +2282,6 @@ def init_agent(
    agent.compression_in_place = compression_in_place
    agent.codex_app_server_auto_compaction = codex_app_server_auto_compaction
    agent.max_compression_attempts = compression_max_attempts
-    agent.compression_idle_compact_after_seconds = (
-        compression_idle_compact_after_seconds
-    )

    # Reject models whose context window is below the minimum required
    # for reliable tool-calling workflows (64K tokens).
@@ -2519,11 +2482,7 @@ def init_agent(
            _active_threshold_pct = getattr(
                agent.context_compressor, "threshold_percent", compression_threshold
            )
-            _cap_note = ""
-            _cap = getattr(agent.context_compressor, "threshold_tokens_cap", None)
-            if _cap and _cap > 0:
-                _cap_note = f" (capped at {_cap:,} tokens)"
-            print(f"📊 Context limit: {agent.context_compressor.context_length:,} tokens (compress at {int(_active_threshold_pct*100)}% = {agent.context_compressor.threshold_tokens:,}{_cap_note})")
+            print(f"📊 Context limit: {agent.context_compressor.context_length:,} tokens (compress at {int(_active_threshold_pct*100)}% = {agent.context_compressor.threshold_tokens:,})")
        else:
            print(f"📊 Context limit: {agent.context_compressor.context_length:,} tokens (auto-compression disabled)")
        # Notice with the exact opt-back-out command. Printed inline at startup
@@ -922,18 +922,6 @@ def recover_with_credential_pool(
            )
            return False, has_retried_429

-    # Capture the current API key before any rotation — needed to
-    # identify which credential actually failed when
-    # mark_exhausted_and_rotate is called.  Without this hint the
-    # pool falls back to current() or _select_unlocked(), which may
-    # return the NEXT (healthy) entry after a prior rotation, marking
-    # the wrong credential as exhausted (#43747).
-    _api_key_hint = getattr(agent, "api_key", None) or None
-    if not _api_key_hint:
-        _cur = pool.current()
-        if _cur:
-            _api_key_hint = getattr(_cur, "runtime_api_key", None)
-
    effective_reason = classified_reason
    if effective_reason is None:
        if status_code == 402:
@@ -964,13 +952,13 @@ def recover_with_credential_pool(

    if effective_reason == FailoverReason.billing:
        rotate_status = status_code if status_code is not None else 402
-        # Runtime credentials can be resolved by a separate pool instance,
-        # leaving this recovery pool without ``current_id``. Match the key
-        # that actually failed instead of quarantining a different account.
        next_entry = pool.mark_exhausted_and_rotate(
            status_code=rotate_status,
            error_context=error_context,
-            api_key_hint=_api_key_hint,
+            # Runtime credentials can be resolved by a separate pool instance,
+            # leaving this recovery pool without ``current_id``. Match the key
+            # that actually failed instead of quarantining a different account.
+            api_key_hint=getattr(agent, "api_key", None),
        )
        if next_entry is not None:
            _ra().logger.info(
@@ -995,7 +983,7 @@ def recover_with_credential_pool(
                current_last_status,
            )
            rotate_status = status_code if status_code is not None else 429
-            next_entry = pool.mark_exhausted_and_rotate(status_code=rotate_status, error_context=error_context, api_key_hint=_api_key_hint)
+            next_entry = pool.mark_exhausted_and_rotate(status_code=rotate_status, error_context=error_context)
            if next_entry is not None:
                _ra().logger.info(
                    "Credential %s (rate limit, pre-exhausted) — rotated to pool entry %s",
@@ -1019,7 +1007,7 @@ def recover_with_credential_pool(
        if not has_retried_429 and not usage_limit_reached:
            return False, True
        rotate_status = status_code if status_code is not None else 429
-        next_entry = pool.mark_exhausted_and_rotate(status_code=rotate_status, error_context=error_context, api_key_hint=_api_key_hint)
+        next_entry = pool.mark_exhausted_and_rotate(status_code=rotate_status, error_context=error_context)
        if next_entry is not None:
            _ra().logger.info(
                "Credential %s (rate limit) — rotated to pool entry %s",
@@ -1119,7 +1107,7 @@ def recover_with_credential_pool(
        # Refresh failed — rotate to next credential instead of giving up.
        # The failed entry is already marked exhausted by try_refresh_current().
        rotate_status = status_code if status_code is not None else 401
-        next_entry = pool.mark_exhausted_and_rotate(status_code=rotate_status, error_context=error_context, api_key_hint=_api_key_hint)
+        next_entry = pool.mark_exhausted_and_rotate(status_code=rotate_status, error_context=error_context)
        if next_entry is not None:
            _ra().logger.info(
                "Credential %s (auth refresh failed) — rotated to pool entry %s",
@@ -1,124 +0,0 @@
-"""Provider-agnostic billing/credit recovery links.
-
-Maps a billing-classified failure onto a recovery link + label. *Detection*
-is not done here — that is :mod:`agent.error_classifier`
-(``FailoverReason.billing``), the single source of truth for "credit wall vs.
-rate limit / auth / transport". The resulting :class:`BillingBlock` rides the
-turn result and the gateway ``message.complete`` event so every surface (CLI,
-TUI, desktop) renders one structured signal instead of re-parsing error text.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass
-from typing import Optional
-
-from utils import base_url_host_matches
-
-
-@dataclass
-class BillingBlock:
-    """Structured billing-wall descriptor shared across every surface.
-
-    ``is_nous`` is the routing bit: Nous has a first-class in-app billing surface
-    (desktop Settings → Billing, TUI/CLI ``/topup``), so surfaces prefer that over
-    ``billing_url``; third-party providers have no in-app flow, so ``billing_url``
-    is the deep link the user actually needs.
-    """
-
-    provider: str
-    provider_label: str
-    model: str
-    billing_url: Optional[str]
-    is_nous: bool
-    message: str
-
-    def to_dict(self) -> dict:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class _Provider:
-    label: str
-    url: str
-    slugs: tuple[str, ...]
-    hosts: tuple[str, ...] = ()
-
-
-# Single source of truth: internal slug(s) + base_url host(s) → billing page.
-# Curated "add credits / manage billing" landing pages, not marketing homes.
-# Hosts back the OpenAI-compatible fallback where the slug is a generic bucket
-# (e.g. "openai_compatible") but base_url reveals the real upstream. An unknown
-# provider degrades to a readable label with no invented URL.
-_PROVIDERS: tuple[_Provider, ...] = (
-    _Provider("OpenAI", "https://platform.openai.com/settings/organization/billing", ("openai",), ("api.openai.com",)),
-    _Provider("Anthropic", "https://console.anthropic.com/settings/billing", ("anthropic",), ("api.anthropic.com",)),
-    _Provider("OpenRouter", "https://openrouter.ai/settings/credits", ("openrouter",), ("openrouter.ai",)),
-    _Provider("xAI", "https://console.x.ai/team/default/billing", ("xai", "xai-oauth"), ("api.x.ai",)),
-    _Provider("DeepSeek", "https://platform.deepseek.com/top_up", ("deepseek",), ("api.deepseek.com",)),
-    _Provider("Groq", "https://console.groq.com/settings/billing", ("groq",), ("api.groq.com",)),
-    _Provider("Mistral", "https://console.mistral.ai/billing", ("mistral",), ("api.mistral.ai",)),
-    _Provider("Together AI", "https://api.together.ai/settings/billing", ("together",), ("api.together.ai", "api.together.xyz")),
-    _Provider("Fireworks AI", "https://fireworks.ai/account/billing", ("fireworks",), ("fireworks.ai",)),
-    _Provider("Perplexity", "https://www.perplexity.ai/settings/api", ("perplexity",), ("perplexity.ai",)),
-    _Provider("Google AI", "https://aistudio.google.com/app/billing", ("google", "gemini"), ("generativelanguage.googleapis.com",)),
-    _Provider("Cohere", "https://dashboard.cohere.com/billing", ("cohere",)),
-    _Provider("Moonshot AI", "https://platform.moonshot.ai/console/pay", ("moonshot",)),
-    _Provider("NVIDIA", "https://build.nvidia.com/settings/billing", ("nvidia",)),
-)
-
-_BY_SLUG: dict[str, _Provider] = {slug: p for p in _PROVIDERS for slug in p.slugs}
-
-
-def is_nous_inference_route(provider: str, base_url: str) -> bool:
-    """True when the failing route is the Nous-managed inference gateway."""
-    if (provider or "").strip().lower() == "nous":
-        return True
-    return base_url_host_matches(str(base_url or ""), "inference-api.nousresearch.com")
-
-
-def _nous_billing_url() -> Optional[str]:
-    """Best-effort Nous portal billing URL (text-surface fallback; Nous prefers the in-app flow)."""
-    try:
-        from hermes_cli.nous_account import nous_portal_billing_url
-
-        return nous_portal_billing_url(None)
-    except Exception:
-        return "https://portal.nousresearch.com/billing"
-
-
-def _resolve_provider_link(slug: str, base_url: str) -> tuple[str, Optional[str]]:
-    """Resolve ``(label, url)``: exact slug → base_url host → readable-label fallback."""
-    hit = _BY_SLUG.get(slug)
-    if hit:
-        return hit.label, hit.url
-
-    base = str(base_url or "")
-    for p in _PROVIDERS:
-        if any(base_url_host_matches(base, host) for host in p.hosts):
-            return p.label, p.url
-
-    return slug.replace("_", " ").replace("-", " ").strip().title() or "your provider", None
-
-
-def build_billing_block(
-    *,
-    provider: str,
-    base_url: str,
-    model: str,
-    message: str = "",
-) -> BillingBlock:
-    """Build the billing descriptor for a billing-classified failure.
-
-    ``message`` is the guidance already assembled by the agent loop
-    (:func:`agent.conversation_loop._billing_or_entitlement_message`), carried
-    through unchanged so every surface shows identical copy.
-    """
-    slug = (provider or "").strip().lower()
-    model = (model or "").strip()
-
-    if is_nous_inference_route(slug, base_url):
-        return BillingBlock(slug or "nous", "Nous Portal", model, _nous_billing_url(), True, message or "")
-
-    label, url = _resolve_provider_link(slug, base_url)
-    return BillingBlock(slug, label, model, url, False, message or "")
@@ -702,16 +702,6 @@ def run_codex_app_server_turn(
        except Exception:
            pass
        agent._codex_session = None
-        _user_interrupted = bool(
-            getattr(agent, "_interrupt_requested", False)
-        )
-        _interrupt_message = (
-            getattr(agent, "_interrupt_message", None)
-            if _user_interrupted
-            else None
-        )
-        if _user_interrupted:
-            agent.clear_interrupt()
        return {
            "final_response": (
                f"Codex app-server turn failed: {exc}. "
@@ -721,27 +711,9 @@ def run_codex_app_server_turn(
            "api_calls": 0,
            "completed": False,
            "partial": True,
-            "interrupted": _user_interrupted,
-            **(
-                {"interrupt_message": _interrupt_message}
-                if _interrupt_message
-                else {}
-            ),
            "error": str(exc),
        }

-    # This runtime bypasses the normal conversation-loop finalizer. Mirror its
-    # interrupt handoff/cleanup so a hard stop cannot poison the next turn and a
-    # message-bearing compatibility interrupt can still be replayed by callers.
-    _user_interrupted = bool(
-        turn.interrupted and getattr(agent, "_interrupt_requested", False)
-    )
-    _interrupt_message = (
-        getattr(agent, "_interrupt_message", None) if _user_interrupted else None
-    )
-    if _user_interrupted:
-        agent.clear_interrupt()
-
    # If the turn signalled the underlying client is wedged (deadline
    # blown, post-tool watchdog tripped, OAuth refresh died, subprocess
    # exited), retire the session so the next turn respawns codex
@@ -847,12 +819,6 @@ def run_codex_app_server_turn(
        "api_calls": api_calls,
        "completed": not turn.interrupted and turn.error is None,
        "partial": turn.interrupted or turn.error is not None,
-        "interrupted": _user_interrupted,
-        **(
-            {"interrupt_message": _interrupt_message}
-            if _interrupt_message
-            else {}
-        ),
        "error": turn.error,
        # The codex app-server runtime IS an early-return path that bypasses
        # conversation_loop, but we flush the projected assistant/tool messages
@@ -30,12 +30,10 @@ from __future__ import annotations

 import copy
 import inspect
-import json
 import logging
 import math
 import os
 import tempfile
-import time
 import uuid
 import threading
 from datetime import datetime
@@ -57,71 +55,6 @@ COMPACTION_STATUS = (
    f"🗜️ {COMPACTION_STATUS_MARKER} — summarizing earlier conversation so I can continue..."
 )

-COMPACTION_DONE_STATUS = "✓ Context compaction complete — continuing turn..."
-
-
-def _emit_compaction_done(agent: Any) -> None:
-    """Emit the structured terminal edge for a started compaction."""
-    status_callback = getattr(agent, "status_callback", None)
-    if not status_callback:
-        return
-    try:
-        status_callback("compacted", COMPACTION_DONE_STATUS)
-    except Exception:
-        logger.debug("status_callback error in compaction completion", exc_info=True)
-
-
-# ── Routine compression status templates ────────────────────────────────────
-# Every ROUTINE (non-failure, non-manual-/compress) compression status line the
-# agent emits lives here so the gateway noise filter and its tests can couple
-# to the real emitted wording instead of hand-copied literals. These are
-# suppressed on human-facing chat platforms by _TELEGRAM_NOISY_STATUS_RE
-# (gateway/run.py) — when rewording ANY of them, update that regex and the
-# pinned data in tests/gateway/test_telegram_noise_filter.py in the same PR.
-# Failure notices (⚠ Compression aborted / empty transcript / codex compaction
-# failed) and manual /compress feedback (manual_compression_feedback.py) are
-# deliberate carve-outs from silence and must NOT be added here.
-PRE_API_COMPRESSION_STATUS_TEMPLATE = (
-    "📦 Pre-API compression: ~{tokens:,} tokens "
-    "near the context/output limit. Compacting before the next model call."
-)
-PREFLIGHT_COMPRESSION_STATUS_TEMPLATE = (
-    "📦 Preflight compression: ~{tokens:,} tokens "
-    ">= {threshold:,} threshold. This may take a moment."
-)
-IDLE_COMPACTION_STATUS_TEMPLATE = (
-    "💤 Resumed after {idle_seconds}s idle — compacting "
-    "~{tokens:,} tokens before continuing."
-)
-COMPRESSION_RETRY_TOO_LARGE_STATUS_TEMPLATE = (
-    "🗜️ Context too large (~{tokens:,} tokens) — compressing ({attempt}/{cap})..."
-)
-COMPRESSION_RETRY_MESSAGES_STATUS_TEMPLATE = (
-    "🗜️ Compressed {before} → {after} messages, retrying..."
-)
-COMPRESSION_RETRY_TOKENS_STATUS_TEMPLATE = (
-    "🗜️ Compressed ~{before:,} → ~{after:,} tokens, retrying..."
-)
-COMPRESSION_RETRY_CONTEXT_REDUCED_STATUS_TEMPLATE = (
-    "🗜️ Context reduced to {new_ctx:,} tokens (was {old_ctx:,}), retrying..."
-)
-
-# Sample-formatted instances of every routine compression status line, for
-# behavioral tests that iterate the ACTUAL emitted wording (formatted from the
-# same constants the emission sites use) through the gateway noise filter.
-ROUTINE_COMPRESSION_STATUS_SAMPLES = (
-    COMPACTION_STATUS,
-    PRE_API_COMPRESSION_STATUS_TEMPLATE.format(tokens=123456),
-    PREFLIGHT_COMPRESSION_STATUS_TEMPLATE.format(tokens=120000, threshold=100000),
-    IDLE_COMPACTION_STATUS_TEMPLATE.format(idle_seconds=3600, tokens=120000),
-    COMPRESSION_RETRY_TOO_LARGE_STATUS_TEMPLATE.format(tokens=250000, attempt=1, cap=3),
-    COMPRESSION_RETRY_MESSAGES_STATUS_TEMPLATE.format(before=30, after=12),
-    COMPRESSION_RETRY_TOKENS_STATUS_TEMPLATE.format(before=250000, after=120000),
-    COMPRESSION_RETRY_CONTEXT_REDUCED_STATUS_TEMPLATE.format(
-        new_ctx=120000, old_ctx=250000
-    ),
-)
-

 def _builtin_memory_prompt_snapshot(agent: Any) -> Optional[Tuple[str, str]]:
    """Return the built-in memory text that can affect a system prompt.
@@ -240,43 +173,6 @@ def _session_was_rotated_by_compression(session_db: Any, session_id: str) -> boo
    )


-def _emit_compression_attempt_telemetry(
-    agent: Any,
-    *,
-    started_at: float,
-    commit_status: str,
-    split_status: str,
-    failure_class: str | None = None,
-) -> None:
-    """Emit one content-free JSON log line for a compression attempt."""
-    try:
-        telemetry = getattr(agent.context_compressor, "_last_compression_telemetry", None)
-        if not isinstance(telemetry, dict):
-            telemetry = {}
-        payload = dict(telemetry)
-        payload.setdefault("event", "compression_attempt")
-        payload.setdefault("attempt_id", getattr(agent, "_compression_attempt_id", "") or uuid.uuid4().hex)
-        payload.setdefault("session_id", getattr(agent, "session_id", "") or "")
-        payload["total_duration_ms"] = int((time.monotonic() - started_at) * 1000)
-        payload["commit_status"] = commit_status
-        payload["split_status"] = split_status
-        if failure_class:
-            payload["failure_class"] = failure_class
-        payload.setdefault("chunking", False)
-        payload.setdefault("chunk_count", 0)
-        payload["fallback_used"] = bool(
-            payload.get("fallback_used")
-            or getattr(agent.context_compressor, "_last_summary_fallback_used", False)
-            or getattr(agent.context_compressor, "_last_aux_model_failure_model", None)
-        )
-        logger.info(
-            "context compression attempt telemetry: %s",
-            json.dumps(payload, sort_keys=True, separators=(",", ":")),
-        )
-    except Exception as exc:
-        logger.debug("failed to emit compression attempt telemetry: %s", exc)
-
-
 def _compression_lock_holder(agent: Any) -> str:
    """Build a unique holder id for the lock: pid:tid:agent-instance:uuid.

@@ -1008,19 +904,6 @@ def compress_context(
    ):
        raise RuntimeError("a compression notification is already pending")

-    _attempt_started_at = time.monotonic()
-    _attempt_id = uuid.uuid4().hex
-    _trigger_source = "manual" if force else "auto"
-    try:
-        agent._compression_attempt_id = _attempt_id
-        setattr(agent.context_compressor, "_compression_telemetry_seed", {
-            "attempt_id": _attempt_id,
-            "session_id": agent.session_id or "",
-            "trigger_source": _trigger_source,
-        })
-    except Exception:
-        pass
-
    # Codex app-server sessions: the codex agent owns the real thread context;
    # Hermes' summarizer would only rewrite a local mirror without shrinking
    # the actual thread (#36801). Route compaction to the app server's own
@@ -1090,14 +973,6 @@ def compress_context(
        focus_topic,
    )
    agent._emit_status(COMPACTION_STATUS)
-    _compaction_done_emitted = False
-
-    def _complete_compaction_lifecycle() -> None:
-        nonlocal _compaction_done_emitted
-        if _compaction_done_emitted:
-            return
-        _compaction_done_emitted = True
-        _emit_compaction_done(agent)

    # ── Compression lock ────────────────────────────────────────────────
    # Atomic, state.db-backed lock per session_id.  Without this, two
@@ -1235,26 +1110,12 @@ def compress_context(
            _existing_sp = getattr(agent, "_cached_system_prompt", None)
            if not _existing_sp:
                _existing_sp = agent._build_system_prompt(system_message)
-            try:
-                if hasattr(agent.context_compressor, "_begin_compression_telemetry"):
-                    agent.context_compressor._begin_compression_telemetry(current_tokens=approx_tokens)
-            except Exception:
-                pass
-            _emit_compression_attempt_telemetry(
-                agent,
-                started_at=_attempt_started_at,
-                commit_status="aborted",
-                split_status="aborted",
-                failure_class="lock_contended",
-            )
-            _complete_compaction_lifecycle()
            return messages, _existing_sp
    _lock_released = False

    def _release_lock() -> None:
        """Release the lock keyed on the OLD session_id (before rotation)."""
        nonlocal _lock_released
-        _complete_compaction_lifecycle()
        if _lock_released:
            return
        _lock_released = True
@@ -1374,7 +1235,7 @@ def compress_context(
        messages_before_compression = copy.deepcopy(messages)
        _activity_heartbeat = _CompressionActivityHeartbeat(agent).start()
        compressed = compress_fn(messages, **compress_kwargs)
-    except BaseException as _compress_exc:
+    except BaseException:
        # ANY exception after lock acquisition — memory hook, capability
        # inspection, engine lookup, or compress() — must release the lock so
        # the session isn't permanently blocked from future compression.
@@ -1382,13 +1243,6 @@ def compress_context(
            _activity_heartbeat.stop("context compression failed")
            _activity_heartbeat = None
        _release_lock()
-        _emit_compression_attempt_telemetry(
-            agent,
-            started_at=_attempt_started_at,
-            commit_status="aborted",
-            split_status="aborted",
-            failure_class=f"exception:{type(_compress_exc).__name__}",
-        )
        raise
    finally:
        if _activity_heartbeat is not None:
@@ -1424,16 +1278,6 @@ def compress_context(
                _existing_sp = getattr(agent, "_cached_system_prompt", None)
                if not _existing_sp:
                    _existing_sp = agent._build_system_prompt(system_message)
-                _emit_compression_attempt_telemetry(
-                    agent,
-                    started_at=_attempt_started_at,
-                    commit_status="aborted",
-                    split_status="aborted",
-                    failure_class=(
-                        getattr(agent.context_compressor, "_last_summary_error", None)
-                        and "summary_generation_aborted"
-                    ),
-                )
                return messages, _existing_sp
            finally:
                _release_lock()
@@ -1452,13 +1296,6 @@ def compress_context(
            _existing_sp = getattr(agent, "_cached_system_prompt", None)
            if not _existing_sp:
                _existing_sp = agent._build_system_prompt(system_message)
-            _emit_compression_attempt_telemetry(
-                agent,
-                started_at=_attempt_started_at,
-                commit_status="aborted",
-                split_status="aborted",
-                failure_class="no_progress",
-            )
            _release_lock()
            return messages, _existing_sp

@@ -1540,9 +1377,7 @@ def compress_context(
            agent._cached_system_prompt = new_system_prompt

        _session_commit_succeeded = False
-        split_status = "not_applicable"
        if agent._session_db:
-            split_status = "pending"
            try:
                # Trigger memory extraction on the current session before the
                # transcript is rewritten (runs in BOTH modes — the logical
@@ -1570,7 +1405,6 @@ def compress_context(
                    # WITHOUT destroying history, unlike a hard replace_messages).
                    # See #38763.
                    agent._session_db.archive_and_compact(agent.session_id, compressed)
-                    split_status = "in_place_committed"
                    # Reset the flush identity set so the next turn's appends are
                    # diffed against the COMPACTED transcript: the compacted dicts
                    # are passed as conversation_history next turn and skipped by
@@ -1687,7 +1521,6 @@ def compress_context(
                        agent._session_db_created = True
                        raise
                    agent._session_db_created = True
-                    split_status = "rotated_committed"
                    # Carry a persistent /goal onto the continuation session.
                    # Compression mints a fresh child id; load_goal does a flat
                    # per-session lookup with no parent walk, so without this an
@@ -1726,7 +1559,6 @@ def compress_context(
                    }
                _session_commit_succeeded = True
            except Exception as e:
-                split_status = "aborted" if locals().get("old_session_id") is None and not in_place else "failed_not_indexed"
                # If the rotation rolled back to the parent (orphan-avoidance
                # above), agent.session_id is the still-indexed parent and
                # old_session_id was cleared — so this is recovery, not an
@@ -1869,18 +1701,6 @@ def compress_context(
            agent.session_id or "none", _pre_msg_count, len(compressed),
            f"{_compressed_est:,}",
        )
-        _commit_status = "committed" if split_status in {"not_applicable", "in_place_committed", "rotated_committed"} else "aborted"
-        _emit_compression_attempt_telemetry(
-            agent,
-            started_at=_attempt_started_at,
-            commit_status=_commit_status,
-            split_status=split_status,
-            failure_class=(
-                "session_split_failed"
-                if split_status in {"failed_not_indexed", "aborted"}
-                else None
-            ),
-        )
        return compressed, new_system_prompt
    finally:
        # Release the lock on the OLD session_id only AFTER rotation completed
@@ -1951,15 +1771,6 @@ def _compress_context_via_codex_app_server(
    except Exception:
        pass

-    _compaction_done_emitted = False
-
-    def _complete_compaction_lifecycle() -> None:
-        nonlocal _compaction_done_emitted
-        if _compaction_done_emitted:
-            return
-        _compaction_done_emitted = True
-        _emit_compaction_done(agent)
-
    _activity_heartbeat: Optional[_CompressionActivityHeartbeat] = None
    try:
        _activity_heartbeat = _CompressionActivityHeartbeat(agent).start()
@@ -1967,7 +1778,6 @@ def _compress_context_via_codex_app_server(
    except BaseException:
        if _activity_heartbeat is not None:
            _activity_heartbeat.stop("context compression failed")
-        _complete_compaction_lifecycle()
        raise

    if getattr(result, "interrupted", False) or getattr(result, "error", None):
@@ -1992,7 +1802,6 @@ def _compress_context_via_codex_app_server(
        existing_prompt = getattr(agent, "_cached_system_prompt", None)
        if not existing_prompt:
            existing_prompt = agent._build_system_prompt(system_message)
-        _complete_compaction_lifecycle()
        return messages, existing_prompt

    try:
@@ -2032,7 +1841,6 @@ def _compress_context_via_codex_app_server(
    existing_prompt = getattr(agent, "_cached_system_prompt", None)
    if not existing_prompt:
        existing_prompt = agent._build_system_prompt(system_message)
-    _complete_compaction_lifecycle()
    return messages, existing_prompt


@@ -2293,7 +2101,6 @@ def try_shrink_image_parts_in_messages(

 __all__ = [
    "COMPACTION_STATUS",
-    "COMPACTION_DONE_STATUS",
    "COMPACTION_STATUS_MARKER",
    "check_compression_model_feasibility",
    "replay_compression_warning",
@@ -28,14 +28,7 @@ import uuid
 from typing import Any, Dict, List, Optional

 from agent.codex_responses_adapter import _summarize_user_message_for_log
-from agent.conversation_compression import (
-    COMPRESSION_RETRY_CONTEXT_REDUCED_STATUS_TEMPLATE,
-    COMPRESSION_RETRY_MESSAGES_STATUS_TEMPLATE,
-    COMPRESSION_RETRY_TOKENS_STATUS_TEMPLATE,
-    COMPRESSION_RETRY_TOO_LARGE_STATUS_TEMPLATE,
-    PRE_API_COMPRESSION_STATUS_TEMPLATE,
-    conversation_history_after_compression,
-)
+from agent.conversation_compression import conversation_history_after_compression
 from agent.display import KawaiiSpinner
 from agent.error_classifier import FailoverReason, classify_api_error
 from agent.iteration_budget import IterationBudget
@@ -110,53 +103,6 @@ _API_CALL_MODULES = frozenset({
 })


-def _apply_active_turn_redirect(agent: Any, messages: List[Dict[str, Any]], text: str) -> None:
-    """Append a provider-safe checkpoint and correction to the live turn.
-
-    Incomplete provider reasoning blocks are not valid replay items (Anthropic
-    signs them; Responses reasoning items require their following output).
-    Preserve only what Hermes actually displayed, demoted to ordinary text,
-    then add the correction as a real user message. This keeps role alternation
-    valid and leaves every previously cached message byte-for-byte unchanged.
-    """
-    reasoning = str(
-        getattr(agent, "_current_streamed_reasoning_text", "") or ""
-    ).strip()
-    visible = agent._strip_think_blocks(
-        getattr(agent, "_current_streamed_assistant_text", "") or ""
-    ).strip()
-
-    checkpoint_parts = ["[This response was interrupted by a user correction.]"]
-    if reasoning:
-        checkpoint_parts.extend(
-            ["Reasoning shown before the interruption:", reasoning]
-        )
-    if visible:
-        checkpoint_parts.extend(
-            ["Visible response before the interruption:", visible]
-        )
-    checkpoint = "\n\n".join(checkpoint_parts)
-
-    # The normal live tail is user or tool, so an assistant checkpoint followed
-    # by the correction preserves strict alternation. If a transport already
-    # committed an assistant item, attribute the checkpoint inside the user
-    # correction instead of creating assistant→assistant.
-    if messages and messages[-1].get("role") == "assistant":
-        correction = (
-            "[Context from the interrupted assistant response]\n"
-            f"{checkpoint}\n\n"
-            f"{text}"
-        )
-        messages.append({"role": "user", "content": correction})
-    else:
-        messages.append({"role": "assistant", "content": checkpoint})
-        messages.append({"role": "user", "content": text})
-
-    agent._current_streamed_assistant_text = ""
-    agent._current_streamed_reasoning_text = ""
-    agent._stream_needs_break = True
-
-
 def _image_error_max_dimension(error: Exception) -> Optional[int]:
    """Extract a provider-reported image dimension ceiling, if present."""
    parts = []
@@ -307,19 +253,6 @@ def _billing_or_entitlement_message(
        ]
        return "\n".join(lines)

-    # Provider-agnostic billing URL derivation (OpenAI, DeepSeek, xAI, Groq,
-    # OpenRouter, …) so every text surface — CLI, gateway messaging, TUI
-    # transcript — shows the same actionable link, not just OpenRouter.
-    try:
-        from agent.billing_links import build_billing_block
-
-        _link = build_billing_block(provider=provider, base_url=base_url, model=model)
-        if _link.provider_label:
-            provider_label = _link.provider_label
-        billing_url = _link.billing_url
-    except Exception:
-        billing_url = None
-
    lines = [
        (
            f"{provider_label} reported that billing, credits, or account "
@@ -327,24 +260,12 @@ def _billing_or_entitlement_message(
        ),
        "Add credits or update billing with that provider, then retry.",
    ]
-    if billing_url:
-        lines.append(f"{provider_label} billing: {billing_url}")
+    if base_url_host_matches(str(base_url or ""), "openrouter.ai"):
+        lines.append("OpenRouter credits: https://openrouter.ai/settings/credits")
    lines.append("You can switch providers temporarily with /model <model> --provider <provider>.")
    return "\n".join(lines)


-def _billing_block_dict(provider, base_url, model, message="") -> Optional[dict]:
-    """Best-effort structured billing descriptor (None if billing_links is unavailable)."""
-    try:
-        from agent.billing_links import build_billing_block
-
-        return build_billing_block(
-            provider=provider, base_url=str(base_url), model=model, message=message
-        ).to_dict()
-    except Exception:
-        return None
-
-
 def _print_billing_or_entitlement_guidance(
    agent,
    *,
@@ -812,16 +733,6 @@ def run_conversation(
        )

    while (api_call_count < agent.max_iterations and agent.iteration_budget.remaining > 0) or agent._budget_grace_call:
-        _redirect_text = agent._drain_pending_redirect()
-        if _redirect_text:
-            _apply_active_turn_redirect(agent, messages, _redirect_text)
-            if isinstance(original_user_message, str):
-                original_user_message = (
-                    f"{original_user_message}\n\n"
-                    f"User correction during the turn: {_redirect_text}"
-                )
-            agent._persist_session(messages, conversation_history)
-
        # Reset per-turn checkpoint dedup so each iteration can take one snapshot
        agent._checkpoint_mgr.new_turn()

@@ -1311,9 +1222,8 @@ def run_conversation(
                max_compression_attempts,
            )
            agent._emit_status(
-                PRE_API_COMPRESSION_STATUS_TEMPLATE.format(
-                    tokens=request_pressure_tokens
-                )
+                f"📦 Pre-API compression: ~{request_pressure_tokens:,} tokens "
+                f"near the context/output limit. Compacting before the next model call."
            )
            _last_preflight_pressure = request_pressure_tokens
            messages, active_system_prompt = agent._compress_context(
@@ -1622,59 +1532,22 @@ def run_conversation(

                from hermes_cli.middleware import run_llm_execution_middleware

-                _model_request_active = getattr(agent, "_model_request_active", None)
-                _redirect_lock = getattr(agent, "_pending_redirect_lock", None)
-                if _redirect_lock is not None:
-                    with _redirect_lock:
-                        if _model_request_active is not None:
-                            _model_request_active.set()
-                elif _model_request_active is not None:
-                    _model_request_active.set()
-                _redirect_crossed_response = False
-                try:
-                    response = run_llm_execution_middleware(
-                        api_kwargs,
-                        _perform_api_call,
-                        original_request=_original_api_kwargs,
-                        task_id=effective_task_id,
-                        turn_id=turn_id,
-                        api_request_id=api_request_id,
-                        session_id=agent.session_id or "",
-                        platform=agent.platform or "",
-                        model=agent.model,
-                        provider=agent.provider,
-                        base_url=agent.base_url,
-                        api_mode=agent.api_mode,
-                        api_call_count=api_call_count,
-                        middleware_trace=list(_llm_middleware_trace),
-                    )
-                finally:
-                    if _redirect_lock is not None:
-                        with _redirect_lock:
-                            if _model_request_active is not None:
-                                _model_request_active.clear()
-                            _redirect_crossed_response = bool(
-                                agent._pending_redirect
-                            )
-                    else:
-                        if _model_request_active is not None:
-                            _model_request_active.clear()
-                        _redirect_crossed_response = agent._has_pending_redirect()
-                if _redirect_crossed_response:
-                    # The response and redirect can cross on different threads:
-                    # redirect() observed the request as active just before this
-                    # call returned. Discard that now-stale response and rebuild
-                    # from the correction rather than silently losing it.
-                    if thinking_spinner:
-                        thinking_spinner.stop("")
-                        thinking_spinner = None
-                    if agent.thinking_callback:
-                        agent.thinking_callback("")
-                    if agent.clear_interrupt(preserve_redirect=True):
-                        _retry.restart_with_redirected_messages = True
-                    else:
-                        interrupted = True
-                    break
+                response = run_llm_execution_middleware(
+                    api_kwargs,
+                    _perform_api_call,
+                    original_request=_original_api_kwargs,
+                    task_id=effective_task_id,
+                    turn_id=turn_id,
+                    api_request_id=api_request_id,
+                    session_id=agent.session_id or "",
+                    platform=agent.platform or "",
+                    model=agent.model,
+                    provider=agent.provider,
+                    base_url=agent.base_url,
+                    api_mode=agent.api_mode,
+                    api_call_count=api_call_count,
+                    middleware_trace=list(_llm_middleware_trace),
+                )
                
                api_duration = time.time() - api_start_time
                
@@ -2636,15 +2509,6 @@ def run_conversation(
                    thinking_spinner = None
                if agent.thinking_callback:
                    agent.thinking_callback("")
-                if agent._has_pending_redirect():
-                    # redirect() deliberately used the interrupt machinery to
-                    # cancel only this provider request. Keep its correction
-                    # queued, clear the cancellation bit, and let the outer
-                    # loop rebuild a clean request tail. Never materialize
-                    # incomplete signed/encrypted reasoning items.
-                    if agent.clear_interrupt(preserve_redirect=True):
-                        _retry.restart_with_redirected_messages = True
-                        break
                api_elapsed = time.time() - api_start_time
                agent._vprint(f"{agent.log_prefix}⚡ Interrupted during API call.", force=True)
                interrupted = True
@@ -3527,9 +3391,8 @@ def run_conversation(
                        )
                        if len(messages) < original_len or old_ctx > _reduced_ctx:
                            agent._buffer_status(
-                                COMPRESSION_RETRY_CONTEXT_REDUCED_STATUS_TEMPLATE.format(
-                                    new_ctx=_reduced_ctx, old_ctx=old_ctx
-                                )
+                                f"🗜️ Context reduced to {_reduced_ctx:,} tokens "
+                                f"(was {old_ctx:,}), retrying..."
                            )
                            time.sleep(2)
                            _retry.restart_with_compressed_messages = True
@@ -3790,9 +3653,9 @@ def run_conversation(

                    if len(messages) < original_len or (new_tokens > 0 and new_tokens < original_tokens * 0.95):
                        if len(messages) < original_len:
-                            agent._buffer_status(COMPRESSION_RETRY_MESSAGES_STATUS_TEMPLATE.format(before=original_len, after=len(messages)))
+                            agent._buffer_status(f"🗜️ Compressed {original_len} → {len(messages)} messages, retrying...")
                        else:
-                            agent._buffer_status(COMPRESSION_RETRY_TOKENS_STATUS_TEMPLATE.format(before=original_tokens, after=new_tokens))
+                            agent._buffer_status(f"🗜️ Compressed ~{original_tokens:,} → ~{new_tokens:,} tokens, retrying...")
                        time.sleep(2)  # Brief pause between compression retries
                        _retry.restart_with_compressed_messages = True
                        break
@@ -4010,7 +3873,7 @@ def run_conversation(
                            "failed": True,
                            "compression_exhausted": True,
                        }
-                    agent._buffer_status(COMPRESSION_RETRY_TOO_LARGE_STATUS_TEMPLATE.format(tokens=approx_tokens, attempt=compression_attempts, cap=max_compression_attempts))
+                    agent._buffer_status(f"🗜️ Context too large (~{approx_tokens:,} tokens) — compressing ({compression_attempts}/{max_compression_attempts})...")

                    original_len = len(messages)
                    original_tokens = estimate_messages_tokens_rough(messages)
@@ -4031,9 +3894,9 @@ def run_conversation(

                    if len(messages) < original_len or (new_tokens > 0 and new_tokens < original_tokens * 0.95) or (new_ctx and new_ctx < old_ctx):
                        if len(messages) < original_len:
-                            agent._buffer_status(COMPRESSION_RETRY_MESSAGES_STATUS_TEMPLATE.format(before=original_len, after=len(messages)))
+                            agent._buffer_status(f"🗜️ Compressed {original_len} → {len(messages)} messages, retrying...")
                        elif new_tokens > 0 and new_tokens < original_tokens * 0.95:
-                            agent._buffer_status(COMPRESSION_RETRY_TOKENS_STATUS_TEMPLATE.format(before=original_tokens, after=new_tokens))
+                            agent._buffer_status(f"🗜️ Compressed ~{original_tokens:,} → ~{new_tokens:,} tokens, retrying...")
                        time.sleep(2)  # Brief pause between compression retries
                        _retry.restart_with_compressed_messages = True
                        break
@@ -4309,31 +4172,6 @@ def run_conversation(
                            final_response=_policy_response,
                            error_detail=_nonretryable_summary,
                        )
-                    # Billing walls are the common non-retryable abort: enrich
-                    # the result with the same structured recovery descriptor as
-                    # the max-retries path so every surface (CLI, TUI, desktop)
-                    # renders one consistent billing signal.
-                    if classified.reason == FailoverReason.billing:
-                        _ce_guidance = _billing_or_entitlement_message(
-                            capability="model access",
-                            provider=_provider,
-                            base_url=str(_base),
-                            model=_model,
-                        )
-                        _ce_final = f"Billing or credits exhausted: {_nonretryable_summary}"
-                        if _ce_guidance:
-                            _ce_final += f"\n\n{_ce_guidance}"
-                        _ce_block = _billing_block_dict(_provider, _base, _model, _ce_guidance)
-                        return {
-                            "final_response": _ce_final,
-                            "messages": messages,
-                            "api_calls": api_call_count,
-                            "completed": False,
-                            "failed": True,
-                            "error": _nonretryable_summary,
-                            "failure_reason": classified.reason.value,
-                            "billing_block": _ce_block,
-                        }
                    return {
                        "final_response": _nonretryable_summary,
                        "messages": messages,
@@ -4494,14 +4332,10 @@ def run_conversation(
                            api_kwargs, reason="max_retries_exhausted", error=api_error,
                        )
                    agent._persist_session(messages, conversation_history)
-                    _billing_block = None
                    if classified.reason == FailoverReason.billing:
                        _final_response = f"Billing or credits exhausted: {_final_summary}"
                        if _billing_guidance:
                            _final_response += f"\n\n{_billing_guidance}"
-                        # Structured recovery descriptor so every surface renders
-                        # the same link + label from one signal (see helper).
-                        _billing_block = _billing_block_dict(_provider, _base, _model, _billing_guidance)
                    else:
                        _final_response = f"API call failed after {max_retries} retries: {_final_summary}"
                    if _is_thinking_timeout:
@@ -4541,9 +4375,6 @@ def run_conversation(
                        # different exit code. ``rate_limit`` / ``billing`` here
                        # mean "quota wall, not a task error".
                        "failure_reason": classified.reason.value,
-                        # Present only for billing walls: structured recovery
-                        # descriptor (provider, billing_url, is_nous, message).
-                        "billing_block": _billing_block,
                    }

                # For rate limits, respect the Retry-After header if present
@@ -4626,15 +4457,6 @@ def run_conversation(
                            f"{int(sleep_end - time.time())}s remaining"
                        )
        
-        if _retry.restart_with_redirected_messages:
-            # The cancelled request produced no valid assistant item. Reuse the
-            # same logical iteration after the outer loop appends the displayed
-            # partial context and correction to ``messages``.
-            api_call_count -= 1
-            agent.iteration_budget.refund()
-            _retry.restart_with_redirected_messages = False
-            continue
-
        # If the API call was interrupted, skip response processing
        if interrupted:
            _turn_exit_reason = "interrupted_during_api_call"
@@ -1484,43 +1484,6 @@ class CredentialPool:
        self._sync_device_code_entry_to_auth_store(updated)
        return updated

-    def _codex_quota_restored_upstream(self, entry: PooledCredential) -> bool:
-        """Live-check whether an exhausted Codex entry's quota reset early.
-
-        A Codex 429 persists a ``last_error_reset_at`` that can be days in
-        the future (weekly windows), but the upstream window can reopen
-        before then — the user redeems a banked rate-limit reset via the
-        Codex CLI / ChatGPT UI, upgrades their plan, or OpenAI resets the
-        window.  Without this check the pool keeps the credential frozen
-        until the stale timestamp elapses even though the account is
-        usable (issue #43747).
-
-        Only fires for openai-codex entries frozen by a 429/quota-shaped
-        error.  The underlying probe is throttled per token (5 min) so this
-        is safe on the hot selection path.
-        """
-        if self.provider != "openai-codex" or entry.last_status != STATUS_EXHAUSTED:
-            return False
-        if not auth_mod._is_codex_rate_limit_shaped(
-            entry.last_error_code,
-            entry.last_error_reason,
-            entry.last_error_message,
-        ):
-            return False
-        token = entry.access_token or ""
-        if not token:
-            return False
-        try:
-            return bool(
-                auth_mod._probe_codex_quota_restored(
-                    token,
-                    base_url=entry.base_url,
-                )
-            )
-        except Exception:
-            logger.debug("Codex quota-restored probe failed", exc_info=True)
-            return False
-
    def _entry_needs_refresh(self, entry: PooledCredential) -> bool:
        if entry.auth_type != AUTH_TYPE_OAUTH:
            return False
@@ -1642,18 +1605,7 @@ class CredentialPool:
            if entry.last_status == STATUS_EXHAUSTED:
                exhausted_until = _exhausted_until(entry)
                if exhausted_until is not None and now < exhausted_until:
-                    # Codex quota windows can reopen EARLY: the user redeems a
-                    # banked rate-limit reset (Codex CLI / ChatGPT UI), upgrades
-                    # their plan, or OpenAI resets the window.  The persisted
-                    # ``last_error_reset_at`` can then be days in the future
-                    # while the account is already usable again — a throttled
-                    # live probe of the Codex usage endpoint detects that and
-                    # lifts the stale cooldown (issue #43747).
-                    if not (
-                        clear_expired
-                        and self._codex_quota_restored_upstream(entry)
-                    ):
-                        continue
+                    continue
                if clear_expired:
                    cleared = replace(
                        entry,
@@ -32,6 +32,7 @@ from __future__ import annotations

 import logging
 import os
+import sysconfig
 import threading
 from functools import lru_cache
 from pathlib import Path
@@ -91,8 +92,12 @@ def _locales_dir() -> Path:

    1. ``HERMES_BUNDLED_LOCALES`` env var -- set by the Nix wrapper (or any
       sealed-packaging system) to point at the installed catalog directory.
-    2. ``<repo-root>/locales`` -- source checkouts and editable installs,
+    2. ``<repo-root>/locales`` -- source checkouts and ``pip install -e .``,
       where the working tree sits next to ``agent/``.
+    3. ``<sysconfig data|purelib|platlib>/locales`` -- pip wheel installs.
+       setuptools ``data-files`` extracts ``locales/*.yaml`` under the
+       interpreter's ``data`` scheme; the other schemes are checked as a
+       safety net for nonstandard layouts.

    Falling through to the source-style path (even when missing) keeps
    ``_load_catalog`` error messages informative -- it logs the path it
@@ -111,6 +116,25 @@ def _locales_dir() -> Path:

    # agent/i18n.py -> agent/ -> repo root (source checkout, editable install)
    source_dir = Path(__file__).resolve().parent.parent / "locales"
+    if source_dir.is_dir():
+        return source_dir
+
+    # pip wheel install: data-files lands under the interpreter data scheme.
+    # ``data`` (== sys.prefix in a venv) is where setuptools data-files extract
+    # and is checked first. ``purelib``/``platlib`` (site-packages) are a safety
+    # net for nonstandard layouts. NOTE: this does NOT cover ``pip install
+    # --user`` (user scheme, ~/.local/locales) or ``pip install --target`` --
+    # both are out of scope; see the plan header.
+    for scheme in ("data", "purelib", "platlib"):
+        raw = sysconfig.get_path(scheme)
+        if not raw:
+            continue
+        candidate = Path(raw) / "locales"
+        if candidate.is_dir():
+            return candidate
+
+    # Last resort: return the source-style path so _load_catalog's catalog-missing
+    # log (logger.debug "i18n catalog missing for %s at %s") stays informative.
    return source_dir


@@ -52,13 +52,6 @@ def busy_input_hint_gateway(mode: str) -> str:
            "Send `/busy interrupt` or `/busy queue` to change this, or "
            "`/busy status` to check. This notice won't appear again."
        )
-    if mode == "redirect":
-        return (
-            "💡 First-time tip — I redirected the current run using your message. "
-            "Completed work stays in context, and `/stop` still cancels the task. "
-            "Send `/busy queue` to wait for a separate turn, or `/busy status` "
-            "to check. This notice won't appear again."
-        )
    return (
        "💡 First-time tip — I just interrupted my current task to answer you. "
        "Send `/busy queue` to queue follow-ups for after the current task instead, "
@@ -81,12 +74,6 @@ def busy_input_hint_cli(mode: str) -> str:
            "after the next tool call. Use /busy interrupt or /busy queue to "
            "change this. This tip only shows once."
        )
-    if mode == "redirect":
-        return (
-            "(tip) Your correction redirected the current run without discarding "
-            "completed work. Use /stop to cancel or /busy queue to wait for a "
-            "separate turn. This tip only shows once."
-        )
    return (
        "(tip) Your message interrupted the current run. "
        "Use /busy queue to queue messages for the next turn instead, "
@@ -300,8 +300,6 @@ class CodexAppServerSession:
        self._client: Optional[CodexAppServerClient] = None
        self._thread_id: Optional[str] = None
        self._interrupt_event = threading.Event()
-        self._active_turn_id: Optional[str] = None
-        self._active_turn_lock = threading.Lock()
        # Pending file-change items, keyed by item id. Populated on
        # item/started for fileChange items; consumed by the approval
        # bridge when codex sends item/fileChange/requestApproval. The
@@ -376,8 +374,6 @@ class CodexAppServerSession:
        if self._closed:
            return
        self._closed = True
-        with self._active_turn_lock:
-            self._active_turn_id = None
        if self._client is not None:
            try:
                self._client.close()
@@ -399,33 +395,6 @@ class CodexAppServerSession:
        and unwind. Called by AIAgent's _interrupt_requested path."""
        self._interrupt_event.set()

-    def request_steer(self, text: str) -> bool:
-        """Append user guidance to the active Codex turn via ``turn/steer``."""
-        cleaned = str(text or "").strip()
-        if not cleaned:
-            return False
-        with self._active_turn_lock:
-            turn_id = self._active_turn_id
-            thread_id = self._thread_id
-            client = self._client
-        if not turn_id or not thread_id or client is None:
-            return False
-        try:
-            response = client.request(
-                "turn/steer",
-                {
-                    "threadId": thread_id,
-                    "input": [{"type": "text", "text": cleaned}],
-                    "expectedTurnId": turn_id,
-                },
-                timeout=10,
-            )
-        except (CodexAppServerError, TimeoutError):
-            logger.debug("turn/steer rejected for active Codex turn", exc_info=True)
-            return False
-        accepted_turn_id = response.get("turnId") if isinstance(response, dict) else None
-        return accepted_turn_id in {None, turn_id}
-
    # ---------- diagnostics ----------

    def _format_error_with_stderr(
@@ -500,18 +469,11 @@ class CodexAppServerSession:
            # Subprocess almost certainly unhealthy — retire so the next
            # turn re-spawns cleanly.
            result.should_retire = True
-            self._interrupt_event.clear()
            return result
        assert self._client is not None and self._thread_id is not None
        result.thread_id = self._thread_id

-        # Do not clear here: a hard stop can arrive while ensure_started() is
-        # spawning/initializing the subprocess. Honor it before launching a
-        # Codex turn instead of erasing the signal.
-        if self._interrupt_event.is_set():
-            result.interrupted = True
-            self._interrupt_event.clear()
-            return result
+        self._interrupt_event.clear()
        projector = CodexEventProjector()

        user_input_text = _coerce_turn_input_text(user_input)
@@ -543,7 +505,6 @@ class CodexAppServerSession:
                result.error = self._format_error_with_stderr(
                    "turn/start failed", exc
                )
-            self._interrupt_event.clear()
            return result
        except TimeoutError as exc:
            # turn/start hanging is a strong signal the subprocess is wedged.
@@ -553,12 +514,9 @@ class CodexAppServerSession:
                "turn/start timed out", exc
            )
            result.should_retire = True
-            self._interrupt_event.clear()
            return result

        result.turn_id = (ts.get("turn") or {}).get("id")
-        with self._active_turn_lock:
-            self._active_turn_id = result.turn_id
        deadline = time.monotonic() + turn_timeout
        turn_complete = False
        # Post-tool watchdog state. last_tool_completion_at is set whenever
@@ -783,9 +741,6 @@ class CodexAppServerSession:
                )
            result.should_retire = True

-        with self._active_turn_lock:
-            self._active_turn_id = None
-        self._interrupt_event.clear()
        return result

    def compact_thread(
@@ -26,16 +26,11 @@ from __future__ import annotations

 import logging
 import threading
-import time
 import uuid
 from dataclasses import dataclass
 from typing import Any, Dict, List, Mapping, Optional

-from agent.conversation_compression import (
-    IDLE_COMPACTION_STATUS_TEMPLATE,
-    PREFLIGHT_COMPRESSION_STATUS_TEMPLATE,
-    conversation_history_after_compression,
-)
+from agent.conversation_compression import conversation_history_after_compression
 from agent.iteration_budget import IterationBudget
 from agent.memory_manager import build_memory_context_block
 from agent.model_metadata import (
@@ -260,40 +255,6 @@ def _should_run_preflight_estimate(
    return estimate_messages_tokens_rough(messages) >= threshold_tokens


-def _should_idle_compact(
-    *,
-    enabled: bool,
-    idle_after_seconds: int,
-    idle_gap_seconds: float,
-    tokens: int,
-    floor_tokens: int,
-    cooldown_active: bool,
-) -> bool:
-    """Decide whether an idle-triggered compaction should run this turn.
-
-    Idle compaction is opt-in (``idle_after_seconds <= 0`` disables it). It
-    fires when a session resumes after a wall-clock gap of at least
-    ``idle_after_seconds`` since its last activity, so a long-lived thread
-    that is paused and later resumed compacts its accumulated history up
-    front instead of re-reading it on every subsequent turn.
-
-    It is orthogonal to the token-threshold trigger: it does NOT require the
-    context to exceed ``threshold_tokens``. It still skips work when the
-    context is at or below ``floor_tokens`` (the size compaction would reduce
-    *to*), so a small idle thread never pays for a summarisation that saves
-    nothing, and it defers to an active compression-failure cooldown.
-
-    Pure predicate so the policy is unit-testable without a live agent.
-    """
-    if not enabled or idle_after_seconds <= 0:
-        return False
-    if idle_gap_seconds < idle_after_seconds:
-        return False
-    if cooldown_active:
-        return False
-    return tokens > floor_tokens
-
-
@dataclass
 class TurnContext:
    """Values produced by the turn prologue and consumed by the turn loop."""
@@ -618,78 +579,6 @@ def build_turn_context(
        if not isinstance(pending_cli_message, dict) or pending_cli_message.get("_db_persisted"):
            agent._pending_cli_user_message = None

-    # ── Idle-triggered compaction (opt-in; ``idle_compact_after_seconds``) ──
-    # When a session resumes after a long idle gap, compact the accumulated
-    # history up front so the rest of the conversation does not keep re-reading
-    # a large stale context on every turn. This fires on elapsed wall-clock time
-    # rather than size, so it complements (does not replace) the token-threshold
-    # preflight below. ``_last_activity_ts`` is the last time this turn loop did
-    # work; nothing has touched it yet this turn, so it measures the gap since
-    # the previous turn finished. The cheap gap pre-check gates the (more
-    # expensive) token estimate, mirroring ``_should_run_preflight_estimate``.
-    _idle_after = getattr(agent, "compression_idle_compact_after_seconds", 0)
-    if agent.compression_enabled and _idle_after > 0 and messages:
-        _idle_gap = time.time() - getattr(agent, "_last_activity_ts", time.time())
-        if _idle_gap >= _idle_after:
-            _compressor = agent.context_compressor
-            _idle_tokens = estimate_request_tokens_rough(
-                messages,
-                system_prompt=active_system_prompt or "",
-                tools=agent.tools or None,
-            )
-            # Post-compression target size: don't summarise a thread already
-            # below what compaction would reduce it to.
-            _idle_floor = int(
-                _compressor.threshold_tokens * _compressor.summary_target_ratio
-            )
-            _idle_cooldown = getattr(
-                _compressor, "get_active_compression_failure_cooldown", lambda: None
-            )()
-            if _should_idle_compact(
-                enabled=agent.compression_enabled,
-                idle_after_seconds=_idle_after,
-                idle_gap_seconds=_idle_gap,
-                tokens=_idle_tokens,
-                floor_tokens=_idle_floor,
-                cooldown_active=bool(_idle_cooldown),
-            ):
-                logger.info(
-                    "Idle compaction: %ss idle >= %ss, ~%s tokens > %s floor "
-                    "(session %s)",
-                    int(_idle_gap),
-                    _idle_after,
-                    f"{_idle_tokens:,}",
-                    f"{_idle_floor:,}",
-                    agent.session_id or "none",
-                )
-                agent._emit_status(
-                    IDLE_COMPACTION_STATUS_TEMPLATE.format(
-                        idle_seconds=int(_idle_gap), tokens=_idle_tokens
-                    )
-                )
-                _idle_input = messages
-                messages, active_system_prompt = agent._compress_context(
-                    messages, system_message, approx_tokens=_idle_tokens,
-                    task_id=effective_task_id,
-                )
-                # ``_compress_context`` returns the INPUT list object when it
-                # skips (per-session lock held by another path, failure
-                # cooldown, anti-thrash breaker, codex-native routing). Only
-                # re-baseline + re-anchor after a real compaction — a skip
-                # must leave the turn's flush baseline and user-message index
-                # untouched.
-                if messages is not _idle_input:
-                    conversation_history = conversation_history_after_compression(
-                        agent, messages
-                    )
-                    # Compaction rebuilt the list, so the index of this turn's
-                    # just-appended user message is stale — re-anchor it the
-                    # same way the preflight path does below.
-                    current_turn_user_idx = reanchor_current_turn_user_idx(
-                        messages, user_message
-                    )
-                    agent._persist_user_message_idx = current_turn_user_idx
-
    # ── Preflight context compression ──
    # Gate the (expensive) full token estimate behind a cheap pre-check.
    # See ``_should_run_preflight_estimate`` for the OR semantics that fix
@@ -772,10 +661,9 @@ def build_turn_context(
                f"{_compressor.context_length:,}",
            )
            agent._emit_status(
-                PREFLIGHT_COMPRESSION_STATUS_TEMPLATE.format(
-                    tokens=_preflight_tokens,
-                    threshold=_compressor.threshold_tokens,
-                )
+                f"📦 Preflight compression: ~{_preflight_tokens:,} tokens "
+                f">= {_compressor.threshold_tokens:,} threshold. "
+                "This may take a moment."
            )
            # Preflight passes honor the same configured per-turn cap
            # (compression.max_attempts) as the loop's compression sites;
@@ -73,10 +73,6 @@ class TurnRetryState:
    # was rolled back off ``messages`` and the loop should re-issue the API
    # call against the newly-activated provider (#32421).
    restart_with_rebuilt_messages: bool = False
-    # A user correction cancelled the in-flight provider request. The outer
-    # loop must append a role-safe checkpoint + user message, rebuild the API
-    # payload, and retry the same logical iteration.
-    restart_with_redirected_messages: bool = False

    def __iter__(self):
        # Convenience for debugging / tests: iterate (name, value) pairs.
@@ -8,10 +8,13 @@
 * Prerequisite: `npm run build` must have been run so dist/ exists.
 */

-import { expect, test } from './test'
+import { test } from './test'

-import { type MockBackendFixture, setupMockBackend, waitForAppReady } from './fixtures'
-import { BLOCKING_CLARIFY_QUESTION, BLOCKING_CLARIFY_TRIGGER } from './mock-server'
+import {
+  type MockBackendFixture,
+  setupMockBackend,
+  waitForAppReady,
+} from './fixtures'
 import { expectVisualSnapshot } from './visual-snapshot'

 let fixture: MockBackendFixture | null = null
@@ -58,7 +61,7 @@ test.describe('chat interaction with mock backend', () => {
        return (body.textContent ?? '').includes('Hello, can you hear me?')
      },
      undefined,
-      { timeout: 15_000 }
+      { timeout: 15_000 },
    )

    // Wait for the mock response to appear. The canned reply is:
@@ -78,61 +81,11 @@ test.describe('chat interaction with mock backend', () => {
        return text.includes('mock inference server') || text.includes('boot chain is working')
      },
      undefined,
-      { timeout: 60_000 }
+      { timeout: 60_000 },
    )
  })

  test('screenshot of chat with messages', async () => {
    await expectVisualSnapshot(fixture!.page, { name: 'chat-with-messages', app: fixture!.app })
  })
-
-  test('offers stop, steer, and queue actions while busy', async ({}, testInfo) => {
-    const page = fixture!.page
-    const composer = page.locator('[contenteditable="true"]').first()
-    const primary = page.locator('[data-slot="composer-root"] button[type="submit"]')
-    const queue = page.locator('[data-slot="composer-root"] button[aria-label="Queue message"]')
-    const dictation = page.locator('[data-slot="composer-root"] button[aria-label="Voice dictation"]')
-    const speakReplies = page.locator(
-      '[data-slot="composer-root"] button[aria-label="Read replies aloud"], [data-slot="composer-root"] button[aria-label="Stop reading replies aloud"]'
-    )
-
-    await composer.click()
-    await composer.type(BLOCKING_CLARIFY_TRIGGER)
-    await page.keyboard.press('Enter')
-    await page.getByText(BLOCKING_CLARIFY_QUESTION).waitFor({ state: 'visible', timeout: 30_000 })
-
-    await expect(primary).toHaveAttribute('aria-label', 'Stop')
-    await expect(primary.locator('span')).toHaveClass(/bg-current/)
-
-    await composer.click()
-    await composer.type('please answer tersely')
-    await expect(primary).toHaveAttribute('aria-label', /Steer/)
-    await expect(dictation).toBeVisible()
-    await expect(speakReplies).toBeVisible()
-    await expect(queue).toBeVisible()
-    await expect(queue.locator('svg.tabler-icon-layers-intersect-2')).toBeVisible()
-    const controlLabels = await page
-      .locator('[data-slot="composer-root"] button')
-      .evaluateAll(buttons => buttons.map(button => button.getAttribute('aria-label')))
-    const speakRepliesIndex = controlLabels.findIndex(
-      label => label === 'Read replies aloud' || label === 'Stop reading replies aloud'
-    )
-    expect(controlLabels.indexOf('Voice dictation')).toBeLessThan(speakRepliesIndex)
-    expect(speakRepliesIndex).toBeLessThan(controlLabels.indexOf('Queue message'))
-    expect(controlLabels.indexOf('Queue message')).toBeLessThan(
-      controlLabels.findIndex(label => label?.startsWith('Steer'))
-    )
-    await page.screenshot({ path: testInfo.outputPath('busy-composer-steer.png') })
-    await expect(primary.locator('svg.tabler-icon-steering-wheel')).toBeVisible()
-
-    await queue.click()
-    await expect(primary).toHaveAttribute('aria-label', 'Stop')
-    await expect(queue).toHaveCount(0)
-    await page.screenshot({ path: testInfo.outputPath('busy-composer-queue.png') })
-    await expect(page.getByText('1 Queued')).toBeVisible()
-
-    await primary.click()
-    await expect(page.getByText('1 Queued — paused')).toBeVisible()
-    await page.screenshot({ path: testInfo.outputPath('busy-composer-queue-paused.png') })
-  })
 })
@@ -1,210 +0,0 @@
-/**
- * Regression coverage for a correction sent during a live response, then a
- * warm session switch away and back. The correction is an accepted user turn,
- * not an optimistic duplicate of the original prompt, and its relative place
- * in the transcript must survive the resume reconciliation.
- */
-
-import { type TestInfo } from '@playwright/test'
-
-import { expect, test, type Page } from './test'
-
-import { type MockBackendFixture, setupMockBackend, waitForAppReady } from './fixtures'
-import { CORRECTION_SWITCH_TRIGGER, MOCK_REPLY } from './mock-server'
-
-const OTHER_SESSION_PROMPT = 'E2E persisted session used for a warm resume.'
-const ORIGINAL_PROMPT = `${CORRECTION_SWITCH_TRIGGER}: original prompt must remain singular after a correction.`
-const CORRECTION = 'E2E correction must stay after the original prompt.'
-const TOOL_STARTED = 'Checking the long-running task before I continue.'
-const CORRECTED_REPLY = 'The corrected task finished.'
-const INFERENCE_SWITCH_TRIGGER = 'E2E_INFERENCE_SWITCH_TRIGGER'
-const INFERENCE_PROMPT = `${INFERENCE_SWITCH_TRIGGER}: original inference prompt must remain singular.`
-const INFERENCE_CORRECTION = `${INFERENCE_SWITCH_TRIGGER}: correction sent while inference is live.`
-
-async function send(page: Page, text: string): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.waitFor({ state: 'visible', timeout: 15_000 })
-  await composer.click()
-  await composer.type(text, { delay: 5 })
-  await page.keyboard.press('Enter')
-}
-
-async function steer(page: Page, text: string): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  const primary = page.locator('[data-slot="composer-root"] button[type="submit"]')
-
-  await composer.waitFor({ state: 'visible', timeout: 15_000 })
-  await composer.click()
-  await composer.type(text, { delay: 5 })
-  await expect(primary).toHaveAttribute('aria-label', /Steer/)
-  await primary.click()
-}
-
-async function waitForTranscriptText(page: Page, text: string): Promise<void> {
-  await page.waitForFunction(
-    (expected: string) => (document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(expected),
-    text,
-    { timeout: 30_000 },
-  )
-}
-
-async function textNodeOccurrences(page: Page, text: string): Promise<number> {
-  return page.evaluate((expected: string) => {
-    const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-    if (!viewport) return 0
-
-    const walker = document.createTreeWalker(viewport, NodeFilter.SHOW_TEXT)
-    let count = 0
-    while (walker.nextNode()) {
-      if (walker.currentNode.textContent?.includes(expected)) {
-        count += 1
-      }
-    }
-    return count
-  }, text)
-}
-
-async function transcriptTextOrder(page: Page): Promise<string[]> {
-  return page.evaluate(() => {
-    const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-    if (!viewport) return []
-
-    return Array.from(viewport.querySelectorAll<HTMLElement>('[data-role="message"], [data-message-id]'))
-      .map(message => message.textContent?.trim() ?? '')
-      .filter(Boolean)
-  })
-}
-
-async function transcriptMessageOrder(page: Page): Promise<string[]> {
-  return page.evaluate(() => {
-    const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-    if (!viewport) return []
-
-    return Array.from(viewport.querySelectorAll<HTMLElement>('[data-role="user"], [data-role="assistant"]'))
-      .map(message => message.textContent?.trim() ?? '')
-      .filter(Boolean)
-  })
-}
-
-async function openFreshDraft(page: Page, priorSessionText: string): Promise<void> {
-  await page.locator('[data-slot="sidebar"] button[aria-label="New session"]').first().click()
-  await page.waitForFunction(
-    (priorText: string) => !(document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(priorText),
-    priorSessionText,
-    { timeout: 15_000 },
-  )
-}
-
-async function openSidebarSession(page: Page, sidebarText: string, expectedTranscriptText: string): Promise<void> {
-  const row = page.locator('[data-slot="sidebar"] button').filter({ hasText: sidebarText }).first()
-  await row.waitFor({ state: 'visible', timeout: 30_000 })
-  await row.click()
-  await waitForTranscriptText(page, expectedTranscriptText)
-}
-
-async function reopenOriginalSession(page: Page): Promise<void> {
-  // A still-running tool has not generated a final title yet, so the sidebar
-  // retains the source prompt as its provisional session title.
-  await openSidebarSession(page, ORIGINAL_PROMPT, ORIGINAL_PROMPT)
-}
-
-async function reopenInferenceSession(page: Page): Promise<void> {
-  const row = page.locator('[data-slot="sidebar"] button').filter({ hasText: INFERENCE_PROMPT }).first()
-  await row.waitFor({ state: 'visible', timeout: 30_000 })
-  await row.click()
-  await waitForTranscriptText(page, INFERENCE_PROMPT)
-}
-
-function relevantOrder(messages: string[]): string[] {
-  return messages.filter(message => message.includes(ORIGINAL_PROMPT) || message.includes(CORRECTION))
-}
-
-function steerTurnOrder(messages: string[]): string[] {
-  return messages.flatMap(message => {
-    if (message.includes(ORIGINAL_PROMPT)) return [ORIGINAL_PROMPT]
-    if (message.includes(CORRECTION)) return [CORRECTION]
-    if (message.includes(CORRECTED_REPLY)) return [CORRECTED_REPLY]
-
-    return []
-  })
-}
-
-test.describe('correction session switch', () => {
-  let fixture: MockBackendFixture | null = null
-
-  test.beforeEach(async () => {
-    fixture = await setupMockBackend({
-      mockServer: { holdFirstStreamForPrompt: INFERENCE_SWITCH_TRIGGER },
-    })
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterEach(async () => {
-    await fixture?.cleanup()
-    fixture = null
-  })
-
-  test('keeps a live correction in place and does not duplicate its original prompt after switching sessions', async ({}, testInfo: TestInfo) => {
-    const { page } = fixture!
-
-    // A blank draft does not exercise session hydration. Seed a real second
-    // session first, matching the observed switch between two saved chats.
-    await send(page, OTHER_SESSION_PROMPT)
-    await waitForTranscriptText(page, MOCK_REPLY)
-    await openFreshDraft(page, OTHER_SESSION_PROMPT)
-
-    await send(page, ORIGINAL_PROMPT)
-    await waitForTranscriptText(page, TOOL_STARTED)
-    await waitForTranscriptText(page, ORIGINAL_PROMPT)
-
-    // The historical session redirects while a foreground terminal task is
-    // running. Use the visible Steer action to cover the real composer path.
-    await steer(page, CORRECTION)
-    await waitForTranscriptText(page, CORRECTION)
-
-    const orderBeforeSwitch = relevantOrder(await transcriptTextOrder(page))
-    expect(orderBeforeSwitch).toEqual([ORIGINAL_PROMPT, CORRECTION])
-    expect(await textNodeOccurrences(page, ORIGINAL_PROMPT)).toBe(1)
-    expect(await textNodeOccurrences(page, CORRECTION)).toBe(1)
-    await page.screenshot({ path: testInfo.outputPath('correction-before-session-switch.png') })
-
-    // Reproduce the observed race: switch to another persisted session while
-    // the foreground tool is live, then return before its redirect settles.
-    await openSidebarSession(page, MOCK_REPLY, OTHER_SESSION_PROMPT)
-    await reopenOriginalSession(page)
-    await page.waitForTimeout(500)
-    await page.screenshot({ path: testInfo.outputPath('correction-after-warm-resume.png') })
-
-    expect(relevantOrder(await transcriptTextOrder(page))).toEqual(orderBeforeSwitch)
-    expect(await textNodeOccurrences(page, ORIGINAL_PROMPT)).toBe(1)
-    expect(await textNodeOccurrences(page, CORRECTION)).toBe(1)
-
-    await waitForTranscriptText(page, CORRECTED_REPLY)
-    expect(steerTurnOrder(await transcriptMessageOrder(page))).toEqual([ORIGINAL_PROMPT, CORRECTION, CORRECTED_REPLY])
-  })
-
-  test('keeps an inference-time correction visible through a warm session switch', async ({}, testInfo: TestInfo) => {
-    const { mock, page } = fixture!
-
-    await send(page, OTHER_SESSION_PROMPT)
-    await waitForTranscriptText(page, MOCK_REPLY)
-    await openFreshDraft(page, OTHER_SESSION_PROMPT)
-
-    await send(page, INFERENCE_PROMPT)
-    await mock.waitForHeldStream()
-    await waitForTranscriptText(page, INFERENCE_PROMPT)
-
-    await send(page, INFERENCE_CORRECTION)
-    await waitForTranscriptText(page, INFERENCE_CORRECTION)
-
-    await openSidebarSession(page, MOCK_REPLY, OTHER_SESSION_PROMPT)
-    await reopenInferenceSession(page)
-
-    expect(await textNodeOccurrences(page, INFERENCE_PROMPT)).toBe(1)
-    expect(await textNodeOccurrences(page, INFERENCE_CORRECTION)).toBe(1)
-    await page.screenshot({ path: testInfo.outputPath('inference-correction-after-warm-resume.png') })
-
-    mock.releaseHeldStream()
-    await waitForTranscriptText(page, MOCK_REPLY)
-  })
-})
@@ -27,7 +27,7 @@ import * as path from 'node:path'

 import { _electron, type ElectronApplication, type Page } from '@playwright/test'

-import { startMockServer, type MockServerOptions } from './mock-server'
+import { startMockServer } from './mock-server'
 import { installErrorBannerGuard } from './test'

 const DESKTOP_ROOT = path.resolve(import.meta.dirname, '..')
@@ -140,30 +140,15 @@ export function createSandbox(prefix: string): Sandbox {
 * Write a config.yaml that pre-configures a mock provider pointing at the
 * mock inference server. The provider is set as the active model provider so
 * the desktop app skips onboarding and boots straight to the chat UI.
- *
- * @param extraDisplayConfig optional YAML lines appended to the `display:`
- *   section, used by the interim-message e2e test.
- * @param extraConfig optional top-level YAML sections for a test scenario.
- * @param modelContextLength optional primary-model context limit.
 */
-export function writeMockProviderConfig(
-  hermesHome: string,
-  mockUrl: string,
-  extraDisplayConfig?: string,
-  extraConfig?: string,
-  modelContextLength?: number,
-): void {
+export function writeMockProviderConfig(hermesHome: string, mockUrl: string): void {
  const configPath = path.join(hermesHome, 'config.yaml')

-  const displaySection = extraDisplayConfig
-    ? `\ndisplay:\n${extraDisplayConfig}\n`
-    : ''
-
  const config = `# Auto-generated by E2E test fixtures
 model:
  default: mock-model
  provider: mock
-${modelContextLength ? `  context_length: ${modelContextLength}\n` : ''}providers:
+providers:
  mock:
    api: ${mockUrl}/v1
    name: Mock
@@ -172,7 +157,7 @@ ${modelContextLength ? `  context_length: ${modelContextLength}\n` : ''}provider
    models:
      mock-model: {}
    context_length: 4096
-${displaySection}${extraConfig ? `\n${extraConfig.trim()}\n` : ''}`
+`

  fs.writeFileSync(configPath, config, 'utf8')
 }
@@ -333,25 +318,11 @@ export async function launchDesktop(
 export interface MockBackendFixture {
  app: ElectronApplication
  page: Page
-  mock: Awaited<ReturnType<typeof startMockServer>>
  mockUrl: string
  sandbox: Sandbox
  cleanup: () => Promise<void>
 }

-export interface MockBackendOptions {
-  /**
-   * Optional YAML lines to inject under the `display:` section of the
-   * generated config.yaml. Used by the interim-message e2e test to toggle
-   * `display.interim_assistant_messages`.
-   */
-  extraDisplayConfig?: string
-  /** Additional top-level config.yaml sections for an E2E scenario. */
-  extraConfig?: string
-  /** Override the mock model's context window for compression scenarios. */
-  modelContextLength?: number
-}
-
 /**
 * Set up a full mock-backend E2E environment:
 *   1. Start the mock inference server
@@ -359,23 +330,13 @@ export interface MockBackendOptions {
 *   3. Launch the desktop app
 *   4. Return handles for test interaction
 */
-export interface MockBackendOptions {
-  mockServer?: MockServerOptions
-}
-
-export async function setupMockBackend(options: MockBackendOptions = {}): Promise<MockBackendFixture> {
+export async function setupMockBackend(): Promise<MockBackendFixture> {
  // 1. Start mock server
-  const mock = await startMockServer(options.mockServer)
+  const mock = await startMockServer()

  // 2. Create sandbox + write config
  const sandbox = createSandbox('mock')
-  writeMockProviderConfig(
-    sandbox.hermesHome,
-    mock.url,
-    options.extraDisplayConfig,
-    options.extraConfig,
-    options.modelContextLength,
-  )
+  writeMockProviderConfig(sandbox.hermesHome, mock.url)
  writeEnvFile(sandbox.hermesHome)

  // 3. Build env + launch
@@ -385,7 +346,6 @@ export async function setupMockBackend(options: MockBackendOptions = {}): Promis
  return {
    app,
    page,
-    mock,
    mockUrl: mock.url,
    sandbox,
    cleanup: async () => {
@@ -1,215 +0,0 @@
-/**
- * E2E test for the interim-assistant-message preservation fix (#65919).
- *
- * Reproduces the bug across all three layers (agent core → tui_gateway →
- * desktop renderer): when the agent emits assistant text alongside a tool
- * call, then completes the turn with a *different* final answer, the
- * interim text must survive in the transcript — not be wiped when
- * message.complete replaces the streaming bubble.
- *
- * The mock server walks through a multi-turn script when it sees the
- * trigger keyword:
- *
- *   Turn 1: "Let me start by planning the approach." + todo tool_call
- *   Turn 2: "Now checking the details before answering." + todo tool_call
- *   Turn 3: (no text) + todo tool_call          → NO interim (no visible text)
- *   Turn 4: "Found something interesting worth noting." + todo tool_call
- *   Turn 5: "All done! Here is the complete summary..." (final, stop)
- *
- * Two describe blocks exercise the config flag both ways:
- *
- *   display.interim_assistant_messages: true (default)
- *     → ALL interim texts AND the final text must be visible in the
- *       transcript.
- *
- *   display.interim_assistant_messages: false
- *     → only the final text is visible (no message.interim events emitted,
- *       so all streamed interim text is replaced at message.complete).
- *
- * Prerequisite: `npm run build` must have been run so dist/ exists.
- */
-
-import { expect, test, type Page } from '@playwright/test'
-
-import {
-  type MockBackendFixture,
-  setupMockBackend,
-  waitForAppReady,
-} from './fixtures'
-import { INTERIM_TEXTS, restartMockServer } from './mock-server'
-
-// ─── Helpers ──────────────────────────────────────────────────────────
-
-/** Unique trigger keyword the mock server detects to switch to the script. */
-const TRIGGER = 'E2E_INTERIM_TRIGGER'
-
-/**
- * Send a message and wait for BOTH the user's message and the agent's
- * final response to appear in the transcript. Returns when the final text
- * is visible, which means message.complete has fired and the transcript
- * has settled.
- */
-async function sendInterimMessage(page: Page): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.waitFor({ state: 'visible', timeout: 10_000 })
-  await composer.click()
-  await composer.type(TRIGGER, { delay: 20 })
-  await page.keyboard.press('Enter')
-
-  // Wait for the user's trigger message to appear.
-  await page.waitForFunction(
-    () => (document.body.textContent ?? '').includes('E2E_INTERIM_TRIGGER'),
-    undefined,
-    { timeout: 15_000 },
-  )
-
-  // Wait for the agent's FINAL response (last turn). This means
-  // message.complete has fired and the transcript is settled.
-  await page.waitForFunction(
-    (finalText) => (document.body.textContent ?? '').includes(finalText),
-    INTERIM_TEXTS.finalText,
-    { timeout: 90_000 },
-  )
-
-  // Give the renderer a moment to settle any final state updates
-  // (hydration, session refresh) before asserting.
-  await page.waitForTimeout(2000)
-}
-
-/**
- * Count how many times `text` appears as distinct text in the chat transcript
- * (excluding the session sidebar, whose session-preview label shows the
- * first streamed text as a title).
- *
- * The desktop app renders the transcript inside a
- * `[data-slot="aui_thread-viewport"]` container (from @assistant-ui/react).
- * The session sidebar's preview labels live outside that container, so
- * scoping the DOM walk to the viewport cleanly excludes them.
- */
-async function countTranscriptMessagesContaining(page: Page, text: string): Promise<number> {
-  return page.evaluate(
-    (search) => {
-      const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-      if (!viewport) {
-        return 0
-      }
-
-      let count = 0
-      const walker = document.createTreeWalker(
-        viewport,
-        NodeFilter.SHOW_ELEMENT,
-        {
-          acceptNode: (node) => {
-            const el = node as HTMLElement
-            const directText = el.textContent ?? ''
-            if (!directText.includes(search)) {
-              return NodeFilter.FILTER_SKIP
-            }
-            // Only count leaf-ish elements to avoid double-counting.
-            const hasChildWithText = Array.from(el.children).some(
-              (child) => (child.textContent ?? '').includes(search),
-            )
-            if (hasChildWithText) {
-              return NodeFilter.FILTER_SKIP
-            }
-            return NodeFilter.FILTER_ACCEPT
-          },
-        },
-      )
-      while (walker.nextNode()) {
-        count++
-      }
-      return count
-    },
-    text,
-  )
-}
-
-// ─── Flag ON: interim_assistant_messages = true (default) ─────────────
-
-test.describe('interim assistant messages — flag ON (default)', () => {
-  test.describe.configure({ mode: 'serial' })
-
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    restartMockServer()
-    fixture = await setupMockBackend()
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('all interim texts survive alongside the final response', async () => {
-    const page = fixture.page
-    await sendInterimMessage(page)
-
-    // Every interim text (turns with visible text + tool calls) must be
-    // present in the transcript as its own sealed message — NOT wiped by
-    // message.complete.
-    for (const interimText of INTERIM_TEXTS.interims) {
-      await expect
-        .poll(
-          () => countTranscriptMessagesContaining(page, interimText),
-          { timeout: 15_000, message: `interim text "${interimText}" should be visible` },
-        )
-        .toBeGreaterThanOrEqual(1)
-    }
-
-    // The final text must also be visible.
-    await expect
-      .poll(
-        () => countTranscriptMessagesContaining(page, INTERIM_TEXTS.finalText),
-        { timeout: 15_000, message: 'final text should be visible' },
-      )
-      .toBeGreaterThanOrEqual(1)
-  })
-})
-
-// ─── Flag OFF: interim_assistant_messages = false ────────────────────
-
-test.describe('interim assistant messages — flag OFF', () => {
-  test.describe.configure({ mode: 'serial' })
-
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    restartMockServer()
-    fixture = await setupMockBackend({
-      extraDisplayConfig: '  interim_assistant_messages: false',
-    })
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('only the final response is visible; all interim texts are wiped', async () => {
-    const page = fixture.page
-    await sendInterimMessage(page)
-
-    // The final text must be visible.
-    await expect
-      .poll(
-        () => countTranscriptMessagesContaining(page, INTERIM_TEXTS.finalText),
-        { timeout: 15_000, message: 'final text should be visible' },
-      )
-      .toBeGreaterThanOrEqual(1)
-
-    // NONE of the interim texts should be visible — with the flag off,
-    // the tui_gateway never installs interim_assistant_callback, so no
-    // message.interim events are emitted. All streamed interim text is
-    // accumulated into the streaming bubble and replaced by
-    // message.complete.
-    for (const interimText of INTERIM_TEXTS.interims) {
-      const count = await countTranscriptMessagesContaining(page, interimText)
-      expect(
-        count,
-        `interim text "${interimText}" should NOT be visible when flag is off`,
-      ).toBe(0)
-    }
-  })
-})
@@ -1,235 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import * as path from 'node:path'
-
-import { type TestInfo } from '@playwright/test'
-
-import { expect, test, type ElectronApplication, type Page } from './test'
-
-import {
-  buildAppEnv,
-  createSandbox,
-  launchDesktop,
-  type Sandbox,
-  waitForAppReady,
-  writeEnvFile,
-  writeMockProviderConfig,
-} from './fixtures'
-import { MOCK_REPLY, startMockServer, type MockServer, type MockServerOptions } from './mock-server'
-
-const DESKTOP_ROOT = path.resolve(import.meta.dirname, '..')
-const REPO_ROOT = path.resolve(DESKTOP_ROOT, '..', '..')
-const SEED_SCRIPT = path.resolve(import.meta.dirname, 'scripts', 'seed_large_session.py')
-const SESSION_TITLE = 'E2E large persisted session'
-const EXPECTED_TEXT = 'E2E persisted user message 52'
-const BACKGROUND_PROMPT = 'E2E background inference must remain attached across resume'
-
-interface SeededFixture {
-  app: ElectronApplication
-  mock: MockServer
-  mockUrl: string
-  page: Page
-  sandbox: Sandbox
-  cleanup: () => Promise<void>
-}
-
-interface PaintState {
-  bursts: number
-  timeline: Array<{ mutations: number; time: number }>
-}
-
-async function setupSeededDesktop(mockServer?: MockServerOptions): Promise<SeededFixture> {
-  const mock = await startMockServer(mockServer)
-  const sandbox = createSandbox('large-session')
-  writeMockProviderConfig(sandbox.hermesHome, mock.url)
-  writeEnvFile(sandbox.hermesHome)
-
-  const seeded = spawnSync('python3', [SEED_SCRIPT, path.join(sandbox.hermesHome, 'state.db')], {
-    cwd: REPO_ROOT,
-    encoding: 'utf8',
-    env: { ...process.env, PYTHONPATH: REPO_ROOT },
-  })
-  if (seeded.status !== 0) {
-    throw new Error(`large-session seed failed:\n${seeded.stdout}\n${seeded.stderr}`)
-  }
-
-  const { app, page } = await launchDesktop(buildAppEnv(sandbox))
-
-  return {
-    app,
-    mock,
-    mockUrl: mock.url,
-    page,
-    sandbox,
-    cleanup: async () => {
-      await app.close().catch(() => undefined)
-      await mock.close()
-      sandbox.cleanup()
-    },
-  }
-}
-
-function sessionRow(page: Page) {
-  return page.locator('[data-slot="sidebar"] button').filter({ hasText: SESSION_TITLE }).first()
-}
-
-async function openSeededSession(page: Page): Promise<void> {
-  const row = sessionRow(page)
-  await row.waitFor({ state: 'visible', timeout: 60_000 })
-  await row.click()
-  await page.waitForFunction(
-    expected => (document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(expected),
-    EXPECTED_TEXT,
-    { timeout: 30_000 },
-  )
-}
-
-async function openNewSession(page: Page): Promise<void> {
-  const button = page.locator('[data-slot="sidebar"] button').filter({ hasText: 'New session' }).first()
-  await button.waitFor({ state: 'visible', timeout: 10_000 })
-  await button.click()
-  await page.waitForFunction(
-    expected => !(document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(expected),
-    EXPECTED_TEXT,
-    { timeout: 15_000 },
-  )
-}
-
-async function submitPrompt(page: Page, prompt: string): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.waitFor({ state: 'visible', timeout: 15_000 })
-  await composer.click()
-  await composer.type(prompt, { delay: 2 })
-  await page.keyboard.press('Enter')
-  await page.waitForFunction(
-    expected => (document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(expected),
-    prompt,
-    { timeout: 15_000 },
-  )
-}
-
-async function startPaintObserver(page: Page): Promise<void> {
-  await page.evaluate(() => {
-    const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-    const state = { bursts: 0, timeline: [] as Array<{ mutations: number; time: number }> }
-    ;(window as Window & { __largeSessionPaints?: typeof state }).__largeSessionPaints = state
-    if (!viewport) return
-
-    let additions = 0
-    let flushTimer: ReturnType<typeof setTimeout> | undefined
-    new MutationObserver(records => {
-      additions += records.reduce(
-        (count, record) => count + (record.type === 'childList' && record.addedNodes.length > 0 ? 1 : 0),
-        0,
-      )
-      if (additions === 0) return
-      if (flushTimer) clearTimeout(flushTimer)
-      flushTimer = setTimeout(() => {
-        state.bursts += 1
-        state.timeline.push({ mutations: additions, time: Date.now() })
-        additions = 0
-      }, 30)
-    }).observe(viewport, { childList: true, subtree: true })
-  })
-}
-
-async function paintState(page: Page): Promise<PaintState> {
-  const state = await page.evaluate(() => (window as Window & { __largeSessionPaints?: PaintState }).__largeSessionPaints)
-  expect(state, 'paint observer should attach to the thread viewport').toBeDefined()
-  return state!
-}
-
-async function textNodeOccurrences(page: Page, expected: string): Promise<number> {
-  return page.evaluate(text => {
-    const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-    if (!viewport) return 0
-
-    const walker = document.createTreeWalker(viewport, NodeFilter.SHOW_TEXT)
-    let count = 0
-    while (walker.nextNode()) {
-      if (walker.currentNode.textContent?.includes(text)) {
-        count += 1
-      }
-    }
-    return count
-  }, expected)
-}
-
-async function reloadIntoColdRenderer(fixture: SeededFixture): Promise<void> {
-  await fixture.page.reload()
-  await waitForAppReady(fixture, 120_000)
-  await openNewSession(fixture.page)
-}
-
-async function assertUnchangedResume(page: Page, testInfo: TestInfo): Promise<void> {
-  await openSeededSession(page)
-  await page.waitForTimeout(1_000)
-  await page.screenshot({ path: testInfo.outputPath('unchanged-session-resume.png'), fullPage: false })
-
-  const paints = await paintState(page)
-  expect(await textNodeOccurrences(page, EXPECTED_TEXT), 'the resumed user message should appear once').toBe(1)
-  // A warm session first restores its retained view, then reconciles it with the
-  // authoritative transcript. That is bounded at two builds; a third paint was
-  // the old eager-prefetch + runtime-rebuild regression. A cold restore has one.
-  expect(paints.bursts, `unexpected transcript paint count: ${JSON.stringify(paints.timeline)}`).toBeLessThanOrEqual(2)
-}
-
-test.describe('large session resume', () => {
-  let fixture: SeededFixture | null = null
-
-  test.afterEach(async () => {
-    await fixture?.cleanup()
-    fixture = null
-  })
-
-  test('cold resume of an unchanged session has one user row and bounded transcript paints', async ({}, testInfo) => {
-    fixture = await setupSeededDesktop()
-    await waitForAppReady(fixture, 120_000)
-
-    await startPaintObserver(fixture.page)
-    await assertUnchangedResume(fixture.page, testInfo)
-  })
-
-  test('fast resume of an unchanged session has one user row and bounded transcript paints', async ({}, testInfo) => {
-    // Known RED: a rapid warm resume rebuilds the transcript three times
-    // (28 → 53 → 53 DOM additions) instead of the two-paint budget. Keep the
-    // regression visible without making unrelated desktop work fail CI.
-    test.fixme(true, 'Fast warm resume has an unresolved third transcript rebuild')
-
-    fixture = await setupSeededDesktop()
-    await waitForAppReady(fixture, 120_000)
-
-    await openSeededSession(fixture.page)
-    await openNewSession(fixture.page)
-    await startPaintObserver(fixture.page)
-    await assertUnchangedResume(fixture.page, testInfo)
-  })
-
-  for (const resumeKind of ['fast', 'cold'] as const) {
-    test(`${resumeKind} resume keeps background inference attached without duplicate messages`, async ({}, testInfo) => {
-      fixture = await setupSeededDesktop({ holdFirstStreamForPrompt: BACKGROUND_PROMPT })
-      await waitForAppReady(fixture, 120_000)
-
-      await openSeededSession(fixture.page)
-      await submitPrompt(fixture.page, BACKGROUND_PROMPT)
-      await fixture.mock.waitForHeldStream()
-      await openNewSession(fixture.page)
-
-      if (resumeKind === 'cold') {
-        await reloadIntoColdRenderer(fixture)
-      }
-
-      await openSeededSession(fixture.page)
-      fixture.mock.releaseHeldStream()
-      await fixture.page.waitForFunction(
-        expected => (document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(expected),
-        MOCK_REPLY,
-        { timeout: 60_000 },
-      )
-      await fixture.page.waitForTimeout(300)
-      await fixture.page.screenshot({ path: testInfo.outputPath(`${resumeKind}-background-inference-resume.png`), fullPage: false })
-
-      expect(await textNodeOccurrences(fixture.page, BACKGROUND_PROMPT), 'the running user prompt should appear once').toBe(1)
-      expect(await textNodeOccurrences(fixture.page, MOCK_REPLY), 'the completed assistant reply should appear once').toBe(1)
-    })
-  }
-})
@@ -15,250 +15,17 @@
 */

 import http from 'node:http'
-import type { ServerResponse } from 'node:http'

 /** A canned assistant reply used for every chat completion request. */
-export const MOCK_REPLY = 'Hello from the mock inference server! The full boot chain is working.'
-
-export interface MockServerOptions {
-  /** Pause the matching stream after its first token for session-switch E2E coverage. */
-  holdFirstStreamForPrompt?: string
-  /** Pause the first completion whose request JSON contains this text. */
-  holdFirstCompletionContaining?: string
-}
-
-export interface MockServer {
-  port: number
-  url: string
-  receivedPrompts: string[]
-  waitForHeldStream: () => Promise<void>
-  waitForHeldCompletion: () => Promise<void>
-  releaseHeldStream: () => void
-  heldCompletionCount: () => number
-  close: () => Promise<void>
-}
-
-// ─── Multi-turn interim script ─────────────────────────────────────────
-//
-// When the user's message contains the trigger keyword, the mock server
-// walks through a scripted sequence of responses that exercise the
-// interim-assistant-message fix (#65919) across several patterns:
-//
-//   1. text + single tool_call  → should produce an interim message
-//   2. text + single tool_call  → another interim message
-//   3. no text + tool_call       → NO interim (no visible text alongside tools)
-//   4. text + single tool_call  → another interim message
-//   5. final answer (stop)      → message.complete, different from all interims
-//
-// Each "turn" is one API call. The agent executes the tool after each
-// tool_calls response, then re-calls the API, advancing to the next turn.
-
-export interface ScriptedTurn {
-  /** Assistant text content to stream. Empty string = no visible text. */
-  text: string
-  /** Tool calls to emit. Empty array = final turn (finish_reason: stop). */
-  toolCalls?: Array<{
-    name: string
-    args: Record<string, unknown>
-  }>
-}
-
-const INTERIM_SCRIPT: ScriptedTurn[] = [
-  {
-    text: 'Let me start by planning the approach.',
-    toolCalls: [{ name: 'todo', args: { todos: [{ id: '1', content: 'Plan', status: 'in_progress' }] } }],
-  },
-  {
-    text: 'Now checking the details before answering.',
-    toolCalls: [{ name: 'todo', args: { todos: [{ id: '2', content: 'Check details', status: 'in_progress' }] } }],
-  },
-  {
-    // No visible text alongside this tool call — should NOT produce an
-    // interim message. The agent fires _emit_interim_assistant_message
-    // but _interim_assistant_visible_text returns "" so it's a no-op.
-    text: '',
-    toolCalls: [{ name: 'todo', args: { todos: [{ id: '3', content: 'Silent step', status: 'completed' }] } }],
-  },
-  {
-    text: 'Found something interesting worth noting.',
-    toolCalls: [{ name: 'todo', args: { todos: [{ id: '4', content: 'Note finding', status: 'completed' }] } }],
-  },
-  {
-    // Final answer — different from all interim texts.
-    text: 'All done! Here is the complete summary of what I found.',
-  },
-]
-
-/** Per-server request counter so we can walk through the script turns. */
-let _scriptIndex = 0
-
-/** Per-server counter for the sidebar-states script (independent from _scriptIndex). */
-let _sidebarScriptIndex = 0
-
-/** Per-server counter for the cross-session sidebar script. */
-let _sidebarCrossIndex = 0
-
-/** Per-server counter for the queue-stop script. */
-let _queueStopIndex = 0
-
-/** Per-server counter for the correction/session-switch script. */
-let _correctionSwitchIndex = 0
-
-/** User messages received by the mock, for E2E assertions on real submits. */
-const _receivedUserTexts: string[] = []
-
-/** Reset the script indices (called between tests via restartMockServer). */
-function resetScriptIndex(): void {
-  _scriptIndex = 0
-  _sidebarScriptIndex = 0
-  _sidebarCrossIndex = 0
-  _queueStopIndex = 0
-  _correctionSwitchIndex = 0
-  _receivedUserTexts.length = 0
-}
-
-/** Return the user prompts the real backend submitted to this mock server. */
-export function receivedUserTexts(): readonly string[] {
-  return _receivedUserTexts
-}
-
-// ─── Sidebar-states script ─────────────────────────────────────────────
-//
-// A separate trigger (E2E_SIDEBAR_TRIGGER) exercises the desktop sidebar's
-// background-process and subagent states. The mock returns tool_calls that
-// the agent executes for real — `terminal(background=true)` spawns a real
-// (but trivial) background process, and `delegate_task` spawns a real
-// subagent that calls the mock server and gets the canned reply.
-//
-// Turn 1: text + terminal(bg=true) + delegate_task → tools execute
-// Turn 2: final answer → message.complete, dot transitions
-
-const SIDEBAR_SCRIPT: ScriptedTurn[] = [
-  {
-    text: 'Let me run a background task and delegate some work.',
-    toolCalls: [
-      {
-        name: 'terminal',
-        args: {
-          command: 'echo "background process output" && sleep 1 && echo "done"',
-          background: true,
-          notify_on_complete: true,
-        },
-      },
-      {
-        name: 'delegate_task',
-        args: {
-          goal: 'Summarize the test results',
-          context: 'This is a test subagent for the sidebar states E2E test.',
-        },
-      },
-    ],
-  },
-  {
-    text: 'All tasks complete. The background process finished and the subagent returned its summary.',
-  },
-]
-
-// ─── Sidebar cross-session script ──────────────────────────────────────
-//
-// E2E_SIDEBAR_CROSS trigger uses a longer background process (sleep 5) so
-// the "background running" dot is visible long enough for the test to:
-//   1. See the background dot while the subagent runs.
-//   2. Open a different session and see session A's dot transition to
-//      "finished unread" when the background process completes.
-
-const SIDEBAR_CROSS_SCRIPT: ScriptedTurn[] = [
-  {
-    text: 'Starting a long background task and delegating work.',
-    toolCalls: [
-      {
-        name: 'terminal',
-        args: {
-          command: 'echo "long bg output" && sleep 5 && echo "finished"',
-          background: true,
-          notify_on_complete: true,
-        },
-      },
-      {
-        name: 'delegate_task',
-        args: {
-          goal: 'Analyze cross-session state',
-          context: 'Testing that the background dot updates across sessions.',
-        },
-      },
-    ],
-  },
-  {
-    text: 'Both tasks are running in the background now.',
-  },
-]
-
-const QUEUE_STOP_SCRIPT: ScriptedTurn[] = [
-  {
-    text: 'Starting a task that will keep this turn active.',
-    toolCalls: [{ name: 'clarify', args: { question: 'Keep working?', choices: ['Yes', 'No'] } }],
-  },
-  { text: 'The paused task completed.' },
-]
-
-// The reported correction arrived while a foreground tool was still running.
-// Keep that boundary open long enough for the renderer to redirect the turn,
-// then let the next model request complete normally.
-const CORRECTION_SWITCH_SCRIPT: ScriptedTurn[] = [
-  {
-    text: 'Checking the long-running task before I continue.',
-    toolCalls: [{ name: 'terminal', args: { command: 'sleep 5' } }],
-  },
-  { text: 'The corrected task finished.' },
-]
-
-export const CORRECTION_SWITCH_TRIGGER = 'E2E_CORRECTION_SWITCH_TRIGGER'
-
-/**
- * A marker that makes the mock emit a real blocking clarify tool call. Tests
- * use it to hold a turn open while exercising busy-composer interactions.
- */
-export const BLOCKING_CLARIFY_TRIGGER = 'E2E_BLOCKING_CLARIFY_TRIGGER'
-export const BLOCKING_CLARIFY_QUESTION = 'Keep this test turn running?'
-
-const BLOCKING_CLARIFY_TURN: ScriptedTurn = {
-  text: '',
-  toolCalls: [{ name: 'clarify', args: { question: BLOCKING_CLARIFY_QUESTION, choices: ['Yes', 'No'] } }],
-}
-
-function includesBlockingClarifyTrigger(value: unknown): boolean {
-  if (typeof value === 'string') {
-    return value.includes(BLOCKING_CLARIFY_TRIGGER)
-  }
-
-  if (Array.isArray(value)) {
-    return value.some(includesBlockingClarifyTrigger)
-  }
-
-  if (value && typeof value === 'object') {
-    return Object.values(value).some(includesBlockingClarifyTrigger)
-  }
-
-  return false
-}
+const CANNED_REPLY = 'Hello from the mock inference server! The full boot chain is working.'

 /**
 * Start the mock server on an ephemeral port.
 *
- * @returns a handle with `port`, `url`, received user prompts, and `close()`.
+ * @returns a handle with `port`, `url`, and `close()`.
 */
-export function startMockServer(options: MockServerOptions = {}): Promise<MockServer> {
+export function startMockServer(): Promise<{ port: number; url: string; close: () => Promise<void> }> {
  return new Promise((resolve, reject) => {
-    const receivedPrompts: string[] = []
-    let resolveHeldStreamStarted: (() => void) | null = null
-    let releaseHeldStream: (() => void) | null = null
-    let heldCompletionCount = 0
-    const heldStreamStarted = new Promise<void>(resolveHeld => {
-      resolveHeldStreamStarted = resolveHeld
-    })
-    const heldStreamReleased = new Promise<void>(resolveRelease => {
-      releaseHeldStream = resolveRelease
-    })
    const server = http.createServer((req, res) => {
      // CORS headers — the Electron renderer doesn't need them, but they
      // don't hurt and make the server usable from a browser context too.
@@ -308,128 +75,88 @@ export function startMockServer(options: MockServerOptions = {}): Promise<MockSe
            // malformed JSON — treat as non-streaming with defaults
          }

-          const lastUserMessage = [...(parsed.messages ?? [])]
-            .reverse()
-            .find((message: { role?: unknown }) => message?.role === 'user')
-
-          if (typeof lastUserMessage?.content === 'string') {
-            receivedPrompts.push(lastUserMessage.content)
-          }
-
          const stream = parsed.stream === true
          const model = parsed.model || 'mock-model'
-          const holdThisCompletion = Boolean(
-            options.holdFirstCompletionContaining &&
-            heldCompletionCount === 0 &&
-            JSON.stringify(parsed).includes(options.holdFirstCompletionContaining),
-          )
-
-          // Detect the interim-message test trigger: the user's message
-          // contains a specific keyword. The mock walks through the
-          // INTERIM_SCRIPT turns in sequence.
-          //
-          // The trigger keyword is chosen so normal chat tests (which send
-          // "Hello, can you hear me?" etc.) never hit this path.
-          const messages: any[] = Array.isArray(parsed.messages) ? parsed.messages : []
-          const lastUserMsg = [...messages].reverse().find(m => m?.role === 'user')
-          const userText = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : ''
-          if (userText) {
-            _receivedUserTexts.push(userText)
-          }
-          const isInterimTrigger = userText.includes('E2E_INTERIM_TRIGGER')
-          const isSidebarTrigger = userText.includes('E2E_SIDEBAR_TRIGGER')
-          const isSidebarCrossTrigger = userText.includes('E2E_SIDEBAR_CROSS')
-          const isQueueStopTrigger = userText.includes('E2E_QUEUE_STOP_TRIGGER')
-          const isCorrectionSwitchTrigger = messages.some(
-            message => typeof message?.content === 'string' && message.content.includes(CORRECTION_SWITCH_TRIGGER),
-          )
-
-          if (includesBlockingClarifyTrigger(parsed.messages)) {
-            if (stream) {
-              streamScriptedTurn(res, model, BLOCKING_CLARIFY_TURN)
-            } else {
-              nonStreamingScriptedTurn(res, model, BLOCKING_CLARIFY_TURN)
-            }
-            return
-          }
-
-          if (isQueueStopTrigger) {
-            const turn = QUEUE_STOP_SCRIPT[_queueStopIndex] ?? QUEUE_STOP_SCRIPT[QUEUE_STOP_SCRIPT.length - 1]
-            _queueStopIndex++
-            if (stream) {
-              streamScriptedTurn(res, model, turn)
-            } else {
-              nonStreamingScriptedTurn(res, model, turn)
-            }
-            return
-          }
-
-          if (isCorrectionSwitchTrigger) {
-            const turn = CORRECTION_SWITCH_SCRIPT[_correctionSwitchIndex] ?? CORRECTION_SWITCH_SCRIPT[CORRECTION_SWITCH_SCRIPT.length - 1]
-            _correctionSwitchIndex++
-            if (stream) {
-              streamScriptedTurn(res, model, turn)
-            } else {
-              nonStreamingScriptedTurn(res, model, turn)
-            }
-            return
-          }
-
-          if (isSidebarCrossTrigger) {
-            const turn = SIDEBAR_CROSS_SCRIPT[_sidebarCrossIndex] ?? SIDEBAR_CROSS_SCRIPT[SIDEBAR_CROSS_SCRIPT.length - 1]
-            _sidebarCrossIndex++
-
-            if (stream) {
-              streamScriptedTurn(res, model, turn)
-            } else {
-              nonStreamingScriptedTurn(res, model, turn)
-            }
-            return
-          }
-
-          if (isSidebarTrigger) {
-            const turn = SIDEBAR_SCRIPT[_sidebarScriptIndex] ?? SIDEBAR_SCRIPT[SIDEBAR_SCRIPT.length - 1]
-            _sidebarScriptIndex++
-
-            if (stream) {
-              streamScriptedTurn(res, model, turn)
-            } else {
-              nonStreamingScriptedTurn(res, model, turn)
-            }
-            return
-          }
-
-          if (isInterimTrigger) {
-            const turn = INTERIM_SCRIPT[_scriptIndex] ?? INTERIM_SCRIPT[INTERIM_SCRIPT.length - 1]
-            _scriptIndex++
-            if (stream) {
-              streamScriptedTurn(res, model, turn)
-            } else {
-              nonStreamingScriptedTurn(res, model, turn)
-            }
-            return
-          }

          if (stream) {
-            const holdThisStream = Boolean(
-              options.holdFirstStreamForPrompt && typeof lastUserMessage?.content === 'string' &&
-                lastUserMessage.content.includes(options.holdFirstStreamForPrompt),
-            )
-            streamTextResponse(res, model, MOCK_REPLY, holdThisStream || holdThisCompletion ? () => {
-              if (holdThisCompletion) {
-                heldCompletionCount++
+            res.writeHead(200, {
+              'Content-Type': 'text/event-stream',
+              'Cache-Control': 'no-cache',
+              Connection: 'keep-alive',
+            })
+
+            // Send the content in a few chunks to simulate streaming.
+            const words = CANNED_REPLY.split(' ')
+            let i = 0
+
+            const sendChunk = () => {
+              if (i >= words.length) {
+                // Final chunk with finish_reason
+                res.write(
+                  `data: ${JSON.stringify({
+                    id: 'mock-completion',
+                    object: 'chat.completion.chunk',
+                    created: 0,
+                    model,
+                    choices: [
+                      {
+                        index: 0,
+                        delta: {},
+                        finish_reason: 'stop',
+                      },
+                    ],
+                  })}\n\n`,
+                )
+                res.write('data: [DONE]\n\n')
+                res.end()
+                return
              }
-              resolveHeldStreamStarted?.()
-              return heldStreamReleased
-            } : undefined)
-          } else {
-            if (holdThisCompletion) {
-              heldCompletionCount++
-              resolveHeldStreamStarted?.()
-              void heldStreamReleased.then(() => nonStreamingTextResponse(res, model, MOCK_REPLY))
-            } else {
-              nonStreamingTextResponse(res, model, MOCK_REPLY)
+
+              const word = i === 0 ? words[i] : ' ' + words[i]
+              res.write(
+                `data: ${JSON.stringify({
+                  id: 'mock-completion',
+                  object: 'chat.completion.chunk',
+                  created: 0,
+                  model,
+                  choices: [
+                    {
+                      index: 0,
+                      delta: { content: word },
+                      finish_reason: null,
+                    },
+                  ],
+                })}\n\n`,
+              )
+              i++
+              // Small delay between chunks to simulate real streaming.
+              setTimeout(sendChunk, 20)
            }
+
+            sendChunk()
+          } else {
+            // Non-streaming response
+            res.writeHead(200, { 'Content-Type': 'application/json' })
+            res.end(
+              JSON.stringify({
+                id: 'mock-completion',
+                object: 'chat.completion',
+                created: 0,
+                model,
+                choices: [
+                  {
+                    index: 0,
+                    message: { role: 'assistant', content: CANNED_REPLY },
+                    finish_reason: 'stop',
+                  },
+                ],
+                usage: {
+                  prompt_tokens: 10,
+                  completion_tokens: 20,
+                  total_tokens: 30,
+                },
+              }),
+            )
          }
        })

@@ -460,11 +187,6 @@ export function startMockServer(options: MockServerOptions = {}): Promise<MockSe
      resolve({
        port,
        url,
-        receivedPrompts,
-        waitForHeldStream: () => heldStreamStarted,
-        waitForHeldCompletion: () => heldStreamStarted,
-        releaseHeldStream: () => releaseHeldStream?.(),
-        heldCompletionCount: () => heldCompletionCount,
        close: () =>
          new Promise((resolveClose, rejectClose) => {
            server.close((err) => {
@@ -479,238 +201,3 @@ export function startMockServer(options: MockServerOptions = {}): Promise<MockSe
    })
  })
 }
-
-// ─── Response helpers ──────────────────────────────────────────────────
-
-/** SSE chunk shape for a streaming chat completion. */
-function sseChunk(model: string, delta: Record<string, unknown>, finishReason: string | null = null): string {
-  return `data: ${JSON.stringify({
-    id: 'mock-completion',
-    object: 'chat.completion.chunk',
-    created: 0,
-    model,
-    choices: [{ index: 0, delta, finish_reason: finishReason }],
-  })}\n\n`
-}
-
-/**
- * Stream a plain text response (no tool calls) as SSE, finishing with
- * `finish_reason: "stop"`. This is the default canned-reply path.
- */
-function streamTextResponse(
-  res: ServerResponse,
-  model: string,
-  text: string,
-  waitForRelease?: () => Promise<void>,
-): void {
-  res.writeHead(200, {
-    'Content-Type': 'text/event-stream',
-    'Cache-Control': 'no-cache',
-    Connection: 'keep-alive',
-  })
-
-  const words = text.split(' ')
-  let i = 0
-
-  const sendChunk = (): void => {
-    if (i >= words.length) {
-      res.write(sseChunk(model, {}, 'stop'))
-      res.write('data: [DONE]\n\n')
-      res.end()
-      return
-    }
-
-    const word = i === 0 ? words[i] : ' ' + words[i]
-    res.write(sseChunk(model, { content: word }))
-    i++
-    if (waitForRelease && i === 1) {
-      waitForRelease().then(() => setTimeout(sendChunk, 20))
-      return
-    }
-    setTimeout(sendChunk, 20)
-  }
-
-  sendChunk()
-}
-
-/** Non-streaming plain text response. */
-function nonStreamingTextResponse(res: ServerResponse, model: string, text: string): void {
-  res.writeHead(200, { 'Content-Type': 'application/json' })
-  res.end(
-    JSON.stringify({
-      id: 'mock-completion',
-      object: 'chat.completion',
-      created: 0,
-      model,
-      choices: [
-        {
-          index: 0,
-          message: { role: 'assistant', content: text },
-          finish_reason: 'stop',
-        },
-      ],
-      usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
-    }),
-  )
-}
-
-/**
- * Stream a single scripted turn: first the text content (word by word),
- * then a chunk carrying the tool_calls (if any), with the appropriate
- * finish_reason.
- *
- * If the turn has no text and no tool calls, it's an empty final response.
- * If it has text but no tool calls, it's a final answer (finish_reason: stop).
- * If it has tool calls (with or without text), finish_reason is "tool_calls".
- */
-function streamScriptedTurn(
-  res: ServerResponse,
-  model: string,
-  turn: ScriptedTurn,
-): void {
-  res.writeHead(200, {
-    'Content-Type': 'text/event-stream',
-    'Cache-Control': 'no-cache',
-    Connection: 'keep-alive',
-  })
-
-  const hasToolCalls = turn.toolCalls && turn.toolCalls.length > 0
-  const finishReason = hasToolCalls ? 'tool_calls' : 'stop'
-
-  // If there's no text to stream, go straight to the tool_calls / finish.
-  if (!turn.text) {
-    if (hasToolCalls) {
-      res.write(
-        sseChunk(model, {
-          tool_calls: turn.toolCalls!.map((tc, idx) => ({
-            index: idx,
-            id: `call_e2e_${_scriptIndex}_${idx}`,
-            type: 'function',
-            function: { name: tc.name, arguments: JSON.stringify(tc.args) },
-          })),
-        }, finishReason),
-      )
-    } else {
-      res.write(sseChunk(model, {}, finishReason))
-    }
-    res.write('data: [DONE]\n\n')
-    res.end()
-    return
-  }
-
-  // Stream the text word by word, then emit tool_calls if present.
-  const words = turn.text.split(' ')
-  let i = 0
-
-  const sendChunk = (): void => {
-    if (i >= words.length) {
-      // All text streamed — emit tool_calls if present, then finish.
-      if (hasToolCalls) {
-        res.write(
-          sseChunk(model, {
-            tool_calls: turn.toolCalls!.map((tc, idx) => ({
-              index: idx,
-              id: `call_e2e_${_scriptIndex}_${idx}`,
-              type: 'function',
-              function: { name: tc.name, arguments: JSON.stringify(tc.args) },
-            })),
-          }, finishReason),
-        )
-      } else {
-        res.write(sseChunk(model, {}, finishReason))
-      }
-      res.write('data: [DONE]\n\n')
-      res.end()
-      return
-    }
-
-    const word = i === 0 ? words[i] : ' ' + words[i]
-    res.write(sseChunk(model, { content: word }))
-    i++
-    setTimeout(sendChunk, 20)
-  }
-
-  sendChunk()
-}
-
-/** Non-streaming version of a scripted turn. */
-function nonStreamingScriptedTurn(
-  res: ServerResponse,
-  model: string,
-  turn: ScriptedTurn,
-): void {
-  const hasToolCalls = turn.toolCalls && turn.toolCalls.length > 0
-  const finishReason = hasToolCalls ? 'tool_calls' : 'stop'
-
-  const message: Record<string, unknown> = { role: 'assistant' }
-  if (turn.text) {
-    message.content = turn.text
-  }
-  if (hasToolCalls) {
-    message.tool_calls = turn.toolCalls!.map((tc, idx) => ({
-      id: `call_e2e_${_scriptIndex}_${idx}`,
-      type: 'function',
-      function: { name: tc.name, arguments: JSON.stringify(tc.args) },
-    }))
-  }
-
-  res.writeHead(200, { 'Content-Type': 'application/json' })
-  res.end(
-    JSON.stringify({
-      id: 'mock-completion',
-      object: 'chat.completion',
-      created: 0,
-      model,
-      choices: [{ index: 0, message, finish_reason: finishReason }],
-      usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
-    }),
-  )
-}
-
-/**
- * Restart the mock server's script index so each test starts from turn 0.
- * Call this between tests that use the interim trigger.
- */
-export function restartMockServer(): void {
-  resetScriptIndex()
-}
-
-/**
- * The interim script's text constants, exported for test assertions.
- * Each entry is the visible text of one turn. Turns with empty text
- * produce no interim message and are excluded from this list.
- */
-export const INTERIM_TEXTS = {
-  /** All interim texts that should appear as sealed messages when the flag is ON. */
-  interims: INTERIM_SCRIPT
-    .filter((t) => t.text && t.toolCalls)
-    .map((t) => t.text),
-  /** The final answer text. */
-  finalText: INTERIM_SCRIPT[INTERIM_SCRIPT.length - 1].text,
-  /** Text that should NOT produce an interim (empty-text tool turn). */
-  silentTurnIndex: INTERIM_SCRIPT.findIndex((t) => !t.text && t.toolCalls),
-} as const
-
-/** The sidebar-states script's text constants, exported for test assertions. */
-export const SIDEBAR_TEXTS = {
-  /** The interim text from turn 1 (alongside tool calls). */
-  interimText: SIDEBAR_SCRIPT[0].text,
-  /** The final answer text. */
-  finalText: SIDEBAR_SCRIPT[SIDEBAR_SCRIPT.length - 1].text,
-  /** The background process command (for asserting process.list entries). */
-  bgCommand: 'echo "background process output" && sleep 1 && echo "done"',
-  /** The subagent's goal (for asserting subagent panel state). */
-  subagentGoal: 'Summarize the test results',
-} as const
-
-/** The cross-session sidebar script's text constants. */
-export const SIDEBAR_CROSS_TEXTS = {
-  /** The interim text from turn 1. */
-  interimText: SIDEBAR_CROSS_SCRIPT[0].text,
-  /** The final answer text. */
-  finalText: SIDEBAR_CROSS_SCRIPT[SIDEBAR_CROSS_SCRIPT.length - 1].text,
-  /** The longer background process command (sleep 5). */
-  bgCommand: 'echo "long bg output" && sleep 5 && echo "finished"',
-  /** The subagent's goal. */
-  subagentGoal: 'Analyze cross-session state',
-} as const
@@ -1,118 +0,0 @@
-/**
- * A queued prompt must remain local until the current inference turn settles.
- *
- * Hold the first streamed reply open after its first token. This gives the
- * composer a live, busy turn while the user queues a follow-up, then lets us
- * assert against the mock provider's real request log before and after the
- * held turn completes.
- */
-
-import { expect, test, type Page } from './test'
-
-import { type MockBackendFixture, setupMockBackend, waitForAppReady } from './fixtures'
-import { MOCK_REPLY } from './mock-server'
-
-const ACTIVE_PROMPT = 'E2E_QUEUE_TURN_BOUNDARY_ACTIVE'
-const QUEUED_PROMPT = 'E2E_QUEUE_TURN_BOUNDARY_QUEUED'
-const STEER_PROMPT = 'E2E_STEER_TURN_BOUNDARY_CORRECTION'
-
-async function send(page: Page, text: string): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.waitFor({ state: 'visible', timeout: 15_000 })
-  await composer.click()
-  await composer.type(text, { delay: 5 })
-  await page.keyboard.press('Enter')
-}
-
-async function steer(page: Page, text: string): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  const primary = page.locator('[data-slot="composer-root"] button[type="submit"]')
-
-  await composer.click()
-  await composer.type(text, { delay: 5 })
-  await expect(primary).toHaveAttribute('aria-label', /Steer/)
-  await primary.click()
-}
-
-async function transcriptMessageOrder(page: Page): Promise<string[]> {
-  return page.evaluate(() => {
-    const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-    if (!viewport) return []
-
-    return Array.from(viewport.querySelectorAll<HTMLElement>('[data-role="user"], [data-role="assistant"]'))
-      .map(message => message.textContent?.trim() ?? '')
-      .filter(Boolean)
-  })
-}
-
-function steerTurnOrder(messages: string[]): string[] {
-  return messages.flatMap(message => {
-    if (message.includes(ACTIVE_PROMPT)) return [ACTIVE_PROMPT]
-    if (message.includes(STEER_PROMPT)) return [STEER_PROMPT]
-    if (message.includes(MOCK_REPLY)) return [MOCK_REPLY]
-
-    return []
-  })
-}
-
-test.describe('queued prompt turn boundary', () => {
-  let fixture: MockBackendFixture | null = null
-
-  test.beforeEach(async () => {
-    fixture = await setupMockBackend({
-      mockServer: { holdFirstStreamForPrompt: ACTIVE_PROMPT }
-    })
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterEach(async () => {
-    await fixture?.cleanup()
-    fixture = null
-  })
-
-  test('submits a queued prompt only after the active turn completes', async () => {
-    const { mock, page } = fixture!
-    const composer = page.locator('[contenteditable="true"]').first()
-    const queue = page.locator('[data-slot="composer-root"] button[aria-label="Queue message"]')
-
-    await send(page, ACTIVE_PROMPT)
-    await mock.waitForHeldStream()
-
-    await composer.click()
-    await composer.type(QUEUED_PROMPT, { delay: 5 })
-    await queue.click()
-    await expect(page.getByText('1 Queued')).toBeVisible()
-
-    // The mock keeps the active SSE stream open, so a queued prompt has no
-    // completed-turn boundary that could legitimately drain it. Wait past the
-    // queue retry interval and assert the provider saw only the active turn.
-    await page.waitForTimeout(1_000)
-    expect(mock.receivedPrompts.filter(prompt => prompt === QUEUED_PROMPT)).toHaveLength(0)
-    await expect(page.locator('[data-slot="aui_thread-viewport"]')).not.toContainText(QUEUED_PROMPT)
-
-    mock.releaseHeldStream()
-    await page.waitForFunction(
-      expected => (document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(expected),
-      MOCK_REPLY,
-      { timeout: 60_000 }
-    )
-    await expect.poll(() => mock.receivedPrompts.filter(prompt => prompt === QUEUED_PROMPT)).toHaveLength(1)
-  })
-
-  test('places a steer prompt before the reply it redirects', async () => {
-    const { mock, page } = fixture!
-
-    await send(page, ACTIVE_PROMPT)
-    await mock.waitForHeldStream()
-    await steer(page, STEER_PROMPT)
-    mock.releaseHeldStream()
-
-    await page.waitForFunction(
-      expected => (document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(expected),
-      MOCK_REPLY,
-      { timeout: 60_000 }
-    )
-
-    expect(steerTurnOrder(await transcriptMessageOrder(page))).toEqual([ACTIVE_PROMPT, STEER_PROMPT, MOCK_REPLY])
-  })
-})
@@ -1,52 +0,0 @@
-#!/usr/bin/env python3
-"""Seed a deterministic, tool-free large session into an isolated state.db."""
-
-import sys
-from pathlib import Path
-
-repo_root = Path(__file__).resolve().parents[3]
-sys.path.insert(0, str(repo_root))
-
-from hermes_state import SessionDB  # noqa: E402
-
-SESSION_ID = "e2e-large-session"
-SESSION_TITLE = "E2E large persisted session"
-
-
-def main() -> None:
-    if len(sys.argv) != 2:
-        raise SystemExit(f"usage: {sys.argv[0]} <state.db>")
-
-    messages = []
-    for index in range(53):
-        role = "user" if index % 2 == 0 else "assistant"
-        content = (
-            f"E2E persisted user message {index}: audit the compatibility matrix"
-            if role == "user"
-            else f"E2E persisted assistant reply {index}: recorded the audit result"
-        )
-        messages.append({"role": role, "content": content, "timestamp": 1_700_000_000 + index})
-
-    database = SessionDB(db_path=Path(sys.argv[1]))
-    result = database.import_sessions(
-        [
-            {
-                "id": SESSION_ID,
-                "source": "desktop",
-                "model": "mock-model",
-                "started_at": 1_700_000_000,
-                "title": SESSION_TITLE,
-                "cwd": str(repo_root),
-                "system_prompt": "",
-                "messages": messages,
-            }
-        ]
-    )
-    database.close()
-
-    if not result.get("ok") or result.get("imported") != 1:
-        raise SystemExit(f"failed to seed large session: {result}")
-
-
-if __name__ == "__main__":
-    main()
@@ -1,146 +0,0 @@
-/**
- * E2E coverage for session compression, which rotates a live backend session.
- */
-
-import { expect, test, type Page } from '@playwright/test'
-
-import {
-  type MockBackendFixture,
-  setupMockBackend,
-  waitForAppReady,
-} from './fixtures'
-import { MOCK_REPLY, receivedUserTexts, restartMockServer } from './mock-server'
-
-async function send(page: Page, text: string, delay = 15): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.click()
-  await composer.type(text, { delay })
-  await page.keyboard.press('Enter')
-}
-
-async function pasteAndSend(page: Page, text: string): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.click()
-  await page.keyboard.insertText(text)
-  await page.keyboard.press('Enter')
-}
-
-
-async function waitForTranscript(page: Page, text: string, timeout = 90_000): Promise<void> {
-  await page.waitForFunction(
-    expected => document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent?.includes(expected) ?? false,
-    text,
-    { timeout },
-  )
-}
-
-test.describe('session compression', () => {
-  test.describe.configure({ mode: 'serial' })
-
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    restartMockServer()
-    fixture = await setupMockBackend()
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('compresses an existing session and accepts a follow-up turn on its continuation', async () => {
-    const { page } = fixture
-    const reply = 'Hello from the mock inference server! The full boot chain is working.'
-
-    // Three completed exchanges leave a compressible middle after the
-    // compressor's protected head/tail boundaries.
-    await send(page, 'E2E_COMPRESSION_FIRST')
-    await waitForTranscript(page, reply)
-    await send(page, 'E2E_COMPRESSION_SECOND')
-    await expect.poll(() => receivedUserTexts().filter(text => text === 'E2E_COMPRESSION_SECOND').length).toBe(1)
-    await send(page, 'E2E_COMPRESSION_THIRD')
-    await expect.poll(() => receivedUserTexts().filter(text => text === 'E2E_COMPRESSION_THIRD').length).toBe(1)
-
-    // Commit the command before typing its argument. This waits for the async
-    // completion request on cold CI workers, then uses the composer's own
-    // keyboard accept path to replace the `/compress` trigger with a command
-    // chip. Clicking a later completion after typing the argument can insert a
-    // second command token (for example `//compress ...`) as plain text.
-    const composer = page.locator('[contenteditable="true"]').first()
-    await composer.click()
-    await composer.type('/compress', { delay: 15 })
-    await page.getByText('/compress').first().waitFor({ state: 'visible' })
-    await page.keyboard.press('Enter')
-    await composer.type(' preserve the three test turns', { delay: 15 })
-    await page.keyboard.press('Enter')
-    await expect
-      .poll(
-        () => page.locator('[data-slot="aui_thread-viewport"]').textContent(),
-        { timeout: 90_000 },
-      )
-      .toMatch(/Compressed|No changes from compression/)
-
-    // Compression rotates the agent's live session id. A post-compression
-    // ordinary turn proves the desktop's runtime binding followed that child.
-    await send(page, 'E2E_COMPRESSION_FOLLOW_UP')
-    await expect.poll(() => receivedUserTexts().filter(text => text === 'E2E_COMPRESSION_FOLLOW_UP').length).toBe(1)
-    await waitForTranscript(page, reply)
-    await page.screenshot({ path: 'test-results/session-compression-continuation.png' })
-  })
-})
-
-test.describe('session compression in progress', () => {
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    fixture = await setupMockBackend({
-      modelContextLength: 64_000,
-      extraConfig: `compression:
-  threshold_tokens: 22000
-  protect_first_n: 0
-  protect_last_n: 1
-auxiliary:
-  compression:
-    provider: custom
-    model: mock-model`,
-      mockServer: {
-        holdFirstCompletionContaining: 'You are a summarization agent creating a context checkpoint.',
-      }
-    })
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('queues an Enter-submitted draft instead of steering while compaction is active', async ({}, testInfo) => {
-    const { page } = fixture
-    const queued = 'E2E_QUEUED_DURING_COMPACTION'
-
-    // A normal message crosses the tiny configured context budget. The mock
-    // blocks only the resulting summary request, so these assertions run
-    // during automatic compaction rather than a slash-command path.
-    await pasteAndSend(page, 'E2E_COMPACTION_HISTORY_ONE '.repeat(5))
-    await waitForTranscript(page, MOCK_REPLY)
-    await pasteAndSend(page, 'E2E_COMPACTION_HISTORY_TWO '.repeat(5))
-    await waitForTranscript(page, MOCK_REPLY)
-    await pasteAndSend(page, 'E2E_TRIGGER_AUTOMATIC_COMPACTION '.repeat(500))
-    await fixture.mock.waitForHeldCompletion()
-    await expect(page.getByRole('status', { name: 'Summarizing thread' }).last()).toBeVisible()
-
-    const primary = page.locator('[data-slot="composer-root"] button[type="submit"]')
-    await expect(primary).toHaveAttribute('aria-label', 'Queue message')
-
-    await send(page, queued)
-    await expect(page.getByText('1 Queued')).toBeVisible()
-    expect(fixture.mock.heldCompletionCount()).toBe(1)
-    expect(receivedUserTexts()).not.toContain(queued)
-    await page.screenshot({ path: testInfo.outputPath('queued-during-compaction.png') })
-
-    fixture.mock.releaseHeldStream()
-    await expect.poll(() => receivedUserTexts().filter(text => text === queued).length).toBe(1)
-    expect(fixture.mock.heldCompletionCount()).toBe(1)
-  })
-})
@@ -1,252 +0,0 @@
-/**
- * E2E tests for desktop sidebar states — background processes, subagents,
- * and session dot transitions.
- *
- * The mock server returns scripted tool_calls that the agent executes for
- * real (trivial commands + real subagent delegations). The tests assert the
- * sidebar states driven by real gateway events.
- *
- * Prerequisite: `npm run build` must have been run so dist/ exists.
- */
-
-import { expect, test, type Page } from '@playwright/test'
-
-import {
-  type MockBackendFixture,
-  setupMockBackend,
-  waitForAppReady,
-} from './fixtures'
-import { SIDEBAR_CROSS_TEXTS, SIDEBAR_TEXTS, restartMockServer } from './mock-server'
-
-/** Background-running dot aria-label (from i18n en.ts). */
-const BG_DOT_LABEL = 'Background task running'
-/** Finished-unread dot aria-label. */
-const UNREAD_DOT_LABEL = 'Finished — unread'
-
-/** Send a message and wait for the final response to appear. */
-async function sendMessageAndWait(
-  page: Page,
-  trigger: string,
-  finalText: string,
-  timeout = 90_000,
-): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.waitFor({ state: 'visible', timeout: 10_000 })
-  await composer.click()
-  await composer.type(trigger, { delay: 20 })
-  await page.keyboard.press('Enter')
-
-  await page.waitForFunction(
-    () => (document.body.textContent ?? '').includes('E2E_'),
-    undefined,
-    { timeout: 15_000 },
-  )
-
-  await page.waitForFunction(
-    (text) => (document.body.textContent ?? '').includes(text),
-    finalText,
-    { timeout },
-  )
-}
-
-// ────────────────────────────────────────────────────────────────────────
-// Test 1: background process + subagent appear in sidebar during turn
-// ────────────────────────────────────────────────────────────────────────
-
-test.describe('sidebar states — background process and subagent', () => {
-  test.describe.configure({ mode: 'serial' })
-
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    restartMockServer()
-    fixture = await setupMockBackend()
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('background process dot appears and disappears, subagent runs, final answer visible', async () => {
-    const page = fixture.page
-
-    await sendMessageAndWait(page, 'E2E_SIDEBAR_TRIGGER', SIDEBAR_TEXTS.finalText)
-
-    // The background process (sleep 1) should have shown a "Background task
-    // running" dot at some point during the turn. We try to catch it; if
-    // the process was too fast, that's OK — the real assertion is that the
-    // final answer appeared and the dot is gone afterward.
-    try {
-      await expect
-        .poll(
-          () => page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count(),
-          { timeout: 15_000, message: 'background dot should appear' },
-        )
-        .toBeGreaterThan(0)
-    } catch {
-      // sleep 1 may have finished before we polled — not a failure.
-    }
-
-    // After the turn completes and auto-dismiss fires, the background dot
-    // should be gone.
-    await page.waitForTimeout(8000)
-    const bgCount = await page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count()
-    expect(bgCount, 'background dot should be gone after auto-dismiss').toBe(0)
-
-    // Evidence: capture the final state — no background dot, final answer visible.
-    await page.screenshot({ path: 'test-results/bg-dot-gone-after-dismiss.png' })
-
-    // The final answer text must be in the transcript.
-    const viewportText = await page
-      .locator('[data-slot="aui_thread-viewport"]')
-      .textContent()
-    expect(viewportText).toContain(SIDEBAR_TEXTS.finalText)
-  })
-})
-
-// ────────────────────────────────────────────────────────────────────────
-// Test 2: subagent running shows background dot too (longer bg process)
-// ────────────────────────────────────────────────────────────────────────
-
-test.describe('sidebar states — subagent and background dot coexist', () => {
-  test.describe.configure({ mode: 'serial' })
-
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    restartMockServer()
-    fixture = await setupMockBackend()
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('background dot visible while subagent runs', async () => {
-    const page = fixture.page
-
-    // Start the turn but DON'T wait for the final answer yet — we want
-    // to assert the background dot is visible WHILE the subagent runs.
-    const composer = page.locator('[contenteditable="true"]').first()
-    await composer.waitFor({ state: 'visible', timeout: 10_000 })
-    await composer.click()
-    await composer.type('E2E_SIDEBAR_CROSS', { delay: 20 })
-    await page.keyboard.press('Enter')
-
-    // Wait for the user's message to appear.
-    await page.waitForFunction(
-      () => (document.body.textContent ?? '').includes('E2E_SIDEBAR_CROSS'),
-      undefined,
-      { timeout: 15_000 },
-    )
-
-    // The background process (sleep 5) should show a "Background task
-    // running" dot while the subagent is also running.
-    await expect
-      .poll(
-        () => page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count(),
-        { timeout: 30_000, message: 'background dot should appear while subagent runs' },
-      )
-      .toBeGreaterThan(0)
-
-    // Evidence: the background dot is visible while the subagent runs.
-    await page.screenshot({ path: 'test-results/bg-dot-while-subagent-runs.png' })
-
-    // Now wait for the final answer to appear.
-    await page.waitForFunction(
-      (text) => (document.body.textContent ?? '').includes(text),
-      SIDEBAR_CROSS_TEXTS.finalText,
-      { timeout: 90_000 },
-    )
-
-    // After the turn + auto-dismiss, the background dot should be gone.
-    await page.waitForTimeout(8000)
-    const bgCount = await page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count()
-    expect(bgCount, 'background dot should be gone after process exits').toBe(0)
-  })
-})
-
-// ────────────────────────────────────────────────────────────────────────
-// Test 3: cross-session — dot updates when viewing a different session
-// ────────────────────────────────────────────────────────────────────────
-
-test.describe('sidebar states — cross-session dot transition', () => {
-  test.describe.configure({ mode: 'serial' })
-
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    restartMockServer()
-    fixture = await setupMockBackend()
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('background dot transitions to finished when viewing another session', async () => {
-    const page = fixture.page
-
-    // Start a turn with a long background process (sleep 5).
-    const composer = page.locator('[contenteditable="true"]').first()
-    await composer.waitFor({ state: 'visible', timeout: 10_000 })
-    await composer.click()
-    await composer.type('E2E_SIDEBAR_CROSS', { delay: 20 })
-    await page.keyboard.press('Enter')
-
-    // Wait for the background dot to appear.
-    await expect
-      .poll(
-        () => page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count(),
-        { timeout: 30_000, message: 'background dot should appear' },
-      )
-      .toBeGreaterThan(0)
-
-    // Wait for the final answer (turn completes, but bg process still running).
-    await page.waitForFunction(
-      (text) => (document.body.textContent ?? '').includes(text),
-      SIDEBAR_CROSS_TEXTS.finalText,
-      { timeout: 90_000 },
-    )
-
-    // The background dot should still be visible (sleep 5 hasn't finished yet,
-    // or auto-dismiss hasn't fired).
-    const bgDuringTurn = await page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count()
-    expect(bgDuringTurn, 'background dot should still be visible after turn completes').toBeGreaterThan(0)
-
-    // Evidence: bg dot visible on session A while its turn is done but the
-    // background process hasn't exited yet.
-    await page.screenshot({ path: 'test-results/cross-session-bg-dot-before-switch.png' })
-
-    // Create a new session (click "New session" button).
-    await page.locator('button:has-text("New session")').first().click()
-    await page.waitForTimeout(2000)
-
-    // Now wait for the background process to finish (sleep 5 + auto-dismiss).
-    // The session A dot should transition away from "background running".
-    await expect
-      .poll(
-        () => page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count(),
-        { timeout: 30_000, message: 'background dot should disappear after process finishes' },
-      )
-      .toBe(0)
-
-    // The original session should show a "finished unread" indicator (green dot)
-    // since its turn completed while we were in a different session. This is an
-    // event-driven transition, so wait for it instead of sampling the DOM right
-    // after the running dot disappears.
-    await expect
-      .poll(
-        () => page.locator(`[aria-label="${UNREAD_DOT_LABEL}"]`).count(),
-        { timeout: 30_000, message: 'original session should show finished-unread dot' },
-      )
-      .toBeGreaterThan(0)
-
-    // Evidence: the green "finished unread" dot on the original session after
-    // switching to a new session — the cross-session dot transition.
-    await page.screenshot({ path: 'test-results/cross-session-unread-dot-after-switch.png' })
-  })
-})
@@ -1,75 +0,0 @@
-/**
- * Regression coverage for #69578: harmless route-token churn during a send
- * must not make the desktop silently drop the prompt before prompt.submit.
- */
-
-import { test, expect } from './test'
-
-import {
-  type MockBackendFixture,
-  setupMockBackend,
-  waitForAppReady,
-} from './fixtures'
-
-const PROMPT = 'E2E route token drift must still submit this prompt.'
-
-let fixture: MockBackendFixture | null = null
-
-test.beforeAll(async () => {
-  fixture = await setupMockBackend()
-  await waitForAppReady(fixture!, 120_000)
-})
-
-test.afterAll(async () => {
-  await fixture?.cleanup()
-  fixture = null
-})
-
-test('submits while same-chat search tokens churn during new-session creation', async ({}, testInfo) => {
-  const { page, mock } = fixture!
-  const composer = page.locator('[contenteditable="true"]').first()
-
-  await composer.click()
-  await composer.type(PROMPT, { delay: 10 })
-
-  // The submit pipeline snapshots the route synchronously, then awaits session
-  // creation. Keep changing only the query string of whichever chat route is
-  // current. Before #69578, comparing the raw route token treated this as a
-  // user chat switch and aborted before prompt.submit.
-  await page.evaluate(() => {
-    let revision = 0
-    const interval = window.setInterval(() => {
-      const pathname = window.location.hash.slice(1).split(/[?#]/, 1)[0] || '/new'
-      window.location.hash = `${pathname}?e2e-route-churn=${revision++}`
-    }, 1)
-
-    ;(window as typeof window & { __e2eStopRouteChurn?: () => void }).__e2eStopRouteChurn = () => {
-      window.clearInterval(interval)
-    }
-  })
-
-  try {
-    await page.keyboard.press('Enter')
-
-    await expect
-      .poll(() => mock.receivedPrompts.includes(PROMPT), { timeout: 60_000 })
-      .toBe(true)
-
-    await page.waitForFunction(
-      prompt => document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent?.includes(prompt) ?? false,
-      PROMPT,
-      { timeout: 15_000 },
-    )
-    await page.waitForFunction(
-      () => document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent?.includes('mock inference server') ?? false,
-      undefined,
-      { timeout: 60_000 },
-    )
-  } finally {
-    await page.evaluate(() => {
-      ;(window as typeof window & { __e2eStopRouteChurn?: () => void }).__e2eStopRouteChurn?.()
-    })
-  }
-
-  await page.screenshot({ path: testInfo.outputPath('same-chat-route-churn-submitted.png') })
-})
@@ -1,210 +0,0 @@
-/**
- * E2E tests for the tile-unread bug — two scenarios:
- *
- * 1. TAB (stacked, not visible) — a session opened as a tab via ⌃-click is
- *    NOT visible on screen. When it finishes, the green "unread" dot IS
- *    correct — the user isn't looking at it. This test PASSES.
- *
- * 2. SPLIT (side-by-side, visible) — a session dragged to the edge of the
- *    workspace zone opens as a split tile, visible on screen at the same time
- *    as the main session. When it finishes, it should NOT get the green
- *    "unread" dot — the user is looking right at it. This test FAILS until
- *    the fix in session-states.ts:174 lands (the unread check only compares
- *    against $selectedStoredSessionId and ignores $sessionTiles).
- *
- * Prerequisite: `npm run build` must have been run so dist/ exists.
- */
-
-import { expect, test } from '@playwright/test'
-
-import {
-  type MockBackendFixture,
-  setupMockBackend,
-  waitForAppReady,
-} from './fixtures'
-import { SIDEBAR_CROSS_TEXTS, restartMockServer } from './mock-server'
-
-/** Finished-unread dot aria-label. */
-const UNREAD_DOT_LABEL = 'Finished — unread'
-/** Background-running dot aria-label. */
-const BG_DOT_LABEL = 'Background task running'
-
-/** Locate a session's sidebar row by its preview text. */
-function sessionRow(page: import('@playwright/test').Page, text: string) {
-  return page.locator('[data-slot="sidebar"] button').filter({ hasText: text }).first()
-}
-
-/** Common setup: start a turn with a sleep 5 bg process + subagent, wait for
- *  the turn to complete, then switch to a new session so the first session is
- *  no longer $selectedStoredSessionId (required before opening a tile). */
-async function startTurnAndSwitchAway(page: import('@playwright/test').Page) {
-  // Send E2E_SIDEBAR_CROSS — starts a turn with sleep 5 + subagent.
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.waitFor({ state: 'visible', timeout: 10_000 })
-  await composer.click()
-  await composer.type('E2E_SIDEBAR_CROSS', { delay: 20 })
-  await page.keyboard.press('Enter')
-
-  // Wait for the user's message to appear.
-  await page.waitForFunction(
-    () => (document.body.textContent ?? '').includes('E2E_SIDEBAR_CROSS'),
-    undefined,
-    { timeout: 15_000 },
-  )
-
-  // Wait for the background dot — confirms the turn is running.
-  await expect
-    .poll(
-      () => page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count(),
-      { timeout: 30_000, message: 'background dot should appear' },
-    )
-    .toBeGreaterThan(0)
-
-  // Wait for the turn to complete (final answer visible).
-  await page.waitForFunction(
-    (text) => (document.body.textContent ?? '').includes(text),
-    SIDEBAR_CROSS_TEXTS.finalText,
-    { timeout: 90_000 },
-  )
-
-  // The background dot should still be visible (sleep 5 hasn't finished).
-  const bgDuringTurn = await page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count()
-  expect(bgDuringTurn, 'background dot should still be visible after turn completes').toBeGreaterThan(0)
-
-  // Switch to a new session — session A is no longer $selectedStoredSessionId.
-  // This is required: openSessionTile bails if the session is already selected.
-  await page.locator('button:has-text("New session")').first().click()
-  await page.waitForTimeout(2000)
-}
-
-/** Wait for the background process to finish (sleep 5 + auto-dismiss). */
-async function waitForBgProcessToFinish(page: import('@playwright/test').Page) {
-  await expect
-    .poll(
-      () => page.locator(`[aria-label="${BG_DOT_LABEL}"]`).count(),
-      { timeout: 30_000, message: 'background dot should disappear after process finishes' },
-    )
-    .toBe(0)
-}
-
-// ────────────────────────────────────────────────────────────────────────
-// Test 1: TAB (not visible) — unread dot IS correct (PASSES)
-// ────────────────────────────────────────────────────────────────────────
-
-test.describe('sidebar states — tab (hidden) unread is correct', () => {
-  test.describe.configure({ mode: 'serial' })
-
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    restartMockServer()
-    fixture = await setupMockBackend()
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('session opened as a tab (not visible) correctly gets unread dot', async () => {
-    const page = fixture.page
-
-    await startTurnAndSwitchAway(page)
-
-    // Evidence: session A is in the background (bg dot in sidebar).
-    await page.screenshot({ path: 'test-results/tile-bug-tab-switched-away.png' })
-
-    // ⌃-click opens the session as a TAB (center dock = stacked, not visible
-    // unless it's the active tab). The session is NOT on screen.
-    const row = sessionRow(page, SIDEBAR_CROSS_TEXTS.finalText)
-    await row.click({ modifiers: ['Control'] })
-    await page.waitForTimeout(2000)
-
-    // Evidence: the tab is open but the session is not visible on screen.
-    await page.screenshot({ path: 'test-results/tile-bug-tab-opened.png' })
-
-    await waitForBgProcessToFinish(page)
-
-    // A tab that's not the active tab IS hidden — the unread dot is correct.
-    // The user is NOT looking at it, so marking it "unread" is right.
-    const unreadCount = await page.locator(`[aria-label="${UNREAD_DOT_LABEL}"]`).count()
-    expect(unreadCount, 'hidden tab should be marked unread').toBeGreaterThan(0)
-
-    await page.screenshot({ path: 'test-results/tile-bug-tab-unread-correct.png' })
-  })
-})
-
-// ────────────────────────────────────────────────────────────────────────
-// Test 2: SPLIT (visible) — unread dot is WRONG (FAILS until fix)
-// ────────────────────────────────────────────────────────────────────────
-
-test.describe.skip('sidebar states — split (visible) unread bug (RED)', () => {
-  test.describe.configure({ mode: 'serial' })
-
-  let fixture: MockBackendFixture
-
-  test.beforeAll(async () => {
-    restartMockServer()
-    fixture = await setupMockBackend()
-    await waitForAppReady(fixture, 120_000)
-  })
-
-  test.afterAll(async () => {
-    await fixture?.cleanup()
-  })
-
-  test('session visible in a split tile does NOT get unread dot when it finishes', async () => {
-    const page = fixture.page
-
-    await startTurnAndSwitchAway(page)
-
-    // Evidence: session A is in the background (bg dot in sidebar).
-    await page.screenshot({ path: 'test-results/tile-bug-split-switched-away.png' })
-
-    // Drag the session row from the sidebar to the right edge of the workspace
-    // zone to create a SPLIT (side-by-side) tile. This triggers the real
-    // startSessionDrag → onCommit → openSessionTile(id, 'right', anchor) path.
-    const row = sessionRow(page, SIDEBAR_CROSS_TEXTS.finalText)
-    const rowBox = await row.boundingBox()
-    expect(rowBox, 'session row must be visible').not.toBeNull()
-
-    // Find the workspace zone — the main chat area. We drop on its right edge.
-    const workspace = page.locator('[data-session-anchor="workspace"]')
-    const wsBox = await workspace.boundingBox()
-    expect(wsBox, 'workspace zone must be visible').not.toBeNull()
-
-    // Drag from the session row to the right edge of the workspace.
-    // The drag-session's subZonePosition resolves a right-edge drop as 'right'
-    // (a split dock), not 'center' (which would be a composer link).
-    await page.mouse.move(rowBox!.x + rowBox!.width / 2, rowBox!.y + rowBox!.height / 2)
-    await page.mouse.down()
-    // Move in steps so the drag-session's pointermove handler tracks the
-    // position and resolves the drop zone (a single jump can miss the
-    // threshold/engage logic).
-    const targetX = wsBox!.x + wsBox!.width - 20
-    const targetY = wsBox!.y + wsBox!.height / 2
-    const steps = 10
-    for (let i = 1; i <= steps; i++) {
-      const x = rowBox!.x + rowBox!.width / 2 + (targetX - (rowBox!.x + rowBox!.width / 2)) * (i / steps)
-      const y = rowBox!.y + rowBox!.height / 2 + (targetY - (rowBox!.y + rowBox!.height / 2)) * (i / steps)
-      await page.mouse.move(x, y)
-      await page.waitForTimeout(30)
-    }
-    await page.mouse.up()
-    await page.waitForTimeout(2000)
-
-    // Evidence: the split tile is now open side-by-side — both sessions visible.
-    await page.screenshot({ path: 'test-results/tile-bug-split-opened.png' })
-
-    await waitForBgProcessToFinish(page)
-
-    // THE BUG: the session visible in the split tile should NOT have the green
-    // "finished unread" dot — the user is looking right at it. This assertion
-    // FAILS until the fix in session-states.ts:174 lands.
-    const unreadCount = await page.locator(`[aria-label="${UNREAD_DOT_LABEL}"]`).count()
-    expect(unreadCount, 'session visible in a split tile should NOT be marked unread').toBe(0)
-
-    // Evidence: the green dot should NOT be here — this screenshot shows the bug.
-    await page.screenshot({ path: 'test-results/tile-bug-split-unread-should-not-exist.png' })
-  })
-})
@@ -1,484 +0,0 @@
-/**
- * E2E regression: warm-route resume must not re-render the transcript more
- * than once.
- *
- * When a session is already in the runtime-id cache (the "warm" path in
- * `resumeSession()`), clicking its sidebar row should paint the transcript
- * exactly once. Before the fix, the warm cache painted via
- * `syncSessionStateToView`, then the `session.activate` RPC returned a
- * reconciled message list with different message object references, causing
- * `syncSessionStateToView` to fire a second `setMessages` — a visual
- * flicker as the transcript DOM was updated.
- *
- * This test pre-seeds a 32-message session into state.db, boots the app,
- * clicks the session (cold resume — populates the warm cache), navigates
- * away to a new chat, then clicks back (warm resume). Two detectors run:
- *
- * 1. A MutationObserver counts additive DOM mutation bursts (childList
- *    additions). More than 1 burst = the transcript was repainted.
- *
- * 2. A 2ms innerHTML-length poll counts "reconciles" — DOM content changes
- *    that happen AFTER the initial paint, while messages are already on
- *    screen. This catches the case where React reconciles by key without
- *    adding/removing nodes (same keys → in-place prop update → no
- *    MutationObserver burst), but `$messages` was still set twice.
- *
- * The test passes when bursts === 1 AND reconciles === 0.
- *
- * Prerequisite: `npm run build` must have been run so dist/ exists.
- */
-
-import { spawnSync } from 'node:child_process'
-import * as fs from 'node:fs'
-import * as os from 'node:os'
-import * as path from 'node:path'
-
-import { expect, test } from './test'
-
-import {
-  type MockBackendFixture,
-  waitForAppReady,
-  createSandbox,
-  writeMockProviderConfig,
-  writeEnvFile,
-  buildAppEnv,
-  launchDesktop,
-} from './fixtures'
-import { startMockServer } from './mock-server'
-
-const DESKTOP_ROOT = path.resolve(import.meta.dirname, '..')
-const REPO_ROOT = path.resolve(DESKTOP_ROOT, '..', '..')
-const SEED_SCRIPT = path.join(DESKTOP_ROOT, 'e2e', 'scripts', 'seed_session_db.py')
-const SESSION_TITLE = 'E2E Warm Resume Jitter Test'
-const SESSION_ID = 'e2e-warm-resume-session'
-/** 32 messages (16 user/assistant pairs) — enough DOM churn for detection. */
-const MESSAGE_COUNT = 32
-/** Seeded PRNG so the generated content is deterministic across runs. */
-const RNG_SEED = 42
-
-/** Mulberry32 — tiny deterministic PRNG. */
-function mulberry32(seed: number): () => number {
-  let a = seed
-  return () => {
-    a |= 0
-    a = (a + 0x6d2b79f5) | 0
-    let t = Math.imul(a ^ (a >>> 15), 1 | a)
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
-  }
-}
-
-/** Generate ~40 chars of gibberish from a seeded PRNG. */
-function gibberish(rng: () => number): string {
-  const len = 30 + Math.floor(rng() * 20)
-  let s = ''
-  for (let i = 0; i < len; i++) {
-    s += String.fromCharCode(97 + Math.floor(rng() * 26))
-  }
-  return s
-}
-
-/** First user message — used as a wait target in the test. */
-const FIRST_USER_MSG = gibberish(mulberry32(RNG_SEED))
-
-/**
- * Generate a session fixture with MESSAGE_COUNT messages (user/assistant
- * pairs) of seeded gibberish — just role + content, enough for SessionDB
- * to import and the transcript to render. Written to a temp file for the
- * seed script.
- */
-function generateSessionFixture(fixturePath: string): void {
-  const rng = mulberry32(RNG_SEED)
-  const messages: Array<{ role: string; content: string }> = []
-
-  for (let i = 0; i < MESSAGE_COUNT / 2; i++) {
-    messages.push({ role: 'user', content: gibberish(rng) })
-    messages.push({ role: 'assistant', content: gibberish(rng) })
-  }
-
-  const session = {
-    id: SESSION_ID,
-    source: 'cli',
-    model: 'mock-model',
-    system_prompt: '',
-    started_at: 1721692800.0,
-    message_count: MESSAGE_COUNT,
-    title: SESSION_TITLE,
-    cwd: '/tmp',
-    archived: 0,
-    rewind_count: 0,
-    compression_fallback_streak: 0,
-    messages,
-  }
-
-  fs.writeFileSync(fixturePath, JSON.stringify(session), 'utf8')
-}
-
-/** Resolve the python binary from the nix devshell (falls back to python3). */
-function findPython(): string {
-  const result = spawnSync('which', ['python'], { encoding: 'utf8' })
-  if (result.status === 0 && result.stdout.trim()) {
-    return result.stdout.trim()
-  }
-  return 'python3'
-}
-
-/**
- * Set up a mock-backend sandbox with a pre-seeded session in state.db.
- *
- * Unlike the shared `setupMockBackend()`, this variant seeds the DB
- * BEFORE launching the app so the session appears in the sidebar on first
- * load — exercising the real `resumeSession()` cold path without needing
- * to send a message first.
- */
-async function setupSeededMockBackend(): Promise<MockBackendFixture> {
-  // 1. Start mock server
-  const mock = await startMockServer()
-
-  // 2. Create sandbox + write config
-  const sandbox = createSandbox('warm-seed')
-  writeMockProviderConfig(sandbox.hermesHome, mock.url)
-  writeEnvFile(sandbox.hermesHome)
-
-  // 3. Pre-seed state.db: generate a fixture JSON to a temp file, then
-  //    run the seed script to import it into state.db BEFORE launching.
-  const stateDbPath = path.join(sandbox.hermesHome, 'state.db')
-  const fixturePath = path.join(os.tmpdir(), `hermes-e2e-warm-resume-${Date.now()}.json`)
-  generateSessionFixture(fixturePath)
-  const python = findPython()
-  const seedResult = spawnSync(
-    python,
-    [SEED_SCRIPT, stateDbPath, fixturePath],
-    {
-      cwd: REPO_ROOT,
-      env: { ...process.env, PYTHONPATH: REPO_ROOT },
-      encoding: 'utf8',
-      timeout: 30_000,
-    },
-  )
-  fs.unlinkSync(fixturePath)
-
-  if (seedResult.status !== 0) {
-    throw new Error(
-      `Failed to seed state.db:\nstdout: ${seedResult.stdout}\nstderr: ${seedResult.stderr}`,
-    )
-  }
-
-  // 4. Build env + launch
-  const env = buildAppEnv(sandbox)
-  const { app, page } = await launchDesktop(env)
-
-  return {
-    app,
-    page,
-    mock,
-    mockUrl: mock.url,
-    sandbox,
-    cleanup: async () => {
-      await app.close().catch(() => undefined)
-      await mock.close()
-      sandbox.cleanup()
-    },
-  }
-}
-
-let fixture: MockBackendFixture | null = null
-
-test.beforeAll(async () => {
-  fixture = await setupSeededMockBackend()
-  await waitForAppReady(fixture!, 120_000)
-})
-
-test.afterAll(async () => {
-  await fixture?.cleanup()
-  fixture = null
-})
-
-/**
- * Install a MutationObserver + text-content poll on the thread viewport
- * to detect re-renders after the initial paint. Returns nothing — call
- * `readRenderCount` to stop and collect results.
- *
- * - MutationObserver: counts additive childList bursts (5ms coalescing).
- * - Text-content poll: counts "reconciles" — first-message text changes
- *   after the initial paint, catching key-based reconciles that don't
- *   add/remove nodes.
- */
-async function installRenderCounter(page: import('@playwright/test').Page): Promise<void> {
-  await page.evaluate(() => {
-    const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-    if (!viewport) {
-      throw new Error('Thread viewport not found before warm resume')
-    }
-
-    const state = { bursts: 0, mutations: 0, timeline: [] as number[], stopped: false, reconciles: 0 }
-    ;(window as unknown as { __RENDER_COUNT__: typeof state }).__RENDER_COUNT__ = state
-
-    let currentBatch = 0
-    let flushTimer: ReturnType<typeof setTimeout> | null = null
-
-    const flush = () => {
-      flushTimer = null
-      if (currentBatch > 0 && !state.stopped) {
-        state.bursts += 1
-        state.timeline.push(currentBatch)
-        currentBatch = 0
-      }
-    }
-
-    const observer = new MutationObserver(records => {
-      if (state.stopped) return
-      let batchAdded = 0
-      for (const record of records) {
-        state.mutations += 1
-        if (record.type === 'childList' && record.addedNodes.length > 0) {
-          batchAdded += 1
-        }
-      }
-      if (batchAdded > 0) {
-        currentBatch += batchAdded
-        if (flushTimer) clearTimeout(flushTimer)
-        flushTimer = setTimeout(flush, 5)
-      }
-    })
-
-    observer.observe(viewport, {
-      childList: true,
-      subtree: true,
-      attributes: false,
-      characterData: false,
-    })
-
-    // Poll the first message's text content every 2ms. The MutationObserver
-    // only catches childList additions; React may reconcile by key without
-    // adding/removing nodes (same keys → in-place prop update → no childList
-    // mutation). The poll catches this by detecting text content changes in
-    // the first message after the initial paint. Metadata-only changes (model
-    // name, busy indicator) don't affect message text, so they don't produce
-    // false positives.
-    const contentEl = viewport.querySelector('[data-slot="aui_thread-content"]') ?? viewport
-    let lastFirstMsgText = ''
-    let hasMessages = false
-    const pollInterval = setInterval(() => {
-      if (state.stopped) {
-        clearInterval(pollInterval)
-        return
-      }
-      const firstMsg = contentEl.querySelector('[data-role="message"], [data-message-id]')
-      const firstMsgText = firstMsg?.textContent ?? ''
-      if (firstMsgText && firstMsgText !== lastFirstMsgText) {
-        if (hasMessages) {
-          state.reconciles = (state.reconciles ?? 0) + 1
-        }
-        lastFirstMsgText = firstMsgText
-        hasMessages = true
-      }
-    }, 2)
-  })
-}
-
-/** Stop the render counter and return the recorded burst/reconcile counts. */
-async function readRenderCount(page: import('@playwright/test').Page): Promise<{
-  bursts: number
-  mutations: number
-  timeline: number[]
-  reconciles: number
-} | null> {
-  return page.evaluate(() => {
-    type RenderCount = { bursts: number; mutations: number; timeline: number[]; stopped: boolean; reconciles: number }
-    const w = window as unknown as { __RENDER_COUNT__?: RenderCount }
-    const rc = w.__RENDER_COUNT__
-    if (rc) {
-      rc.stopped = true
-    }
-    return rc ? { bursts: rc.bursts, mutations: rc.mutations, timeline: rc.timeline, reconciles: rc.reconciles } : null
-  })
-}
-
-/** Assert the render counter shows exactly one paint with no re-renders. */
-function assertNoJitter(result: { bursts: number; mutations: number; timeline: number[]; reconciles: number } | null): void {
-  expect(result, 'MutationObserver should have recorded render data').toBeTruthy()
-  expect(
-    result!.bursts,
-    `Expected 1 additive render burst (single paint), but got ${result!.bursts} bursts. ` +
-      `Mutation timeline: ${JSON.stringify(result!.timeline)}.`,
-  ).toBe(1)
-  expect(
-    result!.reconciles,
-    `Expected 0 reconciles (no re-render after initial paint), but got ${result!.reconciles}. ` +
-      `This means the warm-route resume re-rendered the transcript after the initial paint ` +
-      `— the "warm resume jitter" bug is present.`,
-  ).toBe(0)
-}
-
-test('warm-route resume paints transcript exactly once (no jitter)', async ({}, testInfo) => {
-  const page = fixture!.page
-
-  // Wait for the sidebar to populate with our seeded session.
-  const sessionRow = page
-    .locator('[data-slot="sidebar"] button')
-    .filter({ hasText: SESSION_TITLE })
-    .first()
-  await sessionRow.waitFor({ state: 'visible', timeout: 60_000 })
-
-  // Step 1: Cold resume — click the session row to load it.
-  // This populates the warm cache (runtimeIdByStoredSessionId + sessionStateByRuntimeId).
-  await sessionRow.click()
-
-  // Wait for the transcript to appear — the first user message text confirms
-  // the cold-path prefetch painted.
-  await page.waitForFunction(
-    (text: string) =>
-      document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent?.includes(text) ??
-      false,
-    FIRST_USER_MSG,
-    { timeout: 30_000 },
-  )
-
-  // Wait for the session to fully settle (cold-path RPC + reconciliation).
-  await page.waitForTimeout(2_000)
-
-  // Step 2: Navigate away to a new chat — this does NOT evict the warm cache.
-  const newSessionButton = page
-    .locator('[data-slot="sidebar"] button[aria-label="New session"]')
-    .first()
-  await newSessionButton.click()
-
-  // Wait for the new-chat empty state.
-  await page.waitForFunction(
-    (firstMsg: string) => {
-      const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-      if (!viewport) return false
-      const text = viewport.textContent ?? ''
-      return !text.includes(firstMsg)
-    },
-    FIRST_USER_MSG,
-    { timeout: 15_000 },
-  )
-
-  await page.waitForTimeout(500)
-
-  // Step 3: Install render counter, click back (warm resume), wait, assert.
-  await installRenderCounter(page)
-  await sessionRow.click()
-
-  await page.waitForFunction(
-    (text: string) =>
-      document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent?.includes(text) ??
-      false,
-    FIRST_USER_MSG,
-    { timeout: 30_000 },
-  )
-
-  // Wait for at least 1 burst, then settle.
-  await page.waitForFunction(
-    () => {
-      const w = window as unknown as { __RENDER_COUNT__?: { bursts: number } }
-      return Boolean(w.__RENDER_COUNT__ && w.__RENDER_COUNT__.bursts > 0)
-    },
-    undefined,
-    { timeout: 10_000 },
-  )
-  await page.waitForTimeout(2_000)
-
-  const result = await readRenderCount(page)
-  await page.screenshot({ path: testInfo.outputPath('warm-resume-idle.png') })
-  assertNoJitter(result)
-})
-
-test('warm-route resume after background inference completes (no jitter)', async ({}, testInfo) => {
-  test.fixme(
-    true,
-    'Warm resume repaints after inference: expected one additive burst, got two ([18,1]).',
-  )
-
-  const page = fixture!.page
-  const { mock } = fixture!
-
-  // Wait for the sidebar to populate with our seeded session.
-  const sessionRow = page
-    .locator('[data-slot="sidebar"] button')
-    .filter({ hasText: SESSION_TITLE })
-    .first()
-  await sessionRow.waitFor({ state: 'visible', timeout: 60_000 })
-
-  // Step 1: Cold resume — populate the warm cache.
-  await sessionRow.click()
-  await page.waitForFunction(
-    (text: string) =>
-      document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent?.includes(text) ??
-      false,
-    FIRST_USER_MSG,
-    { timeout: 30_000 },
-  )
-  await page.waitForTimeout(2_000)
-
-  // Step 2: Send a message — triggers inference via the mock server.
-  const PROMPT = 'E2E post-inference warm resume test prompt'
-  const composer = page.locator('[contenteditable="true"]').first()
-  await composer.click()
-  await composer.type(PROMPT, { delay: 10 })
-  await page.keyboard.press('Enter')
-
-  // Wait for the mock response to appear in the transcript, confirming
-  // the turn completed and message.complete fired (which updates the warm
-  // cache via updateSessionState).
-  await page.waitForFunction(
-    () => {
-      const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-      return viewport?.textContent?.includes('mock inference server') ?? false
-    },
-    undefined,
-    { timeout: 60_000 },
-  )
-  // Extra settle for message.complete → updateSessionState → cache write.
-  await page.waitForTimeout(2_000)
-
-  // Verify the prompt was received by the mock server.
-  expect(mock.receivedPrompts).toContain(PROMPT)
-
-  // Step 3: Navigate away — the warm cache retains the updated messages.
-  const newSessionButton = page
-    .locator('[data-slot="sidebar"] button[aria-label="New session"]')
-    .first()
-  await newSessionButton.click()
-  await page.waitForFunction(
-    (prompt: string) => {
-      const viewport = document.querySelector('[data-slot="aui_thread-viewport"]')
-      if (!viewport) return false
-      return !(viewport.textContent ?? '').includes(prompt)
-    },
-    PROMPT,
-    { timeout: 15_000 },
-  )
-  await page.waitForTimeout(500)
-
-  // Step 4: Install render counter, click back (warm resume), wait, assert.
-  await installRenderCounter(page)
-  await sessionRow.click()
-
-  // Wait for the transcript to reappear — the warm cache should already
-  // have the completed turn (updated by message.complete events).
-  await page.waitForFunction(
-    (text: string) =>
-      document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent?.includes(text) ??
-      false,
-    FIRST_USER_MSG,
-    { timeout: 30_000 },
-  )
-
-  // Wait for at least 1 burst, then settle.
-  await page.waitForFunction(
-    () => {
-      const w = window as unknown as { __RENDER_COUNT__?: { bursts: number } }
-      return Boolean(w.__RENDER_COUNT__ && w.__RENDER_COUNT__.bursts > 0)
-    },
-    undefined,
-    { timeout: 10_000 },
-  )
-  await page.waitForTimeout(2_000)
-
-  const result = await readRenderCount(page)
-  await page.screenshot({ path: testInfo.outputPath('warm-resume-post-inference.png') })
-  assertNoJitter(result)
-})
@@ -1,94 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-import { test, expect } from './test'
-
-import {
-  buildAppEnv,
-  createSandbox,
-  launchDesktop,
-  writeEnvFile,
-  writeMockProviderConfig,
-  type MockBackendFixture,
-  waitForAppReady,
-} from './fixtures'
-import { startMockServer } from './mock-server'
-
-const BRANCH_NAME = 'e2e-composer-branch'
-
-function createGitRepo(root: string): string {
-  const repo = path.join(root, 'repo')
-
-  fs.mkdirSync(repo, { recursive: true })
-  execFileSync('git', ['init', '--initial-branch=main'], { cwd: repo })
-  execFileSync('git', ['config', 'user.email', 'e2e@example.com'], { cwd: repo })
-  execFileSync('git', ['config', 'user.name', 'Hermes E2E'], { cwd: repo })
-  fs.writeFileSync(path.join(repo, 'README.md'), '# E2E repo\n', 'utf8')
-  execFileSync('git', ['add', 'README.md'], { cwd: repo })
-  execFileSync('git', ['commit', '-m', 'initial'], { cwd: repo })
-
-  return repo
-}
-
-function configureRepoCwd(hermesHome: string, mockUrl: string, repo: string): void {
-  writeMockProviderConfig(hermesHome, mockUrl)
-  fs.appendFileSync(path.join(hermesHome, 'config.yaml'), `\nterminal:\n  cwd: ${repo}\n`, 'utf8')
-  writeEnvFile(hermesHome)
-}
-
-let fixture: MockBackendFixture | null = null
-
-test.beforeAll(async () => {
-  const sandbox = createSandbox('worktree-branch-status')
-  const repo = createGitRepo(sandbox.root)
-  const mock = await startMockServer()
-
-  configureRepoCwd(sandbox.hermesHome, mock.url, repo)
-
-  const { app, page } = await launchDesktop(buildAppEnv(sandbox))
-  fixture = {
-    app,
-    page,
-    mock,
-    mockUrl: mock.url,
-    sandbox,
-    cleanup: async () => {
-      await app.close().catch(() => undefined)
-      await mock.close()
-      sandbox.cleanup()
-    },
-  }
-
-  await waitForAppReady(fixture, 120_000)
-})
-
-test.afterAll(async () => {
-  await fixture?.cleanup()
-  fixture = null
-})
-
-test('creating a branch with ctrl-shift-b updates the composer git-status branch', async ({}, testInfo) => {
-  const page = fixture!.page
-  const codingRow = page.locator('.coding-status-bar')
-  const composer = page.locator('[contenteditable="true"]').first()
-
-  await composer.click()
-  await composer.type('create a repo-backed e2e session', { delay: 2 })
-  await page.keyboard.press('Enter')
-  await page.waitForFunction(
-    prompt => (document.querySelector('[data-slot="aui_thread-viewport"]')?.textContent ?? '').includes(prompt),
-    'create a repo-backed e2e session',
-    { timeout: 15_000 },
-  )
-  await expect(codingRow).toContainText('main')
-  await page.keyboard.press('Control+Shift+B')
-
-  const branchInput = page.locator('input[placeholder="e.g. my-feature"]').first()
-  await expect(branchInput).toBeVisible()
-  await branchInput.fill(BRANCH_NAME)
-  await page.getByRole('button', { name: 'New worktree' }).click()
-
-  await expect(codingRow).toContainText(BRANCH_NAME, { timeout: 15_000 })
-  await page.screenshot({ path: testInfo.outputPath('composer-branch-after-create.png') })
-})
@@ -12,12 +12,7 @@ import path from 'node:path'

 import { test } from 'vitest'

-import {
-  canImportHermesCli,
-  hermesRuntimeImportProbe,
-  shouldTrustHermesOverride,
-  verifyHermesCli
-} from './backend-probes'
+import { canImportHermesCli, hermesRuntimeImportProbe, verifyHermesCli } from './backend-probes'

 // Resolve the host's own Node binary -- guaranteed to be on disk and
 // runnable. We use it as both a stand-in for "a python that doesn't
@@ -56,15 +51,6 @@ test('hermes runtime import probe checks config dependencies', () => {
  assert.match(probe, /\bimport hermes_cli\.config\b/)
 })

-test('explicit Hermes override is authoritative', () => {
-  assert.equal(shouldTrustHermesOverride('/nix/store/abc/bin/hermes'), true)
-})
-
-test('empty Hermes override is not authoritative', () => {
-  assert.equal(shouldTrustHermesOverride(''), false)
-  assert.equal(shouldTrustHermesOverride(undefined), false)
-})
-
 test('verifyHermesCli returns false when command is falsy', () => {
  assert.equal(verifyHermesCli(''), false)
  assert.equal(verifyHermesCli(null), false)
@@ -104,16 +104,6 @@ function canImportHermesCli(pythonPath: string, opts: { env?: Record<string, str
 *   in resolveHermesBackend.
 * @returns {boolean}
 */
-/**
- * An explicit desktop backend command is a deployment contract, not a PATH
- * discovery candidate. In particular, the Nix desktop wrapper points this at
- * its immutable, matching Hermes package; it must never fall through to the
- * mutable install-script bootstrap path if a best-effort probe is slow.
- */
-function shouldTrustHermesOverride(hermesOverride?: string) {
-  return typeof hermesOverride === 'string' && hermesOverride.trim().length > 0
-}
-
 function verifyHermesCli(hermesCommand: string, opts?: { shell?: boolean }) {
  if (!hermesCommand) {
    return false
@@ -133,4 +123,4 @@ function verifyHermesCli(hermesCommand: string, opts?: { shell?: boolean }) {
  }
 }

-export { canImportHermesCli, hermesRuntimeImportProbe, PROBE_TIMEOUT_MS, shouldTrustHermesOverride, verifyHermesCli }
+export { canImportHermesCli, hermesRuntimeImportProbe, PROBE_TIMEOUT_MS, verifyHermesCli }
@@ -34,7 +34,7 @@ import { stopBackendChild as stopBackendChildImpl } from './backend-child'
 import { dashboardFallbackArgs, sourceDeclaresServe } from './backend-command'
 import { createBackendConnectionState } from './backend-connection-state'
 import { buildDesktopBackendEnv, normalizeHermesHomeRoot } from './backend-env'
-import { canImportHermesCli, shouldTrustHermesOverride, verifyHermesCli } from './backend-probes'
+import { canImportHermesCli, verifyHermesCli } from './backend-probes'
 import { waitForDashboardPortAnnouncement } from './backend-ready'
 import { shouldLatchBackendStartFailure } from './backend-start-failure'
 import { detectRemoteDisplay, isWindowsBinaryPathInWsl, isWslEnvironment } from './bootstrap-platform'
@@ -80,6 +80,19 @@ import { installEmbedReferer } from './embed-referer'
 import { createEventDeduper } from './event-dedupe'
 import { readDirForIpc } from './fs-read-dir'
 import { probeGatewayWebSocket } from './gateway-ws-probe'
+import { runNativeLogin } from './native-oauth-login'
+import {
+  nativeRefreshUrl,
+  parseTokenResponse,
+  resolveLoginStrategy,
+  tokenNeedsRefresh,
+  type NativeTokenSet
+} from './native-oauth'
+import {
+  oauthSessionIsLive,
+  resolveJsonBody,
+  resolveOauthRestAuth
+} from './native-auth-decisions'
 import { scanGitRepos } from './git-repo-scan'
 import {
  fileDiffVsHead,
@@ -116,15 +129,6 @@ import {
 } from './hardening'
 import { createLinkTitleWindow, guardLinkTitleSession, readLinkTitleWindowTitle } from './link-title-window'
 import { ensureMainWindow } from './main-window-lifecycle'
-import { oauthSessionIsLive, resolveJsonBody, resolveOauthRestAuth } from './native-auth-decisions'
-import {
-  nativeRefreshUrl,
-  type NativeTokenSet,
-  parseTokenResponse,
-  resolveLoginStrategy,
-  tokenNeedsRefresh
-} from './native-oauth'
-import { runNativeLogin } from './native-oauth-login'
 import { serializeJsonBody, setJsonRequestHeaders } from './oauth-net-request'
 import { createKeepAwake } from './power-save'
 import { decideProfileDeleteAction, profileNameFromDeleteRequest, resolveRouteProfile } from './profile-delete-routing'
@@ -3564,11 +3568,7 @@ function resolveHermesBackend(backendArgs) {
      // and lets the resolver fall through to step 6 / bootstrap.
      const shellForProbe = isCommandScript(hermesCommand)

-      // HERMES_DESKTOP_HERMES is an explicit deployment override (used by
-      // the Nix wrapper), not a discovered PATH candidate. It must not fall
-      // through to the install-script bootstrap if the optional probe times
-      // out under load; the pinned backend is the only valid runtime there.
-      if (shouldTrustHermesOverride(hermesOverride) || verifyHermesCli(hermesCommand, { shell: shellForProbe })) {
+      if (verifyHermesCli(hermesCommand, { shell: shellForProbe })) {
        return (
          unwrapWindowsVenvHermesCommand(hermesCommand, backendArgs) || {
            label: `existing Hermes CLI at ${hermesCommand}`,
@@ -5851,7 +5851,6 @@ async function ensureNativeAccessToken(baseUrl: string): Promise<string | null>
      { refresh_token: tokens.refreshToken, provider: tokens.provider },
      { timeoutMs: 10_000 }
    )
-
    const rotated = parseTokenResponse(body)
    _storeNativeTokens(baseUrl, rotated)

@@ -5884,7 +5883,6 @@ async function mintGatewayWsTicket(baseUrl) {
      timeoutMs: 8_000,
      bearer: nativeAt
    })) as any
-
    const ticket = body?.ticket

    if (!ticket || typeof ticket !== 'string') {
@@ -6461,7 +6459,10 @@ async function sanitizeDesktopConnectionConfig(config = readDesktopConnectionCon
      // RFC 8252 flow) counts as connected too — otherwise a completed native
      // sign-in shows "not connected" in Settings. The authoritative liveness
      // check is the ws-ticket mint in resolveRemoteBackend at actual connect time.
-      remoteOauthConnected = oauthSessionIsLive(hasNativeSession(remoteUrl), await hasLiveOauthSession(remoteUrl))
+      remoteOauthConnected = oauthSessionIsLive(
+        hasNativeSession(remoteUrl),
+        await hasLiveOauthSession(remoteUrl)
+      )
    } catch {
      remoteOauthConnected = false
    }
@@ -8954,7 +8955,6 @@ ipcMain.handle('hermes:connection-config:oauth-login', async (_event, rawUrl) =>
        postJson: (url, body, opts) => postJsonNoAuth(url, body, opts),
        rememberLog
      })
-
      _storeNativeTokens(baseUrl, tokens)

      return { ok: true, baseUrl, connected: true }
@@ -8977,7 +8977,6 @@ ipcMain.handle('hermes:connection-config:oauth-login', async (_event, rawUrl) =>
 ipcMain.handle('hermes:connection-config:oauth-logout', async (_event, rawUrl) => {
  const baseUrl = rawUrl ? normalizeRemoteBaseUrl(rawUrl) : ''
  await clearOauthSession(baseUrl || undefined)
-
  // Also drop any native (RFC 8252) bearer tokens for this gateway so a
  // logout clears BOTH auth shapes.
  if (baseUrl) {
@@ -8987,7 +8986,9 @@ ipcMain.handle('hermes:connection-config:oauth-logout', async (_event, rawUrl) =
  // Report against the SAME liveness notion the Settings indicator uses
  // (AT-or-RT cookie, or a native token) so a logout that left any session
  // behind is reflected as still-connected rather than silently signed-out.
-  const connected = baseUrl ? (await hasLiveOauthSession(baseUrl)) || hasNativeSession(baseUrl) : false
+  const connected = baseUrl
+    ? (await hasLiveOauthSession(baseUrl)) || hasNativeSession(baseUrl)
+    : false

  return { ok: true, connected }
 })
@@ -10,7 +10,11 @@ import assert from 'node:assert/strict'

 import { test } from 'vitest'

-import { oauthSessionIsLive, resolveJsonBody, resolveOauthRestAuth } from './native-auth-decisions'
+import {
+  oauthSessionIsLive,
+  resolveJsonBody,
+  resolveOauthRestAuth
+} from './native-auth-decisions'

 // --- 1. body encoding (guards the double-JSON.stringify 422) ---

@@ -44,7 +44,9 @@ export function oauthSessionIsLive(hasNativeToken: boolean, hasCookieSession: bo
  return hasNativeToken || hasCookieSession
 }

-export type OauthRestAuth = { kind: 'bearer'; token: string } | { kind: 'cookie' }
+export type OauthRestAuth =
+  | { kind: 'bearer'; token: string }
+  | { kind: 'cookie' }

 /**
 * Decide how an oauth-mode REST request authenticates: prefer the native
@@ -22,18 +22,14 @@ function makeFakeServerFactory(port = 51234) {
  const createServer: any = (handler: any) => {
    state.handler = handler
    const server: any = new EventEmitter()
-
    server.listen = (_port: number, _host: string, cb: () => void) => {
      state.listening = true
      cb()
    }
-
    server.address = () => ({ address: '127.0.0.1', family: 'IPv4', port })
-
    server.close = () => {
      state.closed = true
    }
-
    state.server = server

    return server
@@ -32,10 +32,10 @@ import {
  buildNativeAuthorizeUrl,
  generatePkcePair,
  generateState,
-  type NativeTokenSet,
  nativeTokenUrl,
  parseLoopbackCallback,
-  parseTokenResponse
+  parseTokenResponse,
+  type NativeTokenSet
 } from './native-oauth'

 // Loopback login must complete inside this window (user opens browser,
@@ -90,7 +90,6 @@ export async function runNativeLogin(
  return new Promise<NativeTokenSet>((resolve, reject) => {
    let settled = false
    let timer: NodeJS.Timeout | null = null
-
    const server = createServer((req, res) => {
      // Only the callback path carries the code; any other path (favicon,
      // etc.) still gets the friendly page so the browser tab looks sane.
@@ -180,7 +179,6 @@ export async function runNativeLogin(
      }

      const redirectUri = `http://127.0.0.1:${addr.port}/callback`
-
      const authorizeUrl = buildNativeAuthorizeUrl(baseUrl, {
        challenge,
        redirectUri,
@@ -34,7 +34,6 @@ test('generatePkcePair produces a valid S256 verifier/challenge', () => {
  assert.equal(pair.method, 'S256')
  // Verifier length within RFC 7636 range (43–128).
  assert.ok(pair.verifier.length >= 43 && pair.verifier.length <= 128)
-
  // Challenge must be the base64url SHA-256 of the verifier.
  const expected = createHash('sha256')
    .update(pair.verifier, 'ascii')
@@ -42,7 +41,6 @@ test('generatePkcePair produces a valid S256 verifier/challenge', () => {
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '')
-
  assert.equal(pair.challenge, expected)
  // No padding / URL-unsafe chars.
  assert.doesNotMatch(pair.verifier, /[+/=]/)
@@ -93,7 +91,6 @@ test('buildNativeAuthorizeUrl encodes params and honours a path prefix', () => {
    state: 'STATE',
    provider: 'nous'
  })
-
  const parsed = new URL(url)

  assert.equal(parsed.origin, 'https://gw.example.com')
@@ -111,7 +108,6 @@ test('buildNativeAuthorizeUrl omits provider when not given and preserves prefix
    redirectUri: 'http://127.0.0.1:1/cb',
    state: 'S'
  })
-
  const parsed = new URL(url)

  assert.equal(parsed.pathname, '/hermes/auth/native/authorize')
@@ -132,7 +128,10 @@ test('parseLoopbackCallback returns the code on a state match', () => {
 })

 test('parseLoopbackCallback throws on state mismatch (CSRF)', () => {
-  assert.throws(() => parseLoopbackCallback('/callback?code=abc&state=attacker', 'expected'), /state mismatch/i)
+  assert.throws(
+    () => parseLoopbackCallback('/callback?code=abc&state=attacker', 'expected'),
+    /state mismatch/i
+  )
 })

 test('parseLoopbackCallback surfaces a gateway error param', () => {
@@ -86,7 +86,10 @@ export function statusSupportsNativeFlow(statusBody: any): boolean {
 * (e.g. a corporate proxy that blocks loopback). Precedence written down here,
 * in one place, as a pure function — per the desktop "observable ladder" rule.
 */
-export function resolveLoginStrategy(statusBody: any, opts: { forceEmbedded?: boolean } = {}): 'native' | 'embedded' {
+export function resolveLoginStrategy(
+  statusBody: any,
+  opts: { forceEmbedded?: boolean } = {}
+): 'native' | 'embedded' {
  if (opts.forceEmbedded) {
    return 'embedded'
  }
@@ -106,7 +109,6 @@ export function buildNativeAuthorizeUrl(
 ): string {
  const parsed = new URL(baseUrl)
  const prefix = parsed.pathname.replace(/\/+$/, '')
-
  const q = new URLSearchParams({
    code_challenge: params.challenge,
    code_challenge_method: 'S256',
@@ -143,7 +145,10 @@ export function nativeRefreshUrl(baseUrl: string): string {
 * `expectedState` MUST match (CSRF defense — RFC 6749 §10.12); a mismatch
 * throws rather than proceeding.
 */
-export function parseLoopbackCallback(requestUrl: string, expectedState: string): { code: string } {
+export function parseLoopbackCallback(
+  requestUrl: string,
+  expectedState: string
+): { code: string } {
  // requestUrl is the path+query the loopback server received, e.g.
  // "/callback?code=...&state=...". Resolve against a dummy origin to parse.
  const parsed = new URL(requestUrl, 'http://127.0.0.1')
@@ -198,11 +203,7 @@ export function parseTokenResponse(body: any): NativeTokenSet {
 * before use. `skewSeconds` refreshes slightly early to avoid a race where
 * the token expires in flight (mirrors the server's 60s cookie floor).
 */
-export function tokenNeedsRefresh(
-  tokens: Pick<NativeTokenSet, 'expiresAt'>,
-  nowSeconds: number,
-  skewSeconds = 60
-): boolean {
+export function tokenNeedsRefresh(tokens: Pick<NativeTokenSet, 'expiresAt'>, nowSeconds: number, skewSeconds = 60): boolean {
  if (!tokens || !Number.isFinite(tokens.expiresAt) || tokens.expiresAt <= 0) {
    // Unknown expiry ⇒ treat as needing refresh so we validate before use.
    return true
@@ -11,19 +11,15 @@
    "node": "^20.19.0 || >=22.12.0"
  },
  "scripts": {
-    "clean": "npm run clean:e2e && npm run clean:renderer && npm run clean:electron",
-    "clean:e2e":"tsc --build tsconfig.e2e.json --clean",
-    "clean:renderer":"tsc --build tsconfig.json --clean ",
-    "clean:electron":"tsc --build tsconfig.electron.json --clean",
    "dev": "concurrently -k \"npm:dev:renderer\" \"npm:dev:electron\"",
    "dev:fake-boot": "cross-env HERMES_DESKTOP_BOOT_FAKE=1 HERMES_DESKTOP_BOOT_FAKE_STEP_MS=650 npm run dev",
    "dev:mock": "node scripts/dev-mock.mjs",
-    "dev:renderer": "node scripts/assert-root-install.mjs && npm run clean:renderer && vite --host 127.0.0.1 --port 5174",
-    "dev:electron": "tsc --build tsconfig.electron.json && wait-on http://127.0.0.1:5174 && node scripts/bundle-electron-main.mjs --dev && cross-env XCURSOR_SIZE=24 HERMES_DESKTOP_DEV_SERVER=http://127.0.0.1:5174 electron .",
-    "profile:main": "tsc --build tsconfig.electron.json && wait-on http://127.0.0.1:5174 && node scripts/bundle-electron-main.mjs --dev && cross-env XCURSOR_SIZE=24 HERMES_DESKTOP_DEV_SERVER=http://127.0.0.1:5174 electron --inspect=9229 .",
-    "profile:main:cpu": "tsc --build tsconfig.electron.json && wait-on http://127.0.0.1:5174 && node scripts/bundle-electron-main.mjs --dev && cross-env XCURSOR_SIZE=24 NODE_OPTIONS=--cpu-prof HERMES_DESKTOP_DEV_SERVER=http://127.0.0.1:5174 electron .",
+    "dev:renderer": "node scripts/assert-root-install.mjs && vite --host 127.0.0.1 --port 5174",
+    "dev:electron": "wait-on http://127.0.0.1:5174 && node scripts/bundle-electron-main.mjs --dev && cross-env XCURSOR_SIZE=24 HERMES_DESKTOP_DEV_SERVER=http://127.0.0.1:5174 electron .",
+    "profile:main": "wait-on http://127.0.0.1:5174 && node scripts/bundle-electron-main.mjs --dev && cross-env XCURSOR_SIZE=24 HERMES_DESKTOP_DEV_SERVER=http://127.0.0.1:5174 electron --inspect=9229 .",
+    "profile:main:cpu": "wait-on http://127.0.0.1:5174 && node scripts/bundle-electron-main.mjs --dev && cross-env XCURSOR_SIZE=24 NODE_OPTIONS=--cpu-prof HERMES_DESKTOP_DEV_SERVER=http://127.0.0.1:5174 electron .",
    "start": "npm run build && electron .",
-    "prebuild": "npm run clean",
+    "prebuild": "tsc -b . --clean",
    "build": "node scripts/assert-root-install.mjs && node scripts/write-build-stamp.mjs && vite build && node scripts/bundle-electron-main.mjs && node scripts/stage-native-deps.mjs",
    "postbuild": "node scripts/assert-dist-built.mjs",
    "prebuilder": "node scripts/patch-electron-builder-mac-binary.mjs",
@@ -55,9 +51,9 @@
    "test": "vitest run",
    "preview": "node scripts/assert-root-install.mjs && vite preview --host 127.0.0.1 --port 4174",
    "check": "npm run typecheck && npm run test && npm run test:desktop:all",
-    "test:e2e": "npm run build && playwright test e2e/",
-    "test:e2e:visual": "npm run build && WLR_BACKENDS=headless WLR_NO_HARDWARE_CURSORS=1 cage -- npx playwright test e2e/ --reporter=list",
-    "test:e2e:update-snapshots": "npm run build && WLR_BACKENDS=headless WLR_NO_HARDWARE_CURSORS=1 cage -- npx playwright test e2e/ --reporter=list --update-snapshots"
+    "test:e2e": "playwright test e2e/",
+    "test:e2e:visual": "WLR_BACKENDS=headless WLR_NO_HARDWARE_CURSORS=1 cage -- npx playwright test e2e/ --reporter=list",
+    "test:e2e:update-snapshots": "WLR_BACKENDS=headless WLR_NO_HARDWARE_CURSORS=1 cage -- npx playwright test e2e/ --reporter=list --update-snapshots"
  },
  "dependencies": {
    "@assistant-ui/react": "^0.14.23",
@@ -2,25 +2,17 @@ import { closeActiveTerminal } from '@/app/right-sidebar/terminal/terminals'
 import { closeWorkspaceTab } from '@/components/pane-shell/tree/store'
 import { isFocusWithin } from '@/lib/keybinds/combo'
 import { $filePreviewTabs, $previewTarget, closeActiveRightRailTab } from '@/store/preview'
-import { closeSessionTile, nextSessionTileForWorkspace } from '@/store/session-states'

 /**
 * ⌘W — close the tab of the context you're in, by precedence:
 *   1. a focused terminal → its active terminal tab,
 *   2. right-rail tabs (live preview and/or file peeks),
 *   3. the MAIN zone → its active tab (a session tile stacked into the workspace).
- *   4. the MAIN (workspace) tab itself, when session tabs are stacked with it:
- *      the workspace can't close, so ⌘W shifts the NEXT session tab into main
- *      (loads it as the primary + drops its now-redundant tile).
 * Returns false when nothing closes, so ⌘W is a no-op — it never closes the
 * window (a bare workspace stays put). Shared by the keyboard path (Win/Linux)
 * and the macOS menu-accelerator IPC.
- *
- * `loadSessionIntoWorkspace` carries the app's route-based "load this session
- * into main" (the two call sites have router access); omitting it disables the
- * step-4 promotion (⌘W stays the pre-existing no-op on the main tab).
 */
-export function closeActiveTab(loadSessionIntoWorkspace?: (storedSessionId: string) => void): boolean {
+export function closeActiveTab(): boolean {
  if (isFocusWithin('[data-terminal]')) {
    closeActiveTerminal()

@@ -36,27 +28,5 @@ export function closeActiveTab(loadSessionIntoWorkspace?: (storedSessionId: stri
    return closeActiveRightRailTab()
  }

-  // A closeable main-zone tab (a session tile that's the active tab) closes
-  // outright; the uncloseable workspace tab returns false and falls through.
-  if (closeWorkspaceTab()) {
-    return true
-  }
-
-  // The main (workspace) tab is active and can't be closed — but if session
-  // tabs are stacked with it, ⌘W shifts the next one into the main tab: drop
-  // its tile (the session stays alive, no busy-close prompt) and load it into
-  // main. Order matters — close the tile FIRST so the selection homes to the
-  // workspace instead of re-fronting the tile.
-  if (loadSessionIntoWorkspace) {
-    const next = nextSessionTileForWorkspace()
-
-    if (next) {
-      closeSessionTile(next)
-      loadSessionIntoWorkspace(next)
-
-      return true
-    }
-  }
-
-  return false
+  return closeWorkspaceTab()
 }
@@ -1,79 +0,0 @@
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import type { ChatBarState } from '@/app/chat/composer/types'
-import { I18nProvider } from '@/i18n'
-
-import { ComposerControls } from './controls'
-
-vi.mock('./model-pill', () => ({ ModelPill: () => null }))
-
-const state: ChatBarState = {
-  model: { canSwitch: false, model: '', provider: '' },
-  tools: { enabled: false, label: '' },
-  voice: { active: false, enabled: false }
-}
-
-function renderControls(overrides: Partial<React.ComponentProps<typeof ComposerControls>> = {}) {
-  return render(
-    <I18nProvider configClient={null} initialLocale="en">
-      <ComposerControls
-        autoSpeak={false}
-        busy={false}
-        busyAction="stop"
-        canSubmit={true}
-        conversation={{
-          active: false,
-          level: 0,
-          muted: false,
-          onEnd: vi.fn(),
-          onStart: vi.fn(),
-          onStopTurn: vi.fn(),
-          onToggleMute: vi.fn(),
-          status: 'idle'
-        }}
-        disabled={false}
-        hasComposerPayload={true}
-        onDictate={vi.fn()}
-        onQueue={vi.fn()}
-        onToggleAutoSpeak={vi.fn()}
-        state={state}
-        voiceStatus="idle"
-        {...overrides}
-      />
-    </I18nProvider>
-  )
-}
-
-async function expectShortcutTooltip(label: string, shortcut: string) {
-  fireEvent.pointerMove(screen.getByLabelText(label), { pointerType: 'mouse' })
-
-  const tooltip = await screen.findByRole('tooltip')
-
-  expect(tooltip.textContent).toContain(label)
-  expect(tooltip.textContent).toContain(shortcut)
-}
-
-afterEach(() => {
-  cleanup()
-})
-
-describe('ComposerControls shortcut tooltips', () => {
-  it('shows Enter for Send', async () => {
-    renderControls()
-
-    await expectShortcutTooltip('Send', '↵')
-  })
-
-  it('shows Ctrl+Enter for Steer', async () => {
-    renderControls({ busy: true, busyAction: 'steer' })
-
-    await expectShortcutTooltip('Steer the current run', 'Ctrl+↵')
-  })
-
-  it('shows Enter for Queue', async () => {
-    renderControls({ busy: true, busyAction: 'queue' })
-
-    await expectShortcutTooltip('Queue message', '↵')
-  })
-})
@@ -1,9 +1,11 @@
 import { Button } from '@/components/ui/button'
 import { Codicon } from '@/components/ui/codicon'
-import { Tip, TipKeybindLabel } from '@/components/ui/tooltip'
+import { KbdCombo } from '@/components/ui/kbd'
+import { Tip } from '@/components/ui/tooltip'
 import { useI18n } from '@/i18n'
 import { triggerHaptic } from '@/lib/haptics'
 import { AudioLines, iconSize, Layers3, Loader2, Square, SteeringWheel, Volume2, VolumeX } from '@/lib/icons'
+import { formatCombo } from '@/lib/keybinds/combo'
 import { cn } from '@/lib/utils'

 import type { ConversationStatus } from './hooks/use-voice-conversation'
@@ -40,6 +42,7 @@ export function ComposerControls({
  autoSpeak,
  busy,
  busyAction,
+  canSteer,
  canSubmit,
  compactModelPill = false,
  conversation,
@@ -48,12 +51,13 @@ export function ComposerControls({
  state,
  voiceStatus,
  onDictate,
-  onQueue,
+  onSteer,
  onToggleAutoSpeak
 }: {
  autoSpeak: boolean
  busy: boolean
-  busyAction: 'steer' | 'queue' | 'stop'
+  busyAction: 'queue' | 'stop'
+  canSteer: boolean
  canSubmit: boolean
  compactModelPill?: boolean
  conversation: ConversationProps
@@ -62,39 +66,50 @@ export function ComposerControls({
  state: ChatBarState
  voiceStatus: VoiceStatus
  onDictate: () => void
-  onQueue: () => void
+  onSteer: () => void
  onToggleAutoSpeak: () => void
 }) {
  const { t } = useI18n()
  const c = t.composer
+  const steerCombo = formatCombo('mod+enter')
+  const steerLabel = `${c.steer} (${steerCombo})`
+
+  const steerTip = (
+    <span className="inline-flex items-center gap-1.5">
+      {c.steer}
+      <KbdCombo combo="mod+enter" size="sm" variant="inverted" />
+    </span>
+  )

  if (conversation.active) {
    return <ConversationPill {...conversation} disabled={disabled} />
  }

  const showVoicePrimary = !busy && !hasComposerPayload
-  const busyLabel = busyAction === 'queue' ? c.queueMessage : busyAction === 'steer' ? c.steer : c.stop

  return (
    <div className="ml-auto flex shrink-0 items-center gap-(--composer-control-gap)">
      <ModelPill compact={compactModelPill} disabled={disabled} model={state.model} />
-      <DictationButton disabled={disabled} onToggle={onDictate} state={state.voice} status={voiceStatus} />
-      <AutoSpeakButton active={autoSpeak} disabled={disabled} onToggle={onToggleAutoSpeak} />
-      {busyAction === 'steer' ? (
-        <Tip label={<TipKeybindLabel actionId="composer.send" text={c.queueMessage} />}>
+      {/* While the agent runs and the user is typing, steer takes over the mic's
+          slot rather than crowding the row with an extra button. */}
+      {canSteer ? (
+        <Tip label={steerTip}>
          <Button
-            aria-label={c.queueMessage}
+            aria-label={steerLabel}
            className={GHOST_ICON_BTN}
            disabled={disabled}
-            onClick={onQueue}
+            onClick={onSteer}
            size="icon"
            type="button"
            variant="ghost"
          >
-            <Layers3 className={iconSize.sm} />
+            <SteeringWheel className={iconSize.sm} />
          </Button>
        </Tip>
-      ) : null}
+      ) : (
+        <DictationButton disabled={disabled} onToggle={onDictate} state={state.voice} status={voiceStatus} />
+      )}
+      <AutoSpeakButton active={autoSpeak} disabled={disabled} onToggle={onToggleAutoSpeak} />
      {showVoicePrimary ? (
        <Tip label={c.startVoice}>
          <Button
@@ -112,20 +127,9 @@ export function ComposerControls({
          </Button>
        </Tip>
      ) : (
-        <Tip
-          label={
-            busy ? (
-              <TipKeybindLabel
-                actionId={busyAction === 'steer' ? 'composer.steer' : 'composer.send'}
-                text={busyLabel}
-              />
-            ) : (
-              <TipKeybindLabel actionId="composer.send" text={c.send} />
-            )
-          }
-        >
+        <Tip label={busy ? (busyAction === 'queue' ? c.queueMessage : c.stop) : c.send}>
          <Button
-            aria-label={busy ? busyLabel : c.send}
+            aria-label={busy ? (busyAction === 'queue' ? c.queueMessage : c.stop) : c.send}
            className={PRIMARY_ICON_BTN}
            disabled={disabled || !canSubmit}
            type="submit"
@@ -133,8 +137,6 @@ export function ComposerControls({
            {busy ? (
              busyAction === 'queue' ? (
                <Layers3 className={iconSize.sm} />
-              ) : busyAction === 'steer' ? (
-                <SteeringWheel className={iconSize.sm} />
              ) : (
                <span className="block size-2.5 rounded-[0.1875rem] bg-current" />
              )
@@ -1,167 +0,0 @@
-import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import type { ComposerAttachment } from '@/store/composer'
-
-import { useComposerSubmit } from './use-composer-submit'
-
-interface SubmitHarnessOptions {
-  attachments?: ComposerAttachment[]
-  busy?: boolean
-  compacting?: boolean
-  text?: string
-}
-
-function renderSubmitHook({
-  attachments = [],
-  busy = false,
-  compacting = false,
-  text = ''
-}: SubmitHarnessOptions = {}) {
-  const draftRef = { current: text }
-  const editor = document.createElement('div')
-  editor.dataset.slot = 'composer-rich-input'
-  editor.textContent = text
-  const editorRef = { current: editor }
-  const onCancel = vi.fn()
-  const onSteer = vi.fn(async () => true)
-  const onSubmit = vi.fn(async () => true)
-  const queueCurrentDraft = vi.fn(() => true)
-
-  const clearDraft = vi.fn(() => {
-    draftRef.current = ''
-    editorRef.current!.textContent = ''
-  })
-
-  const hook = renderHook(() =>
-    useComposerSubmit({
-      activeQueueSessionKey: 'stored-session',
-      activeQueueSessionKeyRef: { current: 'stored-session' },
-      attachments,
-      busy,
-      compacting,
-      clearDraft,
-      disabled: false,
-      draftRef,
-      drainNextQueued: vi.fn(async () => false),
-      editorRef,
-      exitQueuedEdit: vi.fn(() => false),
-      focusInput: vi.fn(),
-      inputDisabled: false,
-      loadIntoComposer: vi.fn(),
-      onCancel,
-      onSteer,
-      onSubmit,
-      queueCurrentDraft,
-      queueEdit: null,
-      queuedPrompts: [],
-      sessionId: 'runtime-session',
-      setComposerText: vi.fn(),
-      stashAt: vi.fn()
-    })
-  )
-
-  return { clearDraft, hook, onCancel, onSteer, onSubmit, queueCurrentDraft }
-}
-
-describe('useComposerSubmit busy-turn routing', () => {
-  afterEach(() => {
-    cleanup()
-    vi.restoreAllMocks()
-  })
-
-  it('steers a plain-text follow-up instead of queueing or stopping', async () => {
-    const { hook, onCancel, onSteer, onSubmit, queueCurrentDraft } = renderSubmitHook({
-      busy: true,
-      text: 'change course'
-    })
-
-    act(() => {
-      hook.result.current.submitDraft()
-    })
-
-    await waitFor(() => expect(onSteer).toHaveBeenCalledWith('change course'))
-    expect(queueCurrentDraft).not.toHaveBeenCalled()
-    expect(onCancel).not.toHaveBeenCalled()
-    expect(onSubmit).not.toHaveBeenCalled()
-  })
-
-  it('queues a plain-text follow-up while the active turn is compacting', () => {
-    const { hook, onCancel, onSteer, onSubmit, queueCurrentDraft } = renderSubmitHook({
-      busy: true,
-      compacting: true,
-      text: 'wait for the summary'
-    })
-
-    act(() => {
-      hook.result.current.submitDraft()
-    })
-
-    expect(queueCurrentDraft).toHaveBeenCalledTimes(1)
-    expect(onSteer).not.toHaveBeenCalled()
-    expect(onSubmit).not.toHaveBeenCalled()
-    expect(onCancel).not.toHaveBeenCalled()
-  })
-
-  it('runs slash commands immediately while busy', async () => {
-    const { clearDraft, hook, onCancel, onSteer, onSubmit, queueCurrentDraft } = renderSubmitHook({
-      busy: true,
-      text: '/compress preserve context'
-    })
-
-    act(() => {
-      hook.result.current.submitDraft()
-    })
-
-    await waitFor(() => expect(onSubmit).toHaveBeenCalledWith('/compress preserve context'))
-    expect(clearDraft).toHaveBeenCalledTimes(1)
-    expect(onSteer).not.toHaveBeenCalled()
-    expect(queueCurrentDraft).not.toHaveBeenCalled()
-    expect(onCancel).not.toHaveBeenCalled()
-  })
-
-  it('queues an attachment-bearing follow-up while busy', () => {
-    const attachment: ComposerAttachment = { id: 'doc', kind: 'file', label: 'notes.txt' }
-
-    const { hook, onCancel, onSteer, onSubmit, queueCurrentDraft } = renderSubmitHook({
-      attachments: [attachment],
-      busy: true,
-      text: 'read this'
-    })
-
-    act(() => {
-      hook.result.current.submitDraft()
-    })
-
-    expect(queueCurrentDraft).toHaveBeenCalledTimes(1)
-    expect(onSteer).not.toHaveBeenCalled()
-    expect(onSubmit).not.toHaveBeenCalled()
-    expect(onCancel).not.toHaveBeenCalled()
-  })
-
-  it('stops an active turn only with an empty composer', () => {
-    const { hook, onCancel, onSteer, onSubmit, queueCurrentDraft } = renderSubmitHook({ busy: true })
-
-    act(() => {
-      hook.result.current.submitDraft()
-    })
-
-    expect(onCancel).toHaveBeenCalledTimes(1)
-    expect(onSteer).not.toHaveBeenCalled()
-    expect(onSubmit).not.toHaveBeenCalled()
-    expect(queueCurrentDraft).not.toHaveBeenCalled()
-  })
-
-  it('submits a normal turn while idle', async () => {
-    const { hook, onCancel, onSteer, onSubmit, queueCurrentDraft } = renderSubmitHook({ text: 'ordinary question' })
-
-    act(() => {
-      hook.result.current.submitDraft()
-    })
-
-    await waitFor(() => expect(onSubmit).toHaveBeenCalledWith('ordinary question', { attachments: [] }))
-    expect(onSteer).not.toHaveBeenCalled()
-    expect(queueCurrentDraft).not.toHaveBeenCalled()
-    expect(onCancel).not.toHaveBeenCalled()
-  })
-})
@@ -17,7 +17,7 @@ interface UseComposerSubmitArgs {
  activeQueueSessionKeyRef: RefObject<string | null>
  attachments: ComposerAttachment[]
  busy: boolean
-  compacting: boolean
+  canSteer: boolean
  clearDraft: () => void
  disabled: boolean
  draftRef: RefObject<string>
@@ -43,7 +43,7 @@ interface UseComposerSubmitArgs {
 * queue meet. `submitDraft` is the one decision tree (queue-edit save · slash-
 * now-while-busy · queue · drain · send · stop); `dispatchSubmit` is the shared
 * send-with-restore primitive (re-loads + re-stashes the draft if the gateway
- * rejects, so nothing is ever lost); `steerDraft` redirects the live turn. Reads
+ * rejects, so nothing is ever lost); `steerDraft` nudges the live turn. Reads
 * the draft + queue APIs; owns no state of its own beyond the stable
 * external-submit listener ref.
 */
@@ -52,7 +52,7 @@ export function useComposerSubmit({
  activeQueueSessionKeyRef,
  attachments,
  busy,
-  compacting,
+  canSteer,
  clearDraft,
  disabled,
  draftRef,
@@ -151,14 +151,7 @@ export function useComposerSubmit({
        triggerHaptic('submit')
        clearDraft()
        dispatchSubmit(text)
-      } else if (!compacting && !attachments.length && text.trim()) {
-        // Cursor-style stop-and-correct: interrupt the live turn and redirect
-        // it with this text. redirect() preserves the shown reasoning/work; if
-        // the turn already ended, steerDraft re-queues so nothing is lost.
-        steerDraft()
      } else if (payloadPresent) {
-        // Attachments can't ride a redirect (no tool-result image carriage) —
-        // queue the whole payload for the next turn.
        queueCurrentDraft()
      } else {
        // Stop button (the only way to reach here while busy with an empty
@@ -180,18 +173,16 @@ export function useComposerSubmit({
    focusInput()
  }

-  // Redirect the live turn with a correction. The gateway either restarts the
-  // active model request with its displayed context or waits for the current
-  // tool boundary. If the turn already ended, queue the words instead.
+  // Steer the live turn (nudge without interrupting). Clears the draft up front
+  // for snappy feedback; if the gateway rejects (no live tool window) the words
+  // are re-queued so nothing is lost — same safety net as a plain queue.
  const steerDraft = () => {
-    const text = draftRef.current.trim()
-
-    // Guard on live editor state, not the render-lagged `canSteer`: a redirect
-    // fired on a fast Enter must not be dropped because state hasn't synced.
-    if (!onSteer || !text || attachments.length > 0 || SLASH_COMMAND_RE.test(text)) {
+    if (!onSteer || !canSteer) {
      return
    }

+    const text = draftRef.current.trim()
+
    triggerHaptic('submit')
    clearDraft()

@@ -202,14 +193,5 @@ export function useComposerSubmit({
    })
  }

-  const queueDraft = () => {
-    if (disabled || !busy) {
-      return
-    }
-
-    queueCurrentDraft()
-    focusInput()
-  }
-
-  return { dispatchSubmit, queueDraft, steerDraft, submitDraft }
+  return { dispatchSubmit, steerDraft, submitDraft }
 }
@@ -1,14 +1,7 @@
 import { useCallback, useEffect, useRef, useState } from 'react'

 import { useI18n } from '@/i18n'
-import { monitorSpeechDuringPlayback } from '@/lib/voice-barge-in'
-import {
-  markVoicePlaybackInterrupted,
-  playSpeechText,
-  type SpeechStreamSession,
-  startSpeechStream,
-  stopVoicePlayback
-} from '@/lib/voice-playback'
+import { playSpeechText, stopVoicePlayback } from '@/lib/voice-playback'
 import { notify, notifyError } from '@/store/notifications'

 import { useMicRecorder } from './use-mic-recorder'
@@ -51,9 +44,7 @@ export function useVoiceConversation({
  const awaitingSpokenResponseRef = useRef(false)
  const responseIdRef = useRef<string | null>(null)
  const spokenSourceLengthRef = useRef(0)
-  const speechSessionRef = useRef<null | SpeechStreamSession>(null)
-  const stopBargeMonitorRef = useRef<(() => void) | null>(null)
-  const bargeCapturePendingRef = useRef(false)
+  const speechBufferRef = useRef('')
  const enabledRef = useRef(enabled)
  const mutedRef = useRef(muted)
  const busyRef = useRef(busy)
@@ -83,13 +74,60 @@ export function useVoiceConversation({
    }
  }

-  const dropSpeechSession = () => {
-    stopBargeMonitorRef.current?.()
-    stopBargeMonitorRef.current = null
-    bargeCapturePendingRef.current = false
-    speechSessionRef.current = null
+  const resetSpeechBuffer = () => {
    responseIdRef.current = null
    spokenSourceLengthRef.current = 0
+    speechBufferRef.current = ''
+  }
+
+  const appendSpeechText = (text: string) => {
+    if (!text) {
+      return
+    }
+
+    speechBufferRef.current = `${speechBufferRef.current}${text}`
+  }
+
+  const takeSpeechChunk = (force = false): string | null => {
+    const buffer = speechBufferRef.current.replace(/\s+/g, ' ').trim()
+
+    if (!buffer) {
+      speechBufferRef.current = ''
+
+      return null
+    }
+
+    const sentence = buffer.match(/^(.+?[.!?。！？])(?:\s+|$)/)
+
+    if (sentence?.[1] && (sentence[1].length >= 8 || force)) {
+      const chunk = sentence[1].trim()
+      speechBufferRef.current = buffer.slice(sentence[1].length).trim()
+
+      return chunk
+    }
+
+    if (!force && buffer.length > 220) {
+      const softBoundary = Math.max(
+        buffer.lastIndexOf(', ', 180),
+        buffer.lastIndexOf('; ', 180),
+        buffer.lastIndexOf(': ', 180)
+      )
+
+      if (softBoundary > 80) {
+        const chunk = buffer.slice(0, softBoundary + 1).trim()
+        speechBufferRef.current = buffer.slice(softBoundary + 1).trim()
+
+        return chunk
+      }
+    }
+
+    if (!force) {
+      return null
+    }
+
+    speechBufferRef.current = ''
+
+    return buffer
  }

  const handleTurn = useCallback(
@@ -129,7 +167,7 @@ export function useVoiceConversation({
          }

          awaitingSpokenResponseRef.current = true
-          dropSpeechSession()
+          resetSpeechBuffer()
          await onSubmit(transcript)
          setStatus('thinking')
        } catch (error) {
@@ -155,10 +193,6 @@ export function useVoiceConversation({
      return
    }

-    if (bargeCapturePendingRef.current) {
-      return // the barge monitor is mid-capture and owns the mic
-    }
-
    if (statusRef.current !== 'idle') {
      return
    }
@@ -186,238 +220,24 @@ export function useVoiceConversation({
    }
  }, [handle, handleTurn, onFatalError, voiceCopy.couldNotStartSession, voiceCopy.microphoneFailed])

-  const settleAfterSpeech = useCallback(
-    (barged: boolean) => {
-      if (barged || !awaitingSpokenResponseRef.current) {
-        awaitingSpokenResponseRef.current = false
-        consumePendingResponse()
-      }
-
-      if (bargeCapturePendingRef.current) {
-        // The barge monitor is still capturing the user's interruption — it
-        // owns the next turn. Keep it alive and don't re-open the mic; the
-        // utterance callback transcribes and submits when they go quiet.
-        speechSessionRef.current = null
-        responseIdRef.current = null
-        spokenSourceLengthRef.current = 0
-        setStatus('listening')
-
-        return
-      }
-
-      dropSpeechSession()
-
-      if (enabledRef.current) {
-        pendingStartRef.current = true
-      }
-
-      setStatus('idle')
-    },
-    [consumePendingResponse]
-  )
-
-  /**
-   * Submit the utterance the barge monitor captured — the user's interruption
-   * from its first syllable, no re-listen round trip. Empty/failed captures
-   * fall back to normal listening.
-   */
-  const submitCapturedUtterance = useCallback(
-    async (audio: Blob | null) => {
-      const resumeListening = () => {
-        if (enabledRef.current && !mutedRef.current) {
-          pendingStartRef.current = true
-        }
-
-        setStatus('idle')
-      }
-
-      if (!audio || !onTranscribeAudio) {
-        resumeListening()
-
-        return
-      }
-
-      setStatus('transcribing')
-
-      try {
-        const transcript = (await onTranscribeAudio(audio)).trim()
-
-        if (!transcript) {
-          resumeListening()
-
-          return
-        }
-
-        awaitingSpokenResponseRef.current = true
-        dropSpeechSession()
-        consumePendingResponse()
-        await onSubmit(transcript)
-        setStatus('thinking')
-      } catch (error) {
-        notifyError(error, voiceCopy.transcriptionFailed)
-        resumeListening()
-      }
-    },
-    [consumePendingResponse, onSubmit, onTranscribeAudio, voiceCopy.transcriptionFailed]
-  )
-
-  /** Barge-in monitor wiring shared by the live and fallback speech paths. */
-  const openBargeMonitor = useCallback(
-    (onBarge: () => void) =>
-      monitorSpeechDuringPlayback({
-        onSpeech: () => {
-          bargeCapturePendingRef.current = true
-          onBarge()
-          markVoicePlaybackInterrupted()
-          stopVoicePlayback()
-        },
-        onUtterance: audio => {
-          bargeCapturePendingRef.current = false
-          stopBargeMonitorRef.current = null
-          void submitCapturedUtterance(audio)
-        }
-      }),
-    [submitCapturedUtterance]
-  )
-
-  /** Push any new reply text into the live session; finish when complete. */
-  const feedSpeechSession = useCallback(
-    (responseId: string) => {
-      const session = speechSessionRef.current
-
-      if (!session || responseIdRef.current !== responseId) {
-        return
-      }
-
-      const response = pendingResponse()
-
-      if (response && response.id === responseId) {
-        if (response.text.length > spokenSourceLengthRef.current) {
-          session.append(response.text.slice(spokenSourceLengthRef.current))
-          spokenSourceLengthRef.current = response.text.length
-        }
-
-        if (!response.pending && !busyRef.current) {
-          session.finish()
-        }
-      } else if (!busyRef.current) {
-        // Reply consumed/vanished while we were speaking — close out the turn.
-        session.finish()
-      }
-    },
-    [pendingResponse]
-  )
-
-  /** Whole-text fallback: wait for the reply to complete, then speak it. */
-  const awaitFallbackSpeech = useCallback(
-    (responseId: string) => {
-      const poll = () => {
-        if (responseIdRef.current !== responseId) {
-          return
-        }
-
-        const response = pendingResponse()
-
-        if (!response || response.id !== responseId) {
-          settleAfterSpeech(false)
-
-          return
-        }
-
-        if (response.pending || busyRef.current) {
-          window.setTimeout(poll, 250)
-
-          return
-        }
-
-        let barged = false
-
-        stopBargeMonitorRef.current?.()
-        stopBargeMonitorRef.current = openBargeMonitor(() => {
-          barged = true
-        })
-
-        void playSpeechText(response.text, { source: 'voice-conversation' })
-          .catch(error => notifyError(error, voiceCopy.playbackFailed))
-          .finally(() => {
-            if (responseIdRef.current === responseId) {
-              awaitingSpokenResponseRef.current = false
-              settleAfterSpeech(barged)
-            }
-          })
-      }
-
-      poll()
-    },
-    [openBargeMonitor, pendingResponse, settleAfterSpeech, voiceCopy.playbackFailed]
-  )
-
-  /**
-   * Live-speak the streaming reply: one speech session per response, fed
-   * incremental text as the assistant generates it. Audio overlaps generation
-   * — no wait for the full reply, no per-sentence gaps.
-   */
-  const openLiveSpeech = useCallback(
-    (responseId: string) => {
-      responseIdRef.current = responseId
-      spokenSourceLengthRef.current = 0
+  const speak = useCallback(
+    async (text: string) => {
      setStatus('speaking')

-      let barged = false
-
-      // VAD barge-in: the user talking over the reply cuts playback, drops
-      // the not-yet-spoken remainder, AND keeps capturing — the interruption
-      // is transcribed from its first syllable instead of losing the opening
-      // words to a mic re-open.
-      stopBargeMonitorRef.current = openBargeMonitor(() => {
-        barged = true
-      })
-
-      void (async () => {
-        const session = await startSpeechStream({ source: 'voice-conversation' })
-
-        // The session may resolve after the loop moved on (barge, disable).
-        if (responseIdRef.current !== responseId) {
-          if (session) {
-            stopVoicePlayback()
-          }
-
-          return
+      try {
+        await playSpeechText(text, { source: 'voice-conversation' })
+      } catch (error) {
+        notifyError(error, voiceCopy.playbackFailed)
+      } finally {
+        if (enabledRef.current) {
+          pendingStartRef.current = true
+          setStatus('idle')
+        } else {
+          setStatus('idle')
        }
-
-        if (!session) {
-          // No streaming backend/provider: speak the whole reply once it lands.
-          speechSessionRef.current = null
-          awaitFallbackSpeech(responseId)
-
-          return
-        }
-
-        speechSessionRef.current = session
-
-        // Timer-driven feed: reply text flows into the session at delta rate
-        // regardless of React render cadence.
-        const feedTimer = window.setInterval(() => feedSpeechSession(responseId), 150)
-        feedSpeechSession(responseId)
-
-        const outcome = await session.done
-        window.clearInterval(feedTimer)
-
-        if (responseIdRef.current !== responseId) {
-          return
-        }
-
-        if (outcome === 'fallback') {
-          awaitFallbackSpeech(responseId)
-
-          return
-        }
-
-        awaitingSpokenResponseRef.current = false
-        settleAfterSpeech(barged)
-      })()
+      }
    },
-    [awaitFallbackSpeech, feedSpeechSession, openBargeMonitor, settleAfterSpeech]
+    [voiceCopy.playbackFailed]
  )

  const start = useCallback(async () => {
@@ -434,7 +254,7 @@ export function useVoiceConversation({

    setMuted(false)
    awaitingSpokenResponseRef.current = false
-    dropSpeechSession()
+    resetSpeechBuffer()
    consumePendingResponse()
    pendingStartRef.current = true
    await startListening()
@@ -454,7 +274,7 @@ export function useVoiceConversation({
    handle.cancel()
    turnClosingRef.current = false
    awaitingSpokenResponseRef.current = false
-    dropSpeechSession()
+    resetSpeechBuffer()
    consumePendingResponse()
    setMuted(false)
    setStatus('idle')
@@ -505,9 +325,8 @@ export function useVoiceConversation({
    return () => window.removeEventListener('keydown', onKeyDown, { capture: true })
  }, [enabled, stopTurn])

-  // Drive the loop: when a voice-submitted reply appears, open a live speech
-  // session (which feeds itself from then on). Otherwise start listening when
-  // idle between turns.
+  // Drive the loop: after a voice-submitted turn, speak stable chunks as the
+  // assistant stream grows. Otherwise start listening when idle between turns.
  useEffect(() => {
    if (!enabled || muted) {
      return
@@ -517,15 +336,38 @@ export function useVoiceConversation({
      const response = pendingResponse()

      if (response) {
-        openLiveSpeech(response.id)
+        if (response.id !== responseIdRef.current) {
+          resetSpeechBuffer()
+          responseIdRef.current = response.id
+        }

-        return
+        if (response.text.length > spokenSourceLengthRef.current) {
+          appendSpeechText(response.text.slice(spokenSourceLengthRef.current))
+          spokenSourceLengthRef.current = response.text.length
+        }
+
+        const chunk = takeSpeechChunk(!response.pending && !busy)
+
+        if (chunk) {
+          void speak(chunk)
+
+          return
+        }
+
+        if (!response.pending && !busy) {
+          awaitingSpokenResponseRef.current = false
+          consumePendingResponse()
+          resetSpeechBuffer()
+          pendingStartRef.current = true
+          setStatus('idle')
+
+          return
+        }
      }

      if (!busy && status === 'thinking') {
-        // Turn finished without any speakable reply (tool-only, error).
        awaitingSpokenResponseRef.current = false
-        dropSpeechSession()
+        resetSpeechBuffer()
        pendingStartRef.current = true
        setStatus('idle')

@@ -540,7 +382,7 @@ export function useVoiceConversation({
    if (pendingStartRef.current) {
      void startListening()
    }
-  }, [busy, enabled, muted, openLiveSpeech, pendingResponse, startListening, status])
+  }, [busy, consumePendingResponse, enabled, muted, pendingResponse, speak, startListening, status])

  useEffect(() => {
    if (enabled && !wasEnabledRef.current) {
@@ -11,7 +11,6 @@ import { sanitizeComposerInput } from '@/lib/composer-input-sanitize'
 import { DATA_IMAGE_URL_RE } from '@/lib/embedded-images'
 import { triggerHaptic } from '@/lib/haptics'
 import { cn } from '@/lib/utils'
-import { $compactionActive } from '@/store/compaction'
 import { browseBackward, browseForward, deriveUserHistory, isBrowsingHistory } from '@/store/composer-input-history'
 import { POPOUT_WIDTH_REM } from '@/store/composer-popout'
 import { parkQueuedPrompts, removeQueuedPrompt, unparkQueuedPrompts } from '@/store/composer-queue'
@@ -105,7 +104,6 @@ export function ChatBar({
  // focus-bus key, and awaiting-input edge. Main scope = the legacy globals.
  const scope = useComposerScope()
  const attachments = useStore(scope.attachments.$attachments)
-  const compacting = useStore($compactionActive)
  const scrolledUp = useStore($threadScrolledUp)
  const autoSpeak = useStore($autoSpeakReplies)
  // The turn is parked on the user (clarify / approval / sudo / secret). Esc must
@@ -229,27 +227,20 @@ export function ChatBar({
  const { compactPill, stacked } = useComposerMetrics({ composerRef, composerSurfaceRef, editorRef, poppedOut })
  const hasComposerPayload = hasText || attachments.length > 0
  const canSubmit = busy || hasComposerPayload
+  const busyAction = busy && hasComposerPayload ? 'queue' : 'stop'

  // Steer only makes sense mid-turn, text-only (the gateway can't carry images
  // into a tool result) and never for a slash command (those execute inline).
-  const canSteer = busy && !compacting && !!onSteer && attachments.length === 0 && isSteerableText
-
-  // While busy: text redirects the live turn (Cursor-style stop-and-correct),
-  // attachments queue for the next turn, an empty composer stops.
-  const busyAction: 'steer' | 'queue' | 'stop' = canSteer
-    ? 'steer'
-    : compacting || hasComposerPayload
-      ? 'queue'
-      : 'stop'
+  const canSteer = busy && !!onSteer && attachments.length === 0 && isSteerableText

  // The submit engine — the orchestration seam where draft + queue meet. Owns
  // the submit decision tree, the send-with-restore primitive, and steer.
-  const { queueDraft, steerDraft, submitDraft } = useComposerSubmit({
+  const { steerDraft, submitDraft } = useComposerSubmit({
    activeQueueSessionKey,
    activeQueueSessionKeyRef,
    attachments,
    busy,
-    compacting,
+    canSteer,
    clearDraft,
    disabled,
    draftRef,
@@ -730,6 +721,7 @@ export function ChatBar({
      autoSpeak={autoSpeak}
      busy={busy}
      busyAction={busyAction}
+      canSteer={canSteer}
      canSubmit={canSubmit}
      compactModelPill={poppedOut || compactPill}
      conversation={{
@@ -745,7 +737,7 @@ export function ChatBar({
      disabled={disabled}
      hasComposerPayload={hasComposerPayload}
      onDictate={dictate}
-      onQueue={queueDraft}
+      onSteer={steerDraft}
      onToggleAutoSpeak={handleToggleAutoSpeak}
      state={state}
      voiceStatus={voiceStatus}
@@ -4,7 +4,6 @@ import { useNavigate } from 'react-router-dom'

 import { blurComposerInput } from '@/app/chat/composer/focus'
 import { AGENTS_ROUTE } from '@/app/routes'
-import { BillingBanner } from '@/components/billing-banner'
 import { composerDockCard } from '@/components/chat/composer-dock'
 import { StatusSection } from '@/components/chat/status-section'
 import { Button } from '@/components/ui/button'
@@ -12,7 +11,6 @@ import { Codicon } from '@/components/ui/codicon'
 import { Tip, TipKeybindLabel } from '@/components/ui/tooltip'
 import { type Translations, useI18n } from '@/i18n'
 import { cn } from '@/lib/utils'
-import { $billingBlock } from '@/store/billing-block'
 import {
  $statusItemsBySession,
  type ComposerStatusItem,
@@ -72,7 +70,6 @@ export function ComposerStatusStack({ queue, sessionId }: ComposerStatusStackPro
  const itemsBySession = useStore($statusItemsBySession)
  const previewsBySession = useStore($previewStatusBySession)
  const scrolledUp = useStore($threadScrolledUp)
-  const billing = useStore($billingBlock)

  const groups = useMemo(
    () => groupStatusItems(sessionId ? (itemsBySession[sessionId] ?? []) : []),
@@ -126,13 +123,6 @@ export function ComposerStatusStack({ queue, sessionId }: ComposerStatusStackPro

  const sections: { key: string; node: ReactNode }[] = []

-  // Billing wall sits at the very top of the stack — it's the most important
-  // thing above the composer when the account is out of credits. Rendered here
-  // (not as a composer-disable) so slash commands stay usable.
-  if (billing && sessionId && billing.sessionId === sessionId) {
-    sections.push({ key: 'billing', node: <BillingBanner sessionId={sessionId} /> })
-  }
-
  for (const group of groups) {
    sections.push({
      key: group.type,
@@ -31,10 +31,9 @@ export interface PaneMirror<T> {
  before?: (tile: T) => null | string | undefined
  minWidth: string
  title: (key: string) => string
-  /** Custom lead NODE for the tile's tab (rendered before the label). A live,
-   *  self-subscribing component (e.g. a session's status dot) so the strip needn't
-   *  re-sync on status/color change — only `title` drives re-registration. */
-  tabLead?: (key: string) => ReactNode
+  /** Lead-dot color for the tile's tab (e.g. a session's project color). Re-read
+   *  on every `also` change, so pass the color source in `also` to keep it live. */
+  accent?: (key: string) => string | undefined
  render: (key: string) => ReactNode
  /** Wrap the tile's TAB (domain context menu — session verbs). */
  tabWrap?: (key: string, tab: ReactElement) => ReactNode
@@ -53,7 +52,7 @@ export interface PaneMirror<T> {
 /** Build a `watch*` fn: syncs once, then re-syncs on every source/also change.
 *  Module-level state lives in the returned closure, so call it once per app. */
 export function paneMirror<T>(cfg: PaneMirror<T>): () => void {
-  const registered = new Map<string, { dispose: () => void; title: string }>()
+  const registered = new Map<string, { dispose: () => void; title: string; accent?: string }>()
  const paneId = (key: string) => `${cfg.prefix}:${key}`

  const sync = () => {
@@ -63,10 +62,11 @@ export function paneMirror<T>(cfg: PaneMirror<T>): () => void {
    for (const tile of tiles) {
      const key = cfg.key(tile)
      const title = cfg.title(key)
+      const accent = cfg.accent?.(key)
      const current = registered.get(key)

-      // register() replaces same-id in place — safe for live title refreshes.
-      if (current && current.title === title) {
+      // register() replaces same-id in place — safe for live title/accent refreshes.
+      if (current && current.title === title && current.accent === accent) {
        continue
      }

@@ -75,7 +75,7 @@ export function paneMirror<T>(cfg: PaneMirror<T>): () => void {
        area: 'panes',
        title,
        data: {
-          tabLead: cfg.tabLead ? () => cfg.tabLead!(key) : undefined,
+          accent,
          dock: {
            before: cfg.before?.(tile),
            pane: cfg.anchor?.(tile) ?? 'workspace',
@@ -92,7 +92,7 @@ export function paneMirror<T>(cfg: PaneMirror<T>): () => void {
        render: () => cfg.render(key)
      })

-      registered.set(key, { dispose, title })
+      registered.set(key, { dispose, title, accent })

      if (!current) {
        registerPaneCloser(paneId(key), () => cfg.close(key))
@@ -1,141 +0,0 @@
-import { useStore } from '@nanostores/react'
-
-import { type Translations, useI18n } from '@/i18n'
-import { cn } from '@/lib/utils'
-import { $backgroundRunningSessionIds } from '@/store/composer-status'
-import { $unreadFinishedSessionIds } from '@/store/session'
-import { $sessionColorById, sessionColorFor } from '@/store/session-color'
-import { $attentionSessionIds, $stalledSessionIds, $workingSessionIds } from '@/store/session-states'
-import type { SessionInfo } from '@/types/hermes'
-
-import { type SessionDotState, sessionDotState } from './sidebar/session-row-state'
-
-// A pure lookup table: each state maps to its className, aria-label, and title.
-// No priority resolution here — sessionDotState already picked one. Label/title
-// resolve from sidebar.row translations, keyed by name.
-type DotVariant = {
-  ariaLabel?: (r: Translations['sidebar']['row']) => string
-  className: string
-  role?: 'status'
-  title?: (r: Translations['sidebar']['row']) => string
-}
-
-// Shared base for every active dot; idle is smaller and uses its own class.
-const DOT_BASE = 'relative size-1.5 rounded-full'
-
-// Pseudo-element ping ring that scales outward and fades — shared scaffold for
-// the two pulsing dots. The `before:bg-*` color is written inline per variant
-// (NOT interpolated here): Tailwind only generates utilities it can see as
-// complete static strings, so a `before:bg-${color}` template never emits.
-const PING = "before:absolute before:inset-0 before:animate-ping before:rounded-full before:content-['']"
-
-const DOT_VARIANTS: Record<SessionDotState, DotVariant> = {
-  // Amber steady — a clarify/approval is blocking the turn. Steady (not
-  // pulsing) reads as "your turn", distinct from the accent pulse of a turn.
-  'needs-input': {
-    ariaLabel: r => r.needsInput,
-    className: `${DOT_BASE} quest-glow bg-amber-500`,
-    role: 'status',
-    title: r => r.waitingForAnswer
-  },
-  // Accent pulse — the LLM turn is actively running.
-  working: {
-    ariaLabel: r => r.sessionRunning,
-    className: `${DOT_BASE} bg-(--ui-accent) shadow-[0_0_0.625rem_color-mix(in_srgb,var(--ui-accent)_55%,transparent)] ${PING} before:bg-(--ui-accent) before:opacity-70`,
-    role: 'status'
-  },
-  // Quiet accent pulse — the turn is still authoritative-running, but no
-  // stream activity has arrived for the watchdog window.
-  stalled: {
-    ariaLabel: r => r.sessionRunning,
-    className: `${DOT_BASE} bg-(--ui-accent) opacity-70 ${PING} before:bg-(--ui-accent) before:opacity-40`,
-    role: 'status',
-    title: r => r.sessionRunning
-  },
-  // Pulsing gray — a terminal(background=true) process is alive while the LLM
-  // is idle. Gray (not accent) reads as "something chugging along". Brighter
-  // than muted-foreground so it's visible against the surface.
-  background: {
-    ariaLabel: r => r.backgroundRunning,
-    className: `${DOT_BASE} bg-muted-foreground/80 ${PING} before:bg-muted-foreground/80 before:opacity-60`,
-    role: 'status',
-    title: r => r.backgroundRunning
-  },
-  // Steady green — a background session's turn completed and the user hasn't
-  // opened it since. "Something new here, go look."
-  unread: {
-    ariaLabel: r => r.finishedUnread,
-    className: `${DOT_BASE} bg-emerald-500`,
-    role: 'status',
-    title: r => r.finishedUnread
-  },
-  idle: {
-    className: 'size-1 rounded-full bg-(--ui-text-quaternary) opacity-80'
-  }
-}
-
-export interface SessionStatusDotProps {
-  /** The STORED session id — the key every live-state atom (working /
-   *  attention / stalled / unread / background) is keyed by, on BOTH surfaces:
-   *  the sidebar row's `session.id` and a pane tile's `storedSessionId` are the
-   *  same stored id (`$workingSessionIds` et al. map `storedSessionId`). */
-  storedSessionId: string
-  /** The session row for color resolution — recents OR the project tree. Both
-   *  call sites already hold it; passing it lets the idle dot inherit the
-   *  project color even for a session older than the paginated recents page
-   *  (which has no `$sessionColorById` entry). */
-  session?: null | SessionInfo
-  /** TUI-style tree stem for a branched session (`└─ ` / `├─ `). */
-  branchStem?: string
-  /** Applied to the OUTER wrapper (stem + dot) — e.g. hover-fade on the
-   *  reorder handle. */
-  className?: string
-}
-
-/**
- * SESSION STATUS DOT — the ONE primitive both the sidebar row and the pane tab
- * render, so a session's status/color can never disagree between the two
- * surfaces. It reads every signal itself from the shared stores keyed by the
- * stored session id: live state (working / needs-input / stalled / unread /
- * background, mutually exclusive via `sessionDotState`) and the resolved color
- * (override → project color, via `sessionColorFor`). An idle session shows its
- * project color; the active states own the dot with their semantic color so an
- * attention cue is never masked by the inherited tint.
- */
-export function SessionStatusDot({ storedSessionId, session, branchStem, className }: SessionStatusDotProps) {
-  const { t } = useI18n()
-  const r = t.sidebar.row
-
-  // Subscribe to the shared color map for reactivity; sessionColorFor falls
-  // back to the resolver for a session outside the recents page.
-  useStore($sessionColorById)
-  const color = sessionColorFor(session) ?? null
-
-  const needsInput = useStore($attentionSessionIds).includes(storedSessionId)
-  const isWorking = useStore($workingSessionIds).includes(storedSessionId)
-  const isStalled = useStore($stalledSessionIds).includes(storedSessionId)
-  const isUnread = useStore($unreadFinishedSessionIds).includes(storedSessionId)
-  const hasBackground = useStore($backgroundRunningSessionIds).includes(storedSessionId)
-
-  const dotState = sessionDotState({ hasBackground, isStalled, isUnread, isWorking, needsInput })
-
-  return (
-    <span className={cn('flex items-center gap-0.5', className)}>
-      {branchStem ? (
-        <span aria-hidden className="shrink-0 font-mono text-[0.625rem] leading-none text-(--ui-text-quaternary)">
-          {branchStem}
-        </span>
-      ) : null}
-      {dotState === 'idle' && color ? (
-        <span aria-hidden="true" className="size-1 rounded-full" style={{ backgroundColor: color }} />
-      ) : (
-        <span
-          aria-label={DOT_VARIANTS[dotState].ariaLabel?.(r)}
-          className={DOT_VARIANTS[dotState].className}
-          role={DOT_VARIANTS[dotState].role}
-          title={DOT_VARIANTS[dotState].title?.(r)}
-        />
-      )}
-    </span>
-  )
-}
@@ -21,7 +21,6 @@ import { useEffect, useMemo, useRef } from 'react'

 import { useGatewayRequest } from '@/app/gateway/hooks/use-gateway-request'
 import { useModelControls } from '@/app/session/hooks/use-model-controls'
-import { resolveStoredSession } from '@/app/session/hooks/use-session-actions/utils'
 import { blobToDataUrl } from '@/app/session/hooks/use-prompt-actions/utils'
 import { ModelMenuPanel } from '@/app/shell/model-menu-panel'
 import { formatRefValue } from '@/components/assistant-ui/directive-text'
@@ -37,7 +36,6 @@ import { sessionTitle } from '@/lib/chat-runtime'
 import { createComposerAttachmentScope } from '@/store/composer'
 import { $pinnedSessionIds, pinSession, unpinSession } from '@/store/layout'
 import { $activeGatewayProfile } from '@/store/profile'
-import { $projectTree } from '@/store/projects'
 import { sessionAwaitingInput } from '@/store/prompts'
 import {
  $gatewayState,
@@ -46,6 +44,7 @@ import {
  sessionMatchesStoredId,
  sessionPinId
 } from '@/store/session'
+import { $sessionColorById, sessionColorFor } from '@/store/session-color'
 import {
  $sessionStates,
  $sessionTiles,
@@ -55,14 +54,12 @@ import {
  type SessionTile,
  sessionTileDelegate
 } from '@/store/session-states'
-import type { SessionInfo } from '@/types/hermes'

 import type { SessionDragPayload } from './composer/inline-refs'
 import { type ComposerScope, ComposerScopeProvider } from './composer/scope'
 import { useComposerActions } from './hooks/use-composer-actions'
 import { paneMirror } from './pane-mirror'
 import { startSessionDrag } from './session-drag'
-import { SessionStatusDot } from './session-status-dot'
 import { useSessionTileActions } from './session-tile-actions'
 import { type SessionView, SessionViewProvider } from './session-view'
 import { SessionContextMenu } from './sidebar/session-actions-menu'
@@ -202,53 +199,6 @@ export function SessionTilePane({ storedSessionId }: { storedSessionId: string }
  const resumingRef = useRef(false)
  const view = useMemo(() => buildTileView(storedSessionId), [storedSessionId])

-  // A tab-strip "+"/⌘T tab is created UNLISTED — its session stays out of
-  // $sessions (no sidebar clutter) until it's actually used, so the tab shows
-  // "New session". The moment this tile has a message, pull its row into
-  // $sessions via the lightweight by-id lookup so the tab (and a sidebar row)
-  // resolve the real title. `resolveStoredSession` no-ops when it's already
-  // listed, and 404s harmlessly for an in-memory draft that hasn't persisted a
-  // turn yet — so we retry across that brief persist lag and stop as soon as it
-  // lands (a global turn-complete refresh may beat us to it).
-  const hasMessages = useStore(view.$messagesEmpty) === false
-
-  useEffect(() => {
-    const alreadyListed = () => $sessions.get().some(s => sessionMatchesStoredId(s, storedSessionId))
-
-    if (!runtimeId || !hasMessages || alreadyListed()) {
-      return
-    }
-
-    let cancelled = false
-    let timer: number | undefined
-
-    const attempt = (remaining: number) => {
-      if (cancelled || alreadyListed()) {
-        return
-      }
-
-      void resolveStoredSession(storedSessionId)
-        .then(resolved => {
-          if (cancelled || resolved || remaining <= 0) {
-            return
-          }
-
-          timer = window.setTimeout(() => attempt(remaining - 1), 500)
-        })
-        .catch(() => undefined)
-    }
-
-    attempt(6)
-
-    return () => {
-      cancelled = true
-
-      if (timer !== undefined) {
-        window.clearTimeout(timer)
-      }
-    }
-  }, [hasMessages, runtimeId, storedSessionId])
-
  // Same gating as the primary's route resume (use-route-resume): never fire
  // session.resume before the gateway is OPEN. Persisted tiles mount at boot
  // while it's still connecting — an ungated resume rejected there and
@@ -328,34 +278,21 @@ export function SessionTilePane({ storedSessionId }: { storedSessionId: string }
 // Tile -> pane contribution sync (call once from the app root).
 // ---------------------------------------------------------------------------

-/** Resolve a tile's stored row: the recents list first, then the project
- *  tree. A session opened as a tab from a project group is often older than
- *  the paginated recents page, so it has no `$sessions` row at all until new
- *  activity lands it there — resolving through the tree keeps its tab titled
- *  and tinted instead of a grey "Session" placeholder. */
-export function tileStoredRow(storedSessionId: string): SessionInfo | undefined {
-  const match = (s: SessionInfo) => sessionMatchesStoredId(s, storedSessionId)
+function tileTitle(storedSessionId: string): string {
+  const stored = $sessions.get().find(s => sessionMatchesStoredId(s, storedSessionId))

-  return (
-    $sessions.get().find(match) ??
-    $projectTree
-      .get()
-      .flatMap(p => [...p.repos.flatMap(r => r.groups.flatMap(g => g.sessions)), ...(p.previewSessions ?? [])])
-      .find(match)
-  )
+  return stored ? sessionTitle(stored) : 'Session'
 }

-function tileTitle(storedSessionId: string): string {
-  const stored = tileStoredRow(storedSessionId)
-
-  // A tab-strip "+" tab is unlisted until its first turn persists, so it isn't
-  // in $sessions yet — label it "New session" rather than a bare "Session".
-  return stored ? sessionTitle(stored) : 'New session'
+/** The tab's lead-dot color — the tile's session resolved through the SAME
+ *  shared map the sidebar reads, so a row and its tab always agree. */
+function tileAccent(storedSessionId: string): string | undefined {
+  return sessionColorFor($sessions.get().find(s => sessionMatchesStoredId(s, storedSessionId)))
 }

 /** The `@session` link payload for a tile tab drag — id + owning profile + title. */
 function tileDragPayload(storedSessionId: string): SessionDragPayload {
-  const stored = tileStoredRow(storedSessionId)
+  const stored = $sessions.get().find(s => sessionMatchesStoredId(s, storedSessionId))

  return { id: storedSessionId, profile: stored?.profile ?? '', title: tileTitle(storedSessionId) }
 }
@@ -444,12 +381,9 @@ export function SessionTabMenu({
  /** Layout-tree pane id — powers the Close-others/right/all verbs. */
  tabPaneId: string
 }) {
-  // Subscribe for reactivity; the row is read imperatively via tileStoredRow
-  // (which spans both sources), so the values themselves are unused here.
-  useStore($sessions)
-  useStore($projectTree)
+  const sessions = useStore($sessions)
  const pinnedSessionIds = useStore($pinnedSessionIds)
-  const stored = tileStoredRow(storedSessionId)
+  const stored = sessions.find(s => sessionMatchesStoredId(s, storedSessionId))
  const pinId = stored ? sessionPinId(stored) : storedSessionId
  const pinned = pinnedSessionIds.includes(pinId)

@@ -506,10 +440,7 @@ export function WorkspaceTabMenu({ children }: { children: React.ReactElement })
 *  `$sessions`). Tiles dock against main on the chosen edge, flex width. */
 export const watchSessionTiles = paneMirror<SessionTile>({
  source: $sessionTiles,
-  // $projectTree: a tile whose session is older than the recents page resolves
-  // its title through the tree, which loads after the tiles register. (The tab's
-  // status dot subscribes to color/state itself, so it needs no `also` entry.)
-  also: [$sessions, $projectTree],
+  also: [$sessions, $sessionColorById],
  key: t => t.storedSessionId,
  prefix: 'session-tile',
  dir: t => t.dir,
@@ -517,13 +448,7 @@ export const watchSessionTiles = paneMirror<SessionTile>({
  before: t => t.before,
  minWidth: '20rem',
  title: tileTitle,
-  // The tab's status dot — the SAME primitive the sidebar row renders, keyed by
-  // the stored id, so a session's status/color can never disagree between the
-  // two surfaces. Self-subscribing (live state + resolved color), so the strip
-  // needn't re-sync when it changes.
-  tabLead: storedSessionId => (
-    <SessionStatusDot session={tileStoredRow(storedSessionId)} storedSessionId={storedSessionId} />
-  ),
+  accent: tileAccent,
  render: storedSessionId => <SessionTilePane storedSessionId={storedSessionId} />,
  tabWrap: (storedSessionId, tab) => (
    <SessionTabMenu
@@ -15,7 +15,7 @@ import {
 import type { HermesGitWorktree } from '@/global'
 import type { SessionInfo } from '@/hermes'
 import { useI18n } from '@/i18n'
-import { $dismissedWorktreeIds, dismissWorktree, setWorkspaceNodeOpen } from '@/store/layout'
+import { $dismissedWorktreeIds, dismissWorktree } from '@/store/layout'
 import { notifyError } from '@/store/notifications'
 import { removeWorktreePath } from '@/store/projects'

@@ -257,15 +257,7 @@ function RepoFlatSection({
      <WorkspaceHeader
        action={
          onNewSession && (
-            <WorkspaceAddButton
-              label={s.newSessionIn(repo.label)}
-              onClick={() => {
-                // Reveal the repo the new session targets if the user had it
-                // collapsed — the session lands in one of its lanes.
-                setWorkspaceNodeOpen(repo.id, true)
-                onNewSession(repo.path)
-              }}
-            />
+            <WorkspaceAddButton label={s.newSessionIn(repo.label)} onClick={() => onNewSession(repo.path)} />
          )
        }
        count={repoCount}
@@ -5,7 +5,7 @@ import type { HermesGitWorktree } from '@/global'
 import type { SessionInfo } from '@/hermes'
 import { desktopGit } from '@/lib/desktop-git'
 import { mapPool } from '@/lib/pool'
-import { $sidebarWorkspaceNodeOpen, toggleWorkspaceNodeCollapsed } from '@/store/layout'
+import { $sidebarWorkspaceCollapsedIds, toggleWorkspaceNodeCollapsed } from '@/store/layout'
 import { $worktreeRefreshToken } from '@/store/projects'

 import { sessionRecency, type SidebarProjectTree } from './workspace-groups'
@@ -123,13 +123,14 @@ export function useRepoWorktreeMap(
 // Persisted open/collapse for a repo/worktree node. Lets a project's folder
 // layout auto-restore when you enter it, and survive reloads.
 //
-// State is stored as the RESOLVED boolean per node (see `$sidebarWorkspaceNodeOpen`),
-// so a node whose `defaultOpen` flips — an empty worktree/branch lane defaults
-// collapsed, then defaults open once it holds a session — keeps whatever the
-// user explicitly chose instead of having it silently reinterpreted. An absent
-// id follows `defaultOpen`, so empty lanes still start collapsed until opened.
+// The persisted set is an OVERRIDE of `defaultOpen`, not an absolute "collapsed"
+// list: XOR lets one store serve both polarities. A default-open node (repo,
+// populated lane) lists collapses; a default-collapsed node (an EMPTY lane — no
+// sessions yet) instead records an explicit expand. So empty worktree/branch
+// lanes start collapsed and only open when the user clicks in.
 export function useWorkspaceNodeOpen(id: string, defaultOpen = true): [boolean, () => void] {
-  const state = useStore($sidebarWorkspaceNodeOpen)
+  const collapsed = useStore($sidebarWorkspaceCollapsedIds)
+  const overridden = collapsed.includes(id)

-  return [state[id] ?? defaultOpen, () => toggleWorkspaceNodeCollapsed(id, defaultOpen)]
+  return [defaultOpen ? !overridden : overridden, () => toggleWorkspaceNodeCollapsed(id)]
 }
@@ -4,7 +4,6 @@ import { useState } from 'react'
 import { Codicon } from '@/components/ui/codicon'
 import type { SessionInfo } from '@/hermes'
 import { useI18n } from '@/i18n'
-import { setWorkspaceNodeOpen } from '@/store/layout'
 import { notifyError } from '@/store/notifications'
 import { newSessionInProfile } from '@/store/profile'
 import { switchBranchInRepo } from '@/store/projects'
@@ -69,11 +68,6 @@ export function SidebarWorkspaceGroup({ group, renderRows, onNewSession, onRemov
  }

  const handleNewSession = async () => {
-    // Reveal the lane the new session targets — an empty worktree/branch lane
-    // starts collapsed, so without this the session lands in a folder the user
-    // can't see. Stable across the lane's default flipping open once populated.
-    setWorkspaceNodeOpen(group.id, true)
-
    if (isProfileGroup) {
      newSessionInProfile(group.id)

@@ -505,24 +505,6 @@ describe('liveSessionProjectId', () => {
    expect(id).toBe('p_app')
  })

-  it('places a cwd-outside-root session under an explicit project matching either path', () => {
-    // A mid-session relocation (or a sibling worktree) leaves cwd outside the
-    // recorded repo root. An explicit folder match is still authoritative —
-    // only the auto-project (repo root) fallback needs cwd-under-root
-    // confidence. Match via the repo root...
-    expect(
-      liveSessionProjectId(makeSession('/www/elsewhere', { git_repo_root: '/home/u/proj' }), [
-        makeProject('p_proj', ['/home/u/proj'])
-      ])
-    ).toBe('p_proj')
-    // ...and via the cwd.
-    expect(
-      liveSessionProjectId(makeSession('/www/elsewhere/sub', { git_repo_root: '/home/u/proj' }), [
-        makeProject('p_www', ['/www/elsewhere'])
-      ])
-    ).toBe('p_www')
-  })
-
  it('matches a mixed-case/separator Windows cwd to its explicit project in the live overlay', () => {
    // The bug: a fresh Windows session drops into the overlay before the next
    // backend refresh; case-sensitive matching missed its project until then.
@@ -571,14 +553,6 @@ describe('sessionProjectColor', () => {
    expect(sessionProjectColor(session, [colored('p_app', ['/www/app'], '#4a9eff')])).toBe('#4a9eff')
  })

-  it('colors a cwd-outside-root session when an explicit project folder matches', () => {
-    // The backend tree groups such a row under the project; the client color
-    // derivation must agree instead of leaving the row (and its tab) grey.
-    const session = makeSession('/www/elsewhere', { git_repo_root: '/home/u/proj' })
-
-    expect(sessionProjectColor(session, [colored('p_proj', ['/home/u/proj'], '#4a9eff')])).toBe('#4a9eff')
-  })
-
  it('returns null for a session that only maps to an auto repo root (no explicit project)', () => {
    // liveSessionProjectId falls back to the repo root id, which is not a
    // project row and therefore carries no color.
@@ -357,11 +357,7 @@ function isPathUnder(folder: string, target: string): boolean {
 * the overview at once instead of waiting for the next backend refresh. Returns
 * null only for sessions we genuinely can't place from the row alone: cwd-less,
 * kanban-task worktrees (they fold into the kanban bucket), or a worktree that
- * lives OUTSIDE the repo root (a sibling dir) AND under no explicit project
- * folder. An explicit-project folder match always places the row — even when
- * the row's cwd sits outside its recorded repo root (a mid-session relocation,
- * or a sibling worktree of a project repo), the folder match is authoritative;
- * only the repo-root AUTO-project fallback needs cwd-under-root confidence.
+ * lives OUTSIDE the repo root (a sibling dir whose project can't be derived).
 */
 export function liveSessionProjectId(session: SessionInfo, explicitProjects: ProjectInfo[]): null | string {
  const cwd = (session.cwd || '').trim()
@@ -376,6 +372,13 @@ export function liveSessionProjectId(session: SessionInfo, explicitProjects: Pro
    return null
  }

+  // With a cwd present it must sit under the repo root (a sibling worktree
+  // outside the root can't be placed from the row alone); a root-only session
+  // skips this — the root IS the anchor.
+  if (cwd && !isPathUnder(repoRoot, cwd)) {
+    return null
+  }
+
  let projectId = ''
  let bestLen = -1

@@ -396,19 +399,7 @@ export function liveSessionProjectId(session: SessionInfo, explicitProjects: Pro
    }
  }

-  if (projectId) {
-    return projectId
-  }
-
-  // AUTO-project fallback (the repo root itself): with a cwd present it must
-  // sit under the repo root (a sibling worktree outside the root can't be
-  // placed from the row alone); a root-only session skips this — the root IS
-  // the anchor.
-  if (cwd && !isPathUnder(repoRoot, cwd)) {
-    return null
-  }
-
-  return repoRoot
+  return projectId || repoRoot
 }

 /**
@@ -273,10 +273,7 @@ function useSessionActions({
  const workItems: ItemSpec[] = [
    spec({
      disabled: !onBranch,
-      // Fork glyph to match the inline message action's GitFork icon
-      // (assistant-message.tsx). NB: this codicon font has no `git-fork`
-      // glyph (only `git-fork-private`); `repo-forked` is the fork icon.
-      icon: 'repo-forked',
+      icon: 'git-branch',
      label: r.branchFrom,
      onSelect: () => {
        triggerHaptic('selection')
@@ -14,14 +14,15 @@ import { triggerHaptic } from '@/lib/haptics'
 import { handoffOriginSource, sessionSourceLabel } from '@/lib/session-source'
 import { coarseElapsed } from '@/lib/time'
 import { cn } from '@/lib/utils'
-import { $attentionSessionIds, openSessionTile } from '@/store/session-states'
+import { $backgroundRunningSessionIds } from '@/store/composer-status'
+import { $unreadFinishedSessionIds } from '@/store/session'
+import { $sessionColorById } from '@/store/session-color'
+import { $attentionSessionIds, $stalledSessionIds, openSessionTile } from '@/store/session-states'
 import { canOpenSessionWindow, openSessionInNewWindow } from '@/store/windows'

-import { SessionStatusDot } from '../session-status-dot'
-
 import { SidebarRowBody, SidebarRowGrab, SidebarRowLabel, SidebarRowLead, SidebarRowShell } from './chrome'
 import { SessionActionsMenu, SessionContextMenu } from './session-actions-menu'
-import { sessionShowsRunningArc } from './session-row-state'
+import { type SessionDotState, sessionDotState, sessionShowsRunningArc } from './session-row-state'
 import { useProfilePrewarm } from './use-profile-prewarm'

 interface SidebarSessionRowProps extends React.ComponentProps<'div'> {
@@ -87,6 +88,22 @@ export function SidebarSessionRow({
  const handoffLabel = handoffSource ? (sessionSourceLabel(handoffSource) ?? handoffSource) : null
  // True when a clarify prompt in this session is waiting on the user.
  const needsInput = useStore($attentionSessionIds).includes(session.id)
+  // True when the session's most recent turn finished in the background (while
+  // the user was viewing a different session) and hasn't been opened since.
+  const isUnread = useStore($unreadFinishedSessionIds).includes(session.id)
+  // True when the turn is still running but the stream has been quiet long
+  // enough to soften the animation. This must never look like an idle row.
+  const isStalled = useStore($stalledSessionIds).includes(session.id)
+  // True when a terminal(background=true) process is alive in this session.
+  const hasBackground = useStore($backgroundRunningSessionIds).includes(session.id)
+  // The session's resolved color (idle dot tint), read from the ONE shared map
+  // the pane tabs also read — an O(1) lookup, never re-derived per render.
+  const projectColor = useStore($sessionColorById)[session.id] ?? null
+
+  // Resolve the dot's display state once — the four signals are mutually
+  // exclusive by priority, so threading them as booleans through wrappers just
+  // to collapse them at the leaf is backwards.
+  const dotState = sessionDotState({ hasBackground, isStalled, isUnread, isWorking, needsInput })

  return (
    <SessionContextMenu
@@ -220,16 +237,16 @@ export function SidebarSessionRow({
              dragHandleProps={dragHandleProps}
              leadClassName={needsInput ? 'overflow-visible' : undefined}
            >
-              <SessionStatusDot
+              <SessionRowLeadDot
                branchStem={branchStem}
                className="transition-opacity group-hover/handle:opacity-0 group-focus-within/handle:opacity-0"
-                session={session}
-                storedSessionId={session.id}
+                dotState={dotState}
+                projectColor={projectColor}
              />
            </SidebarRowGrab>
          ) : (
            <SidebarRowLead className={needsInput ? 'overflow-visible' : 'overflow-hidden'}>
-              <SessionStatusDot branchStem={branchStem} session={session} storedSessionId={session.id} />
+              <SessionRowLeadDot branchStem={branchStem} dotState={dotState} projectColor={projectColor} />
            </SidebarRowLead>
          )}
          {handoffSource && handoffLabel ? (
@@ -250,3 +267,128 @@ export function SidebarSessionRow({
    </SessionContextMenu>
  )
 }
+
+function SessionRowLeadDot({
+  branchStem,
+  dotState = 'idle',
+  className,
+  projectColor
+}: {
+  branchStem?: string
+  dotState?: SessionDotState
+  className?: string
+  projectColor?: null | string
+}) {
+  return (
+    <span className={cn('flex items-center gap-0.5', className)}>
+      {branchStem ? (
+        <span aria-hidden className="shrink-0 font-mono text-[0.625rem] leading-none text-(--ui-text-quaternary)">
+          {branchStem}
+        </span>
+      ) : null}
+      <SidebarRowDot dotState={dotState} projectColor={projectColor} />
+    </span>
+  )
+}
+
+// A pure lookup table: each state maps to its className, aria-label, and
+// title. No priority resolution here — the call site already picked one.
+// Label/title are resolved from sidebar.row translations, keyed by name.
+type DotVariant = {
+  ariaLabel?: (r: Translations['sidebar']['row']) => string
+  className: string
+  role?: 'status'
+  title?: (r: Translations['sidebar']['row']) => string
+}
+
+// Shared base for every active dot; idle is smaller and uses its own class.
+const DOT_BASE = 'relative size-1.5 rounded-full'
+
+// Pseudo-element ping ring that scales outward and fades — shared scaffold for
+// the two pulsing dots. The `before:bg-*` color is written inline per variant
+// (NOT interpolated here): Tailwind only generates utilities it can see as
+// complete static strings, so a `before:bg-${color}` template never emits.
+const PING = "before:absolute before:inset-0 before:animate-ping before:rounded-full before:content-['']"
+
+const DOT_VARIANTS: Record<SessionDotState, DotVariant> = {
+  // Amber steady — a clarify/approval is blocking the turn. Steady (not
+  // pulsing) reads as "your turn", distinct from the accent pulse of a turn.
+  'needs-input': {
+    ariaLabel: r => r.needsInput,
+    className: `${DOT_BASE} quest-glow bg-amber-500`,
+    role: 'status',
+    title: r => r.waitingForAnswer
+  },
+  // Accent pulse — the LLM turn is actively running.
+  working: {
+    ariaLabel: r => r.sessionRunning,
+    className: `${DOT_BASE} bg-(--ui-accent) shadow-[0_0_0.625rem_color-mix(in_srgb,var(--ui-accent)_55%,transparent)] ${PING} before:bg-(--ui-accent) before:opacity-70`,
+    role: 'status'
+  },
+  // Quiet accent pulse — the turn is still authoritative-running, but no
+  // stream activity has arrived for the watchdog window.
+  stalled: {
+    ariaLabel: r => r.sessionRunning,
+    className: `${DOT_BASE} bg-(--ui-accent) opacity-70 ${PING} before:bg-(--ui-accent) before:opacity-40`,
+    role: 'status',
+    title: r => r.sessionRunning
+  },
+  // Pulsing gray — a terminal(background=true) process is alive while the LLM
+  // is idle. Gray (not accent) reads as "something chugging along". Brighter
+  // than muted-foreground so it's visible against the sidebar surface.
+  background: {
+    ariaLabel: r => r.backgroundRunning,
+    className: `${DOT_BASE} bg-muted-foreground/80 ${PING} before:bg-muted-foreground/80 before:opacity-60`,
+    role: 'status',
+    title: r => r.backgroundRunning
+  },
+  // Steady green — a background session's turn completed and the user hasn't
+  // opened it since. "Something new here, go look."
+  unread: {
+    ariaLabel: r => r.finishedUnread,
+    className: `${DOT_BASE} bg-emerald-500`,
+    role: 'status',
+    title: r => r.finishedUnread
+  },
+  idle: {
+    className: 'size-1 rounded-full bg-(--ui-text-quaternary) opacity-80'
+  }
+}
+
+function SidebarRowDot({
+  dotState,
+  className,
+  projectColor
+}: {
+  dotState: SessionDotState
+  className?: string
+  projectColor?: null | string
+}) {
+  const { t } = useI18n()
+  const r = t.sidebar.row
+
+  // An idle session inherits its project's color (a quiet marker matching the
+  // project row's own color dot). The active states (working / needs-input /
+  // background / unread) own the dot and keep their semantic color, so the
+  // inherited tint never competes with an attention cue.
+  if (dotState === 'idle' && projectColor) {
+    return (
+      <span
+        aria-hidden="true"
+        className={cn('size-1 rounded-full', className)}
+        style={{ backgroundColor: projectColor }}
+      />
+    )
+  }
+
+  const variant = DOT_VARIANTS[dotState]
+
+  return (
+    <span
+      aria-label={variant.ariaLabel?.(r)}
+      className={cn(variant.className, className)}
+      role={variant.role}
+      title={variant.title?.(r)}
+    />
+  )
+}
@@ -3,7 +3,6 @@ import { computed } from 'nanostores'
 import type { CSSProperties, ReactElement, PointerEvent as ReactPointerEvent } from 'react'

 import { PREVIEW_RAIL_MAX_WIDTH, PREVIEW_RAIL_MIN_WIDTH } from '@/app/chat/right-rail'
-import { SessionStatusDot } from '@/app/chat/session-status-dot'
 import { PALETTE_AREA, type PaletteContribution } from '@/app/command-palette/contrib'
 import { type StatusbarItem } from '@/app/shell/statusbar-controls'
 import { IdleMount } from '@/components/idle-mount'
@@ -54,6 +53,7 @@ import {
 import { $filePreviewTarget, $previewTarget, closeRightRail } from '@/store/preview'
 import { $reviewOpen, closeReview, REVIEW_PANE_ID } from '@/store/review'
 import { $currentCwd, $selectedStoredSessionId, $sessions, sessionMatchesStoredId } from '@/store/session'
+import { $sessionColorById, sessionColorFor } from '@/store/session-color'

 import type { SessionDragPayload } from '../chat/composer/inline-refs'
 import { watchRouteTiles } from '../chat/route-tile'
@@ -410,10 +410,9 @@ const syncWorkspaceTitle = () => {
    area: 'panes',
    title: stored ? storedSessionTitle(stored) : 'New session',
    data: {
-      // The tab's status dot — the SAME primitive the sidebar row and session
-      // tiles render, so the main tab never disagrees with its sidebar row. No
-      // dot on a fresh draft (no session yet).
-      tabLead: selected ? () => <SessionStatusDot session={stored} storedSessionId={selected} /> : undefined,
+      // The tab's lead dot — same shared map the sidebar row reads, so the
+      // main tab and its sidebar row always show the same color.
+      accent: sessionColorFor(stored),
      // Pages aren't tab-able: the main zone's bar stands down while one shows.
      headerVeto: $workspaceIsPage.get(),
      placement: 'main',
@@ -428,6 +427,7 @@ const syncWorkspaceTitle = () => {

 $selectedStoredSessionId.listen(syncWorkspaceTitle)
 $sessions.listen(syncWorkspaceTitle)
+$sessionColorById.listen(syncWorkspaceTitle)
 $workspaceIsPage.listen(syncWorkspaceTitle)

 // Layout reset collapses every session tile into main as a tab (after the
@@ -155,12 +155,10 @@ export function useDesktopIntegrations({
  // OS-standard window close, esp. secondary windows). The Win/Linux keyboard
  // path is the `view.closeTab` keybind (use-keybinds), sharing closeActiveTab.
  useEffect(() => {
-    const unsubscribe = window.hermesDesktop?.onClosePreviewRequested?.(() =>
-      void closeActiveTab(id => navigate(sessionRoute(id)))
-    )
+    const unsubscribe = window.hermesDesktop?.onClosePreviewRequested?.(() => void closeActiveTab())

    return () => unsubscribe?.()
-  }, [navigate])
+  }, [])

  // Another window mutated the shared session list -> re-pull the sidebar.
  useEffect(() => {
@@ -14,7 +14,6 @@ import { type CSSProperties, lazy, type ReactNode, Suspense, useCallback, useEff
 import { useLocation, useNavigate } from 'react-router-dom'

 import { formatRefValue } from '@/components/assistant-ui/directive-text'
-import { $newSessionTabAction } from '@/components/pane-shell/tree/store'
 import { BootFailureOverlay } from '@/components/boot-failure-overlay'
 import { DesktopInstallOverlay } from '@/components/desktop-install-overlay'
 import { GatewayConnectingOverlay } from '@/components/gateway-connecting-overlay'
@@ -28,12 +27,11 @@ import { type ChatMessage, chatMessageText, preserveLocalAssistantErrors, toChat
 import { sessionMessagesSignature } from '@/lib/session-signatures'
 import { isMessagingSource } from '@/lib/session-source'
 import { latestSessionTodos } from '@/lib/todos'
-import { $billingSettingsRequest } from '@/store/billing-block'
 import { setCronFocusJobId } from '@/store/cron'
 import { $pinnedSessionIds, pinSession, restoreWorktree, unpinSession } from '@/store/layout'
 import { $filePreviewTarget, $previewTarget } from '@/store/preview'
 import { $activeGatewayProfile, $freshSessionRequest, $profileScope, refreshActiveProfile } from '@/store/profile'
-import { $startWorkSessionRequest, followActiveSessionCwd } from '@/store/projects'
+import { $startWorkSessionRequest, followActiveSessionCwd, resolveNewSessionCwd } from '@/store/projects'
 import {
  $activeSessionId,
  $connection,
@@ -50,6 +48,8 @@ import {
  sessionPinId,
  setAwaitingResponse,
  setBusy,
+  setCurrentBranch,
+  setCurrentCwd,
  setCurrentModel,
  setCurrentModelSource,
  setCurrentProvider,
@@ -89,7 +89,6 @@ import { useRouteResume } from '../session/hooks/use-route-resume'
 import { useSessionActions } from '../session/hooks/use-session-actions'
 import { useSessionListActions } from '../session/hooks/use-session-list-actions'
 import { useSessionStateCache } from '../session/hooks/use-session-state-cache'
-import { startWorkspaceSession } from '../session/workspace-session-target'
 import { useOverlayRouting } from '../shell/hooks/use-overlay-routing'
 import { useWindowControlsOverlayWidth } from '../shell/hooks/use-window-controls-overlay-width'
 import { titlebarControlsPosition } from '../shell/titlebar'
@@ -127,10 +126,6 @@ export function ContribWiring({ children }: { children: ReactNode }) {

  const busyRef = useRef(false)
  const creatingSessionRef = useRef(false)
-  // Billing recovery routes to Settings → Billing from surfaces without router
-  // context (the sticky toast). The shell owns `navigate`, so it consumes the
-  // intent counter here; the ref skips the initial mount value.
-  const billingSettingsSeenRef = useRef(0)
  const messagingTranscriptSignatureRef = useRef(new Map<string, string>())
  // Stable identity for the whole callback surface (see WiringActions). Mutated
  // in place each render so memoized surfaces never re-render on churn.
@@ -138,20 +133,7 @@ export function ContribWiring({ children }: { children: ReactNode }) {

  const gatewayState = useStore($gatewayState)
  const activeSessionId = useStore($activeSessionId)
-  const billingSettingsRequest = useStore($billingSettingsRequest)
  const currentCwd = useStore($currentCwd)
-
-  useEffect(() => {
-    if (billingSettingsRequest === billingSettingsSeenRef.current) {
-      return
-    }
-
-    billingSettingsSeenRef.current = billingSettingsRequest
-
-    if (billingSettingsRequest > 0) {
-      navigate(`${SETTINGS_ROUTE}?tab=billing`)
-    }
-  }, [billingSettingsRequest, navigate])
  const freshDraftReady = useStore($freshDraftReady)
  const resumeFailedSessionId = useStore($resumeFailedSessionId)
  const resumeExhaustedSessionId = useStore($resumeExhaustedSessionId)
@@ -254,7 +236,10 @@ export function ContribWiring({ children }: { children: ReactNode }) {
    requestGateway
  })

-  const { refreshHermesConfig, sttEnabled, voiceMaxRecordingSeconds } = useHermesConfig({ activeSessionIdRef })
+  const { refreshHermesConfig, sttEnabled, voiceMaxRecordingSeconds } = useHermesConfig({
+    activeSessionIdRef,
+    refreshProjectBranch
+  })

  const { refreshCurrentModel, selectModel, updateModelOptionsCache } = useModelControls({
    queryClient,
@@ -465,16 +450,33 @@ export function ContribWiring({ children }: { children: ReactNode }) {
  // also drills the sidebar into that project so the new lane is visible.
  const startSessionInWorkspace = useCallback(
    (path: null | string) => {
-      startWorkspaceSession({
-        activeSessionIdRef,
-        followActiveSessionCwd,
-        onExplicitWorkspace: restoreWorktree,
-        path,
-        requestGateway,
-        startFreshSessionDraft
-      })
+      startFreshSessionDraft()
+
+      // A worktree lane carries its own path; the trunk "+" can be path-less
+      // (the main checkout is implicit), so fall back to the active project's
+      // root instead of no-op'ing on null.
+      const target = path?.trim() || resolveNewSessionCwd()
+
+      if (!target) {
+        return
+      }
+
+      setCurrentCwd(target)
+      void requestGateway<{ branch?: string; cwd?: string }>('config.get', { key: 'project', cwd: target })
+        .then(info => {
+          const resolved = info.cwd || target
+
+          setCurrentCwd(resolved)
+          setCurrentBranch(info.branch || '')
+
+          if (path?.trim()) {
+            restoreWorktree(resolved)
+            void followActiveSessionCwd(resolved)
+          }
+        })
+        .catch(() => undefined)
    },
-    [activeSessionIdRef, requestGateway, startFreshSessionDraft]
+    [requestGateway, startFreshSessionDraft]
  )

  // Composer "branch off into a new worktree": open a fresh session anchored
@@ -710,33 +712,15 @@ export function ContribWiring({ children }: { children: ReactNode }) {
    }
  }, [])

-  // The tab-strip "+" and ⌘T share one action: open a new session as its own
-  // tab (stacked into the workspace zone) WITHOUT polluting the session list.
-  // Created `listed: false`, so each new tab's in-memory session stays out of
-  // the sidebar until its first message persists a turn and a refresh surfaces
-  // it — Cursor-style. Every click opens a fresh "New session" tab (multiple
-  // empty tabs are fine since none touch the session list).
-  const openNewSessionTab = useCallback(() => {
-    void openNewSessionTile('center', { listed: false })
-  }, [openNewSessionTile])
-
  // Single global listener for every rebindable hotkey plus the on-screen
  // keybind editor's capture mode (same as DesktopController).
  useKeybinds({
-    openNewSessionTab,
+    openNewSessionTab: () => void openNewSessionTile('center'),
    startFreshSession: startFreshSessionDraft,
    toggleCommandCenter,
    toggleSelectedPin
  })

-  // Register the tab-strip "+" action (the generic renderer stays
-  // session-agnostic; null until wired hides the glyph).
-  useEffect(() => {
-    $newSessionTabAction.set(openNewSessionTab)
-
-    return () => $newSessionTabAction.set(null)
-  }, [openNewSessionTab])
-
  // The controller's entire callback surface, gathered into the stable
  // `actions` bag. `nextActions` is TS-checked against WiringActions each
  // render; its fields are copied into the ref object so `actions` keeps one
@@ -181,12 +181,10 @@ export function useKeybinds(deps: KeybindRuntimeDeps): void {
    'view.closeTerminal': () => $terminalTakeover.get() && closeActiveTerminal(),
    'view.flipPanes': togglePanesFlipped,
    // ⌘W: close the focused tab (terminal / preview target / zone tree tab).
-    // On the main tab with session tabs stacked, it shifts the next one in —
-    // the loader navigates to that session's route (loads it into main). On
-    // macOS the menu accelerator owns ⌘W and routes through the same
+    // On macOS the menu accelerator owns ⌘W and routes through the same
    // closeActiveTab via IPC (see use-desktop-integrations); this binding is
    // the Win/Linux path where ⌘W reaches the renderer directly.
-    'view.closeTab': () => void closeActiveTab(id => navigate(sessionRoute(id))),
+    'view.closeTab': () => void closeActiveTab(),
    'view.reopenTab': reopenLastClosedTile,

    'appearance.toggleMode': () => setMode(resolvedMode === 'dark' ? 'light' : 'dark'),
@@ -19,7 +19,7 @@ import { isDesktopFsRemoteMode } from '@/lib/desktop-fs'
 import { normalizeOrLocalPreviewTarget } from '@/lib/local-preview'
 import { cn } from '@/lib/utils'
 import { $renamingPath, copyFilePath, revealFile, toRelativePath } from '@/store/file-actions'
-import { $sidebarWorkspaceNodeOpen, revealFileInTree, toggleWorkspaceNodeCollapsed } from '@/store/layout'
+import { $sidebarWorkspaceCollapsedIds, revealFileInTree, toggleWorkspaceNodeCollapsed } from '@/store/layout'
 import { notifyError } from '@/store/notifications'
 import { setCurrentSessionPreviewTarget } from '@/store/preview'
 import {
@@ -198,9 +198,9 @@ function ReviewDirRow({
  motion: boolean
  node: ReviewTreeNode
 }) {
-  const nodeOpen = useStore($sidebarWorkspaceNodeOpen)
+  const collapsed = useStore($sidebarWorkspaceCollapsedIds)
  const id = `review:${node.id}`
-  const open = nodeOpen[id] ?? true
+  const open = !collapsed.includes(id)
  const toggle = () => toggleWorkspaceNodeCollapsed(id)

  return (
@@ -1,125 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { NEW_CHAT_ROUTE, sessionRoute, SETTINGS_ROUTE } from '../../routes'
-
-import { routeTargetFromToken, sessionContextDrift } from './session-context-drift'
-
-const SESS_A = 'sess-a'
-const SESS_B = 'sess-b'
-
-// Build a route token the way desktop-controller does: pathname:search:hash.
-const routeToken = (pathname: string, search = '', hash = '') => `${pathname}:${search}:${hash}`
-
-describe('routeTargetFromToken', () => {
-  it('maps a session route to its session id, a non-chat route to null, and the new-chat route to __new__', () => {
-    expect(routeTargetFromToken(routeToken(sessionRoute(SESS_A)))).toBe(SESS_A)
-    expect(routeTargetFromToken(routeToken(SETTINGS_ROUTE))).toBeNull()
-    expect(routeTargetFromToken(routeToken(NEW_CHAT_ROUTE))).toBe('__new__')
-  })
-
-  it('ignores search and hash — only the pathname selects the chat', () => {
-    expect(routeTargetFromToken(routeToken(sessionRoute(SESS_A), '?panel=preview', '#reply'))).toBe(SESS_A)
-  })
-
-  it('treats a colon-free token as a bare pathname', () => {
-    expect(routeTargetFromToken(sessionRoute(SESS_A))).toBe(SESS_A)
-  })
-})
-
-describe('sessionContextDrift', () => {
-  it('does not drift on search/hash-only route churn', () => {
-    const reason = sessionContextDrift({
-      startRouteToken: routeToken(sessionRoute(SESS_A)),
-      nowRouteToken: routeToken(sessionRoute(SESS_A), '?panel=preview', '#reply'),
-      startSelectedStoredId: SESS_A,
-      nowSelectedStoredId: SESS_A,
-      submitTargetStoredId: SESS_A
-    })
-
-    expect(reason).toBeNull()
-  })
-
-  it('does not drift on a selection null-reset (gateway/profile switch, reconnect)', () => {
-    const reason = sessionContextDrift({
-      startRouteToken: routeToken(sessionRoute(SESS_A)),
-      nowRouteToken: routeToken(sessionRoute(SESS_A)),
-      startSelectedStoredId: SESS_A,
-      nowSelectedStoredId: null,
-      submitTargetStoredId: SESS_A
-    })
-
-    expect(reason).toBeNull()
-  })
-
-  it('drifts when selection moves to a different non-null stored session', () => {
-    const reason = sessionContextDrift({
-      startRouteToken: routeToken(sessionRoute(SESS_A)),
-      nowRouteToken: routeToken(sessionRoute(SESS_A)),
-      startSelectedStoredId: SESS_A,
-      nowSelectedStoredId: SESS_B,
-      submitTargetStoredId: SESS_A
-    })
-
-    expect(reason).toBe('selection:sess-a->sess-b')
-  })
-
-  it('drifts when the routed session id changes to another session', () => {
-    const reason = sessionContextDrift({
-      startRouteToken: routeToken(sessionRoute(SESS_A)),
-      nowRouteToken: routeToken(sessionRoute(SESS_B)),
-      startSelectedStoredId: SESS_A,
-      nowSelectedStoredId: SESS_A,
-      submitTargetStoredId: SESS_A
-    })
-
-    expect(reason).toBe('route:sess-a->sess-b')
-  })
-
-  it('drifts when the route moves to the new-chat route mid-submit', () => {
-    const reason = sessionContextDrift({
-      startRouteToken: routeToken(sessionRoute(SESS_A)),
-      nowRouteToken: routeToken(NEW_CHAT_ROUTE),
-      startSelectedStoredId: SESS_A,
-      nowSelectedStoredId: SESS_A,
-      submitTargetStoredId: SESS_A
-    })
-
-    expect(reason).toBe('route:sess-a->__new__')
-  })
-
-  it('does not drift when the route moves to a non-chat route (null target)', () => {
-    const reason = sessionContextDrift({
-      startRouteToken: routeToken(sessionRoute(SESS_A)),
-      nowRouteToken: routeToken(SETTINGS_ROUTE),
-      startSelectedStoredId: SESS_A,
-      nowSelectedStoredId: SESS_A,
-      submitTargetStoredId: SESS_A
-    })
-
-    expect(reason).toBeNull()
-  })
-
-  it('does not drift when route and selection re-home onto the submit target (the create pipeline re-home)', () => {
-    const reason = sessionContextDrift({
-      startRouteToken: routeToken(NEW_CHAT_ROUTE),
-      nowRouteToken: routeToken(sessionRoute(SESS_A)),
-      startSelectedStoredId: null,
-      nowSelectedStoredId: SESS_A,
-      submitTargetStoredId: SESS_A
-    })
-
-    expect(reason).toBeNull()
-  })
-
-  it('drifts when a new-chat draft with no target yet is switched to an existing chat', () => {
-    const reason = sessionContextDrift({
-      startRouteToken: routeToken(NEW_CHAT_ROUTE),
-      nowRouteToken: routeToken(sessionRoute(SESS_B)),
-      startSelectedStoredId: null,
-      nowSelectedStoredId: SESS_B,
-      submitTargetStoredId: null
-    })
-
-    expect(reason).toBe('route:__new__->sess-b')
-  })
-})
@@ -1,84 +0,0 @@
-import { isNewChatRoute, routeSessionId } from '../../routes'
-
-/**
- * The chat a route token points at: the stored/routed session id, `'__new__'`
- * for the new-chat route, or null for a route that isn't a chat (settings and
- * the other overlay routes). Used to compare two route tokens by their *chat*
- * rather than their raw string.
- */
-export type RouteTarget = string | null
-
-/**
- * Reduce a route token to the chat it targets. The token is
- * `${pathname}:${search}:${hash}` (desktop-controller's routeToken), and only
- * the pathname selects the chat — search/hash carry overlay/panel state, so a
- * change there must not read as a session switch. We take the substring before
- * the first ':' as the pathname; that is safe because `location.pathname` never
- * contains a raw ':' (sessionRoute encodeURIComponent's the id, so a ':' in an
- * id arrives as %3A, and the app's other routes are literal colon-free paths).
- */
-export function routeTargetFromToken(token: string): RouteTarget {
-  const separator = token.indexOf(':')
-  const pathname = separator === -1 ? token : token.slice(0, separator)
-
-  return routeSessionId(pathname) ?? (isNewChatRoute(pathname) ? '__new__' : null)
-}
-
-interface SessionContextDriftArgs {
-  startRouteToken: string
-  nowRouteToken: string
-  startSelectedStoredId: string | null
-  nowSelectedStoredId: string | null
-  /**
-   * The stored session this submit is bound to, when known. Drift ignores a
-   * move *to* this id: the submit pipeline itself re-homes selection and route
-   * onto its target (a fresh create, a resume), and that self-inflicted move is
-   * not a user switch. Omit it (pre-create new-chat draft) to treat any move to
-   * a real chat as drift.
-   */
-  submitTargetStoredId?: string | null
-}
-
-/**
- * Decide whether the session context genuinely changed under an in-flight
- * submit — the user (or a real navigation) moved to a DIFFERENT chat — as
- * opposed to the programmatic churn a busy gateway produces constantly:
- *   - selection null-resets on a gateway/profile switch or reconnect
- *     (gateway-switch's `setSelectedStoredSessionId(null)`),
- *   - search/hash-only route changes from overlays and side panels,
- *   - background gateway events retargeting the active runtime id (#47709 class,
- *     which is why the active ref is not a prong here at all).
- * Returns null when nothing genuinely drifted, or a short reason string
- * (`route:<from>-><to>` / `selection:<from>-><to>`) for the abort log.
- */
-export function sessionContextDrift({
-  startRouteToken,
-  nowRouteToken,
-  startSelectedStoredId,
-  nowSelectedStoredId,
-  submitTargetStoredId
-}: SessionContextDriftArgs): string | null {
-  const targetStart = routeTargetFromToken(startRouteToken)
-  const targetNow = routeTargetFromToken(nowRouteToken)
-
-  // Route prong: the routed chat moved to a different, real chat. A null target
-  // (navigated to settings / a non-chat overlay route) or a search/hash-only
-  // change (same target) is not drift, and neither is landing on the submit's
-  // own target.
-  if (targetNow !== targetStart && targetNow !== null && targetNow !== submitTargetStoredId) {
-    return `route:${targetStart}->${targetNow}`
-  }
-
-  // Selection prong: selection moved to a different, real stored session. A
-  // null-reset (nowSelectedStoredId === null) or a move onto the submit's own
-  // target is not drift.
-  if (
-    nowSelectedStoredId !== null &&
-    nowSelectedStoredId !== startSelectedStoredId &&
-    nowSelectedStoredId !== submitTargetStoredId
-  ) {
-    return `selection:${startSelectedStoredId}->${nowSelectedStoredId}`
-  }
-
-  return null
-}
@@ -47,37 +47,133 @@ describe('useHermesConfig refreshHermesConfig', () => {
    persistString(WORKSPACE_CWD_KEY, null)
  })

-  it('does not let terminal.cwd replace an inactive selected workspace', async () => {
-    setCurrentCwd('/Users/example/repo/.worktrees/feature')
+  it('applies terminal.cwd from config even when localStorage has a stale value', async () => {
+    // Simulate a stale remembered workspace cwd
+    persistString(WORKSPACE_CWD_KEY, '/Users/old/stale-project')
+    setCurrentCwd('/Users/old/stale-project')

    mockConfig({ terminal: { cwd: '/Users/example/new-workspace' } })
-    const { result } = renderHook(() => useHermesConfig({ activeSessionIdRef: { current: null } }))
+
+    const { result } = renderHook(() =>
+      useHermesConfig({
+        activeSessionIdRef: { current: null },
+        refreshProjectBranch: vi.fn().mockResolvedValue(undefined)
+      })
+    )

    await act(async () => {
      await result.current.refreshHermesConfig()
    })

-    expect($currentCwd.get()).toBe('/Users/example/repo/.worktrees/feature')
+    // The configured terminal.cwd must override the stale localStorage value
+    expect($currentCwd.get()).toBe('/Users/example/new-workspace')
  })

-  it('does not let terminal.cwd replace an active session workspace', async () => {
-    setCurrentCwd('/Users/example/repo/.worktrees/attached')
+  it('keeps the active session workspace when a session is running', async () => {
+    setCurrentCwd('/workspace/attached-project')

    mockConfig({ terminal: { cwd: '/Users/example/new-workspace' } })
-    const { result } = renderHook(() => useHermesConfig({ activeSessionIdRef: { current: 'session-1' } }))
+
+    const { result } = renderHook(() =>
+      useHermesConfig({
+        activeSessionIdRef: { current: 'session-1' },
+        refreshProjectBranch: vi.fn().mockResolvedValue(undefined)
+      })
+    )

    await act(async () => {
      await result.current.refreshHermesConfig()
    })

-    expect($currentCwd.get()).toBe('/Users/example/repo/.worktrees/attached')
+    // Config refreshes mid-session must not yank the workspace out from
+    // under the attached session.
+    expect($currentCwd.get()).toBe('/workspace/attached-project')
+  })
+
+  it('uses empty string when terminal.cwd is not set and localStorage is empty', async () => {
+    mockConfig({})
+
+    const { result } = renderHook(() =>
+      useHermesConfig({
+        activeSessionIdRef: { current: null },
+        refreshProjectBranch: vi.fn().mockResolvedValue(undefined)
+      })
+    )
+
+    await act(async () => {
+      await result.current.refreshHermesConfig()
+    })
+
+    expect($currentCwd.get()).toBe('')
+  })
+
+  it('ignores terminal.cwd when it is "."', async () => {
+    mockConfig({ terminal: { cwd: '.' } })
+
+    const { result } = renderHook(() =>
+      useHermesConfig({
+        activeSessionIdRef: { current: null },
+        refreshProjectBranch: vi.fn().mockResolvedValue(undefined)
+      })
+    )
+
+    await act(async () => {
+      await result.current.refreshHermesConfig()
+    })
+
+    expect($currentCwd.get()).toBe('')
+  })
+
+  it('calls refreshProjectBranch with the configured cwd', async () => {
+    const refreshProjectBranch = vi.fn().mockResolvedValue(undefined)
+    setCurrentCwd('')
+
+    mockConfig({ terminal: { cwd: '/workspace/project-a' } })
+
+    const { result } = renderHook(() =>
+      useHermesConfig({
+        activeSessionIdRef: { current: null },
+        refreshProjectBranch
+      })
+    )
+
+    await act(async () => {
+      await result.current.refreshHermesConfig()
+    })
+
+    expect(refreshProjectBranch).toHaveBeenCalledWith('/workspace/project-a')
+  })
+
+  it('refreshes the branch for the session cwd (not config) when a session is active', async () => {
+    const refreshProjectBranch = vi.fn().mockResolvedValue(undefined)
+    setCurrentCwd('/workspace/attached-project')
+
+    mockConfig({ terminal: { cwd: '/Users/example/new-workspace' } })
+
+    const { result } = renderHook(() =>
+      useHermesConfig({
+        activeSessionIdRef: { current: 'session-1' },
+        refreshProjectBranch
+      })
+    )
+
+    await act(async () => {
+      await result.current.refreshHermesConfig()
+    })
+
+    expect(refreshProjectBranch).toHaveBeenCalledWith('/workspace/attached-project')
  })

  it('does not let a stale forced config refresh overwrite newer draft selector intent', async () => {
    const profileConfig = deferred<Awaited<ReturnType<typeof getHermesConfig>>>()
    vi.mocked(getHermesConfig).mockReturnValueOnce(profileConfig.promise)

-    const { result } = renderHook(() => useHermesConfig({ activeSessionIdRef: { current: null } }))
+    const { result } = renderHook(() =>
+      useHermesConfig({
+        activeSessionIdRef: { current: null },
+        refreshProjectBranch: vi.fn().mockResolvedValue(undefined)
+      })
+    )

    let pendingRefresh!: Promise<void>
    act(() => {
@@ -107,7 +203,12 @@ describe('useHermesConfig refreshHermesConfig', () => {
    const profileC = deferred<Awaited<ReturnType<typeof getHermesConfig>>>()
    vi.mocked(getHermesConfig).mockReturnValueOnce(profileB.promise).mockReturnValueOnce(profileC.promise)

-    const { result } = renderHook(() => useHermesConfig({ activeSessionIdRef: { current: null } }))
+    const { result } = renderHook(() =>
+      useHermesConfig({
+        activeSessionIdRef: { current: null },
+        refreshProjectBranch: vi.fn().mockResolvedValue(undefined)
+      })
+    )

    let refreshB!: Promise<void>
    let refreshC!: Promise<void>
@@ -4,9 +4,11 @@ import { getHermesConfig, getHermesConfigDefaults } from '@/hermes'
 import { BUILTIN_PERSONALITIES, normalizePersonalityValue, personalityNamesFromConfig } from '@/lib/chat-runtime'
 import { normalize } from '@/lib/text'
 import {
+  $currentCwd,
  getComposerSelectionGeneration,
  getCurrentModelSource,
  setAvailablePersonalities,
+  setCurrentCwd,
  setCurrentFastMode,
  setCurrentPersonality,
  setCurrentReasoningEffort,
@@ -41,9 +43,10 @@ function normalizeConfigEffort(value: unknown): string {

 interface HermesConfigOptions {
  activeSessionIdRef: MutableRefObject<string | null>
+  refreshProjectBranch: (cwd: string) => Promise<void>
 }

-export function useHermesConfig({ activeSessionIdRef }: HermesConfigOptions) {
+export function useHermesConfig({ activeSessionIdRef, refreshProjectBranch }: HermesConfigOptions) {
  const [voiceMaxRecordingSeconds, setVoiceMaxRecordingSeconds] = useState(DEFAULT_VOICE_SECONDS)
  const [sttEnabled, setSttEnabled] = useState(true)
  const profileRefreshEpochRef = useRef(0)
@@ -80,6 +83,16 @@ export function useHermesConfig({ activeSessionIdRef }: HermesConfigOptions) {
          ])
        ])

+        const cwd = (config.terminal?.cwd ?? '').trim()
+
+        if (cwd && cwd !== '.') {
+          // Configured terminal.cwd beats a stale remembered workspace cwd
+          // (#38855) — but never yank the workspace out from under an active
+          // session; those keep their own cwd until the user detaches.
+          setCurrentCwd(prev => (activeSessionIdRef.current ? prev : cwd))
+          void refreshProjectBranch($currentCwd.get() || cwd)
+        }
+
        const reasoning = normalizeConfigEffort(config.agent?.reasoning_effort)
        const tier = (config.agent?.service_tier ?? '').trim()

@@ -102,7 +115,7 @@ export function useHermesConfig({ activeSessionIdRef }: HermesConfigOptions) {
        // Config is nice-to-have; chat still works without it.
      }
    },
-    [activeSessionIdRef]
+    [activeSessionIdRef, refreshProjectBranch]
  )

  return { refreshHermesConfig, sttEnabled, voiceMaxRecordingSeconds }
@@ -79,14 +79,4 @@ describe('useMessageStream compaction lifecycle', () => {

    expect($compactingSessions.get()).toEqual({ [OTHER_SID]: true })
  })
-
-  it('clears the compaction phase on the structured completion edge', async () => {
-    await mountStream()
-    setSessionCompacting(OTHER_SID, true)
-
-    emit('status.update', { kind: 'compacting' })
-    emit('status.update', { kind: 'compacted' })
-
-    expect($compactingSessions.get()).toEqual({ [OTHER_SID]: true })
-  })
 })
@@ -1,4 +1,3 @@
-import type { BillingBlock } from '@hermes/shared'
 import type { HermesSkin } from '@hermes/shared/skin'
 import type { QueryClient } from '@tanstack/react-query'
 import { type MutableRefObject, useCallback, useEffect, useRef } from 'react'
@@ -16,7 +15,6 @@ import { triggerHaptic } from '@/lib/haptics'
 import { modelOptionsQueryKey } from '@/lib/model-options'
 import { isProviderSetupErrorMessage } from '@/lib/provider-setup-errors'
 import { reconcileApprovalModeForProfile } from '@/store/approval-mode'
-import { billingCtaLabel, clearBillingBlock, runBillingRecovery, setBillingBlock } from '@/store/billing-block'
 import { clearClarifyRequest, setClarifyRequest } from '@/store/clarify'
 import { setSessionCompacting } from '@/store/compaction'
 import { refreshBackgroundProcesses } from '@/store/composer-status'
@@ -24,7 +22,6 @@ import { $gateway } from '@/store/gateway'
 import { dispatchNativeNotification } from '@/store/native-notifications'
 import { notify } from '@/store/notifications'
 import { requestDesktopOnboarding } from '@/store/onboarding'
-import { revealDesktopPane } from '@/store/pane-focus'
 import { flashPetActivity, markPetUnread, setPetActivity } from '@/store/pet'
 import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 import { followActiveSessionCwd } from '@/store/projects'
@@ -59,50 +56,6 @@ import type { ClientSessionState } from '../../../types'

 import { hasSessionInfoStatePatch, sessionInfoStatePatch, SUBAGENT_EVENT_TYPES, toTodoPayload } from './utils'

-function firstBillingLine(text: string): string {
-  return (text || '').split('\n')[0]?.trim() ?? ''
-}
-
-/**
- * A turn failed on a billing wall (out of credits / payment required). The
- * gateway forwards the structured descriptor built by `agent/billing_links.py`;
- * we cache it per-session (drives the in-chat banner) AND raise one sticky,
- * billing-specific toast — never the generic "Hermes error" — with a smart CTA
- * (Nous → in-app Settings → Billing, other providers → their billing page).
- */
-function surfaceBillingBlock(sessionId: string, raw: unknown): void {
-  if (!raw || typeof raw !== 'object') {
-    return
-  }
-
-  const block = raw as BillingBlock
-
-  if (typeof block.provider !== 'string') {
-    return
-  }
-
-  setBillingBlock(sessionId, block)
-
-  const ctaCopy = {
-    addCredits: translateNow('billingBlock.addCredits'),
-    openBilling: translateNow('billingBlock.openBilling')
-  }
-
-  notify({
-    // Collapse repeat walls from the same provider into one toast.
-    id: `billing-block:${block.provider}`,
-    kind: 'warning',
-    icon: 'credit-card',
-    title: block.is_nous
-      ? translateNow('billingBlock.titleNous')
-      : translateNow('billingBlock.titleProvider', block.provider_label),
-    message: firstBillingLine(block.message) || translateNow('billingBlock.fallbackMessage'),
-    // Sticky: a credit wall blocks every turn until resolved.
-    durationMs: 0,
-    action: { label: billingCtaLabel(block, ctaCopy), onClick: () => runBillingRecovery(block) }
-  })
-}
-
 const COMPACTION_RESUME_EVENT_TYPES = new Set([
  'message.delta',
  'message.interim',
@@ -436,9 +389,6 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
        setSessionCompacting(sessionId, false)
        compactedTurnRef.current.delete(sessionId)
        nativeSubagentSessionsRef.current.delete(sessionId)
-        // A fresh turn on this session optimistically clears its billing wall;
-        // if credits are still exhausted the next failure re-raises it.
-        clearBillingBlock(sessionId)

        if (isActiveEvent) {
          triggerHaptic('streamStart')
@@ -562,12 +512,6 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
        const finalText = coerceGatewayText(payload?.text) || coerceGatewayText(payload?.rendered)
        completeAssistantMessage(sessionId, finalText, payload?.response_previewed)

-        // Structured billing wall forwarded by the gateway (out of credits /
-        // payment required) — cache it + raise a billing-specific toast.
-        if (payload?.billing) {
-          surfaceBillingBlock(sessionId, payload.billing)
-        }
-
        if (isActiveEvent) {
          setTurnStartedAt(null)

@@ -806,21 +750,10 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
        // Agent closed its own read-only tab via the desktop-gated close_terminal tool.
        // The process is untouched — this only drops the view.
        closeAgentTerminalByProc(payload?.process_id ?? '')
-      } else if (event.type === 'pane.reveal') {
-        // Agent revealed a pane via the desktop-gated focus_pane tool, in
-        // response to an explicit user request. Active session only — a
-        // background turn must never move the user's focus (desktop AGENTS.md:
-        // offer, don't hijack).
-        if (isActiveEvent) {
-          revealDesktopPane(payload?.pane ?? '')
-        }
      } else if (event.type === 'status.update') {
        if (sessionId && payload?.kind === 'compacting') {
          setSessionCompacting(sessionId, true)
          compactedTurnRef.current.add(sessionId)
-        } else if (sessionId && payload?.kind === 'compacted') {
-          setSessionCompacting(sessionId, false)
-          compactedTurnRef.current.delete(sessionId)
        } else if (sessionId && payload?.kind === 'process') {
          // The gateway's notification poller announces background process
          // completions / watch matches here — re-sync the status stack.
@@ -55,13 +55,6 @@ interface QueuedStreamDeltas {
  reasoning: string
 }

-// Date.now() alone can collide when an interim seal and the next segment's
-// first delta land in the same millisecond — the new segment would then find
-// the sealed bubble by id and append into it instead of starting fresh.
-let streamMessageSeq = 0
-
-const nextStreamMessageId = (prefix: string) => `${prefix}-${Date.now()}-${++streamMessageSeq}`
-
 export function useMessageStream({
  activeGatewayProfile = 'default',
  activeSessionIdRef,
@@ -98,7 +91,7 @@ export function useMessageStream({
            return state
          }

-          const streamId = state.streamId ?? nextStreamMessageId('assistant-stream')
+          const streamId = state.streamId ?? `assistant-stream-${Date.now()}`
          const groupId = state.pendingBranchGroup ?? undefined
          const prev = state.messages
          let nextMessages: ChatMessage[]
@@ -404,21 +397,19 @@ export function useMessageStream({
        let nextMessages = state.messages

        if (streamId && nextMessages.some(m => m.id === streamId)) {
-          // Seal the streaming bubble in place, marked interim so it renders
-          // without an action footer (see ChatMessage.interim).
+          // Finalize the existing streaming bubble in place
          nextMessages = nextMessages.map(m =>
-            m.id === streamId ? { ...m, parts: replaceTextPart(m.parts), pending: false, interim: true } : m
+            m.id === streamId ? { ...m, parts: replaceTextPart(m.parts), pending: false } : m
          )
        } else {
          // No streaming bubble — create a standalone interim message
          nextMessages = [
            ...nextMessages,
            {
-              id: nextStreamMessageId('assistant-interim'),
+              id: `assistant-interim-${Date.now()}`,
              role: 'assistant' as const,
              parts: [assistantTextPart(authoritativeText)],
              pending: false,
-              interim: true,
              branchGroupId: state.pendingBranchGroup ?? undefined
            }
          ]
@@ -468,15 +459,19 @@ export function useMessageStream({
          return mergeFinalAssistantText(parts, visibleFinalText)
        }

-        // Settling the final response onto a bubble makes it the turn's real
-        // reply — clear `interim` so it regains the action footer.
-        const completeMessage = (message: ChatMessage): ChatMessage => {
-          const settled = { ...message, pending: false, interim: false }
-
-          return completionError
-            ? { ...settled, error: completionError, parts: message.parts.filter(part => part.type !== 'text') }
-            : { ...settled, parts: replaceTextPart(message.parts) }
-        }
+        const completeMessage = (message: ChatMessage): ChatMessage =>
+          completionError
+            ? {
+                ...message,
+                error: completionError,
+                parts: message.parts.filter(part => part.type !== 'text'),
+                pending: false
+              }
+            : {
+                ...message,
+                parts: replaceTextPart(message.parts),
+                pending: false
+              }

        const newAssistantFromCompletion = (): ChatMessage => ({
          id: `assistant-${Date.now()}`,
@@ -111,36 +111,6 @@ describe('useMessageStream interim text sealing', () => {
    expect(texts).toContain('All checks passed.')
  })

-  it('marks sealed interim bubbles interim and leaves the final reply unmarked', async () => {
-    await mountStream()
-    await start()
-
-    await delta('Let me check the files.')
-    await interim('Let me check the files.')
-    await delta('Now the second pass.')
-    await interim('Now the second pass.')
-    await complete('All done.')
-
-    const assistants = getState().messages.filter(m => m.role === 'assistant' && !m.hidden)
-    const byText = (text: string) => assistants.find(m => chatMessageText(m) === text)
-
-    expect(byText('Let me check the files.')?.interim).toBe(true)
-    expect(byText('Now the second pass.')?.interim).toBe(true)
-    expect(byText('All done.')?.interim).toBeFalsy()
-  })
-
-  it('clears the interim mark when a previewed final settles onto the interim bubble', async () => {
-    await mountStream()
-    await start()
-
-    await interim('same reply')
-    await completePreviewed('same reply')
-
-    const assistants = getState().messages.filter(m => m.role === 'assistant' && !m.hidden)
-    expect(assistants).toHaveLength(1)
-    expect(assistants[0].interim).toBeFalsy()
-  })
-
  it('dedupes interim text when the final response includes it', async () => {
    await mountStream()
    await start()
@@ -120,46 +120,6 @@ describe('usePreviewRouting', () => {
    expect(window.hermesDesktop.normalizePreviewTarget).not.toHaveBeenCalled()
  })

-  it('opens the preview pane on a preview.open event for the active session', async () => {
-    render(
-      <PreviewRoutingHarness
-        onEvent={handler => {
-          handleEvent = handler
-        }}
-      />
-    )
-
-    act(() =>
-      handleEvent({
-        payload: { url: 'https://www.cnn.com', label: 'CNN' },
-        session_id: 'session-1',
-        type: 'preview.open'
-      })
-    )
-
-    await waitFor(() => {
-      expect($previewTarget.get()).toMatchObject({ kind: 'url', label: 'CNN', url: 'https://www.cnn.com' })
-    })
-  })
-
-  it('ignores a preview.open event for a background session', async () => {
-    render(
-      <PreviewRoutingHarness
-        onEvent={handler => {
-          handleEvent = handler
-        }}
-      />
-    )
-
-    act(() =>
-      handleEvent({ payload: { url: 'https://www.cnn.com' }, session_id: 'other-session', type: 'preview.open' })
-    )
-
-    // Give any (wrongly) scheduled async open a tick to resolve before asserting.
-    await Promise.resolve()
-    expect($previewTarget.get()).toBeNull()
-  })
-
  it('does not auto-open a preview from tool results', async () => {
    render(
      <PreviewRoutingHarness
@@ -2,7 +2,6 @@ import { useStore } from '@nanostores/react'
 import { type MutableRefObject, useCallback, useEffect } from 'react'

 import { gatewayEventCompletedFileDiff } from '@/lib/gateway-events'
-import { normalizeOrLocalPreviewTarget } from '@/lib/local-preview'
 import {
  $previewTarget,
  $sessionPreviewRegistry,
@@ -11,7 +10,6 @@ import {
  getSessionPreviewRecord,
  progressPreviewServerRestart,
  requestPreviewReload,
-  setCurrentSessionPreviewTarget,
  setPreviewTarget
 } from '@/store/preview'
 import { $currentCwd } from '@/store/session'
@@ -103,30 +101,6 @@ export function usePreviewRouting({
    event => {
      baseHandleGatewayEvent(event)

-      if (event.type === 'preview.open') {
-        // Agent-driven open in response to an explicit user request ("show
-        // cnn.com in the preview pane"). Honor it only for the active session —
-        // a background turn must not yank the pane open (see desktop AGENTS.md:
-        // offer, don't hijack). Routes through the same normalizer as the file
-        // browser so URLs, localhost, and file paths all resolve correctly.
-        const { url, label } = asRecord(event.payload)
-        const target = typeof url === 'string' ? url.trim() : ''
-
-        if (target && (!event.session_id || event.session_id === activeSessionIdRef.current)) {
-          void normalizeOrLocalPreviewTarget(target, $currentCwd.get() || currentCwd || undefined).then(resolved => {
-            if (resolved) {
-              const trimmedLabel = typeof label === 'string' ? label.trim() : ''
-              setCurrentSessionPreviewTarget(
-                trimmedLabel ? { ...resolved, label: trimmedLabel } : resolved,
-                'tool-result'
-              )
-            }
-          })
-        }
-
-        return
-      }
-
      if (event.type === 'preview.restart.complete') {
        const { task_id, text } = asRecord(event.payload)

@@ -152,7 +126,7 @@ export function usePreviewRouting({
        requestPreviewReload()
      }
    },
-    [activeSessionIdRef, baseHandleGatewayEvent, currentCwd]
+    [activeSessionIdRef, baseHandleGatewayEvent]
  )

  return { handleDesktopGatewayEvent, restartPreviewServer }
@@ -5,18 +5,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

 import { textPart } from '@/lib/chat-messages'
 import { $composerAttachments, $composerDraft, type ComposerAttachment, setComposerDraft } from '@/store/composer'
-import { $notifications, clearNotifications } from '@/store/notifications'
-import {
-  $busy,
-  $connection,
-  $currentUsage,
-  $messages,
-  $sessions,
-  $turnStartedAt,
-  setCurrentUsage,
-  setMessages,
-  setSessions
-} from '@/store/session'
+import { $busy, $connection, $messages, $sessions, $turnStartedAt, setSessions } from '@/store/session'
 import type { SessionInfo } from '@/types/hermes'

 import type { SubmitTextOptions } from './utils'
@@ -72,10 +61,7 @@ interface HarnessHandle {
  activeSessionIdRef: MutableRefObject<string | null>
  cancelRun: () => Promise<void>
  restoreToMessage: (messageId: string, target?: { text?: string; userOrdinal?: number | null }) => Promise<void>
-  redirectPrompt: (text: string) => Promise<boolean>
-  /** @deprecated Use `redirectPrompt`. */
  steerPrompt: (text: string) => Promise<boolean>
-  submitTextRaw: (text: string, options?: SubmitTextOptions) => Promise<boolean>
  submitText: (text: string, options?: SubmitTextOptions) => Promise<boolean>
 }

@@ -112,7 +98,7 @@ function Harness({
  onSeedState?: (state: Record<string, unknown>) => void
  openMemoryGraph?: () => void
  refreshSessions: () => Promise<void>
-  requestGateway: <T>(method: string, params?: Record<string, unknown>, timeoutMs?: number) => Promise<T>
+  requestGateway: <T>(method: string, params?: Record<string, unknown>) => Promise<T>
  resumeStoredSession?: (storedSessionId: string) => Promise<void> | void
  seedMessages?: unknown[]
  selectedStoredSessionIdRef?: MutableRefObject<string | null>
@@ -174,18 +160,14 @@ function Harness({
        act(async () => actions.cancelRun(...args)) as Promise<void>,
      restoreToMessage: (...args: Parameters<typeof actions.restoreToMessage>) =>
        act(async () => actions.restoreToMessage(...args)) as Promise<void>,
-      redirectPrompt: (...args: Parameters<typeof actions.redirectPrompt>) =>
-        act(async () => actions.redirectPrompt(...args)) as Promise<boolean>,
      steerPrompt: (...args: Parameters<typeof actions.steerPrompt>) =>
        act(async () => actions.steerPrompt(...args)) as Promise<boolean>,
-      submitTextRaw: actions.submitText,
      submitText: (...args: Parameters<typeof actions.submitText>) =>
        act(async () => actions.submitText(...args)) as Promise<boolean>
    })
  }, [
    actions.cancelRun,
    actions.restoreToMessage,
-    actions.redirectPrompt,
    actions.steerPrompt,
    actions.submitText,
    activeSessionIdRef,
@@ -296,513 +278,6 @@ describe('usePromptActions /title', () => {
  })
 })

-// Helper: extract rendered text parts from captured updateSessionState seeds.
-function renderedSeedTexts(seeds: Record<string, unknown>[]): string[] {
-  return seeds.flatMap(state => {
-    const messages = Array.isArray(state.messages)
-      ? (state.messages as Array<{ parts?: Array<{ text?: string }> }>)
-      : []
-
-    return messages.flatMap(message => (message.parts ?? []).map(part => part.text ?? ''))
-  })
-}
-
-describe('usePromptActions /compress', () => {
-  beforeEach(() => {
-    setSessions(() => [sessionInfo()])
-  })
-
-  afterEach(() => {
-    cleanup()
-    clearNotifications()
-    setCurrentUsage({ calls: 0, input: 0, output: 0, total: 0 })
-    setMessages([])
-    vi.restoreAllMocks()
-  })
-
-  it('routes through session.compress (not slash.exec) with a 120s timeout and renders the summary', async () => {
-    const seeds: Record<string, unknown>[] = []
-
-    const requestGateway = vi.fn(async (method: string, _params?: Record<string, unknown>, _timeoutMs?: number) => {
-      if (method === 'session.compress') {
-        return {
-          removed: 8,
-          summary: {
-            headline: 'Compressed: 234 → 226 messages',
-            noop: false,
-            token_line: 'Approx request size: ~285,727 → ~198,104 tokens'
-          }
-        } as never
-      }
-
-      return {} as never
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={s => seeds.push(s)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    await handle!.submitText('/compress')
-
-    // The dedicated RPC is the TUI's path and has no slash-worker pipe
-    // timeout — and the call carries an LLM-sized client timeout instead of
-    // the 30s WS default, so a large session's compression can finish.
-    expect(requestGateway).toHaveBeenCalledWith(
-      'session.compress',
-      expect.objectContaining({ session_id: RUNTIME_SESSION_ID }),
-      120_000
-    )
-    expect(requestGateway).not.toHaveBeenCalledWith('slash.exec', expect.anything())
-    expect(requestGateway).not.toHaveBeenCalledWith('command.dispatch', expect.anything())
-  })
-
-  it('replaces the transcript from the response messages', async () => {
-    const seeds: Record<string, unknown>[] = []
-
-    const requestGateway = vi.fn(async (method: string, _params?: Record<string, unknown>, _timeoutMs?: number) => {
-      if (method === 'session.compress') {
-        return {
-          removed: 2,
-          summary: { headline: 'Compressed: 4 → 2 messages' },
-          messages: [
-            { role: 'user', content: 'summarized context' },
-            { role: 'assistant', content: 'sure, here is the summary' }
-          ]
-        } as never
-      }
-
-      return {} as never
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={s => seeds.push(s)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    await handle!.submitText('/compress')
-
-    // The transcript was replaced with the post-compress history.
-    const finalMessages = seeds[seeds.length - 1]?.messages as Array<{ parts?: Array<{ text?: string }> }>
-
-    const renderedText = (finalMessages ?? [])
-      .flatMap(message => (message.parts ?? []).map(part => part.text ?? ''))
-      .join('\n')
-
-    expect(renderedText).toContain('summarized context')
-    expect(renderedText).toContain('sure, here is the summary')
-  })
-
-  it('uses the compute-host response transcript and success output', async () => {
-    const seeds: Record<string, unknown>[] = []
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.compress') {
-        return {
-          host_ack: { output: 'Compressed 4 → 2 messages' },
-          messages: [
-            { role: 'user', content: 'compute-host summary' },
-            { role: 'assistant', content: 'compute-host answer' }
-          ]
-        } as never
-      }
-
-      return {} as never
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={s => seeds.push(s)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    await handle!.submitText('/compress')
-
-    const computeHostTexts = renderedSeedTexts(seeds)
-    expect(computeHostTexts).toEqual(expect.arrayContaining(['compute-host summary', 'compute-host answer']))
-    expect(computeHostTexts.some(text => text.includes('Compressed 4 → 2 messages'))).toBe(true)
-    expect($notifications.get()).toEqual(
-      expect.arrayContaining([expect.objectContaining({ message: 'Compressed 4 → 2 messages' })])
-    )
-  })
-
-  it('renders an aborted compression as an error, not a success', async () => {
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.compress') {
-        return {
-          status: 'aborted',
-          summary: {
-            aborted: true,
-            headline: 'Compression aborted: 6 messages preserved',
-            note: 'No compression provider is configured.'
-          }
-        } as never
-      }
-
-      return {} as never
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness onReady={h => (handle = h)} refreshSessions={async () => undefined} requestGateway={requestGateway} />
-    )
-
-    await handle!.submitText('/compress')
-
-    expect($notifications.get()).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ kind: 'error', message: expect.stringContaining('Compression aborted') })
-      ])
-    )
-    expect($notifications.get()).not.toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ kind: 'success', message: expect.stringContaining('Compression aborted') })
-      ])
-    )
-  })
-
-  it('passes a focus topic through as focus_topic', async () => {
-    const requestGateway = vi.fn(
-      async (_method: string, _params?: Record<string, unknown>, _timeoutMs?: number) => ({ removed: 0 }) as never
-    )
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness onReady={h => (handle = h)} refreshSessions={async () => undefined} requestGateway={requestGateway} />
-    )
-
-    await handle!.submitText('/compress the auth refactor')
-
-    expect(requestGateway).toHaveBeenCalledWith(
-      'session.compress',
-      expect.objectContaining({ focus_topic: 'the auth refactor' }),
-      120_000
-    )
-  })
-
-  it('surfaces the RPC error verbatim (e.g. the busy guard) instead of a routing error', async () => {
-    const seeds: Record<string, unknown>[] = []
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.compress') {
-        throw new Error('session busy — /interrupt the current turn before /compress')
-      }
-
-      return {} as never
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={s => seeds.push(s)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    await handle!.submitText('/compress')
-
-    const texts = renderedSeedTexts(seeds)
-    expect(texts.some(text => text.includes('session busy'))).toBe(true)
-    expect(texts.some(text => text.includes('not a quick/plugin/skill command'))).toBe(false)
-  })
-
-  it('falls back to the slash worker when an older gateway lacks session.compress', async () => {
-    const seeds: Record<string, unknown>[] = []
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.compress') {
-        throw new Error('method not found: session.compress')
-      }
-
-      if (method === 'slash.exec') {
-        return { output: 'compressed by legacy gateway' } as never
-      }
-
-      throw new Error(`unexpected method: ${method}`)
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={s => seeds.push(s)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    await handle!.submitText('/compress')
-
-    expect(requestGateway).toHaveBeenCalledWith('slash.exec', expect.objectContaining({ command: 'compress' }))
-    expect(renderedSeedTexts(seeds).some(text => text.includes('compressed by legacy gateway'))).toBe(true)
-  })
-
-  it('does not clobber the foreground transcript when compression resolves after a session switch', async () => {
-    const RUNTIME_SESSION_B = 'rt-session-b'
-    const storedSessionIdRef: MutableRefObject<string | null> = { current: 'stored-a' }
-    const updates: Array<{ sessionId: string; storedSessionId: null | string | undefined }> = []
-
-    let resolveCompress: (value: unknown) => void = () => undefined
-
-    const compressResult = new Promise(resolve => {
-      resolveCompress = resolve
-    })
-
-    const activeSessionIdRef: MutableRefObject<string | null> = { current: RUNTIME_SESSION_ID }
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.compress') {
-        return (await compressResult) as never
-      }
-
-      throw new Error(`unexpected method: ${method}`)
-    })
-
-    setMessages([{ id: 'foreground-b', parts: [textPart('session B transcript')], role: 'user', timestamp: 0 }])
-    setCurrentUsage({ calls: 7, input: 70, output: 30, total: 100 })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        activeSessionIdRef={activeSessionIdRef}
-        onReady={h => (handle = h)}
-        onUpdateState={(sessionId, storedSessionId) => updates.push({ sessionId, storedSessionId })}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-        selectedStoredSessionIdRef={storedSessionIdRef}
-      />
-    )
-
-    // Start the request in a synchronous act. The async `submitText` harness
-    // helper cannot be used here: this test intentionally keeps its promise
-    // pending while the user switches sessions, which would leave React's
-    // async act scope open and overlap the wait below.
-    let submitted: Promise<boolean>
-    act(() => {
-      submitted = handle!.submitTextRaw('/compress')
-    })
-    await waitFor(() => expect(requestGateway).toHaveBeenCalledWith('session.compress', expect.anything(), 120_000))
-
-    // Switch to session B before compression resolves.
-    activeSessionIdRef.current = RUNTIME_SESSION_B
-    resolveCompress({
-      info: { usage: { context_used: 4_000, total: 12_000 } },
-      messages: [{ content: 'compressed session A transcript', role: 'system' }],
-      removed: 5
-    })
-    await act(async () => {
-      await submitted
-    })
-
-    // The foreground transcript + usage are unchanged — the late result only
-    // updated session A's cache, not the active session B's.
-    expect($messages.get()).toEqual([
-      { id: 'foreground-b', parts: [textPart('session B transcript')], role: 'user', timestamp: 0 }
-    ])
-    expect($currentUsage.get()).toEqual(expect.objectContaining({ calls: 7, input: 70, output: 30, total: 100 }))
-    expect(updates).toContainEqual({ sessionId: RUNTIME_SESSION_ID, storedSessionId: 'stored-a' })
-  })
-
-  it('keeps a late compression error bound to its invocation-time stored session', async () => {
-    const RUNTIME_SESSION_B = 'rt-session-b'
-    const storedSessionIdRef: MutableRefObject<string | null> = { current: 'stored-a' }
-    const activeSessionIdRef: MutableRefObject<string | null> = { current: RUNTIME_SESSION_ID }
-    const updates: Array<{ sessionId: string; storedSessionId: null | string | undefined }> = []
-    let rejectCompress: (reason?: unknown) => void = () => undefined
-
-    const compressResult = new Promise((_, reject) => {
-      rejectCompress = reject
-    })
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.compress') {
-        return (await compressResult) as never
-      }
-
-      throw new Error(`unexpected method: ${method}`)
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        activeSessionIdRef={activeSessionIdRef}
-        onReady={h => (handle = h)}
-        onUpdateState={(sessionId, storedSessionId) => updates.push({ sessionId, storedSessionId })}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-        selectedStoredSessionIdRef={storedSessionIdRef}
-      />
-    )
-
-    // Keep the RPC pending while the selected stored session changes without
-    // leaving an async React act scope open (see the foreground-race test).
-    let submitted: Promise<boolean>
-    act(() => {
-      submitted = handle!.submitTextRaw('/compress')
-    })
-    await waitFor(() => expect(requestGateway).toHaveBeenCalledWith('session.compress', expect.anything(), 120_000))
-    activeSessionIdRef.current = RUNTIME_SESSION_B
-    storedSessionIdRef.current = 'stored-b'
-    rejectCompress(new Error('compression failed'))
-    await act(async () => {
-      await submitted
-    })
-
-    expect(updates).toContainEqual({ sessionId: RUNTIME_SESSION_ID, storedSessionId: 'stored-a' })
-  })
-  it('shows a compression progress toast outside the transcript', async () => {
-    let resolveCompress: (value: unknown) => void = () => undefined
-
-    const compressResult = new Promise(resolve => {
-      resolveCompress = resolve
-    })
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.compress') {
-        return (await compressResult) as never
-      }
-
-      throw new Error(`unexpected method: ${method}`)
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness onReady={h => (handle = h)} refreshSessions={async () => undefined} requestGateway={requestGateway} />
-    )
-
-    const submitted = handle!.submitTextRaw('/compress')
-    await waitFor(() => expect($notifications.get().some(item => item.message === 'compressing context...')).toBe(true))
-    resolveCompress({ messages: [{ content: 'compressed transcript', role: 'system' }] })
-    await submitted
-  })
-})
-
-describe('usePromptActions exec fallback error reporting', () => {
-  beforeEach(() => {
-    setSessions(() => [sessionInfo()])
-  })
-
-  afterEach(() => {
-    cleanup()
-    vi.restoreAllMocks()
-  })
-
-  it('surfaces the slash.exec failure when command.dispatch only adds "not a quick/plugin/skill command"', async () => {
-    const seeds: Record<string, unknown>[] = []
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'slash.exec') {
-        throw new Error('slash worker timed out')
-      }
-
-      if (method === 'command.dispatch') {
-        throw new Error('not a quick/plugin/skill command: debug')
-      }
-
-      return {} as never
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={s => seeds.push(s)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    // /debug still goes through exec (no dedicated RPC), so it exercises the
-    // slash.exec → command.dispatch fallback + error unmasking path.
-    await handle!.submitText('/debug')
-
-    // The dispatch fallback knowing nothing about /debug is routing noise;
-    // the worker timeout is what actually went wrong (#44456).
-    const texts = renderedSeedTexts(seeds)
-    expect(texts.some(text => text.includes('slash worker timed out'))).toBe(true)
-    expect(texts.some(text => text.includes('not a quick/plugin/skill command'))).toBe(false)
-  })
-
-  it('falls back to slash.exec when an older gateway lacks a dedicated RPC', async () => {
-    const seeds: Record<string, unknown>[] = []
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.status') {
-        throw new Error('method not found: session.status')
-      }
-
-      if (method === 'slash.exec') {
-        return { output: 'session status from slash worker' } as never
-      }
-
-      throw new Error(`unexpected method: ${method}`)
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={s => seeds.push(s)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    await handle!.submitText('/status')
-
-    expect(requestGateway).toHaveBeenCalledWith('session.status', expect.anything(), undefined)
-    expect(requestGateway).toHaveBeenCalledWith('slash.exec', expect.objectContaining({ command: 'status' }))
-    expect(renderedSeedTexts(seeds).some(text => text.includes('session status from slash worker'))).toBe(true)
-  })
-
-  it('still reports a real command.dispatch failure for skill/quick commands', async () => {
-    const seeds: Record<string, unknown>[] = []
-
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'slash.exec') {
-        throw new Error('skill command: use command.dispatch for /my-skill')
-      }
-
-      if (method === 'command.dispatch') {
-        throw new Error('quick command failed with exit code 1')
-      }
-
-      return {} as never
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={s => seeds.push(s)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    await handle!.submitText('/my-skill')
-
-    const texts = renderedSeedTexts(seeds)
-    expect(texts.some(text => text.includes('quick command failed with exit code 1'))).toBe(true)
-  })
-})
-
 describe('usePromptActions slash.exec dispatch payloads', () => {
  afterEach(() => {
    cleanup()
@@ -1056,40 +531,6 @@ describe('usePromptActions submit / queue drain semantics', () => {
    )
  })

-  it('flags prompt.submit with interrupted:true after a voice-playback barge', async () => {
-    const { markVoicePlaybackInterrupted } = await import('@/lib/voice-playback')
-    const requestGateway = vi.fn(async () => ({}) as never)
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness onReady={h => (handle = h)} refreshSessions={async () => undefined} requestGateway={requestGateway} />
-    )
-
-    markVoicePlaybackInterrupted()
-    await handle!.submitText('stop! rude interruption')
-
-    // The latch is one-shot: the flag rides this submit, the next is clean.
-    expect(requestGateway).toHaveBeenCalledWith(
-      'prompt.submit',
-      {
-        session_id: RUNTIME_SESSION_ID,
-        text: 'stop! rude interruption',
-        interrupted: true
-      },
-      1_800_000
-    )
-
-    await handle!.submitText('follow-up without a barge')
-    expect(requestGateway).toHaveBeenLastCalledWith(
-      'prompt.submit',
-      {
-        session_id: RUNTIME_SESSION_ID,
-        text: 'follow-up without a barge'
-      },
-      1_800_000
-    )
-  })
-
  it('a fromQueue drain sends even when busyRef is still true on the settle edge', async () => {
    // busyRef lags $busy by one effect tick on the busy→false settle edge, so a
    // drained queue send would otherwise hit the busy guard and silently no-op.
@@ -1262,41 +703,32 @@ describe('usePromptActions submit / queue drain semantics', () => {
  })
 })

-describe('usePromptActions redirectPrompt', () => {
+describe('usePromptActions steerPrompt', () => {
  afterEach(() => {
    cleanup()
    vi.restoreAllMocks()
  })

-  it('redirects the live turn with trimmed correction text', async () => {
-    const requestGateway = vi.fn(async () => ({ status: 'redirected' }) as never)
+  it('injects the trimmed text via session.steer and reports acceptance on a queued status', async () => {
+    const requestGateway = vi.fn(async () => ({ status: 'queued' }) as never)

    let handle: HarnessHandle | null = null
-    const capturedStates: Record<string, unknown>[] = []
    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={state => capturedStates.push(state)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
+      <Harness onReady={h => (handle = h)} refreshSessions={async () => undefined} requestGateway={requestGateway} />
    )

-    const accepted = await handle!.redirectPrompt('  nudge the run  ')
+    const accepted = await handle!.steerPrompt('  nudge the run  ')

    expect(accepted).toBe(true)
-    expect(requestGateway).toHaveBeenCalledWith('session.redirect', {
+    // Steer never starts a turn — it rides the live run via session.steer only.
+    expect(requestGateway).toHaveBeenCalledWith('session.steer', {
      session_id: RUNTIME_SESSION_ID,
      text: 'nudge the run'
    })
    expect(requestGateway).not.toHaveBeenCalledWith('prompt.submit', expect.anything())
-    expect((capturedStates.at(-1)?.messages as unknown[]).at(-1)).toMatchObject({
-      role: 'user',
-      parts: [{ type: 'text', text: 'nudge the run' }]
-    })
  })

-  it('reports rejection so the caller queues when the turn already ended', async () => {
+  it('reports rejection (so the caller queues) when the gateway has no live tool window', async () => {
    const requestGateway = vi.fn(async () => ({ status: 'rejected' }) as never)

    let handle: HarnessHandle | null = null
@@ -1304,12 +736,12 @@ describe('usePromptActions redirectPrompt', () => {
      <Harness onReady={h => (handle = h)} refreshSessions={async () => undefined} requestGateway={requestGateway} />
    )

-    expect(await handle!.redirectPrompt('too late')).toBe(false)
+    expect(await handle!.steerPrompt('too late')).toBe(false)
  })

-  it('reports rejection without throwing when the redirect RPC errors', async () => {
+  it('reports rejection (never throws) when the steer RPC errors', async () => {
    const requestGateway = vi.fn(async () => {
-      throw new Error('agent does not support redirect')
+      throw new Error('agent does not support steer')
    })

    let handle: HarnessHandle | null = null
@@ -1317,93 +749,20 @@ describe('usePromptActions redirectPrompt', () => {
      <Harness onReady={h => (handle = h)} refreshSessions={async () => undefined} requestGateway={requestGateway} />
    )

-    expect(await handle!.redirectPrompt('boom')).toBe(false)
+    expect(await handle!.steerPrompt('boom')).toBe(false)
  })

  it('skips the RPC entirely for empty text', async () => {
-    const requestGateway = vi.fn(async () => ({ status: 'redirected' }) as never)
+    const requestGateway = vi.fn(async () => ({ status: 'queued' }) as never)

    let handle: HarnessHandle | null = null
    await actRender(
      <Harness onReady={h => (handle = h)} refreshSessions={async () => undefined} requestGateway={requestGateway} />
    )

-    expect(await handle!.redirectPrompt('   ')).toBe(false)
+    expect(await handle!.steerPrompt('   ')).toBe(false)
    expect(requestGateway).not.toHaveBeenCalled()
  })
-
-  it('accepts a queued redirect during the agent-build window and records the correction', async () => {
-    // running=True but the agent is still building: the gateway queues the
-    // correction instead of rejecting, so the composer must NOT re-queue it.
-    const requestGateway = vi.fn(async () => ({ status: 'queued' }) as never)
-
-    let handle: HarnessHandle | null = null
-    const capturedStates: Record<string, unknown>[] = []
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        onSeedState={state => capturedStates.push(state)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-      />
-    )
-
-    expect(await handle!.redirectPrompt('build-window nudge')).toBe(true)
-    expect(requestGateway).toHaveBeenCalledWith('session.redirect', {
-      session_id: RUNTIME_SESSION_ID,
-      text: 'build-window nudge'
-    })
-    expect(requestGateway).not.toHaveBeenCalledWith('prompt.submit', expect.anything())
-    expect((capturedStates.at(-1)?.messages as unknown[]).at(-1)).toMatchObject({
-      role: 'user',
-      parts: [{ type: 'text', text: 'build-window nudge' }]
-    })
-  })
-
-  it('resumes the stored session and retries once when session.redirect reports "session not found"', async () => {
-    const STORED_SESSION_ID = 'stored-db-xyz789'
-    const RECOVERED_SESSION_ID = 'rt-recovered-456'
-    const calls: { method: string; params?: Record<string, unknown> }[] = []
-    let redirectAttempts = 0
-
-    const requestGateway = vi.fn(async (method: string, params?: Record<string, unknown>) => {
-      calls.push({ method, params })
-
-      if (method === 'session.redirect') {
-        redirectAttempts += 1
-
-        if (redirectAttempts === 1) {
-          throw new Error('session not found')
-        }
-
-        return { status: 'redirected' } as never
-      }
-
-      if (method === 'session.resume') {
-        return { session_id: RECOVERED_SESSION_ID } as never
-      }
-
-      return {} as never
-    })
-
-    let handle: HarnessHandle | null = null
-    await actRender(
-      <Harness
-        onReady={h => (handle = h)}
-        refreshSessions={async () => undefined}
-        requestGateway={requestGateway}
-        storedSessionId={STORED_SESSION_ID}
-      />
-    )
-    await waitFor(() => expect(handle).not.toBeNull())
-
-    expect(await handle!.redirectPrompt('reconnect nudge')).toBe(true)
-    expect(calls.map(c => c.method)).toEqual(['session.redirect', 'session.resume', 'session.redirect'])
-    expect(calls[0]?.params).toEqual({ session_id: RUNTIME_SESSION_ID, text: 'reconnect nudge' })
-    expect(calls[1]?.params).toEqual({ session_id: STORED_SESSION_ID, source: 'desktop' })
-    expect(calls[2]?.params).toEqual({ session_id: RECOVERED_SESSION_ID, text: 'reconnect nudge' })
-    expect(handle!.activeSessionIdRef.current).toBe(RECOVERED_SESSION_ID)
-  })
 })

 describe('usePromptActions restoreToMessage', () => {
@@ -41,7 +41,7 @@ import type {
  HandoffRequestResponse,
  HandoffStateResponse,
  ImageAttachResponse,
-  SessionRedirectResponse
+  SessionSteerResponse
 } from '../../../types'

 import {
@@ -220,13 +220,7 @@ export function usePromptActions({
  const copy = t.desktop

  const appendSessionTextMessage = useCallback(
-    (
-      sessionId: string,
-      role: ChatMessage['role'],
-      text: string,
-      storedSessionId?: string | null,
-      options: { insertBeforeActiveReply?: boolean } = {}
-    ) => {
+    (sessionId: string, role: ChatMessage['role'], text: string) => {
      // Strip ANSI: slash-command output from the backend worker carries SGR
      // color codes (e.g. "Unknown command" in red). The ESC byte is invisible
      // in the chat panel, so without this the `[1;31m…[0m` payload leaks as
@@ -237,39 +231,21 @@ export function usePromptActions({
        return
      }

-      const messageId = `${role}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
-
      updateSessionState(
        sessionId,
-        state => {
-          const message: ChatMessage = {
-            id: messageId,
-            role,
-            parts: [textPart(body)]
-          }
-
-          const streamIndex =
-            options.insertBeforeActiveReply && state.streamId
-              ? state.messages.findIndex(candidate => candidate.id === state.streamId)
-              : -1
-
-          const lastAssistantIndex = options.insertBeforeActiveReply
-            ? state.messages.map(candidate => candidate.role).lastIndexOf('assistant')
-            : -1
-
-          const insertionIndex = streamIndex >= 0 ? streamIndex : lastAssistantIndex
-
-          const messages =
-            insertionIndex >= 0
-              ? [...state.messages.slice(0, insertionIndex), message, ...state.messages.slice(insertionIndex)]
-              : [...state.messages, message]
-
-          return { ...state, messages }
-        },
-        storedSessionId ?? selectedStoredSessionIdRef.current
+        state => ({
+          ...state,
+          messages: [
+            ...state.messages,
+            {
+              id: `${role}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+              role,
+              parts: [textPart(body)]
+            }
+          ]
+        }),
+        selectedStoredSessionIdRef.current
      )
-
-      return messageId
    },
    [selectedStoredSessionIdRef, updateSessionState]
  )
@@ -502,10 +478,8 @@ export function usePromptActions({
    refreshSessions,
    requestGateway,
    resumeStoredSession,
-    selectedStoredSessionIdRef,
    startFreshSessionDraft,
-    submitPromptText,
-    updateSessionState
+    submitPromptText
  })

  const submitText = useCallback(
@@ -625,11 +599,11 @@ export function usePromptActions({
    }
  }, [activeSessionIdRef, busyRef, copy.stopFailed, requestGateway, selectedStoredSessionIdRef, updateSessionState])

-  // The desktop steering action is an immediate correction: the core cancels
-  // model generation and rebuilds the live turn with displayed reasoning and
-  // completed work intact. During a tool it waits for the safe result boundary.
-  // Returns false when the turn raced to completion so the composer can queue.
-  const redirectPrompt = useCallback(
+  // Steer = nudge the live turn without interrupting: the gateway appends the
+  // text to the next tool result so the model reads it on its next iteration
+  // (desktop parity with `/steer`). Returns false on reject (no live tool
+  // window) so the caller can fall back to queueing the words for the next turn.
+  const steerPrompt = useCallback(
    async (rawText: string): Promise<boolean> => {
      const text = sanitizeComposerInput(rawText).trim()
      const sessionId = activeSessionId || activeSessionIdRef.current
@@ -638,97 +612,25 @@ export function usePromptActions({
        return false
      }

-      // Accepted whether the live turn was redirected in place or queued for
-      // the next turn (the build window, before the agent is wired) — either
-      // way the correction reaches the model, so record it once as a real user
-      // message after the interrupted checkpoint, matching the durable core
-      // transcript rather than a system note that changes role after reload.
-      const send = async (id: string): Promise<boolean> => {
-        // Redirect aborts the model request, so the completion event can race
-        // its RPC response. Insert before the live reply *before* awaiting the
-        // gateway; appending after the response leaves the correction below a
-        // reply that the redirect has already replaced.
-        const messageId = appendSessionTextMessage(id, 'user', text, undefined, { insertBeforeActiveReply: true })
-
-        const discardOptimisticMessage = () =>
-          updateSessionState(id, state => ({
-            ...state,
-            messages: state.messages.filter(message => message.id !== messageId)
-          }))
-
-        const moveOptimisticMessageToEnd = () =>
-          updateSessionState(id, state => {
-            const message = state.messages.find(candidate => candidate.id === messageId)
-
-            return message
-              ? { ...state, messages: [...state.messages.filter(candidate => candidate.id !== messageId), message] }
-              : state
-          })
-
-        try {
-          const result = await requestGateway<SessionRedirectResponse>('session.redirect', { session_id: id, text })
-
-          if (result?.status === 'redirected') {
-            triggerHaptic('submit')
-
-            return true
-          }
-
-          if (result?.status === 'queued') {
-            // Build-window redirects become the next turn, not part of the
-            // active reply, so retain the optimistic row at the tail.
-            moveOptimisticMessageToEnd()
-            triggerHaptic('submit')
-
-            return true
-          }
-        } catch (err) {
-          discardOptimisticMessage()
-          throw err
-        }
-
-        discardOptimisticMessage()
-
-        return false
-      }
-
      try {
-        return await send(sessionId)
-      } catch (err) {
-        // A stale runtime id after reconnect 404s ("session not found"): resume
-        // the stored session and retry once, mirroring stopPrompt so a
-        // correction right after a reconnect isn't lost to the race.
-        if (isSessionNotFoundError(err) && selectedStoredSessionIdRef.current) {
-          try {
-            const resumed = await requestGateway<{ session_id: string }>('session.resume', {
-              session_id: selectedStoredSessionIdRef.current,
-              source: 'desktop'
-            })
+        const result = await requestGateway<SessionSteerResponse>('session.steer', { session_id: sessionId, text })

-            const recoveredId = resumed?.session_id
+        if (result?.status === 'queued') {
+          triggerHaptic('submit')
+          // Inline note (not a toast) so the nudge lives in the transcript next
+          // to the turn it steered. The `steer:` prefix is rendered as a codicon
+          // row by SystemMessage (see STEER_NOTE_RE), same style as slash output.
+          appendSessionTextMessage(sessionId, 'system', `steer:${text}`)

-            if (recoveredId) {
-              activeSessionIdRef.current = recoveredId
-
-              return await send(recoveredId)
-            }
-          } catch {
-            // fall through — caller queues so nothing is lost
-          }
+          return true
        }
+      } catch {
        // Swallow — caller queues the text so nothing is lost.
      }

      return false
    },
-    [
-      activeSessionId,
-      activeSessionIdRef,
-      appendSessionTextMessage,
-      requestGateway,
-      selectedStoredSessionIdRef,
-      updateSessionState
-    ]
+    [activeSessionId, activeSessionIdRef, appendSessionTextMessage, requestGateway]
  )

  const reloadFromMessage = useCallback(
@@ -904,9 +806,7 @@ export function usePromptActions({
    handoffSession,
    reloadFromMessage,
    restoreToMessage,
-    redirectPrompt,
-    /** @deprecated Use `redirectPrompt` — this is an active-turn redirect, not tool steer. */
-    steerPrompt: redirectPrompt,
+    steerPrompt,
    submitText,
    transcribeVoiceAudio
  }
@@ -1,23 +1,21 @@
-import { type MutableRefObject, useCallback, useRef } from 'react'
+import { type MutableRefObject, useCallback } from 'react'

 import { getProfiles } from '@/hermes'
 import type { Translations } from '@/i18n'
-import { type ChatMessage, toChatMessages } from '@/lib/chat-messages'
+import { type ChatMessage } from '@/lib/chat-messages'
 import { parseCommandDispatch, parseSlashCommand, sessionTitle } from '@/lib/chat-runtime'
 import {
  type CommandsCatalogLike,
  type DesktopActionId,
-  type DesktopCommandSurface,
  type DesktopPickerId,
  desktopSlashUnavailableMessage,
  isDesktopSlashCommand,
  resolveDesktopCommand
 } from '@/lib/desktop-slash-commands'
-import { isMissingRpcMethod } from '@/lib/gateway-rpc'
 import { setSessionYolo } from '@/lib/yolo-session'
 import { openCommandPalettePage } from '@/store/command-palette'
 import { setComposerDraft } from '@/store/composer'
-import { dismissNotification, notify, notifyError } from '@/store/notifications'
+import { notify, notifyError } from '@/store/notifications'
 import { setPetScale } from '@/store/pet-gallery'
 import { $petGenInput, openPetGenerate } from '@/store/pet-generate'
 import { $activeGatewayProfile, $newChatProfile, ensureGatewayProfile, normalizeProfileKey } from '@/store/profile'
@@ -25,35 +23,22 @@ import {
  $connection,
  $sessions,
  $yoloActive,
-  setCurrentUsage,
  setModelPickerOpen,
  setSessionPickerOpen,
  setSessions,
  setYoloActive
 } from '@/store/session'

-import type {
-  BrowserManageResponse,
-  ClientSessionState,
-  SessionCompressResponse,
-  SessionTitleResponse,
-  SlashExecResponse
-} from '../../../types'
+import type { BrowserManageResponse, SessionTitleResponse, SlashExecResponse } from '../../../types'

 import {
  type GatewayRequest,
  isSessionIdCandidate,
  renderCommandsCatalog,
-  renderRpcResult,
  slashStatusText,
  type SubmitTextOptions
 } from './utils'

-// Manual compression is LLM-bound and routinely outlives the desktop's 30s
-// default WS request timeout on large sessions — give it the TUI client's
-// 120s RPC budget (HERMES_TUI_RPC_TIMEOUT_MS default) instead.
-const SESSION_COMPRESS_TIMEOUT_MS = 120_000
-
 /** Everything a slash handler needs about the invocation it's serving. */
 interface SlashActionCtx {
  arg: string
@@ -65,12 +50,7 @@ interface SlashActionCtx {

 interface SlashCommandDeps {
  activeSessionIdRef: MutableRefObject<string | null>
-  appendSessionTextMessage: (
-    sessionId: string,
-    role: ChatMessage['role'],
-    text: string,
-    storedSessionId?: string | null
-  ) => void
+  appendSessionTextMessage: (sessionId: string, role: ChatMessage['role'], text: string) => void
  branchCurrentSession: () => Promise<boolean>
  busyRef: MutableRefObject<boolean>
  copy: Translations['desktop']
@@ -84,14 +64,8 @@ interface SlashCommandDeps {
  refreshSessions: () => Promise<void>
  requestGateway: GatewayRequest
  resumeStoredSession: (storedSessionId: string) => Promise<void> | void
-  selectedStoredSessionIdRef: MutableRefObject<string | null>
  startFreshSessionDraft: () => void
  submitPromptText: (rawText: string, options?: SubmitTextOptions) => Promise<boolean>
-  updateSessionState: (
-    sessionId: string,
-    updater: (state: ClientSessionState) => ClientSessionState,
-    storedSessionId?: string | null
-  ) => ClientSessionState
 }

 /** The /slash command dispatcher, extracted from usePromptActions. */
@@ -109,14 +83,10 @@ export function useSlashCommand(deps: SlashCommandDeps) {
    refreshSessions,
    requestGateway,
    resumeStoredSession,
-    selectedStoredSessionIdRef,
    startFreshSessionDraft,
-    submitPromptText,
-    updateSessionState
+    submitPromptText
  } = deps

-  const compressInFlightRef = useRef(new Set<string>())
-
  return useCallback(
    async (rawCommand: string, options?: { sessionId?: string; recordInput?: boolean }) => {
      const ensureSessionId = async (sessionHint?: string) =>
@@ -127,7 +97,7 @@ export function useSlashCommand(deps: SlashCommandDeps) {
      // build-renderSlashOutput boilerplate every exec-style handler repeats.
      const withSlashOutput = async (
        ctx: SlashActionCtx
-      ): Promise<{ render: (text: string) => void; sessionId: string; storedSessionId: string | null } | null> => {
+      ): Promise<{ render: (text: string) => void; sessionId: string } | null> => {
        const sessionId = await ensureSessionId(ctx.sessionHint)

        if (!sessionId) {
@@ -136,19 +106,10 @@ export function useSlashCommand(deps: SlashCommandDeps) {
          return null
        }

-        // A long-running command can finish after a session switch. Keep its
-        // output bound to the stored session selected at invocation time.
-        const storedSessionId = selectedStoredSessionIdRef.current
-
        const render = (text: string) =>
-          appendSessionTextMessage(
-            sessionId,
-            'system',
-            ctx.recordInput ? slashStatusText(ctx.command, text) : text,
-            storedSessionId
-          )
+          appendSessionTextMessage(sessionId, 'system', ctx.recordInput ? slashStatusText(ctx.command, text) : text)

-        return { render, sessionId, storedSessionId }
+        return { render, sessionId }
      }

      // `exec` commands (and unknown skill / quick commands the backend owns)
@@ -170,8 +131,6 @@ export function useSlashCommand(deps: SlashCommandDeps) {
          return
        }

-        let slashExecError: unknown = null
-
        const handleDispatch = async (
          dispatch: NonNullable<ReturnType<typeof parseCommandDispatch>>
        ): Promise<void> => {
@@ -247,11 +206,8 @@ export function useSlashCommand(deps: SlashCommandDeps) {
          renderSlashOutput(output?.warning ? `warning: ${output.warning}\n${body}` : body)

          return
-        } catch (error) {
-          // Fall back to command.dispatch for skill/send/alias directives, but
-          // keep the worker error: a slash.exec worker timeout/crash is the real
-          // failure, not the "not a quick/plugin/skill command" routing noise.
-          slashExecError = error
+        } catch {
+          // Fall back to command.dispatch for skill/send/alias directives.
        }

        try {
@@ -267,66 +223,6 @@ export function useSlashCommand(deps: SlashCommandDeps) {

          await handleDispatch(dispatch)
        } catch (err) {
-          // "not a quick/plugin/skill command" just means the fallback had
-          // nothing to add — the slash.exec failure (worker timeout, crash) is
-          // the real error, so don't bury it under the routing noise.
-          const dispatchMessage = err instanceof Error ? err.message : String(err)
-
-          if (slashExecError && /not a quick\/plugin\/skill command/i.test(dispatchMessage)) {
-            const original = slashExecError instanceof Error ? slashExecError.message : String(slashExecError)
-            renderSlashOutput(`error: /${name} failed: ${original}`)
-
-            return
-          }
-
-          renderSlashOutput(`error: ${dispatchMessage}`)
-        }
-      }
-
-      // `rpc` commands have a dedicated gateway handler — skip slash.exec /
-      // command.dispatch entirely. The response is structured (a JSON RPC
-      // reply, not an inline text stream) so we render it via the generic
-      // `renderRpcResult` shaper that knows the field conventions shared by
-      // session.save / session.status / session.usage / session.steer /
-      // process.stop / agents.list.
-      async function runRpc(
-        surface: Extract<DesktopCommandSurface, { kind: 'rpc' }>,
-        ctx: SlashActionCtx
-      ): Promise<void> {
-        const resolved = await withSlashOutput(ctx)
-
-        if (!resolved) {
-          return
-        }
-
-        const { render: renderSlashOutput, sessionId } = resolved
-
-        try {
-          const params = surface.buildParams({
-            arg: ctx.arg,
-            command: ctx.command,
-            name: ctx.name,
-            sessionId
-          })
-
-          // Forward the surface's declared timeout when present; the default
-          // requestGateway layer keeps (30s) is too tight for RPCs that do
-          // real work.
-          const result = await requestGateway<unknown>(surface.rpc, params, surface.timeoutMs)
-          const body = renderRpcResult(result, ctx.name)
-
-          renderSlashOutput(body || `/${ctx.name}: no output`)
-        } catch (err) {
-          // TODO: remove this compatibility fallback once every supported
-          // managed runtime exposes the dedicated RPC surface. Desktop and its
-          // gateway update independently; older gateways still support the
-          // slash-worker route.
-          if (isMissingRpcMethod(err)) {
-            await runExec(ctx)
-
-            return
-          }
-
          renderSlashOutput(`error: ${err instanceof Error ? err.message : String(err)}`)
        }
      }
@@ -341,145 +237,6 @@ export function useSlashCommand(deps: SlashCommandDeps) {
        branch: async () => {
          await branchCurrentSession()
        },
-        // /compress (alias /compact) runs the gateway's dedicated
-        // session.compress RPC — the TUI's path
-        // (ui-tui/src/app/slash/commands/session.ts). It must NOT go through
-        // runExec: compressing a large session outlives the slash worker's pipe
-        // timeout (45s) and the desktop's 30s WS default, and the resulting
-        // slash.exec error cascaded into command.dispatch's misleading "not a
-        // quick/plugin/skill command: compress" (#44456).
-        //
-        // The RPC returns the post-compress `messages` array (same shape
-        // session.resume returns), so we replace the transcript from it —
-        // otherwise the summarized bubbles stay on screen forever (#44462
-        // review). `updateSessionState` only publishes for the active runtime,
-        // so a late result after a session switch refreshes its own cache
-        // without clobbering the foreground transcript (#53755 review).
-        compress: async ctx => {
-          const resolved = await withSlashOutput(ctx)
-
-          if (!resolved) {
-            return
-          }
-
-          const { render: renderSlashOutput, sessionId, storedSessionId } = resolved
-          const focusTopic = ctx.arg.trim()
-          const noticeId = `session-compress:${sessionId}`
-
-          // Coalesce concurrent compress requests for the same session so a
-          // double-enter doesn't fire two LLM summarise calls.
-          if (compressInFlightRef.current.has(sessionId)) {
-            return
-          }
-
-          compressInFlightRef.current.add(sessionId)
-          notify({
-            durationMs: 0,
-            id: noticeId,
-            kind: 'info',
-            message: focusTopic ? `compressing context for: ${focusTopic}` : 'compressing context...'
-          })
-
-          try {
-            const result = await requestGateway<SessionCompressResponse>(
-              'session.compress',
-              {
-                session_id: sessionId,
-                ...(focusTopic ? { focus_topic: focusTopic } : {})
-              },
-              SESSION_COMPRESS_TIMEOUT_MS
-            )
-
-            // Replace the transcript with the post-compress history so the
-            // summarized bubbles actually disappear. `messages` is the same
-            // shape session.resume returns (_history_to_messages), so
-            // toChatMessages handles it directly. updateSessionState only
-            // publishes for the active runtime, guarding against a late result
-            // clobbering the foreground after a session switch.
-            if (Array.isArray(result?.messages)) {
-              updateSessionState(
-                sessionId,
-                state => ({ ...state, messages: toChatMessages(result.messages!) }),
-                storedSessionId
-              )
-            }
-
-            const usage = { ...result?.usage, ...result?.info?.usage }
-
-            if (Object.keys(usage).length && activeSessionIdRef.current === sessionId) {
-              setCurrentUsage(current => ({ ...current, ...usage }))
-            }
-
-            if (result?.info?.title !== undefined) {
-              setSessions(prev =>
-                prev.map(session =>
-                  session.id === sessionId ? { ...session, title: result.info!.title || null } : session
-                )
-              )
-            }
-
-            if (result?.summary?.headline) {
-              const lines = [result.summary.headline, result.summary.token_line, result.summary.note].filter(
-                (line): line is string => Boolean(line)
-              )
-
-              const aborted = result.status === 'aborted' || result.summary.aborted === true
-
-              if (!aborted) {
-                // Keep a durable record of a successful manual compression in
-                // the chat after replacing it with the authoritative backend
-                // transcript. Errors remain transient: appending an error as a
-                // system message would look like a successful state change.
-                renderSlashOutput(lines.join('\n'))
-              }
-
-              notify({
-                durationMs: 5_000,
-                id: noticeId,
-                kind: aborted ? 'error' : 'success',
-                message: lines.join('\n')
-              })
-
-              return
-            }
-
-            const hostOutput = result?.host_ack?.output?.trim()
-
-            if (hostOutput) {
-              renderSlashOutput(hostOutput)
-              notify({ durationMs: 5_000, id: noticeId, kind: 'success', message: hostOutput })
-
-              return
-            }
-
-            const removed = result?.removed ?? 0
-            const message = removed > 0 ? `compressed ${removed} messages` : 'nothing to compress'
-            renderSlashOutput(message)
-            notify({
-              durationMs: 5_000,
-              id: noticeId,
-              kind: 'success',
-              message
-            })
-          } catch (err) {
-            dismissNotification(noticeId)
-
-            // Desktop and gateway runtimes update independently. Preserve the
-            // historical slash-worker path for an older gateway that has not
-            // shipped session.compress yet; it cannot offer the longer RPC
-            // timeout, but it must not turn a once-working command into an
-            // immediate "method not found" error.
-            if (isMissingRpcMethod(err)) {
-              await runExec(ctx)
-
-              return
-            }
-
-            renderSlashOutput(`error: ${err instanceof Error ? err.message : String(err)}`)
-          } finally {
-            compressInFlightRef.current.delete(sessionId)
-          }
-        },
        // /yolo maps to the status-bar YOLO control — a per-session approval
        // bypass, same scope as the TUI's Shift+Tab. With no session yet we arm
        // it locally; the session-create path applies it on the first message.
@@ -850,9 +607,6 @@ export function useSlashCommand(deps: SlashCommandDeps) {
          case 'action':
            return actionHandlers[surface.action](ctx)

-          case 'rpc':
-            return runRpc(surface, ctx)
-
          default:
            // exec spec, or an unknown skill / quick command the backend owns.
            return runExec(ctx)
@@ -874,10 +628,8 @@ export function useSlashCommand(deps: SlashCommandDeps) {
      refreshSessions,
      requestGateway,
      resumeStoredSession,
-      selectedStoredSessionIdRef,
      startFreshSessionDraft,
-      submitPromptText,
-      updateSessionState
+      submitPromptText
    ]
  )
 }
@@ -6,12 +6,6 @@ import { type ChatMessage, textPart } from '@/lib/chat-messages'
 import { optimisticAttachmentRef } from '@/lib/chat-runtime'
 import { sanitizeComposerInput } from '@/lib/composer-input-sanitize'
 import { setMutableRef } from '@/lib/mutable-ref'
-import {
-  isVoicePlaybackActive,
-  markVoicePlaybackInterrupted,
-  stopVoicePlayback,
-  takeVoicePlaybackInterrupted
-} from '@/lib/voice-playback'
 import {
  $composerAttachments,
  clearComposerAttachments,
@@ -23,7 +17,6 @@ import { requestDesktopOnboarding } from '@/store/onboarding'
 import { setAwaitingResponse, setBusy, setMessages } from '@/store/session'

 import type { ClientSessionState } from '../../../types'
-import { sessionContextDrift } from '../session-context-drift'

 import {
  _submitInFlight,
@@ -148,16 +141,6 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
        return false
      }

-      // Typing barge-in: a new send silences any in-flight spoken reply.
-      if (isVoicePlaybackActive()) {
-        markVoicePlaybackInterrupted()
-        stopVoicePlayback()
-      }
-
-      // Barged mid-speech (here or via the voice loop's VAD)? Flag the submit
-      // so the backend notes the interruption to the model.
-      const interrupted = takeVoicePlaybackInterrupted()
-
      // Queue drains carry their source session explicitly. A background drain
      // must never inherit the currently selected session after the user moves
      // to another chat.
@@ -192,28 +175,11 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {

      let startingRouteToken = getRouteToken()

-      // Reason string (or null) for why the session context genuinely drifted
-      // under this in-flight submit. sessionContextDrift ignores the churn a
-      // busy gateway produces (selection null-resets on a gateway/profile
-      // switch, search/hash-only route changes, background active-ref
-      // retargets) so a second-session send doesn't silently abort — it fires
-      // only on a real move to a DIFFERENT chat. Reads the live refs/route each
-      // call and measures against the (mutable) baseline, which is re-pinned to
-      // the created chat after createBackendSessionForSend. submitTargetStoredId
-      // is the stored session this submit targets, so a move ONTO it (the
-      // pipeline's own re-home) is never counted as drift.
-      const sessionDriftReason = (): string | null =>
-        targetStartedInCurrentView
-          ? sessionContextDrift({
-              startRouteToken: startingRouteToken,
-              nowRouteToken: getRouteToken(),
-              startSelectedStoredId: startingStoredSessionId,
-              nowSelectedStoredId: selectedStoredSessionIdRef.current,
-              submitTargetStoredId: startingStoredSessionId
-            })
-          : null
+      const sessionContextDrifted = (): boolean =>
+        targetStartedInCurrentView &&
+        (selectedStoredSessionIdRef.current !== startingStoredSessionId || getRouteToken() !== startingRouteToken)

-      const targetIsCurrentView = (): boolean => targetStartedInCurrentView && !sessionDriftReason()
+      const targetIsCurrentView = (): boolean => targetStartedInCurrentView && !sessionContextDrifted()

      // One submit in flight per session — drop any concurrent re-fire so a
      // stalled turn can't stack the same prompt into multiple real turns. The
@@ -351,11 +317,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
          return abortForSessionSwitch(null)
        }

-        const routedResumeDrift = sessionDriftReason()
-
-        if (routedResumeDrift) {
-          console.warn('[submit-drift-abort]', routedResumeDrift, { phase: 'post-routed-resume' })
-
+        if (sessionContextDrifted()) {
          return abortForSessionSwitch(null)
        }

@@ -389,11 +351,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
            source: 'desktop'
          })

-          const resumeDrift = sessionDriftReason()
-
-          if (resumeDrift) {
-            console.warn('[submit-drift-abort]', resumeDrift, { phase: 'post-resume' })
-
+          if (sessionContextDrifted()) {
            return abortForSessionSwitch(sessionId)
          }

@@ -413,11 +371,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
          return abortForSessionSwitch(null)
        }

-        const resumeSettleDrift = sessionDriftReason()
-
-        if (resumeSettleDrift) {
-          console.warn('[submit-drift-abort]', resumeSettleDrift, { phase: 'post-resume-settle' })
-
+        if (sessionContextDrifted()) {
          return abortForSessionSwitch(sessionId)
        }

@@ -446,11 +400,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
          // createBackendSessionForSend returns null when the user switched
          // sessions mid-create (it closes the orphaned session itself) —
          // abort silently. Anything else is a real failure worth a toast.
-          const createNullDrift = sessionDriftReason()
-
-          if (createNullDrift) {
-            console.warn('[submit-drift-abort]', createNullDrift, { phase: 'post-create-null' })
-
+          if (sessionContextDrifted()) {
            return abortForSessionSwitch(null)
          }

@@ -489,11 +439,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
          updateComposerAttachments: usingComposerAttachments
        })

-        const attachmentsDrift = sessionDriftReason()
-
-        if (attachmentsDrift) {
-          console.warn('[submit-drift-abort]', attachmentsDrift, { phase: 'post-attachments' })
-
+        if (sessionContextDrifted()) {
          return abortForSessionSwitch(sessionId)
        }

@@ -504,12 +450,6 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
        rewriteOptimistic(sessionId)
        const text = buildContextText(syncedAttachments)

-        const submitParams = (targetId: string) => ({
-          session_id: targetId,
-          text,
-          ...(interrupted && { interrupted })
-        })
-
        // On sleep/wake the gateway's in-memory session may have been cleared
        // while the desktop app still holds the old session ID. Detect this,
        // resume the stored session to re-register it, and retry once.
@@ -517,7 +457,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {

        try {
          await withSessionBusyRetry(() =>
-            requestGateway('prompt.submit', submitParams(sessionId), PROMPT_SUBMIT_REQUEST_TIMEOUT_MS)
+            requestGateway('prompt.submit', { session_id: sessionId, text }, PROMPT_SUBMIT_REQUEST_TIMEOUT_MS)
          )
        } catch (firstErr) {
          const recoverStoredSessionId = targetStoredSessionId ?? selectedStoredSessionIdRef.current
@@ -533,11 +473,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
              source: 'desktop'
            })

-            const resumeRetryDrift = sessionDriftReason()
-
-            if (resumeRetryDrift) {
-              console.warn('[submit-drift-abort]', resumeRetryDrift, { phase: 'post-resume-retry' })
-
+            if (sessionContextDrifted()) {
              return abortForSessionSwitch(sessionId)
            }

@@ -549,7 +485,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
              }

              await withSessionBusyRetry(() =>
-                requestGateway('prompt.submit', submitParams(recoveredId), PROMPT_SUBMIT_REQUEST_TIMEOUT_MS)
+                requestGateway('prompt.submit', { session_id: recoveredId, text }, PROMPT_SUBMIT_REQUEST_TIMEOUT_MS)
              )
            } else {
              submitErr = firstErr
@@ -12,7 +12,6 @@ import {
  isSessionBusyError,
  isSessionIdCandidate,
  isSessionNotFoundError,
-  renderRpcResult,
  slashStatusText,
  visibleUserIndexAtOrdinal,
  visibleUserOrdinal
@@ -126,139 +125,3 @@ describe('visible user ordinals', () => {
    expect(visibleUserIndexAtOrdinal(messages, 5)).toBe(-1)
  })
 })
-
-describe('renderRpcResult', () => {
-  describe('session.compress (summary shape)', () => {
-    it('renders the summary headline with token line and note', () => {
-      expect(
-        renderRpcResult(
-          {
-            summary: {
-              headline: 'Compressed: 280 → 120 messages',
-              token_line: 'Approx request size: ~126,575 → ~30,000 tokens',
-              note: 'Removed 8 older turns',
-              noop: false
-            }
-          },
-          'compress'
-        )
-      ).toBe(
-        [
-          '✓ Compressed: 280 → 120 messages',
-          '  Approx request size: ~126,575 → ~30,000 tokens',
-          '  Removed 8 older turns'
-        ].join('\n')
-      )
-    })
-
-    it('drops the checkmark when the summary is a noop', () => {
-      expect(
-        renderRpcResult(
-          { summary: { headline: 'Already compressed', note: 'No new turns since last compress', noop: true } },
-          'compress'
-        )
-      ).toBe('Already compressed\n  No new turns since last compress')
-    })
-  })
-
-  describe('session.steer', () => {
-    it('reports a queued steer with the original text', () => {
-      expect(renderRpcResult({ status: 'queued', text: 'skip the docs' }, 'steer')).toBe(
-        'Steered · "skip the docs" queued for next tool call'
-      )
-    })
-
-    it('reports a rejected steer without echoing user text', () => {
-      expect(renderRpcResult({ status: 'rejected', text: 'whatever' }, 'steer')).toBe(
-        'Steer rejected — agent declined input'
-      )
-    })
-  })
-
-  describe('process.stop', () => {
-    it('reports the numeric number of stopped processes', () => {
-      expect(renderRpcResult({ killed: 2 }, 'stop')).toBe('Stopped 2 background processes.')
-    })
-
-    it('reports nothing-to-stop when the numeric count is zero', () => {
-      expect(renderRpcResult({ killed: 0 }, 'stop')).toBe('No background processes to stop.')
-    })
-  })
-
-  describe('session.save', () => {
-    it('echoes the saved file path', () => {
-      expect(renderRpcResult({ file: '/home/user/.hermes/sessions/saved/x.json' }, 'save')).toBe(
-        'Saved transcript to /home/user/.hermes/sessions/saved/x.json'
-      )
-    })
-  })
-
-  describe('session.status', () => {
-    it('passes through the multi-line plain-text output verbatim', () => {
-      const output = 'Hermes TUI Status\n\nSession ID: s-1\nModel: nous-hermes-3 (unknown)'
-      expect(renderRpcResult({ output }, 'status')).toBe(output)
-    })
-  })
-
-  describe('session.usage', () => {
-    it('formats calls / input / output / total with thousands separators', () => {
-      expect(renderRpcResult({ calls: 12, input: 1_234_567, output: 89_012, total: 1_323_579 }, 'usage')).toBe(
-        'Usage: 12 calls · 1,234,567 in / 89,012 out · 1,323,579 total'
-      )
-    })
-
-    it('appends credits_lines when present', () => {
-      const body = renderRpcResult(
-        {
-          calls: 1,
-          input: 10,
-          output: 20,
-          total: 30,
-          credits_lines: ['Nous credits: 8,420 remaining', 'Resets: 2026-08-01']
-        },
-        'usage'
-      )
-
-      expect(body.split('\n')).toEqual([
-        'Usage: 1 calls · 10 in / 20 out · 30 total',
-        'Nous credits: 8,420 remaining',
-        'Resets: 2026-08-01'
-      ])
-    })
-  })
-
-  describe('agents.list', () => {
-    it('reports no running tasks when the array is empty', () => {
-      expect(renderRpcResult({ processes: [] }, 'agents')).toBe('No background tasks running.')
-    })
-
-    it('formats each process with status, command, and metadata', () => {
-      expect(
-        renderRpcResult(
-          {
-            processes: [
-              { session_id: 's-1', command: 'npm test', status: 'running', uptime: 42 },
-              { session_id: 's-2', command: 'vitest', status: 'completed' }
-            ]
-          },
-          'agents'
-        )
-      ).toBe(['• [running] npm test (42s · s-1)', '• [completed] vitest (s-2)'].join('\n'))
-    })
-  })
-
-  describe('fallback', () => {
-    it('serialises unknown shapes as JSON so we never lose data', () => {
-      expect(renderRpcResult({ custom: 'value', nested: { a: 1 } }, 'mystery')).toBe(
-        '/mystery: {"custom":"value","nested":{"a":1}}'
-      )
-    })
-
-    it('returns an empty string for null and primitive payloads', () => {
-      expect(renderRpcResult(null, 'x')).toBe('')
-      expect(renderRpcResult(undefined, 'x')).toBe('')
-      expect(renderRpcResult('plain string', 'x')).toBe('')
-      expect(renderRpcResult(42, 'x')).toBe('')
-    })
-  })
-})
@@ -192,140 +192,6 @@ export function slashStatusText(command: string, output: string): string {
  return [`slash:${command}`, output.trim()].filter(Boolean).join('\n')
 }

-/**
- * Format the JSON reply from a gateway RPC surfaced as `kind: 'rpc'` in
- * desktop-slash-commands.ts. Kept here (instead of slash.ts) so it has no
- * React / store dependencies and can be unit-tested in isolation.
- *
- * The renderer follows the field conventions shared by the gateway handlers
- * we route to today:
- * - `session.compress`: { summary: { headline, token_line, note, noop } }
- *   (only used if /compress ever moves to `rpc`; it's an `action` today
- *   because it needs transcript replacement)
- * - `session.status`:   { output: "<multi-line plain text>" }
- * - `session.save`:     { file: "<absolute path>" }
- * - `session.usage`:    { calls, input, output, total, credits_lines? }
- * - `session.steer`:    { status: 'queued' | 'rejected', text }
- * - `process.stop`:     { killed: boolean }
- * - `agents.list`:      { processes: [{ session_id, command, status, uptime }] }
- *
- * Any RPC whose response doesn't match these shapes falls through to a
- * JSON.stringify dump so we never silently swallow data.
- */
-export function renderRpcResult(response: unknown, name: string): string {
-  if (!response || typeof response !== 'object') {
-    return ''
-  }
-
-  const r = response as Record<string, unknown>
-
-  const summary = r.summary as { headline?: string; token_line?: string; note?: string; noop?: boolean } | undefined
-
-  if (summary && typeof summary === 'object' && typeof summary.headline === 'string' && summary.headline) {
-    const lines: string[] = [`${summary.noop ? '' : '✓ '}${summary.headline}`]
-
-    if (summary.token_line) {
-      lines.push(`  ${summary.token_line}`)
-    }
-
-    if (summary.note) {
-      lines.push(`  ${summary.note}`)
-    }
-
-    return lines.join('\n')
-  }
-
-  // session.steer — { status: 'queued' | 'rejected', text }
-  if (r.status === 'queued' || r.status === 'rejected') {
-    const text = typeof r.text === 'string' ? r.text : ''
-
-    if (r.status === 'queued') {
-      return text ? `Steered · "${text}" queued for next tool call` : 'Steered next tool call'
-    }
-
-    return 'Steer rejected — agent declined input'
-  }
-
-  // process.stop — { killed: number }
-  if ('killed' in r && typeof r.killed === 'number') {
-    return r.killed > 0
-      ? `Stopped ${r.killed} background process${r.killed === 1 ? '' : 'es'}.`
-      : 'No background processes to stop.'
-  }
-
-  // session.save — { file }
-  if (typeof r.file === 'string' && r.file) {
-    return `Saved transcript to ${r.file}`
-  }
-
-  // session.status — { output }
-  if (typeof r.output === 'string' && r.output) {
-    return r.output
-  }
-
-  // session.usage — { calls, input, output, total, credits_lines? }
-  if ('total' in r || 'input' in r || 'output' in r || 'calls' in r) {
-    const calls = Number(r.calls ?? 0)
-    const input = Number(r.input ?? 0)
-    const output = Number(r.output ?? 0)
-    const total = Number(r.total ?? 0)
-
-    const lines: string[] = [
-      `Usage: ${calls.toLocaleString()} calls · ${input.toLocaleString()} in / ${output.toLocaleString()} out · ${total.toLocaleString()} total`
-    ]
-
-    if (Array.isArray(r.credits_lines)) {
-      for (const credit of r.credits_lines) {
-        if (typeof credit === 'string' && credit.trim()) {
-          lines.push(credit.trim())
-        }
-      }
-    }
-
-    return lines.join('\n')
-  }
-
-  // agents.list — { processes: [{ session_id, command, status, uptime }] }
-  if (Array.isArray(r.processes)) {
-    if (r.processes.length === 0) {
-      return 'No background tasks running.'
-    }
-
-    return r.processes
-      .map(p => {
-        if (!p || typeof p !== 'object') {
-          return ''
-        }
-
-        const proc = p as Record<string, unknown>
-        const status = typeof proc.status === 'string' ? proc.status : 'unknown'
-        const command = typeof proc.command === 'string' ? proc.command : ''
-        const sessionId = typeof proc.session_id === 'string' ? proc.session_id : ''
-        const uptime = proc.uptime
-
-        const meta: string[] = []
-
-        if (typeof uptime === 'number' && uptime >= 0) {
-          meta.push(`${uptime}s`)
-        }
-
-        if (sessionId) {
-          meta.push(sessionId)
-        }
-
-        const tail = meta.length ? ` (${meta.join(' · ')})` : ''
-
-        return `• [${status}] ${command}${tail}`
-      })
-      .filter(Boolean)
-      .join('\n')
-  }
-
-  // Generic fallback — keeps us honest if the gateway adds new fields we
-  // haven't shaped yet.
-  return `/${name}: ${JSON.stringify(r)}`
-}
-
 export function appendText(message: AppendMessage): string {
  return message.content
    .map(part => ('text' in part ? part.text : ''))
@@ -33,7 +33,6 @@ import {
  setSelectedStoredSessionId,
  setSessions
 } from '@/store/session'
-import { $sessionTiles } from '@/store/session-states'

 import { sessionRoute } from '../../routes'
 import type { ClientSessionState } from '../../types'
@@ -976,11 +975,9 @@ describe('resumeSession failure recovery', () => {
 })

 function BranchHarness({
-  navigate = vi.fn(),
  onReady,
  requestGateway
 }: {
-  navigate?: ReturnType<typeof vi.fn>
  onReady: (branchStoredSession: (storedSessionId: string, sessionProfile?: string | null) => Promise<boolean>) => void
  requestGateway: <T>(method: string, params?: Record<string, unknown>) => Promise<T>
 }) {
@@ -994,7 +991,7 @@ function BranchHarness({
    ensureSessionState: () => ({}) as ClientSessionState,
    getRouteToken: () => 'token',
    getRoutedStoredSessionId: () => null,
-    navigate: navigate as never,
+    navigate: vi.fn() as never,
    requestGateway,
    resetViewSync: vi.fn(),
    runtimeIdByStoredSessionIdRef: ref(new Map<string, string>()),
@@ -1016,48 +1013,9 @@ describe('branchStoredSession desktop source tagging', () => {
  afterEach(() => {
    cleanup()
    setSessions([])
-    $sessionTiles.set([])
-    setSelectedStoredSessionId(null)
    vi.restoreAllMocks()
  })

-  it('opens the branch as a new tab and leaves the parent chat selected', async () => {
-    const requestGateway = vi.fn(async (method: string) => {
-      if (method === 'session.create') {
-        return { session_id: 'branch-runtime', stored_session_id: 'branch-stored' } as never
-      }
-
-      return {} as never
-    })
-
-    // Parent is the currently-open (primary) chat.
-    setSessions([storedSession({ id: 'stored-parent', message_count: 1 })])
-    setSelectedStoredSessionId('stored-parent')
-    vi.mocked(getSessionMessages).mockResolvedValue({
-      messages: [{ content: 'branch me', role: 'user', timestamp: 1 }],
-      session_id: 'stored-parent'
-    } as never)
-
-    const navigate = vi.fn()
-    let branchStoredSession: ((storedSessionId: string) => Promise<boolean>) | null = null
-    render(
-      <BranchHarness
-        navigate={navigate}
-        onReady={branch => (branchStoredSession = branch)}
-        requestGateway={requestGateway}
-      />
-    )
-    await waitFor(() => expect(branchStoredSession).not.toBeNull())
-
-    await expect(branchStoredSession!('stored-parent')).resolves.toBe(true)
-
-    // The branch opened as its own tab...
-    expect($sessionTiles.get().some(tile => tile.storedSessionId === 'branch-stored')).toBe(true)
-    // ...without stealing the primary selection or navigating away from the parent.
-    expect($selectedStoredSessionId.get()).toBe('stored-parent')
-    expect(navigate).not.toHaveBeenCalledWith(sessionRoute('branch-stored'))
-  })
-
  it('tags desktop branch sessions as desktop sessions', async () => {
    let createParams: Record<string, unknown> | undefined

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Teknium	373ad70f4c	test(plugins): cover catalog CLI surface and plugin validation Behavior contracts for catalog-name install resolution (ref pin + sidecar), custom-URL banner, --allow-removed wiring, catalog-pin updates, list annotations, live-index fetch/fallback/TTL cache, search/browse/info rendering, doctor, argparse dispatch, and the validate checks incl. undeclared-capability diffs, crash containment, and built-in tool collisions.	2026-07-22 08:14:51 -07:00
Teknium	f1b30414d5	feat(plugins): catalog CLI surface — search/browse/info/install/update/doctor - install: catalog names resolve to the pinned SHA (ref= checkout), print tier + capability summary before the enable prompt, and write a .hermes-catalog.json provenance sidecar; raw git URLs get a 'custom (unreviewed) source' banner; --allow-removed loudly bypasses the removed blocklist (skip_removed_check=True) - update: sidecar installs compare against the current catalog pin and force-reinstall at the new SHA (enabled state preserved); plain git installs keep the git-pull flow - list: catalog:<tier>@<shaShort> annotation + red 'REMOVED from catalog' lines for blocklisted installs (table and --json) - search/browse/info: live-index catalog tables and full entry detail with removed-list warnings - validate: human ✓/✗ output, --json for CI, exit 0/1 - doctor: per-plugin manifest/enabled/load-error/env/requires_hermes/ provenance/pin/removed diagnosis, compact table or single-name detail	2026-07-22 08:14:51 -07:00
Teknium	44624631bf	feat(plugins): subprocess-isolated plugin validation for catalog CI New hermes_cli/plugin_validate.py — the checks behind 'hermes plugins validate <dir>': manifest fields, strict requires_hermes spec parsing, config: shape, UPPER_SNAKE requires_env, a capability probe that imports the plugin and calls register(ctx) against a recording stub in a scratch subprocess (throwaway HERMES_HOME, 30s timeout) and diffs actual registrations against provides_* (undeclared = fail, unregistered = warn), plus built-in tool collision checks via the discovered tool registry.	2026-07-22 08:14:51 -07:00
Teknium	8b70bf4c40	feat(plugins): live catalog index with 6h cache and fallback Add fetch_live_catalog()/load_catalog_live() to hermes_cli.plugin_catalog: list plugin-catalog/*.yaml via the GitHub contents API (unauthenticated, 5s timeout), raw-fetch each entry, and cache under <hermes_home>/cache/plugin-catalog/ with a 6h TTL. Any network failure falls back silently to the in-tree catalog. Also expose filter_entries() so callers can reuse search semantics on a live entry list.	2026-07-22 08:14:51 -07:00
Teknium	6f5608bed3	test(plugins): cover plugin catalog, version gate, and installer - catalog loader validation, search, removed matching, capability summary - _version_satisfies operators and permissive fallbacks - requires_hermes load gate (skip vs normal load) - config spec parsing + ctx.plugin_config merge - _install_plugin_core ref checkout and removed-block via local file:// repos	2026-07-22 07:30:55 -07:00
Teknium	dc4d991373	feat(plugins): install-time ref checkout and removed-blocklist check - _install_plugin_core accepts ref= (full-depth clone + git checkout, PluginOperationError on failure) and skip_removed_check= - installs are refused when the identifier or resolved repo URL matches plugin-catalog/removed.yaml, with the recorded reason and date	2026-07-22 07:30:55 -07:00
Teknium	dcdb9b25e4	feat(plugins): requires_hermes gate, config spec, ctx.plugin_config - plugin.yaml gains requires_hermes (version spec) and config: (list of {key, prompt, type, default, secret}) parsed onto PluginManifest - PluginManager skips loading (clean error, no traceback) when the running Hermes version does not satisfy requires_hermes; local _version_satisfies helper supports >=,>,<=,<,==,!= and comma specs - PluginContext.plugin_config merges config-spec defaults under plugins.entries.<plugin_id> values from config.yaml	2026-07-22 07:30:55 -07:00
Teknium	a22d2918d6	feat(plugins): add curated plugin catalog module and in-tree catalog dir - hermes_cli/plugin_catalog.py: loader/search/removed-blocklist for the new plugin-catalog/ directory (exact 40-hex SHA pins, https-only repos, official/community tiers; invalid entries skipped with a warning) - plugin-catalog/: admission-policy README, example-plugin seed entry, and removed.yaml blocklist	2026-07-22 07:30:55 -07:00