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
1065 changed files with 13854 additions and 96420 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
@@ -10,7 +10,7 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 20
    outputs:
-      checks: ${{ steps.set-matrix.outputs.checks }}
+      packages: ${{ steps.set-matrix.outputs.packages }}
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
@@ -22,40 +22,21 @@ jobs:
          command: npm ci --ignore-scripts
      - id: set-matrix
        run: |
-          node -e '
-          const { execSync } = require("child_process");
-          const pkgs = JSON.parse(execSync("npm query .workspace", { encoding: "utf-8" }));
-          if (pkgs.length === 0) {
-            console.error("::error::Workspace discovery produced an empty package list — refusing to emit a zero-length matrix (would skip all JS/TS checks silently).");
-            process.exit(1);
-          }
-          const checks = [];
-          for (const pkg of pkgs) {
-            const scripts = pkg.scripts || {};
-            const subs = Object.keys(scripts).filter(s => /^check:.+$/.test(s));
-            if (subs.length > 0) {
-              for (const script of subs) {
-                checks.push({ package: pkg.location, script });
-              }
-            } else if (scripts.check) {
-              checks.push({ package: pkg.location, script: "check" });
-            }
-          }
-          if (checks.length === 0) {
-            console.error("::error::No check scripts found in any workspace package.");
-            process.exit(1);
-          }
-          process.stdout.write("checks=" + JSON.stringify(checks) + "\n");
-          ' >> "$GITHUB_OUTPUT"
+          PACKAGES=$(npm query .workspace | jq -c '[.[].location]')
+          if [ "$PACKAGES" = "[]" ] || [ -z "$PACKAGES" ]; then
+            echo "::error::Workspace discovery produced an empty package list — refusing to emit a zero-length matrix (would skip all JS/TS checks silently)."
+            exit 1
+          fi
+          echo "packages=$PACKAGES" >> "$GITHUB_OUTPUT"

  check:
-    name: ${{ matrix.package }} / ${{ matrix.script }}
+    name: Typecheck & Test
    needs: workspaces
    runs-on: ubuntu-latest
    timeout-minutes: 20
    strategy:
      matrix:
-        include: ${{ fromJson(needs.workspaces.outputs.checks) }}
+        package: ${{ fromJson(needs.workspaces.outputs.packages) }}
      fail-fast: false # report all failures, not just the first one
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -66,4 +47,5 @@ jobs:
      - uses: ./.github/actions/retry
        with:
          command: npm ci
-      - run: npm run --prefix ${{ matrix.package }} ${{ matrix.script }}
+      - run: npm run --prefix ${{ matrix.package }} check
+      - run: npm run --prefix ${{ matrix.package }} fix
@@ -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])

@@ -1936,8 +1826,8 @@ class HermesACPAgent(acp.Agent):
                return "No tools available."
            lines = [f"Available tools ({len(tools)}):"]
            for t in tools:
-                name = (t.get("function") or {}).get("name", "?")
-                desc = (t.get("function") or {}).get("description", "")
+                name = t.get("function", {}).get("name", "?")
+                desc = t.get("function", {}).get("description", "")
                # Truncate long descriptions
                if len(desc) > 80:
                    desc = desc[:77] + "..."
@@ -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=(
@@ -69,43 +69,6 @@ def _ra():
    return run_agent


-def _moa_reference_output_allowed(agent: Any) -> bool:
-    """Keep MoA display events off only the machine-readable ``-Q`` surface."""
-    return not (
-        getattr(agent, "platform", None) == "cli"
-        and getattr(agent, "tool_progress_mode", "all") == "off"
-    )
-
-
-def _relay_moa_reference_event(agent: Any, event: str, **kwargs: Any) -> None:
-    """Relay MoA display events while preserving the ``-Q`` stdout contract."""
-    if not _moa_reference_output_allowed(agent):
-        return
-    cb = getattr(agent, "tool_progress_callback", None)
-    if cb is None:
-        return
-    try:
-        if event == "moa.reference":
-            cb(
-                "moa.reference",
-                str(kwargs.get("label") or ""),
-                str(kwargs.get("text") or ""),
-                None,
-                moa_index=kwargs.get("index"),
-                moa_count=kwargs.get("count"),
-            )
-        elif event == "moa.aggregating":
-            cb(
-                "moa.aggregating",
-                str(kwargs.get("aggregator") or ""),
-                None,
-                None,
-                moa_ref_count=kwargs.get("ref_count"),
-            )
-    except Exception:
-        pass
-
-
 def _normalize_route_base_url(base_url: Any) -> str:
    """Canonicalize an endpoint URL for model-route identity comparisons."""
    return normalize_route_base_url(base_url)
@@ -517,7 +480,6 @@ def init_agent(
    checkpoint_max_total_size_mb: int = 500,
    checkpoint_max_file_size_mb: int = 10,
    pass_session_id: bool = False,
-    requested_provider: str = None,
 ):
    """
    Initialize the AI Agent.
@@ -526,7 +488,6 @@ def init_agent(
        base_url (str): Base URL for the model API (optional)
        api_key (str): API key for authentication (optional, uses env var if not provided)
        provider (str): Provider identifier (optional; used for telemetry/routing hints)
-        requested_provider (str): Original provider identity before runtime canonicalization
        api_mode (str): API mode override: "chat_completions" or "codex_responses"
        model (str): Model name to use (default: "anthropic/claude-opus-4.6")
        max_iterations (int): Maximum number of tool calling iterations (default: 90)
@@ -607,11 +568,6 @@ def init_agent(
    agent.base_url = base_url or ""
    provider_name = provider.strip().lower() if isinstance(provider, str) and provider.strip() else None
    agent.provider = provider_name or ""
-    agent.requested_provider = (
-        requested_provider.strip().lower()
-        if isinstance(requested_provider, str) and requested_provider.strip()
-        else agent.provider
-    )
    agent._credential_pool = credential_pool
    agent.acp_command = acp_command or command
    agent.acp_args = list(acp_args or args or [])
@@ -764,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
@@ -777,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
@@ -950,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).
@@ -1062,20 +1003,49 @@ def init_agent(
                elif isinstance(effective_key, str) and len(effective_key) > 12:
                    print(f"🔑 Using token: {effective_key[:8]}...{effective_key[-4:]}")
    elif agent.provider == "moa":
-        from agent.moa_loop import build_moa_facade
+        from agent.moa_loop import MoAClient
        agent.api_mode = "chat_completions"

-        # build_moa_facade wires the reference relay that routes
-        # reference-model outputs to the agent's tool_progress_callback so
+        # Route reference-model outputs to the agent's tool_progress_callback so
        # every surface that already consumes it (CLI spinner/scrollback, TUI,
-        # desktop, gateway) can show each reference's answer as a labelled
-        # block before the aggregator acts. The facade emits "moa.reference",
-        # "moa.progress", "moa.phase", and "moa.aggregating" events, forwarded
-        # through the same callback the tool lifecycle uses. Best-effort and
-        # cache-safe — display-only events, they never touch the message
-        # history. The factory is shared with the fallback-restore/recovery
-        # paths so a restored facade keeps emitting these events (#53802).
-        agent.client = build_moa_facade(agent, agent.model)
+        # desktop, gateway) can show each reference's answer as a labelled block
+        # before the aggregator acts. The facade emits "moa.reference" and
+        # "moa.aggregating" events; we forward them through the same callback
+        # the tool lifecycle uses. Best-effort and cache-safe — these are
+        # display-only events, they never touch the message history.
+        def _moa_reference_relay(event: str, **kwargs: Any) -> None:
+            cb = getattr(agent, "tool_progress_callback", None)
+            if cb is None:
+                return
+            try:
+                if event == "moa.reference":
+                    label = str(kwargs.get("label") or "")
+                    text = str(kwargs.get("text") or "")
+                    idx = kwargs.get("index")
+                    count = kwargs.get("count")
+                    cb(
+                        "moa.reference",
+                        label,
+                        text,
+                        None,
+                        moa_index=idx,
+                        moa_count=count,
+                    )
+                elif event == "moa.aggregating":
+                    cb(
+                        "moa.aggregating",
+                        str(kwargs.get("aggregator") or ""),
+                        None,
+                        None,
+                        moa_ref_count=kwargs.get("ref_count"),
+                    )
+            except Exception:
+                pass
+
+        agent.client = MoAClient(
+            agent.model or "default",
+            reference_callback=_moa_reference_relay,
+        )
        agent._client_kwargs = {}
        agent.api_key = api_key or "moa-virtual-provider"
        agent.base_url = "moa://local"
@@ -1818,28 +1788,6 @@ def init_agent(
    compression_enabled = str(_compression_cfg.get("enabled", True)).lower() in {"true", "1", "yes"}
    compression_target_ratio = float(_compression_cfg.get("target_ratio", 0.20))
    compression_protect_last = int(_compression_cfg.get("protect_last_n", 20))
-    # Minimum REAL (actionable) user messages guaranteed to survive in the
-    # uncompressed tail (compression.min_tail_user_messages).  Default 1
-    # preserves current behavior exactly — the existing single-user tail
-    # anchor.  Values > 1 extend the guarantee to the last N actionable
-    # user turns.  Booleans rejected (bool subclasses int), non-int-like
-    # values fall back to 1, floor at 1.
-    _raw_min_tail_users = _compression_cfg.get("min_tail_user_messages", 1)
-    if isinstance(_raw_min_tail_users, bool):
-        compression_min_tail_users = 1
-    elif isinstance(_raw_min_tail_users, int):
-        compression_min_tail_users = _raw_min_tail_users
-    elif isinstance(_raw_min_tail_users, float):
-        compression_min_tail_users = (
-            int(_raw_min_tail_users) if _raw_min_tail_users.is_integer() else 1
-        )
-    else:
-        try:
-            compression_min_tail_users = int(str(_raw_min_tail_users).strip())
-        except (TypeError, ValueError):
-            compression_min_tail_users = 1
-    if compression_min_tail_users < 1:
-        compression_min_tail_users = 1
    # Cap on compression retry rounds before a turn gives up with "max
    # compression attempts reached" (compression.max_attempts).  Hardcoding 3
    # strands sessions that legitimately need more rounds — e.g. a restart
@@ -1868,39 +1816,6 @@ def init_agent(
    if compression_max_attempts < 1:
        compression_max_attempts = 3
    compression_max_attempts = min(compression_max_attempts, 10)
-
-    def _parse_prune_int(raw, default):
-        # Same parser semantics as compression.max_attempts above: reject
-        # booleans (bool subclasses int — YAML `true` would coerce to 1),
-        # reject fractional floats rather than truncating them, accept
-        # integral floats and numeric strings, fall back to the default on
-        # anything else.
-        if isinstance(raw, bool):
-            return default
-        if isinstance(raw, int):
-            return raw
-        if isinstance(raw, float):
-            return int(raw) if raw.is_integer() else default
-        try:
-            return int(str(raw).strip())
-        except (TypeError, ValueError):
-            return default
-
-    # Opt-in proactive tool-result prune trigger (0 = disabled — the
-    # default, so an unset key is behavior-neutral).  Negative values are
-    # treated as disabled rather than erroring.
-    compression_proactive_prune_tokens = max(
-        0, _parse_prune_int(_compression_cfg.get("proactive_prune_tokens", 0), 0)
-    )
-    compression_proactive_prune_min_chars = _parse_prune_int(
-        _compression_cfg.get("proactive_prune_min_result_chars", 8000), 8000
-    )
-    compression_proactive_prune_min_reclaim = max(
-        0,
-        _parse_prune_int(
-            _compression_cfg.get("proactive_prune_min_reclaim_tokens", 4096), 4096
-        ),
-    )
    # protect_first_n is the number of non-system messages to protect at
    # the head, in addition to the system prompt (which is always
    # implicitly protected by the compressor).  Floor at 0 — a value of
@@ -1924,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
@@ -1954,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
@@ -2374,11 +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,
-            proactive_prune_tokens=compression_proactive_prune_tokens,
-            proactive_prune_min_result_chars=compression_proactive_prune_min_chars,
-            proactive_prune_min_reclaim_tokens=compression_proactive_prune_min_reclaim,
-            min_tail_user_messages=compression_min_tail_users,
        )
    _bind_session_state = getattr(agent.context_compressor, "bind_session_state", None)
    if callable(_bind_session_state):
@@ -2390,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).
@@ -2593,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
@@ -2643,7 +2528,6 @@ def init_agent(
    agent._primary_runtime = {
        "model": agent.model,
        "provider": agent.provider,
-        "requested_provider": agent.requested_provider,
        "base_url": agent.base_url,
        "api_mode": agent.api_mode,
        "api_key": getattr(agent, "api_key", ""),
@@ -922,23 +922,6 @@ def recover_with_credential_pool(
            )
            return False, has_retried_429

-    # Attribute the failure to the API key the agent actually dispatched the
-    # request with, not to pool.current(). The current() pointer is shared,
-    # mutable state — round-robin select() advances it on every call, and
-    # concurrent turns or a second process (gateway/dashboard) reloading the
-    # pool reset it to None — so by the time recovery runs it routinely points
-    # at a DIFFERENT, healthy entry. Marking that entry exhausted copies this
-    # request's error/reset time onto it and can take the whole pool offline
-    # from a single rate-limited key (#43747). ``_swap_credential`` keeps
-    # ``agent.api_key`` in sync with the entry in use, so it identifies the
-    # failing entry exactly; fall back to current()'s key only when the agent
-    # carries no key at all.
-    _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:
@@ -969,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(
@@ -992,16 +975,7 @@ def recover_with_credential_pool(
        # rotate immediately. This prevents the "cancel-between-429s" trap
        # where has_retried_429 (a local var) gets reset on each new prompt,
        # causing the pool to retry the same exhausted credential forever.
-        # Prefer the entry matching the failing key over the shared current()
-        # pointer, for the same attribution reason as above.
-        current_entry = None
-        if _api_key_hint:
-            current_entry = next(
-                (e for e in pool.entries() if e.runtime_api_key == _api_key_hint),
-                None,
-            )
-        if current_entry is None:
-            current_entry = pool.current()
+        current_entry = pool.current()
        current_last_status = getattr(current_entry, "last_status", None) if current_entry else None
        if current_last_status == STATUS_EXHAUSTED:
            _ra().logger.info(
@@ -1009,11 +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",
@@ -1037,11 +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",
@@ -1056,7 +1022,7 @@ def recover_with_credential_pool(
        # Subscription/entitlement 403s look like auth failures on the wire
        # but refresh cannot fix them — the OAuth token is already valid,
        # the account simply lacks the entitlement.  Without this guard,
-        # the refresh path keeps minting fresh tokens against the
+        # ``try_refresh_current()`` keeps minting fresh tokens against the
        # same unsubscribed account and the main agent loop spins re-issuing
        # the same 403 until the user Ctrl+C's.
        #
@@ -1109,13 +1075,9 @@ def recover_with_credential_pool(
                agent.provider or "provider",
            )
            return False, has_retried_429
-        # Refresh the entry that supplied the failing key, not current():
-        # the shared pointer can reference a different, healthy entry, and
-        # refreshing it would consume that entry's single-use refresh token
-        # (or mark it exhausted on failure) for a failure it never had.
-        refreshed = pool.try_refresh_matching(api_key_hint=_api_key_hint)
+        refreshed = pool.try_refresh_current()
        if refreshed is not None:
-            # ``try_refresh_matching()`` re-mints a fresh OAuth token and reports
+            # ``try_refresh_current()`` re-mints a fresh OAuth token and reports
            # success even when the upstream keeps rejecting it — a single-entry
            # pool (common for OAuth/Max subscribers) has nothing to rotate to,
            # so a bare "refreshed → retry" loop spins forever on the same dead
@@ -1143,13 +1105,9 @@ def recover_with_credential_pool(
            agent._swap_credential(refreshed)
            return True, has_retried_429
        # Refresh failed — rotate to next credential instead of giving up.
-        # The failed entry is already marked exhausted by the refresh attempt.
+        # 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",
@@ -1208,7 +1166,6 @@ def try_recover_primary_transport(
        agent._client_kwargs = dict(rt["client_kwargs"])
        agent.model = rt["model"]
        agent.provider = rt["provider"]
-        agent.requested_provider = rt.get("requested_provider", agent.provider)
        agent.base_url = rt["base_url"]
        agent.api_mode = rt["api_mode"]
        if hasattr(agent, "_transport_cache"):
@@ -1225,14 +1182,6 @@ def try_recover_primary_transport(
            )
            agent._is_anthropic_oauth = rt["is_anthropic_oauth"]
            agent.client = None
-        elif (agent.provider or "").strip().lower() == "moa":
-            # MoA is a virtual provider with empty client_kwargs — rebuilding
-            # via _create_openai_client would raise "api_key client option
-            # must be set". Recreate the facade through the shared factory so
-            # the reference_callback relay survives recovery (#53802).
-            from agent.moa_loop import build_moa_facade
-
-            agent.client = build_moa_facade(agent, agent.model)
        else:
            agent.client = agent._create_openai_client(
                dict(rt["client_kwargs"]),
@@ -1380,7 +1329,6 @@ def restore_primary_runtime(agent) -> bool:
        # ── Core runtime state ──
        agent.model = rt["model"]
        agent.provider = rt["provider"]
-        agent.requested_provider = rt.get("requested_provider", agent.provider)
        agent.base_url = rt["base_url"]           # setter updates _base_url_lower
        agent.api_mode = rt["api_mode"]
        if hasattr(agent, "_transport_cache"):
@@ -1396,18 +1344,7 @@ def restore_primary_runtime(agent) -> bool:
        )

        # ── Rebuild client for the primary provider ──
-        if agent.provider == "moa":
-            # MoA is a virtual chat-completions provider.  It never has real
-            # OpenAI client kwargs; restoring it after a fallback must recreate
-            # the facade, not call OpenAI() with an empty api_key.  Use the
-            # shared factory so the restored facade keeps the reference_callback
-            # relay wired at init — a bare MoAClient() would silently stop
-            # emitting moa.reference/moa.aggregating display events (#53802).
-            from agent.moa_loop import build_moa_facade
-
-            agent.client = build_moa_facade(agent, agent.model)
-            agent._anthropic_client = None
-        elif agent.api_mode == "anthropic_messages":
+        if agent.api_mode == "anthropic_messages":
            from agent.anthropic_adapter import build_anthropic_client
            agent._anthropic_api_key = rt["anthropic_api_key"]
            agent._anthropic_base_url = rt["anthropic_base_url"]
@@ -2056,7 +1993,6 @@ def switch_model(agent, new_model, new_provider, api_key='', base_url='', api_mo
        for name in (
            "model",
            "provider",
-            "requested_provider",
            "base_url",
            "api_mode",
            "api_key",
@@ -2085,7 +2021,6 @@ def switch_model(agent, new_model, new_provider, api_key='', base_url='', api_mo
        # ── Swap core runtime fields ──
        agent.model = new_model
        agent.provider = new_provider
-        agent.requested_provider = new_provider
        # Use the new base_url when provided. When it's empty AND the
        # provider is actually changing, do NOT fall back to the current
        # (old provider's) URL — that silently pairs the new provider label
@@ -2143,7 +2078,7 @@ def switch_model(agent, new_model, new_provider, api_key='', base_url='', api_mo

        # ── Build new client ──
        if (new_provider or "").strip().lower() == "moa":
-            from agent.moa_loop import build_moa_facade
+            from agent.moa_loop import MoAClient

            # The MoA virtual provider speaks only chat.completions via the
            # MoAClient facade — the aggregator's real transport
@@ -2160,7 +2095,7 @@ def switch_model(agent, new_model, new_provider, api_key='', base_url='', api_mo
            agent.api_key = api_key or "moa-virtual-provider"
            agent.base_url = "moa://local"
            agent._client_kwargs = {}
-            agent.client = build_moa_facade(agent, agent.model)
+            agent.client = MoAClient(agent.model or "default")
        elif api_mode == "anthropic_messages":
            from agent.anthropic_adapter import (
                build_anthropic_client,
@@ -2335,7 +2270,6 @@ def switch_model(agent, new_model, new_provider, api_key='', base_url='', api_mo
    agent._primary_runtime = {
        "model": agent.model,
        "provider": agent.provider,
-        "requested_provider": agent.requested_provider,
        "base_url": agent.base_url,
        "api_mode": agent.api_mode,
        "api_key": getattr(agent, "api_key", ""),
@@ -1881,28 +1881,6 @@ def _content_parts_to_anthropic_blocks(parts: Any) -> List[Dict[str, Any]]:
    return out


-_EMPTY_TEXT_PLACEHOLDER = "(empty)"
-
-
-def _safe_text(text: Any) -> str:
-    """Return ``text`` if it's non-whitespace, else a non-whitespace placeholder.
-
-    The Anthropic Messages API rejects requests where a text content block is
-    empty or whitespace-only (HTTP 400 "text content blocks must contain
-    non-whitespace text"). When such a block gets stored in session history —
-    e.g. produced by context compression — it is replayed verbatim on every
-    subsequent turn, permanently wedging the session. Coercing to a
-    non-whitespace placeholder is self-healing: the next API call recovers.
-
-    Mirrors ``bedrock_adapter._safe_text`` (#9486); ref #69512.
-    """
-    if text is None:
-        return _EMPTY_TEXT_PLACEHOLDER
-    if not isinstance(text, str):
-        text = str(text)
-    return text if text.strip() else _EMPTY_TEXT_PLACEHOLDER
-
-
 def _sanitize_replay_block(b: Dict[str, Any]) -> Optional[Dict[str, Any]]:
    """Strip output-only fields from a stored Anthropic content block so it is
    valid as REQUEST input on replay.
@@ -1920,10 +1898,7 @@ def _sanitize_replay_block(b: Dict[str, Any]) -> Optional[Dict[str, Any]]:
        return None
    btype = b.get("type")
    if btype == "text":
-        # Coerce empty/whitespace-only text to a non-whitespace placeholder;
-        # the Messages input schema rejects blank text blocks (#69512), and a
-        # blank block stored in history replays on every turn → permanent 400.
-        out: Dict[str, Any] = {"type": "text", "text": _safe_text(b.get("text", ""))}
+        out: Dict[str, Any] = {"type": "text", "text": b.get("text", "")}
        # citations is input-valid ONLY when it's a non-empty list; the SDK
        # emits citations=None on responses, which the input schema rejects.
        cits = b.get("citations")
@@ -2083,16 +2058,7 @@ def _convert_assistant_message(m: Dict[str, Any]) -> Dict[str, Any]:
    # Anthropic rejects empty assistant content
    effective = blocks or content
    if not effective or effective == "":
-        effective = [{"type": "text", "text": _EMPTY_TEXT_PLACEHOLDER}]
-    elif isinstance(effective, list):
-        # The all-empty guard above misses a list that still contains a
-        # whitespace-only text block (e.g. from a content array of blank parts,
-        # or compression). Those also trip "text content blocks must contain
-        # non-whitespace text" (#69512). Coerce text blocks in place; other
-        # block types (thinking/tool_use/image) are left untouched.
-        for blk in effective:
-            if isinstance(blk, dict) and blk.get("type") == "text":
-                blk["text"] = _safe_text(blk.get("text", ""))
+        effective = [{"type": "text", "text": "(empty)"}]
    return {"role": "assistant", "content": effective}


@@ -2303,62 +2303,6 @@ def _read_main_base_url() -> str:
    return ""


-def _resolve_moa_aggregator(preset_name: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
-    """Resolve a MoA preset to its aggregator (provider, model) pair.
-
-    "moa" is a virtual provider — the acting model of a preset is its
-    aggregator slot, and there is no real "moa" HTTP endpoint. Auxiliary
-    tasks (title generation, compression, vision, commit messages, …) don't
-    need the reference fan-out, so every aux resolution layer maps
-    provider="moa"/model=<preset> to the aggregator's real provider+model
-    through this single helper (shared by ``_resolve_auto``,
-    ``_resolve_task_provider_model``, and ``resolve_provider_client`` so the
-    preset lookup and validation cannot drift between paths).
-
-    Args:
-        preset_name: The MoA preset name (usually carried in the "model"
-            field), or None/"" to resolve the user's default preset.
-
-    Returns:
-        (aggregator_provider, aggregator_model), or (None, None) when the
-        preset cannot be resolved (missing config, renamed/deleted preset,
-        or a malformed aggregator slot).
-    """
-    try:
-        from hermes_cli.config import load_config
-        from hermes_cli.moa_config import resolve_moa_preset
-
-        preset = resolve_moa_preset(load_config().get("moa") or {}, preset_name or None)
-        agg = preset.get("aggregator") or {}
-        agg_provider = str(agg.get("provider") or "").strip()
-        agg_model = str(agg.get("model") or "").strip()
-        if agg_provider and agg_model and agg_provider.lower() != "moa":
-            return agg_provider, agg_model
-    except Exception:
-        logger.debug(
-            "MoA aggregator resolution failed for preset %r", preset_name, exc_info=True
-        )
-    return None, None
-
-
-def _read_main_model_for_aux() -> str:
-    """Main model with MoA presets unwrapped to the aggregator's model.
-
-    When the main provider is ``moa``, ``_read_main_model()`` returns a MoA
-    *preset name* (e.g. "opus-gpt") — never a valid wire model id on any
-    provider. Auxiliary fallback chains that pre-fill a missing model from
-    the main model must use this reader instead, so unset aux models default
-    to the preset's acting (aggregator) model. Returns "" when the main
-    provider is moa but the preset cannot be resolved — sending nothing is
-    strictly better than sending a preset name that 400s.
-    """
-    model = _read_main_model()
-    if (_read_main_provider() or "").strip().lower() == "moa":
-        _, agg_model = _resolve_moa_aggregator(model)
-        return agg_model or ""
-    return model
-
-
 def _read_main_api_key_if_same_host(aux_base_url: str) -> str:
    """Return the main api_key only when *aux_base_url* points at the same
    host as the main model's base_url.
@@ -2434,7 +2378,6 @@ def set_runtime_main(
    provider: str,
    model: str,
    *,
-    requested_provider: str = "",
    base_url: str = "",
    api_key: Any = "",
    api_mode: str = "",
@@ -2450,7 +2393,6 @@ def set_runtime_main(
    global _RUNTIME_MAIN_AUTH_MODE, _RUNTIME_MAIN_COMPAT_SNAPSHOT
    runtime = {
        "provider": (provider or "").strip().lower(),
-        "requested_provider": (requested_provider or "").strip().lower(),
        "model": (model or "").strip(),
        "base_url": (base_url or "").strip(),
        "api_key": (
@@ -2631,7 +2573,7 @@ def _try_custom_endpoint() -> Tuple[Optional[Any], Optional[str]]:
        return None, None
    if custom_base.lower().startswith(_CODEX_AUX_BASE_URL.lower()):
        return None, None
-    model = _read_main_model_for_aux() or "gpt-4o-mini"
+    model = _read_main_model() or "gpt-4o-mini"
    logger.debug("Auxiliary client: custom endpoint (%s, api_mode=%s)", model, custom_mode or "chat_completions")
    _clean_base, _dq = _extract_url_query_params(custom_base)
    _extra = {"default_query": _dq} if _dq else {}
@@ -2923,7 +2865,6 @@ _AUTO_PROVIDER_LABELS = {
 }

 _MAIN_RUNTIME_FIELDS = ("provider", "model", "base_url", "api_key", "api_mode", "auth_mode")
-_MAIN_RUNTIME_CONTEXT_FIELDS = _MAIN_RUNTIME_FIELDS + ("requested_provider",)


 def _normalize_main_runtime(main_runtime: Optional[Dict[str, Any]]) -> Dict[str, Any]:
@@ -2946,7 +2887,7 @@ def _normalize_main_runtime(main_runtime: Optional[Dict[str, Any]]) -> Dict[str,
    if not isinstance(main_runtime, dict):
        return {}
    normalized: Dict[str, Any] = {}
-    for field in _MAIN_RUNTIME_CONTEXT_FIELDS:
+    for field in _MAIN_RUNTIME_FIELDS:
        value = main_runtime.get(field)
        # Preserve a callable api_key (Entra ID bearer provider) unchanged.
        if field == "api_key" and callable(value) and not isinstance(value, str):
@@ -2954,10 +2895,9 @@ def _normalize_main_runtime(main_runtime: Optional[Dict[str, Any]]) -> Dict[str,
            continue
        if isinstance(value, str) and value.strip():
            normalized[field] = value.strip()
-    for identity_field in ("provider", "requested_provider"):
-        identity = normalized.get(identity_field)
-        if isinstance(identity, str):
-            normalized[identity_field] = identity.lower()
+    provider = normalized.get("provider")
+    if isinstance(provider, str):
+        normalized["provider"] = provider.lower()
    return normalized


@@ -3648,7 +3588,6 @@ def _retry_same_provider_sync(
    effective_timeout: float,
    effective_extra_body: dict,
    reasoning_config: Optional[dict],
-    extra_headers: Optional[Dict[str, str]] = None,
 ) -> Any:
    if task == "vision":
        _, retry_client, retry_model = resolve_vision_provider_client(
@@ -3684,13 +3623,7 @@ def _retry_same_provider_sync(
        extra_body=effective_extra_body,
        reasoning_config=reasoning_config,
        base_url=retry_base or resolved_base_url,
-        task=task,
    )
-    # Preserve per-request attribution headers (e.g. Copilot's
-    # ``x-initiator: user``) across the rebuilt-client retry — dropping them
-    # here would let a recovery retry silently lose capability gating (#60293).
-    if extra_headers:
-        retry_kwargs["extra_headers"] = dict(extra_headers)
    if _is_anthropic_compat_endpoint(resolved_provider, retry_base):
        retry_kwargs["messages"] = _convert_openai_images_to_anthropic(retry_kwargs["messages"])
    return _validate_llm_response(
@@ -3714,7 +3647,6 @@ async def _retry_same_provider_async(
    effective_timeout: float,
    effective_extra_body: dict,
    reasoning_config: Optional[dict],
-    extra_headers: Optional[Dict[str, str]] = None,
 ) -> Any:
    if task == "vision":
        _, retry_client, retry_model = resolve_vision_provider_client(
@@ -3750,12 +3682,7 @@ async def _retry_same_provider_async(
        extra_body=effective_extra_body,
        reasoning_config=reasoning_config,
        base_url=retry_base or resolved_base_url,
-        task=task,
    )
-    # Preserve per-request attribution headers across the rebuilt-client
-    # retry — see the sync variant above (#60293).
-    if extra_headers:
-        retry_kwargs["extra_headers"] = dict(extra_headers)
    if _is_anthropic_compat_endpoint(resolved_provider, retry_base):
        retry_kwargs["messages"] = _convert_openai_images_to_anthropic(retry_kwargs["messages"])
    return _validate_llm_response(
@@ -3830,24 +3757,6 @@ def _refresh_provider_credentials(provider: str) -> bool:
                return False
            _evict_cached_clients(normalized)
            return True
-        if normalized == "vertex":
-            # Mirrors run_agent.py's _try_refresh_vertex_client_credentials
-            # for the main conversation loop. Without this branch, an
-            # auxiliary Vertex client (vision, title generation, reflection,
-            # context compression, ...) that 401s on its ~1h token expiry
-            # falls through to the final `return False` below: the stale
-            # client is never evicted from _client_cache (whose cache key
-            # ignores the rotating bearer token), so every subsequent
-            # auxiliary Vertex call keeps 401ing until process restart.
-            from agent.vertex_adapter import get_vertex_config
-
-            token, base_url = get_vertex_config()
-            if not isinstance(token, str) or not token.strip():
-                return False
-            if not isinstance(base_url, str) or not base_url.strip():
-                return False
-            _evict_cached_clients(normalized)
-            return True
    except Exception as exc:
        logger.debug("Auxiliary provider credential refresh failed for %s: %s", normalized, exc)
        return False
@@ -3961,7 +3870,7 @@ def _call_fallback_candidate_sync(
        temperature=temperature, max_tokens=max_tokens,
        tools=tools, timeout=effective_timeout,
        extra_body=effective_extra_body, reasoning_config=reasoning_config,
-        base_url=fb_base, task=task)
+        base_url=fb_base)
    try:
        return _validate_llm_response(
            fb_client.chat.completions.create(**fb_kwargs), task)
@@ -3978,7 +3887,7 @@ def _call_fallback_candidate_sync(
                    tools=tools, timeout=effective_timeout,
                    extra_body=effective_extra_body,
                    reasoning_config=reasoning_config,
-                    base_url=str(getattr(retry_client, "base_url", "") or fb_base), task=task)
+                    base_url=str(getattr(retry_client, "base_url", "") or fb_base))
                try:
                    return _validate_llm_response(
                        retry_client.chat.completions.create(**retry_kwargs), task)
@@ -4027,7 +3936,7 @@ async def _call_fallback_candidate_async(
        temperature=temperature, max_tokens=max_tokens,
        tools=tools, timeout=effective_timeout,
        extra_body=effective_extra_body, reasoning_config=reasoning_config,
-        base_url=fb_base, task=task)
+        base_url=fb_base)
    try:
        return _validate_llm_response(
            await fb_client.chat.completions.create(**fb_kwargs), task)
@@ -4045,7 +3954,7 @@ async def _call_fallback_candidate_async(
                    tools=tools, timeout=effective_timeout,
                    extra_body=effective_extra_body,
                    reasoning_config=reasoning_config,
-                    base_url=str(getattr(retry_client, "base_url", "") or fb_base), task=task)
+                    base_url=str(getattr(retry_client, "base_url", "") or fb_base))
                try:
                    return _validate_llm_response(
                        await retry_client.chat.completions.create(**retry_kwargs), task)
@@ -4132,13 +4041,6 @@ def _try_main_agent_model_fallback(
    """
    main_provider = (_read_main_provider() or "").strip()
    main_model = (_read_main_model() or "").strip()
-    if main_provider.lower() == "moa":
-        # MoA virtual provider: fall back to the preset's aggregator — the
-        # acting model — instead of the unreachable "moa"/<preset-name> pair.
-        _agg_provider, _agg_model = _resolve_moa_aggregator(main_model)
-        if not _agg_provider or not _agg_model:
-            return None, None, ""
-        main_provider, main_model = _agg_provider, _agg_model
    if not main_provider or not main_model or main_provider.lower() in {"auto", ""}:
        return None, None, ""

@@ -4539,17 +4441,26 @@ def _resolve_auto(
    # model. Resolve the MoA preset to its aggregator slot and continue Step 1
    # with that real provider+model. Mirrors the MoA context-length resolution.
    if main_provider == "moa":
-        _agg_provider, _agg_model = _resolve_moa_aggregator(main_model)
-        if _agg_provider and _agg_model:
-            main_provider = _agg_provider
-            main_model = _agg_model
-            # The MoA virtual runtime carries a non-HTTP base_url
-            # ("moa://local") and a placeholder api_key; they belong to the
-            # facade, not the aggregator's real provider. Drop them so the
-            # aggregator resolves through its own provider credentials.
-            runtime_base_url = ""
-            runtime_api_key = ""
-            runtime_api_mode = ""
+        try:
+            from hermes_cli.config import load_config
+            from hermes_cli.moa_config import resolve_moa_preset
+
+            _preset = resolve_moa_preset(load_config().get("moa") or {}, main_model)
+            _agg = _preset.get("aggregator") or {}
+            _agg_provider = str(_agg.get("provider") or "").strip()
+            _agg_model = str(_agg.get("model") or "").strip()
+            if _agg_provider and _agg_model and _agg_provider.lower() != "moa":
+                main_provider = _agg_provider
+                main_model = _agg_model
+                # The MoA virtual runtime carries a non-HTTP base_url
+                # ("moa://local") and a placeholder api_key; they belong to the
+                # facade, not the aggregator's real provider. Drop them so the
+                # aggregator resolves through its own provider credentials.
+                runtime_base_url = ""
+                runtime_api_key = ""
+                runtime_api_mode = ""
+        except Exception:
+            logger.debug("MoA aux resolution to aggregator failed", exc_info=True)

    if (main_provider and main_model
            and main_provider not in {"auto", ""}):
@@ -4804,27 +4715,6 @@ def resolve_provider_client(
    # Normalise aliases
    provider = _normalize_aux_provider(provider)

-    # MoA virtual provider chokepoint: "moa" is not a real HTTP provider —
-    # its acting model is the preset's aggregator slot. The two resolver
-    # layers above (_resolve_auto, _resolve_task_provider_model) already
-    # unwrap their own paths, but callers that route here directly (vision
-    # auto-detect, _try_main_agent_model_fallback, get_available_vision_backends,
-    # plugin code) would otherwise dead-end in the unknown-provider branch.
-    # ``model`` carries the preset name for moa calls; when the preset can't
-    # be resolved we leave the call untouched and let the normal
-    # missing-provider handling produce its diagnostic.
-    if provider == "moa":
-        _agg_provider, _agg_model = _resolve_moa_aggregator(model)
-        if _agg_provider and _agg_model:
-            original_provider = _agg_provider.strip().lower()
-            provider = _normalize_aux_provider(_agg_provider)
-            model = _agg_model
-            # The moa:// facade endpoint and placeholder key belong to the
-            # virtual runtime, not the aggregator's real provider.
-            if explicit_base_url and str(explicit_base_url).lower().startswith("moa://"):
-                explicit_base_url = None
-                explicit_api_key = None
-
    # Universal model-resolution fallback for concrete providers. ``auto`` is
    # intentionally excluded: `_resolve_auto(main_runtime=...)` returns the
    # model paired with the provider it actually selected. Pre-filling an auto
@@ -4845,10 +4735,6 @@ def resolve_provider_client(
    #      the load-bearing step for OAuth providers: an xai-oauth user
    #      with grok-4.3 configured gets grok-4.3 for title generation
    #      instead of silently dropping to whatever Step-2 fallback (#31845).
-    #      When the main provider is MoA, ``_read_main_model_for_aux()``
-    #      substitutes the preset's aggregator model — the preset NAME is
-    #      never a valid wire model id, so unset aux models default to the
-    #      preset's acting model instead.
    #
    # Each provider branch below sees a non-empty ``model`` whenever the
    # user has *anything* configured — no provider-specific empty-model
@@ -4865,7 +4751,7 @@ def resolve_provider_client(
    # return the actual current runtime model when the caller did not explicitly
    # request one. (# compression-current-model)
    if not model and provider != "auto":
-        model = _get_aux_model_for_provider(provider) or _read_main_model_for_aux() or model
+        model = _get_aux_model_for_provider(provider) or _read_main_model() or model

    def _needs_codex_wrap(client_obj, base_url_str: str, model_str: str) -> bool:
        """Decide if a plain OpenAI client should be wrapped for Responses API.
@@ -5139,7 +5025,7 @@ def resolve_provider_client(
                    model
                    or custom_entry.get("model")
                    or (main_runtime.get("model") if main_runtime else None)
-                    or _read_main_model_for_aux()
+                    or _read_main_model()
                    or "gpt-4o-mini",
                    provider,
                )
@@ -5374,7 +5260,7 @@ def resolve_provider_client(
        final_model = _normalize_resolved_model(
            model
            or (main_runtime.get("model") if main_runtime else None)
-            or _read_main_model_for_aux(),
+            or _read_main_model(),
            provider,
        )
        if provider == "copilot-acp":
@@ -5742,24 +5628,7 @@ def resolve_vision_provider_client(
        #   5. Stop
        main_provider = str(runtime.get("provider") or _read_main_provider())
        main_model = str(runtime.get("model") or _read_main_model())
-        if main_provider.strip().lower() == "moa":
-            # MoA virtual provider: main_model is a preset NAME, and every
-            # capability probe below (_PROVIDERS_WITHOUT_VISION,
-            # _main_model_supports_vision, _resolve_provider_vision_default)
-            # would run against a provider/model pair that doesn't exist on
-            # any wire. Unwrap to the preset's aggregator slot first so the
-            # checks and the eventual client target the real acting model.
-            _agg_provider, _agg_model = _resolve_moa_aggregator(main_model)
-            if _agg_provider and _agg_model:
-                main_provider, main_model = _agg_provider, _agg_model
-                # Drop the moa:// facade endpoint from the runtime view used
-                # below — it belongs to the virtual provider, not the
-                # aggregator's real provider.
-                runtime = dict(runtime)
-                runtime["base_url"] = ""
-                runtime["api_key"] = ""
-                runtime["api_mode"] = ""
-        if main_provider and main_provider not in {"auto", "", "moa"}:
+        if main_provider and main_provider not in {"auto", ""}:
            # A provider-specific vision default wins over the user's chat model:
            # static overrides (xiaomi/zai) and catalog-backed discovery (the
            # DeepInfra profile hook) both yield a *known* vision-capable model,
@@ -6356,8 +6225,8 @@ def _resolve_task_provider_model(
    task: str = None,
    provider: str = None,
    model: str = None,
-    base_url: Optional[str] = None,
-    api_key: Optional[str] = None,
+    base_url: str = None,
+    api_key: str = None,
 ) -> Tuple[str, Optional[str], Optional[str], Optional[str], Optional[str]]:
    """Determine provider + model for a call.

@@ -6400,57 +6269,12 @@ def _resolve_task_provider_model(
    # which downstream consumers like ContextCompressor accept as the task output.
    # The provider-side 'auto' is handled in _resolve_auto() via main_runtime
    # fallback, so dropping cfg_model to None here lets that path do its job.
-    #
-    # The explicit `model` kwarg needs the identical normalization: MoA slots
-    # (agent/moa_loop.py's _slot_runtime) forward a preset's `model:` field as
-    # this explicit argument rather than through auxiliary.<task> config, so a
-    # user-configured `model: auto` on a MoA reference/aggregator slot reaches
-    # this function here, not as cfg_model. Only normalizing cfg_model let that
-    # literal "auto" slip through via `model or cfg_model` below.
-    if model and model.lower() == "auto":
-        model = None
    if cfg_model and cfg_model.lower() == "auto":
        cfg_model = None

    resolved_model = model or cfg_model
    resolved_api_mode = cfg_api_mode

-    # MoA virtual provider: an *explicit* `provider: moa` override (either the
-    # caller-passed `provider` arg or `auxiliary.<task>.provider` in
-    # config.yaml) reaches this function directly — it never goes through
-    # _resolve_auto(), which only unwraps the *implicit* "main provider is
-    # moa" case (#53827). Left as-is, "moa" is returned verbatim and
-    # resolve_provider_client() looks it up in PROVIDER_REGISTRY (which has
-    # no "moa" entry — it's not a real HTTP provider), falls to the
-    # unknown-provider dead end, and call_llm surfaces a nonsensical
-    # "MOA_API_KEY environment variable" error for a provider that was never
-    # meant to be reached over the wire. Auxiliary tasks don't need the
-    # reference fan-out — resolve to the preset's aggregator slot instead,
-    # exactly like the implicit path does (shared helper: _resolve_moa_aggregator).
-    def _unwrap_moa_provider(prov: str, mdl: Optional[str]) -> Tuple[str, Optional[str]]:
-        if prov.strip().lower() != "moa":
-            return prov, mdl
-        agg_provider, agg_model = _resolve_moa_aggregator(mdl)
-        if agg_provider and agg_model:
-            return agg_provider, agg_model
-        return prov, mdl
-
-    if provider and str(provider).strip().lower() == "moa":
-        provider, resolved_model = _unwrap_moa_provider(provider, resolved_model)
-        # The moa:// virtual endpoint (if any explicit base_url/api_key was
-        # passed alongside provider="moa") belongs to the facade, not the
-        # aggregator's real provider — drop it so the aggregator resolves
-        # through its own provider credentials, mirroring _resolve_auto().
-        if provider and provider.lower() != "moa":
-            base_url = None
-            api_key = None
-    elif cfg_provider and str(cfg_provider).strip().lower() == "moa":
-        cfg_provider, cfg_model = _unwrap_moa_provider(cfg_provider, resolved_model)
-        if cfg_provider and cfg_provider.lower() != "moa":
-            resolved_model = cfg_model
-            cfg_base_url = None
-            cfg_api_key = None
-
    # Convenience aliases for direct API-key endpoints that aren't first-class
    # providers (e.g. ``provider: openai`` → custom + api.openai.com/v1).
    # Applied to both explicit args and config-derived values. When the user
@@ -6807,7 +6631,6 @@ def _build_call_kwargs(
    extra_body: Optional[dict] = None,
    reasoning_config: Optional[dict] = None,
    base_url: Optional[str] = None,
-    task: Optional[str] = None,
 ) -> dict:
    """Build kwargs for .chat.completions.create() with model/provider adjustments."""
    kwargs: Dict[str, Any] = {
@@ -6862,32 +6685,11 @@ def _build_call_kwargs(
            _provider_norm in {"nvidia", "nvidia-nim", "nim", "build-nvidia", "nemotron"}
            or base_url_host_matches(_effective_base, "integrate.api.nvidia.com")
        )
-        _is_moa = bool(task) and str(task) == "moa_reference"
-        # Gemini's native generateContent maps max_tokens → maxOutputTokens and,
-        # when it is omitted, applies a fixed 65,535-token ceiling rather than
-        # "the model's full budget" (see gemini_native_adapter.build_gemini_request).
-        # So an explicit cap is both safe and the ONLY way to honor it here —
-        # dropping max_tokens silently makes MoA's reference_max_tokens a no-op
-        # for gemini advisors (they run effectively uncapped).
-        _is_gemini_native = _provider_norm in {
-            "gemini", "google", "google-gemini", "google-ai-studio",
-        }
-        if not _is_gemini_native and _effective_base:
-            try:
-                from agent.gemini_native_adapter import is_native_gemini_base_url
-                _is_gemini_native = is_native_gemini_base_url(_effective_base)
-            except Exception:
-                pass
        if (
            _is_anthropic_compat_endpoint(provider, _effective_base)
            or _is_nvidia_nim
-            or _is_moa
-            or _is_gemini_native
        ):
-            # Use auxiliary_max_tokens_param() so models that require
-            # max_completion_tokens (GPT-5 family, Copilot) get the right
-            # parameter name instead of a hardcoded max_tokens that 400s.
-            kwargs.update(auxiliary_max_tokens_param(max_tokens, model=model))
+            kwargs["max_tokens"] = max_tokens

    if tools:
        # Defensive dedup: providers like Google Vertex, Azure, and Bedrock
@@ -7119,7 +6921,6 @@ def call_llm(
    timeout: float = None,
    extra_body: dict = None,
    reasoning_config: Optional[dict] = None,
-    extra_headers: Optional[Dict[str, str]] = None,
    api_mode: str = None,
    stream: bool = False,
    stream_options: dict = None,
@@ -7145,9 +6946,6 @@ def call_llm(
        extra_body: Additional request body fields.
        reasoning_config: Optional Hermes reasoning config for direct model calls
              such as MoA reference/aggregator slots.
-        extra_headers: Additional per-request HTTP headers. These override
-            client-level defaults for providers that gate capabilities on
-            request attribution (for example Copilot's ``x-initiator``).
        stream: When True, return the raw SDK streaming iterator instead of a
            validated complete response. The caller is responsible for consuming
            chunks (and for any fallback). Used by the MoA aggregator so its
@@ -7260,9 +7058,7 @@ def call_llm(
        temperature=temperature, max_tokens=max_tokens,
        tools=tools, timeout=effective_timeout, extra_body=effective_extra_body,
        reasoning_config=reasoning_config,
-        base_url=_base_info or resolved_base_url, task=task)
-    if extra_headers:
-        kwargs["extra_headers"] = dict(extra_headers)
+        base_url=_base_info or resolved_base_url)

    # Convert image blocks for Anthropic-compatible endpoints (e.g. MiniMax)
    _client_base = str(getattr(client, "base_url", "") or "")
@@ -7516,7 +7312,6 @@ def call_llm(
                    effective_timeout=effective_timeout,
                    effective_extra_body=effective_extra_body,
                    reasoning_config=reasoning_config,
-                    extra_headers=extra_headers,
                )

        # ── Same-provider credential-pool recovery ─────────────────────
@@ -7560,7 +7355,6 @@ def call_llm(
                        effective_timeout=effective_timeout,
                        effective_extra_body=effective_extra_body,
                        reasoning_config=reasoning_config,
-                        extra_headers=extra_headers,
                    )
                except Exception as retry2_err:
                    # The rotated key also hit a quota/auth wall.  Mark it
@@ -7880,7 +7674,7 @@ async def async_call_llm(
        temperature=temperature, max_tokens=max_tokens,
        tools=tools, timeout=effective_timeout, extra_body=effective_extra_body,
        reasoning_config=reasoning_config,
-        base_url=_client_base or resolved_base_url, task=task)
+        base_url=_client_base or resolved_base_url)

    # Convert image blocks for Anthropic-compatible endpoints (e.g. MiniMax)
    if _is_anthropic_compat_endpoint(resolved_provider, _client_base):
@@ -433,29 +433,6 @@ def _model_supports_tool_use(model_id: str) -> bool:
    return not any(pattern in model_lower for pattern in _NON_TOOL_CALLING_PATTERNS)


-# ---------------------------------------------------------------------------
-# Prompt-cache capability detection (Converse API cachePoint)
-# ---------------------------------------------------------------------------
-# Claude on Bedrock already gets prompt caching through the AnthropicBedrock
-# SDK path (see is_anthropic_bedrock_model / runtime_provider.py's dual-path
-# routing) — it never reaches build_converse_kwargs unless bearer-token auth
-# forces the Converse path (#28156). This allowlist covers the Converse API
-# itself: sending an unsupported model a cachePoint block raises a
-# ValidationException, so — like _model_supports_tool_use but inverted —
-# unknown models default to NOT receiving cache markers until confirmed.
-# Ref: https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
-_CACHE_POINT_PATTERNS = [
-    "anthropic.claude",  # bearer-token fallback path
-    "amazon.nova",
-]
-
-
-def _model_supports_prompt_cache(model_id: str) -> bool:
-    """Return True if the model accepts a Converse API cachePoint block."""
-    model_lower = model_id.lower()
-    return any(pattern in model_lower for pattern in _CACHE_POINT_PATTERNS)
-
-
 def is_anthropic_bedrock_model(model_id: str) -> bool:
    """Return True if the model is an Anthropic Claude model on Bedrock.

@@ -787,22 +764,14 @@ def normalize_converse_response(response: Dict) -> SimpleNamespace:
        reasoning_content="\n\n".join(reasoning_parts) if reasoning_parts else None,
    )

-    # Build usage stats. Converse's inputTokens excludes cache read/write
-    # tokens (unlike OpenAI's prompt_tokens, which includes them) — restore
-    # the OpenAI-style "total includes cache" convention here so downstream
-    # normalize_usage() can subtract them back out consistently, and surface
-    # the Anthropic-named fields it already falls back to for cache reads.
+    # Build usage stats
    usage_data = response.get("usage", {})
-    input_tokens = usage_data.get("inputTokens", 0)
-    cache_read_tokens = usage_data.get("cacheReadInputTokens", 0)
-    cache_write_tokens = usage_data.get("cacheWriteInputTokens", 0)
-    output_tokens = usage_data.get("outputTokens", 0)
    usage = SimpleNamespace(
-        prompt_tokens=input_tokens + cache_read_tokens + cache_write_tokens,
-        completion_tokens=output_tokens,
-        total_tokens=input_tokens + cache_read_tokens + cache_write_tokens + output_tokens,
-        cache_read_input_tokens=cache_read_tokens,
-        cache_creation_input_tokens=cache_write_tokens,
+        prompt_tokens=usage_data.get("inputTokens", 0),
+        completion_tokens=usage_data.get("outputTokens", 0),
+        total_tokens=(
+            usage_data.get("inputTokens", 0) + usage_data.get("outputTokens", 0)
+        ),
    )

    finish_reason = _converse_stop_reason_to_openai(stop_reason)
@@ -967,8 +936,6 @@ def stream_converse_with_callbacks(
            usage_data = {
                "inputTokens": meta_usage.get("inputTokens", 0),
                "outputTokens": meta_usage.get("outputTokens", 0),
-                "cacheReadInputTokens": meta_usage.get("cacheReadInputTokens", 0),
-                "cacheWriteInputTokens": meta_usage.get("cacheWriteInputTokens", 0),
            }

    # Flush remaining text
@@ -982,16 +949,12 @@ def stream_converse_with_callbacks(
        reasoning_content="\n\n".join(reasoning_parts) if reasoning_parts else None,
    )

-    input_tokens = usage_data.get("inputTokens", 0)
-    cache_read_tokens = usage_data.get("cacheReadInputTokens", 0)
-    cache_write_tokens = usage_data.get("cacheWriteInputTokens", 0)
-    output_tokens = usage_data.get("outputTokens", 0)
    usage = SimpleNamespace(
-        prompt_tokens=input_tokens + cache_read_tokens + cache_write_tokens,
-        completion_tokens=output_tokens,
-        total_tokens=input_tokens + cache_read_tokens + cache_write_tokens + output_tokens,
-        cache_read_input_tokens=cache_read_tokens,
-        cache_creation_input_tokens=cache_write_tokens,
+        prompt_tokens=usage_data.get("inputTokens", 0),
+        completion_tokens=usage_data.get("outputTokens", 0),
+        total_tokens=(
+            usage_data.get("inputTokens", 0) + usage_data.get("outputTokens", 0)
+        ),
    )

    finish_reason = _converse_stop_reason_to_openai(stop_reason)
@@ -1030,7 +993,6 @@ def build_converse_kwargs(
    Converts OpenAI-format inputs to Converse API parameters.
    """
    system_prompt, converse_messages = convert_messages_to_converse(messages)
-    cache_enabled = _model_supports_prompt_cache(model)

    kwargs: Dict[str, Any] = {
        "modelId": model,
@@ -1041,8 +1003,6 @@ def build_converse_kwargs(
    }

    if system_prompt:
-        if cache_enabled:
-            system_prompt = system_prompt + [{"cachePoint": {"type": "default"}}]
        kwargs["system"] = system_prompt

    from agent.anthropic_adapter import _forbids_sampling_params
@@ -1066,8 +1026,6 @@ def build_converse_kwargs(
            # Strip tools for known non-tool-calling models and warn the user.
            # Ref: PR #7920 feedback from @ptlally, pattern from PR #4346.
            if _model_supports_tool_use(model):
-                if cache_enabled:
-                    converse_tools = converse_tools + [{"cachePoint": {"type": "default"}}]
                kwargs["toolConfig"] = {"tools": converse_tools}
            else:
                logger.warning(
@@ -1075,14 +1033,6 @@ def build_converse_kwargs(
                    "The agent will operate in text-only mode.", model
                )

-    if cache_enabled and len(converse_messages) >= 2:
-        # Checkpoint everything up to (not including) the newest turn, so the
-        # marker survives unchanged across requests as only the tail grows —
-        # mirroring the Anthropic system_and_3 strategy in prompt_caching.py.
-        content = converse_messages[-2].get("content")
-        if isinstance(content, list) and content:
-            content.append({"cachePoint": {"type": "default"}})
-
    if guardrail_config:
        kwargs["guardrailConfig"] = guardrail_config

@@ -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 "")
@@ -1712,7 +1712,6 @@ def try_activate_fallback(agent, reason: "FailoverReason | None" = None) -> bool
        agent._config_context_length = None
        agent.model = fb_model
        agent.provider = fb_provider
-        agent.requested_provider = fb_provider
        agent.base_url = fb_base_url
        agent.api_mode = fb_api_mode
        if hasattr(agent, "_transport_cache"):
@@ -1946,17 +1945,7 @@ def handle_max_iterations(agent, messages: list, api_call_count: int) -> str:
            for internal_key in [k for k in api_msg if isinstance(k, str) and k.startswith("_")]:
                api_msg.pop(internal_key, None)
            if _needs_sanitize:
-                # In MoA mode, agent.model is the virtual preset name,
-                # not the actual aggregator model.  Resolve the real
-                # aggregator model so Gemini preserves thought_signature.
-                _sanitize_model = agent.model
-                if agent.provider == "moa":
-                    _moa_client = getattr(agent, "client", None)
-                    if _moa_client is not None:
-                        _agg_slot = getattr(_moa_client, "last_aggregator_slot", None)
-                        if _agg_slot and _agg_slot.get("model"):
-                            _sanitize_model = _agg_slot["model"]
-                agent._sanitize_tool_calls_for_strict_api(api_msg, model=_sanitize_model)
+                agent._sanitize_tool_calls_for_strict_api(api_msg, model=agent.model)
            api_messages.append(api_msg)

        effective_system = agent._cached_system_prompt or ""
@@ -2473,11 +2462,7 @@ def interruptible_streaming_api_call(agent, api_kwargs: dict, *, on_first_delta=
    request_client_holder = {"client": None, "diag": None, "owner_tid": None}
    # Transport kind of the registered request client — see the non-streaming
    # variant. Routes _close_request_client_once to anthropic vs openai abort/
-    # close helpers (#67142). ``kind="stream"`` registers a per-request
-    # *stream handle* instead of a client — used under the MoA facade, whose
-    # singleton client has no per-request sockets to abort
-    # (_abort_request_openai_client is a no-op on it), so interrupts must
-    # close the stream object itself (#57354).
+    # close helpers (#67142).
    request_client_kind = {"value": "openai"}
    request_client_lock = threading.Lock()
    # Request-local cancellation flag — see interruptible_api_call for the full
@@ -2497,44 +2482,6 @@ def interruptible_streaming_api_call(agent, api_kwargs: dict, *, on_first_delta=
            request_client_holder["owner_tid"] = threading.get_ident()
        return client

-    def _stream_close_callable(stream):
-        close = getattr(stream, "close", None)
-        if callable(close):
-            return close
-        response = getattr(stream, "response", None)
-        close = getattr(response, "close", None)
-        if callable(close):
-            return close
-        return None
-
-    def _set_request_stream_handle(stream):
-        # Register the per-request *stream* under kind="stream" so an
-        # interrupt closes the stream handle itself. Under the MoA facade the
-        # registered "client" is the shared facade singleton whose
-        # per-request abort helpers are no-ops, leaving the underlying HTTP
-        # stream open until the provider drained it (#57354).
-        if _stream_close_callable(stream) is None:
-            return stream
-        with request_client_lock:
-            request_client_holder["client"] = stream
-            request_client_kind["value"] = "stream"
-            request_client_holder["owner_tid"] = threading.get_ident()
-        return stream
-
-    def _close_request_stream_handle(stream, reason: str) -> None:
-        close = _stream_close_callable(stream)
-        if close is None:
-            return
-        try:
-            close()
-            logger.info("Streaming response handle closed (%s)", reason)
-        except Exception as exc:
-            logger.debug(
-                "Streaming response handle close failed (%s): %s",
-                reason,
-                exc,
-            )
-
    def _close_request_client_once(reason: str) -> None:
        # See #29507 explanation in the non-streaming variant above. A
        # stranger thread (the interrupt-check / stale-stream detector loop)
@@ -2542,15 +2489,9 @@ def interruptible_streaming_api_call(agent, api_kwargs: dict, *, on_first_delta=
        # so the worker thread retains ownership of the FD release.
        with request_client_lock:
            request_client = request_client_holder.get("client")
-            request_kind = request_client_kind.get("value", "openai")
            owner_tid = request_client_holder.get("owner_tid")
-            # A registered stream handle (kind="stream", MoA facade path) is
-            # safe to close from any thread — closing IS the abort — so the
-            # stranger-thread ownership carve-out only applies to real
-            # per-request clients (#57354).
            stranger_thread = (
-                request_kind != "stream"
-                and request_client is not None
+                request_client is not None
                and owner_tid is not None
                and owner_tid != threading.get_ident()
            )
@@ -2559,9 +2500,8 @@ def interruptible_streaming_api_call(agent, api_kwargs: dict, *, on_first_delta=
                request_client_holder["owner_tid"] = None
        if request_client is None:
            return
-        if request_kind == "stream":
-            _close_request_stream_handle(request_client, reason)
-        elif request_kind == "anthropic_messages":
+        kind = request_client_kind.get("value", "openai")
+        if kind == "anthropic_messages":
            if stranger_thread:
                agent._abort_request_anthropic_client(request_client, reason=reason)
            else:
@@ -2740,11 +2680,6 @@ def interruptible_streaming_api_call(agent, api_kwargs: dict, *, on_first_delta=
        _diag = agent._stream_diag_init()
        request_client_holder["diag"] = _diag
        stream = request_client.chat.completions.create(**stream_kwargs)
-        if agent.provider == "moa":
-            # The MoA facade is a shared singleton — abort/close of the
-            # registered client is a no-op, so register the stream handle
-            # itself for interrupt teardown (#57354).
-            stream = _set_request_stream_handle(stream)
        # Claim the delta sink for THIS attempt (#65991). If a prior attempt's
        # stream is somehow still alive (a stale-stream reconnect whose socket
        # abort raced), this claim supersedes it so its late chunks are fenced
@@ -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
@@ -53,39 +53,6 @@ def sanitize_memory_context(memory_context: str) -> str:
    )


-def automatic_compaction_status_message(
-    engine: Any,
-    *,
-    phase: str,
-    default_message: str,
-    **context: Any,
-) -> str | None:
-    """Resolve host-visible status for an automatic compaction event.
-
-    Engines can suppress routine automatic status with
-    ``emit_automatic_compaction_status = False`` or customize it by defining
-    ``get_automatic_compaction_status_message(...)``. Empty strings and
-    ``None`` mean "do not emit a lifecycle status".
-    """
-    if not getattr(engine, "emit_automatic_compaction_status", True):
-        return None
-
-    formatter = getattr(engine, "get_automatic_compaction_status_message", None)
-    if callable(formatter):
-        message = formatter(
-            phase=phase,
-            default_message=default_message,
-            **context,
-        )
-    else:
-        message = default_message
-
-    if message is None:
-        return None
-    message = str(message).strip()
-    return message or None
-
-
 class ContextEngine(ABC):
    """Base class all context engines must implement."""

@@ -122,12 +89,6 @@ class ContextEngine(ABC):
    protect_first_n: int = 3
    protect_last_n: int = 6

-    # User-visible lifecycle status for automatic host-triggered compaction.
-    # Alternative engines that treat compaction as routine background
-    # maintenance can set this false to keep successful automatic passes silent;
-    # warnings, errors, and explicit manual commands should still surface.
-    emit_automatic_compaction_status: bool = True
-
    # -- Core interface ----------------------------------------------------

    @abstractmethod
@@ -146,19 +107,6 @@ class ContextEngine(ABC):
    def should_compress(self, prompt_tokens: int = None) -> bool:
        """Return True if compaction should fire this turn."""

-    def should_compress_info(self, prompt_tokens: int = None) -> "tuple[bool, str | None]":
-        """Return ``(should_compress, reason)``.
-
-        The base implementation is backward-compatible: engines that only
-        implement ``should_compress`` get ``(should_compress(prompt_tokens),
-        None)``. Concrete engines with richer block reasons (e.g. a
-        summary-LLM cooldown or an anti-thrashing guard) override this to
-        surface a human-readable reason so callers can warn the user instead
-        of silently skipping compression. Added for the silent-overflow
-        warning fix (#62625) so plugin engines don't raise AttributeError.
-        """
-        return self.should_compress(prompt_tokens), None
-
    @abstractmethod
    def compress(
        self,
@@ -189,144 +137,6 @@ class ContextEngine(ABC):
                host filters unsupported optional arguments by signature.
        """

-    # -- Optional: proactive tool-result prune -----------------------------
-
-    def prune_tool_results_only(
-        self,
-        messages: List[Dict[str, Any]],
-        current_tokens: int | None = None,
-    ) -> tuple[List[Dict[str, Any]], int]:
-        """Deterministically trim old tool-result payloads without an LLM call.
-
-        Runs on a low, cost-oriented trigger independent of ``should_compress``
-        so large-window engines can reclaim re-sent tool output long before full
-        compaction would fire. Returns ``(messages, n_pruned)``.
-
-        Default is a safe no-op: the list is returned unchanged with ``0``
-        pruned. Engines that don't implement a cheap prune — and any engine that
-        predates this hook — inherit this default, so the agent loop's
-        post-tool-call prune path never raises ``AttributeError`` on them. The
-        built-in ContextCompressor overrides this with the real implementation.
-        """
-        return messages, 0
-
-    # -- Optional: per-turn context selection (distinct from compression) --
-
-    def select_context(
-        self,
-        request_messages: List[Dict[str, Any]],
-        *,
-        conversation_messages: List[Dict[str, Any]] = None,
-        incoming_message: Dict[str, Any] = None,
-        budget_tokens: int = 0,
-    ) -> List[Dict[str, Any]]:
-        """Optionally choose/replace the context for THIS request, pre-generation.
-
-        Called every turn after the request message list is assembled and
-        before it is dispatched to the provider — independent of
-        ``should_compress()``. This lets an engine *select* which context
-        enters the prompt (retrieval, topic routing, role/branch switching)
-        rather than *shrink* context that is already there. The two verbs are
-        orthogonal:
-
-          - ``compress()``      : context is too long  -> make it shorter.
-          - ``select_context()``: this turn belongs to a different context
-                                  -> use that one instead.
-
-        Without this hook, engines that need per-turn access to the message
-        list have to force ``should_compress()`` to return ``True`` so that
-        ``compress()`` is invoked every turn purely as a callback — which
-        conflates selection with compression and degrades behaviour when the
-        engine's backend is unavailable. ``select_context()`` removes the need
-        for that workaround.
-
-        The returned list is request-only: it replaces the messages sent to
-        the provider for this single call and MUST NOT be treated as persisted
-        transcript state. The conversation history in the session DB is left
-        untouched, so nothing leaks across turns. Return ``None`` to leave the
-        request unchanged.
-
-        Unlike the ``pre_llm_call`` plugin hook (which appends to the user
-        message and intentionally never rewrites the list, to preserve the
-        cache prefix), ``select_context()`` may *replace* the message list.
-
-        Ordering / cache contract: the host runs this hook **before** prompt
-        cache-control and **before** every request sanitizer (orphaned-tool
-        cleanup, thinking-only/role normalization, whitespace/JSON
-        normalization). So (a) whatever the hook returns still passes through
-        the same validation as any request — a malformed replacement cannot
-        reach the provider — and (b) prompt-cache stability (an AGENTS.md
-        invariant) is preserved: the default no-op leaves the request
-        byte-identical, so cache behaviour is unchanged for the built-in
-        compressor and any non-implementing engine. An engine that *does*
-        replace the list changes its own cache prefix by definition; that is
-        the engine's concern, and cache-control breakpoints are re-derived on
-        the selected list. The hook is evaluated per provider request (so it
-        re-runs on retries within a turn), consistent with "select the context
-        for THIS request".
-
-        Args:
-            request_messages: The assembled request message list (system
-                prompt + history + any ephemeral prefill), in OpenAI format.
-            conversation_messages: The unmodified persisted conversation
-                history, for reference only (do not mutate).
-            incoming_message: The current turn's user message, if available.
-            budget_tokens: The active model's context length, or 0 if unknown.
-
-        Default returns ``None`` (no-op) — zero impact on the built-in
-        compressor or any existing engine.
-        """
-        return None
-
-    def on_turn_complete(
-        self,
-        messages: List[Dict[str, Any]],
-        usage: Dict[str, Any] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Observe a finished user turn (post-turn ingestion / observation).
-
-        Called from the standard turn-finalization path once the assistant/tool
-        loop completes, with the finalized in-memory transcript snapshot. This
-        is the complement to ``select_context()``: selection happens *before*
-        the request, while observation happens *after* the turn. It lets an
-        engine ingest, index, summarize, or update routing / topic / session
-        state from what actually happened — so the next ``select_context()``
-        can act on it.
-
-        Coverage: this fires from the normal finalization seam. Some abnormal
-        early-return paths in the loop (e.g. a content-policy block or a
-        provider terminal failure) persist and return without routing through
-        finalization, and therefore do not currently emit this hook. Treat it
-        as a best-effort post-turn observation for completed turns, not a
-        guaranteed callback for every possible early exit; unifying all
-        terminal paths behind one finalization seam is a separate follow-up.
-
-        Together the two hooks remove the need to abuse ``should_compress()`` /
-        ``compress()`` as a generic per-turn callback just to observe history,
-        and they cover the case where a turn finishes and there may be no next
-        request from which to infer the previous turn.
-
-        ``messages`` is a shallow copy and should be treated as read-only:
-        return values are ignored and this hook must not rely on transcript
-        mutation for persistence. ``kwargs`` may include ``turn_id``,
-        ``task_id``, ``api_call_count``, ``interrupted``, ``failed``, and
-        ``turn_exit_reason``.
-
-        ``usage`` carries the completed turn's canonical token usage (the same
-        dict shape passed to ``update_from_response`` — ``prompt_tokens`` /
-        ``completion_tokens`` / ``total_tokens`` plus the canonical
-        ``input_tokens`` / ``output_tokens`` / ``cache_read_tokens`` /
-        ``cache_write_tokens`` / ``reasoning_tokens`` buckets) so an engine can
-        weigh how large/expensive the selected context actually was when
-        deciding the next ``select_context()``. It is ``None`` on finalized
-        turns that never reached a provider response (e.g. interrupt); engines
-        must treat it as optional.
-
-        Default is a no-op.
-        """
-        return None
-
    # -- Optional: pre-flight check ----------------------------------------

    def should_compress_preflight(self, messages: List[Dict[str, Any]]) -> bool:
@@ -346,27 +156,6 @@ class ContextEngine(ABC):
        """
        return False

-    def get_automatic_compaction_status_message(
-        self,
-        *,
-        phase: str,
-        default_message: str,
-        **context: Any,
-    ) -> str | None:
-        """Return user-visible status for automatic host-triggered compaction.
-
-        Return ``None`` to suppress successful automatic lifecycle status for
-        this compaction event. ``phase`` identifies the host call site (for
-        example ``"preflight"`` or ``"compress"``). ``context`` contains
-        best-effort fields such as ``approx_tokens`` and ``threshold_tokens``.
-
-        This hook does not control warning/error messages or explicit manual
-        commands such as ``/compress``.
-        """
-        if not self.emit_automatic_compaction_status:
-            return None
-        return default_message
-
    # -- Optional: manual /compress preflight ------------------------------

    def has_content_to_compress(self, messages: List[Dict[str, Any]]) -> bool:
@@ -30,22 +30,17 @@ 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
 from pathlib import Path
 from typing import Any, Optional, Tuple

-from agent.context_engine import (
-    automatic_compaction_status_message,
-    sanitize_memory_context,
-)
+from agent.context_engine import sanitize_memory_context
 from agent.model_metadata import estimate_request_tokens_rough

 logger = logging.getLogger(__name__)
@@ -60,87 +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..."
-)
-
-# FAILURE-CLASS notice — a deliberate carve-out from routine-compression
-# silence (#16775 class): the context is over the compression threshold but
-# compression is blocked (summary-LLM cooldown / anti-thrash breaker), so the
-# session will keep growing until the hard provider token limit kills it.
-# This MUST stay visible on chat gateways. Do NOT add it to
-# ROUTINE_COMPRESSION_STATUS_SAMPLES or the gateway noise regex
-# (_TELEGRAM_NOISY_STATUS_RE); it is pinned un-swallowed in
-# tests/gateway/test_telegram_noise_filter.py::VISIBLE_COMPRESSION_MESSAGES.
-CONTEXT_OVERFLOW_BLOCKED_WARNING_TEMPLATE = (
-    "⚠ Context is over the compression threshold "
-    "(~{tokens:,} tokens >= {threshold:,}) "
-    "but compression is currently blocked ({reason}). "
-    "The model may stop responding. Run /new to start a fresh "
-    "session or /compress to retry immediately."
-)
-
-# 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.
@@ -207,64 +121,6 @@ def _cached_prompt_reflects_builtin_memory(agent: Any, cached_prompt: str) -> bo
    return True


-class CompressionCommitFence:
-    """Fence timeout cancellation against post-summary session mutation.
-
-    Compression itself is synchronous and may be running in an executor thread.
-    A caller can stop waiting for the summary, but it cannot kill that thread.
-    This fence makes the commit boundary deterministic: cancellation either wins
-    before session mutation starts, or waits until an already-started commit is
-    fully complete before the caller proceeds.
-    """
-
-    def __init__(self) -> None:
-        self._lock = threading.Lock()
-        self._cancelled = False
-        self._commit_started = False
-
-    def cancel_before_commit(self) -> bool:
-        """Cancel a pending commit, or wait for an active commit to finish.
-
-        Returns ``True`` when cancellation won before the commit boundary.
-        Returns ``False`` when the worker had already entered the boundary; in
-        that case acquiring this lock waits until all session mutation finishes.
-        """
-        with self._lock:
-            if self._commit_started:
-                return False
-            self._cancelled = True
-            return True
-
-    def try_cancel_before_commit(self) -> Optional[bool]:
-        """Non-blocking form of :meth:`cancel_before_commit`.
-
-        Returns ``None`` while an active commit owns the fence, allowing an
-        async caller to yield instead of blocking its event loop.
-        """
-        if not self._lock.acquire(blocking=False):
-            return None
-        try:
-            if self._commit_started:
-                return False
-            self._cancelled = True
-            return True
-        finally:
-            self._lock.release()
-
-    def begin_commit(self) -> bool:
-        """Enter the commit boundary unless cancellation already won."""
-        self._lock.acquire()
-        if self._cancelled:
-            self._lock.release()
-            return False
-        self._commit_started = True
-        return True
-
-    def finish_commit(self) -> None:
-        """Leave a commit boundary entered by :meth:`begin_commit`."""
-        self._lock.release()
-
-
 def _lock_api_is_absent_on_session_db(lock_db: Any) -> bool:
    """Whether the live in-memory SessionDB class structurally predates locks.

@@ -293,7 +149,6 @@ def _refresh_persisted_compression_guards(compressor: Any) -> None:
    method_calls = (
        ("get_active_compression_failure_cooldown", {"refresh": True}),
        ("_load_fallback_compression_streak", {}),
-        ("_load_ineffective_compression_count", {}),
    )
    for method_name, kwargs in method_calls:
        method = getattr(type(compressor), method_name, None)
@@ -318,61 +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_skipped_due_to_lock(agent: Any) -> bool:
-    """Type-pinned read of the #69870 lock-skip signal.
-
-    ``agent._compression_skipped_due_to_lock`` is set by ``compress_context``
-    when a compression pass no-ops because another path holds the per-session
-    compression lock (holder string when the holder was confirmed, ``True``
-    otherwise) and cleared to ``None`` at the entry of every call.
-
-    The read MUST be type-pinned (``is True or isinstance(x, str)``), never
-    bare truthiness: MagicMock test-double agents auto-create truthy
-    attributes, and a bare ``if getattr(agent, ...)`` would hijack every
-    mocked agent in sibling suites into the lock-skip branch (the
-    #69870 × #69840 type-ahead incident).
-    """
-    _sig = getattr(agent, "_compression_skipped_due_to_lock", None)
-    return _sig is True or isinstance(_sig, str)
-
-
 def _compression_lock_holder(agent: Any) -> str:
    """Build a unique holder id for the lock: pid:tid:agent-instance:uuid.

@@ -826,11 +626,7 @@ def replay_compression_warning(agent: Any) -> None:
            pass


-def conversation_history_after_compression(
-    agent: Any,
-    messages: list,
-    previous_history: Optional[list] = None,
-) -> Optional[list]:
+def conversation_history_after_compression(agent: Any, messages: list) -> Optional[list]:
    """Return the correct flush baseline after a compression boundary.

    Legacy compression rotates to a fresh child session. That child has not
@@ -847,19 +643,7 @@ def conversation_history_after_compression(

    A shallow copy is intentional: it captures the current compacted dict
    identities as history while allowing later same-turn appends to remain new.
-
-    An aborted or no-op attempt after an earlier in-place compaction must retain
-    the pre-attempt baseline.  Treating all current messages as persisted would
-    drop any later, unflushed turns on restart; clearing the baseline would
-    append the already-persisted compacted rows a second time.
    """
-    if bool(getattr(agent, "_last_compression_attempt_recorded", False)):
-        attempt_in_place = getattr(agent, "_last_compression_attempt_in_place", None)
-        if attempt_in_place is True:
-            return list(messages)
-        if attempt_in_place is False:
-            return None
-        return previous_history
    if bool(getattr(agent, "_last_compaction_in_place", False)):
        return list(messages)
    return None
@@ -918,37 +702,6 @@ def _is_real_user_message(message: Any) -> bool:
    return not ContextCompressor._is_synthetic_compression_user_turn(message)


-def _strip_stale_todo_snapshot(content: Any) -> Any:
-    """Remove a previously merged todo-snapshot block from message content.
-
-    Snapshot merges (see the injection site in ``compress_context``) always
-    append the block at the end of the trailing user turn, so a surviving
-    header marks stale todo state from an earlier compaction boundary.
-    Stripping before re-injection keeps repeated boundaries from
-    accumulating outdated snapshots (#26981).
-    """
-    from tools.todo_tool import TODO_INJECTION_HEADER
-
-    if isinstance(content, str):
-        idx = content.find(TODO_INJECTION_HEADER)
-        if idx == -1:
-            return content
-        return content[:idx].rstrip()
-    if isinstance(content, list):
-        return [
-            part
-            for part in content
-            if not (
-                isinstance(part, dict)
-                and part.get("type") == "text"
-                and str(part.get("text") or "")
-                .lstrip()
-                .startswith(TODO_INJECTION_HEADER)
-            )
-        ]
-    return content
-
-
 def _merge_anchor_into_user_message(target: dict, anchor: dict) -> None:
    """Fold the human anchor into an existing user-role scaffolding turn.

@@ -1118,7 +871,6 @@ def compress_context(
    focus_topic: Optional[str] = None,
    force: bool = False,
    defer_context_engine_notification: bool = False,
-    commit_fence: Optional[CompressionCommitFence] = None,
 ) -> Tuple[list, str]:
    """Compress conversation context and split the session in SQLite.

@@ -1138,9 +890,6 @@ def compress_context(
            callers use the default ``False``.
        defer_context_engine_notification: Delay the existing context-engine
            hook until a manual host commits its outer history transaction.
-        commit_fence: Optional cooperative fence for executor callers that
-            may time out. It prevents a late worker from mutating session state
-            after its caller has moved on.

    Returns:
        ``(compressed_messages, new_system_prompt)`` tuple.  When
@@ -1155,34 +904,6 @@ def compress_context(
    ):
        raise RuntimeError("a compression notification is already pending")

-    # ``conversation_history_after_compression()`` needs the latest attempt's
-    # outcome, while ``_last_compaction_in_place`` remains the run-level signal
-    # read by gateway callers. ``None`` means this attempt aborted or made no
-    # boundary, so the previous flush baseline remains authoritative.
-    agent._last_compression_attempt_recorded = True
-    agent._last_compression_attempt_in_place = None
-    # Clear the lock-skip signal at the VERY TOP, before the codex route and
-    # the breaker gates below can early-return (per-attempt state rule,
-    # #58630/#69853). A stale ``True``/holder value from a prior lock-skip
-    # must never make a later breaker/codex no-op look like lock contention
-    # to the automatic-path consumers (compression_deferred, #49874) — the
-    # second clear before lock acquisition below stays for the same reason
-    # it was added in #69870 and is simply idempotent now.
-    agent._compression_skipped_due_to_lock = None
-
-    _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
@@ -1192,26 +913,14 @@ def compress_context(
    # the app server does not expose its native summary prompt, so there is no
    # truthful injection point for ``on_pre_compress()`` return text here.
    if getattr(agent, "api_mode", None) == "codex_app_server":
-        _codex_fence_entered = False
-        if commit_fence is not None:
-            _codex_fence_entered = commit_fence.begin_commit()
-            if not _codex_fence_entered:
-                existing_prompt = getattr(agent, "_cached_system_prompt", None)
-                if not existing_prompt:
-                    existing_prompt = agent._build_system_prompt(system_message)
-                return messages, existing_prompt
-        try:
-            return _compress_context_via_codex_app_server(
-                agent,
-                messages,
-                system_message,
-                approx_tokens=approx_tokens,
-                task_id=task_id,
-                force=force,
-            )
-        finally:
-            if _codex_fence_entered:
-                commit_fence.finish_commit()
+        return _compress_context_via_codex_app_server(
+            agent,
+            messages,
+            system_message,
+            approx_tokens=approx_tokens,
+            task_id=task_id,
+            force=force,
+        )

    # Every automatic entrypoint must honor compressor-owned cooldown and
    # breaker state. Gateway hygiene constructs a fresh AIAgent, so the
@@ -1263,32 +972,7 @@ def compress_context(
        f"{approx_tokens:,}" if approx_tokens else "unknown", agent.model,
        focus_topic,
    )
-    _compaction_status = COMPACTION_STATUS
-    if not force:
-        _compaction_status = automatic_compaction_status_message(
-            agent.context_compressor,
-            phase="compress",
-            default_message=_compaction_status,
-            approx_tokens=approx_tokens,
-            message_count=_pre_msg_count,
-            model=agent.model,
-            focus_topic=focus_topic,
-        )
-    _compaction_status_emitted = bool(_compaction_status)
-    if _compaction_status:
-        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
-        # A suppressed start (quiet context engine) opened no visible
-        # compaction phase — emit no terminal edge either. Failure warnings
-        # go through agent._emit_warning and are never suppressed here.
-        if _compaction_status_emitted:
-            _emit_compaction_done(agent)
+    agent._emit_status(COMPACTION_STATUS)

    # ── Compression lock ────────────────────────────────────────────────
    # Atomic, state.db-backed lock per session_id.  Without this, two
@@ -1325,12 +1009,6 @@ def compress_context(
    _try_acquire_lock = None
    _lock_lookup_error: Optional[Exception] = None
    _legacy_session_db_without_lock_api = False
-    # Clear any stale lock-skip signal from a prior call so this call's
-    # outcome alone determines what callers see.  Without this an
-    # auto-compress lock-skip followed by a successful manual /compress
-    # would falsely report "Compression already in progress" and discard
-    # the compression results.
-    agent._compression_skipped_due_to_lock = None
    if _lock_db is not None:
        try:
            _legacy_session_db_without_lock_api = _lock_api_is_absent_on_session_db(
@@ -1418,11 +1096,6 @@ def compress_context(
                _lock_sid, existing,
            )
            _lock_holder = None  # don't release a lock we don't own
-            # Signal to callers that this no-op is due to a concurrent lock,
-            # not a genuine "nothing to compress" or aux-model failure.
-            # Manual /compress callers can surface a clear status message
-            # instead of the misleading "No changes from compression" text.
-            agent._compression_skipped_due_to_lock = existing or True
            # Surface to the user once — quiet for downstream auto-compress loops
            if getattr(agent, "_last_compression_lock_warning_sid", None) != _lock_sid:
                agent._last_compression_lock_warning_sid = _lock_sid
@@ -1437,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
@@ -1576,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.
@@ -1584,19 +1243,11 @@ 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:
            _activity_heartbeat.stop("context compression completed")

-    _commit_fence_entered = False
    try:
        # Capture boundary quality before session-rotation callbacks run. Built-in
        # and plugin lifecycle hooks may reset per-session compressor fields while
@@ -1627,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()
@@ -1655,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

@@ -1684,28 +1318,6 @@ def compress_context(
            _release_lock()
            return messages, _existing_sp

-        if commit_fence is not None:
-            _commit_fence_entered = commit_fence.begin_commit()
-            if not _commit_fence_entered:
-                logger.info(
-                    "Compression commit cancelled before session mutation "
-                    "(session=%s).",
-                    agent.session_id or "none",
-                )
-                agent._last_compaction_in_place = False
-                _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="commit_fence_cancelled",
-                )
-                _release_lock()
-                return messages, _existing_sp
-
        summary_error = getattr(agent.context_compressor, "_last_summary_error", None)
        if summary_error:
            if getattr(agent, "_last_compression_summary_warning", None) != summary_error:
@@ -1734,54 +1346,11 @@ def compress_context(

        todo_snapshot = agent._todo_store.format_for_injection()
        if todo_snapshot:
-            # Fold the snapshot into a trailing REAL user message so
-            # compression never introduces a synthetic user/user pair. Any
-            # snapshot merged at an earlier boundary is stripped first so
-            # repeated compactions refresh rather than accumulate todo state
-            # (#26981). Scaffolding tails (continuation marker, summary
-            # handoff, a bare stale snapshot row) must never absorb the
-            # snapshot: merging would upgrade them to "real user" evidence
-            # and break zero-user provenance (#69292), so those keep the
-            # flagged standalone append and the real-user preservation pass
-            # continues to see todo scaffolding, not human intent.
-            from agent.context_compressor import _append_text_to_content
-
-            merged = False
-            _tail = (
-                compressed[-1]
-                if compressed and isinstance(compressed[-1], dict)
-                else None
-            )
-            if _tail is not None and _tail.get("role") == "user":
-                _stripped = _strip_stale_todo_snapshot(_tail.get("content"))
-                _probe = {
-                    key: value for key, value in _tail.items() if key != "content"
-                }
-                _probe["content"] = _stripped
-                if _is_real_user_message(_probe):
-                    _snapshot_text = (
-                        f"\n\n{todo_snapshot}"
-                        if isinstance(_stripped, str) and _stripped
-                        else todo_snapshot
-                    )
-                    _tail["content"] = _append_text_to_content(
-                        _stripped, _snapshot_text
-                    )
-                    merged = True
-                elif _stripped != _tail.get("content") and not _message_text(
-                    {"role": "user", "content": _stripped}
-                ).strip():
-                    # The tail was nothing but an earlier snapshot row —
-                    # refresh it in place instead of stacking a duplicate.
-                    _tail["content"] = todo_snapshot
-                    _tail["_todo_snapshot_synthetic"] = True
-                    merged = True
-            if not merged:
-                compressed.append({
-                    "role": "user",
-                    "content": todo_snapshot,
-                    "_todo_snapshot_synthetic": True,
-                })
+            compressed.append({
+                "role": "user",
+                "content": todo_snapshot,
+                "_todo_snapshot_synthetic": True,
+            })
        _ensure_compressed_has_user_turn(messages, compressed)

        cached_system_prompt = agent._cached_system_prompt
@@ -1808,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
@@ -1838,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
@@ -1955,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
@@ -1994,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
@@ -2091,7 +1655,6 @@ def compress_context(
        # via a rotation-independent flag. The gateway uses this — NOT an
        # id-change diff — to re-baseline transcript handling (history_offset=0 +
        # rewrite on the same id) when compaction happened in place. See #38763.
-        agent._last_compression_attempt_in_place = compacted_in_place
        agent._last_compaction_in_place = compacted_in_place

        # Keep the post-compression rough estimate for diagnostics, but do not
@@ -2138,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
@@ -2157,11 +1708,7 @@ def compress_context(
        # file dedup) ran. A concurrent path that wakes up the moment we
        # release will see the NEW session_id in state.db / SessionEntry and
        # acquire on that — no race against our just-finished work.
-        try:
-            _release_lock()
-        finally:
-            if _commit_fence_entered:
-                commit_fence.finish_commit()
+        _release_lock()


 def _compress_context_via_codex_app_server(
@@ -2224,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()
@@ -2240,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):
@@ -2265,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:
@@ -2305,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


@@ -2566,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",
@@ -503,10 +503,6 @@ class CopilotACPClient:

    def _run_prompt(self, prompt_text: str, *, timeout_seconds: float) -> tuple[str, str]:
        try:
-            # Hide the console the CLI child would otherwise flash on Windows
-            # (#56747). Hide-only — stdio pipes stay intact for the ACP wire.
-            from hermes_cli._subprocess_compat import windows_hide_flags
-
            proc = subprocess.Popen(
                [self._acp_command] + self._acp_args,
                stdin=subprocess.PIPE,
@@ -516,7 +512,6 @@ class CopilotACPClient:
                bufsize=1,
                cwd=self._acp_cwd,
                env=_build_subprocess_env(),
-                creationflags=windows_hide_flags(),
            )
        except FileNotFoundError as exc:
            raise RuntimeError(
@@ -596,32 +596,20 @@ class CredentialPool:
        self._last_no_entries_log_at: Optional[float] = None

    def has_credentials(self) -> bool:
-        with self._lock:
-            return bool(self._entries)
+        return bool(self._entries)

    def has_available(self) -> bool:
        """True if at least one entry is not currently in exhaustion cooldown."""
-        # ``_available_entries`` is not read-only: it prunes aged-out DEAD
-        # manual entries (rebinding ``self._entries``) and persists.  It must
-        # run under ``self._lock`` like every other caller (``select`` etc.),
-        # otherwise a status probe here can race a concurrent ``select`` /
-        # rotation and tear ``self._entries`` or double-write auth.json.
-        with self._lock:
-            return bool(self._available_entries())
+        return bool(self._available_entries())

    def entries(self) -> List[PooledCredential]:
-        with self._lock:
-            return list(self._entries)
+        return list(self._entries)

-    def _current_unlocked(self) -> Optional[PooledCredential]:
+    def current(self) -> Optional[PooledCredential]:
        if not self._current_id:
            return None
        return next((entry for entry in self._entries if entry.id == self._current_id), None)

-    def current(self) -> Optional[PooledCredential]:
-        with self._lock:
-            return self._current_unlocked()
-
    def _replace_entry(self, old: PooledCredential, new: PooledCredential) -> None:
        """Swap an entry in-place by id, preserving sort order."""
        for idx, entry in enumerate(self._entries):
@@ -664,8 +652,6 @@ class CredentialPool:
        entry: PooledCredential,
        status_code: Optional[int],
        error_context: Optional[Dict[str, Any]] = None,
-        *,
-        persist: bool = True,
    ) -> PooledCredential:
        normalized_error = _normalize_error_context(error_context)
        # Permanent OAuth failures (token_invalidated, token_revoked, etc.)
@@ -689,8 +675,7 @@ class CredentialPool:
            last_error_reset_at=normalized_error.get("reset_at"),
        )
        self._replace_entry(entry, updated)
-        if persist:
-            self._persist()
+        self._persist()
        return updated

    def _sync_anthropic_entry_from_credentials_file(self, entry: PooledCredential) -> PooledCredential:
@@ -1499,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
@@ -1657,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,
@@ -1741,21 +1678,18 @@ class CredentialPool:
            self._entries = [replace(candidate, priority=idx) for idx, candidate in enumerate(rotated)]
            self._persist()
            self._current_id = entry.id
-            return self._current_unlocked() or entry
+            return self.current() or entry

        entry = available[0]
        self._current_id = entry.id
        return entry

    def peek(self) -> Optional[PooledCredential]:
-        # Single lock acquisition for the whole read; call the unlocked
-        # helpers so we don't re-enter the non-reentrant ``self._lock``.
-        with self._lock:
-            current = self._current_unlocked()
-            if current is not None:
-                return current
-            available = self._available_entries()
-            return available[0] if available else None
+        current = self.current()
+        if current is not None:
+            return current
+        available = self._available_entries()
+        return available[0] if available else None

    def mark_exhausted_and_rotate(
        self,
@@ -1775,49 +1709,12 @@ class CredentialPool:
                    (e for e in self._entries if e.runtime_api_key == api_key_hint),
                    None,
                )
-                if entry is None:
-                    # The failed key is identifiable but matches no entry
-                    # (rotated away, or a wrapper whose runtime key differs).
-                    # Falling through to current()/_select_unlocked() would
-                    # mark an INNOCENT healthy key exhausted for the full
-                    # cooldown TTL.  Don't guess — just hand back a fresh
-                    # selection so the caller can retry.
-                    logger.info(
-                        "credential pool: failed key hint matched no %s entry; "
-                        "rotating without marking any credential exhausted",
-                        self.provider,
-                    )
-                    self._current_id = None
-                    return self._select_unlocked()
            if entry is None:
-                entry = self._current_unlocked() or self._select_unlocked()
+                entry = self.current() or self._select_unlocked()
            if entry is None:
                return None
            _label = entry.label or entry.id[:8]
            self._mark_exhausted(entry, status_code, error_context)
-            # A 402/429/401 is an API-key–level failure: the account is out of
-            # balance, rate-limited, or its key is rejected.  The same key can
-            # back more than one pool entry (e.g. an explicit pool entry plus a
-            # ``model_config`` entry auto-seeded from ``model.api_key`` — both
-            # carry the identical ``runtime_api_key``).  Marking only the first
-            # match leaves the sibling entries OK, so ``_select_unlocked()``
-            # keeps handing back the same depleted key and rotation never
-            # converges — the caller ``continue``s forever until the client
-            # disconnects (a ~2.5min hang with no error surfaced to the user).
-            # Mark every entry sharing the failed key so the pool can reach the
-            # "no available entries" state and let the error propagate.
-            if api_key_hint:
-                siblings_marked = False
-                for sibling in self._entries:
-                    if sibling.id == entry.id:
-                        continue
-                    if sibling.runtime_api_key == api_key_hint:
-                        self._mark_exhausted(
-                            sibling, status_code, error_context, persist=False
-                        )
-                        siblings_marked = True
-                if siblings_marked:
-                    self._persist()
            # Re-read the updated entry to log the correct terminal state.
            updated_entry = next(
                (e for e in self._entries if e.id == entry.id), entry,
@@ -1907,14 +1804,14 @@ class CredentialPool:
                    None,
                )
            else:
-                entry = self._current_unlocked() or self._select_unlocked(refresh=False)
+                entry = self.current() or self._select_unlocked(refresh=False)
            if entry is None:
                return None
            self._current_id = entry.id
            return self._try_refresh_current_unlocked()

    def _try_refresh_current_unlocked(self) -> Optional[PooledCredential]:
-        entry = self._current_unlocked()
+        entry = self.current()
        if entry is None:
            return None
        refreshed = self._refresh_entry(entry, force=True)
@@ -1923,80 +1820,76 @@ class CredentialPool:
        return refreshed

    def reset_statuses(self) -> int:
-        with self._lock:
-            count = 0
-            new_entries = []
-            for entry in self._entries:
-                if entry.last_status or entry.last_status_at or entry.last_error_code:
-                    new_entries.append(
-                        replace(
-                            entry,
-                            last_status=None,
-                            last_status_at=None,
-                            last_error_code=None,
-                            last_error_reason=None,
-                            last_error_message=None,
-                            last_error_reset_at=None,
-                        )
+        count = 0
+        new_entries = []
+        for entry in self._entries:
+            if entry.last_status or entry.last_status_at or entry.last_error_code:
+                new_entries.append(
+                    replace(
+                        entry,
+                        last_status=None,
+                        last_status_at=None,
+                        last_error_code=None,
+                        last_error_reason=None,
+                        last_error_message=None,
+                        last_error_reset_at=None,
                    )
-                    count += 1
-                else:
-                    new_entries.append(entry)
-            if count:
-                self._entries = new_entries
-                self._persist()
-            return count
+                )
+                count += 1
+            else:
+                new_entries.append(entry)
+        if count:
+            self._entries = new_entries
+            self._persist()
+        return count

    def remove_index(self, index: int) -> Optional[PooledCredential]:
-        with self._lock:
-            if index < 1 or index > len(self._entries):
-                return None
-            removed = self._entries.pop(index - 1)
-            self._entries = [
-                replace(entry, priority=new_priority)
-                for new_priority, entry in enumerate(self._entries)
-            ]
-            write_credential_pool(
-                self.provider,
-                [entry.to_dict() for entry in self._entries],
-                removed_ids=[removed.id],
-            )
-            if self._current_id == removed.id:
-                self._current_id = None
-            return removed
+        if index < 1 or index > len(self._entries):
+            return None
+        removed = self._entries.pop(index - 1)
+        self._entries = [
+            replace(entry, priority=new_priority)
+            for new_priority, entry in enumerate(self._entries)
+        ]
+        write_credential_pool(
+            self.provider,
+            [entry.to_dict() for entry in self._entries],
+            removed_ids=[removed.id],
+        )
+        if self._current_id == removed.id:
+            self._current_id = None
+        return removed

    def resolve_target(self, target: Any) -> Tuple[Optional[int], Optional[PooledCredential], Optional[str]]:
        raw = str(target or "").strip()
        if not raw:
            return None, None, "No credential target provided."

-        with self._lock:
-            for idx, entry in enumerate(self._entries, start=1):
-                if entry.id == raw:
-                    return idx, entry, None
+        for idx, entry in enumerate(self._entries, start=1):
+            if entry.id == raw:
+                return idx, entry, None

-            label_matches = [
-                (idx, entry)
-                for idx, entry in enumerate(self._entries, start=1)
-                if entry.label.strip().lower() == raw.lower()
-            ]
-            if len(label_matches) == 1:
-                return label_matches[0][0], label_matches[0][1], None
-            if len(label_matches) > 1:
-                return None, None, f'Ambiguous credential label "{raw}". Use the numeric index or entry id instead.'
-            if raw.isdigit():
-                index = int(raw)
-                if 1 <= index <= len(self._entries):
-                    return index, self._entries[index - 1], None
-                return None, None, f"No credential #{index}."
-            return None, None, f'No credential matching "{raw}".'
+        label_matches = [
+            (idx, entry)
+            for idx, entry in enumerate(self._entries, start=1)
+            if entry.label.strip().lower() == raw.lower()
+        ]
+        if len(label_matches) == 1:
+            return label_matches[0][0], label_matches[0][1], None
+        if len(label_matches) > 1:
+            return None, None, f'Ambiguous credential label "{raw}". Use the numeric index or entry id instead.'
+        if raw.isdigit():
+            index = int(raw)
+            if 1 <= index <= len(self._entries):
+                return index, self._entries[index - 1], None
+            return None, None, f"No credential #{index}."
+        return None, None, f'No credential matching "{raw}".'

    def add_entry(self, entry: PooledCredential) -> PooledCredential:
-        with self._lock:
-            entry = replace(entry, priority=_next_priority(self._entries))
-            self._entries.append(entry)
-            self._persist()
-            return entry
+        entry = replace(entry, priority=_next_priority(self._entries))
+        self._entries.append(entry)
+        self._persist()
+        return entry


 def _upsert_entry(entries: List[PooledCredential], provider: str, source: str, payload: Dict[str, Any]) -> bool:
@@ -316,21 +316,12 @@ def evaluate_credits_notices(
            active.discard(CREDITS_USAGE_KEY)
        if target_band is not None:
            # Belt-and-suspenders: a producer could set subscription_limit_micros
-            # without subscription_limit_usd. Render "$?" rather than "$None".
+            # without subscription_limit_usd. Render "$? cap" rather than "$None cap".
            _cap_usd = state.subscription_limit_usd or "?"
            _level = current_band[1]  # type: ignore[index]  (current_band set when target_band set)
-            # Report absolute dollars used, not a bare "N% used": the percentage is
-            # only meaningful against a Nous subscription cap (no cap → never fires),
-            # so dollars are clearer and don't imply a universal %. Used = cap −
-            # remaining (micros, money-safe), clamped to [0, cap]. Re-emits on band
-            # change (50 → 75 → 90), not every turn — a snapshot, not a live ticker.
-            _lim = state.subscription_limit_micros or 0
-            _used_micros = max(0, min(_lim, _lim - state.subscription_micros))
-            _used_usd = f"{_used_micros / 1_000_000:.2f}" if _lim else "?"
-            _glyph = "⚠" if _level == "warn" else "•"
            to_show.append(
                AgentNotice(
-                    text=f"{_glyph} You've used ${_used_usd} of your ${_cap_usd} cap",
+                    text=f"{'⚠' if _level == 'warn' else '•'} Credits {target_band}% used · ${_cap_usd} cap",
                    level=_level,
                    kind=CREDITS_NOTICE_KIND,
                    key=CREDITS_USAGE_KEY,
@@ -422,9 +422,7 @@ CURATOR_REVIEW_PROMPT = (
    "INSTRUCTIONS AND EXPERIENTIAL KNOWLEDGE. A collection of hundreds of "
    "narrow skills where each one captures one session's specific bug is "
    "a FAILURE of the library — not a feature. An agent searching skills "
-    "matches on descriptions, not on exact names (note: long descriptions "
-    "are truncated to 57 chars in the system prompt skill index — keep the "
-    "trigger class in that window). One broad umbrella "
+    "matches on descriptions, not on exact names; one broad umbrella "
    "skill with labeled subsections beats five narrow siblings for "
    "discoverability, not the other way around.\n\n"
    "The right target shape is CLASS-LEVEL skills with rich SKILL.md "
@@ -1,85 +0,0 @@
-"""Context-local state for delegate_task child execution.
-
-The parent Hermes process may itself be a Kanban dispatcher worker with
-HERMES_KANBAN_* variables in process env. delegate_task children run inside the
-same Python process, but they are not dispatcher-owned Kanban workers. This
-module lets code paths that resolve tool schemas or spawn subprocesses fail
-closed for delegated children without mutating global os.environ for the parent.
-"""
-from __future__ import annotations
-
-from contextlib import contextmanager
-from contextvars import ContextVar
-from typing import Iterator, Mapping, MutableMapping
-
-_DELEGATED_CHILD_CONTEXT: ContextVar[bool] = ContextVar(
-    "hermes_delegated_child_context",
-    default=False,
-)
-
-DELEGATED_CHILD_ENV_MARKER = "HERMES_DELEGATED_CHILD_CONTEXT"
-
-KANBAN_ENV_KEYS: tuple[str, ...] = (
-    "HERMES_KANBAN_TASK",
-    "HERMES_KANBAN_RUN_ID",
-    "HERMES_KANBAN_WORKSPACE",
-    "HERMES_KANBAN_WORKSPACES_ROOT",
-    "HERMES_KANBAN_CLAIM_LOCK",
-    "HERMES_KANBAN_BOARD",
-    "HERMES_KANBAN_DB",
-)
-
-
-@contextmanager
-def delegated_child_context() -> Iterator[None]:
-    """Mark the current execution context as a delegate_task child."""
-    token = _DELEGATED_CHILD_CONTEXT.set(True)
-    try:
-        yield
-    finally:
-        _DELEGATED_CHILD_CONTEXT.reset(token)
-
-
-def is_delegated_child_context() -> bool:
-    """Return True while code is running for a delegate_task child."""
-    return bool(_DELEGATED_CHILD_CONTEXT.get())
-
-
-def is_delegated_child_process_context() -> bool:
-    """Return True in this process or a subprocess spawned by a child."""
-    import os
-
-    return bool(_DELEGATED_CHILD_CONTEXT.get()) or bool(
-        os.environ.get(DELEGATED_CHILD_ENV_MARKER)
-    )
-
-
-def scrub_kanban_env(env: Mapping[str, str] | MutableMapping[str, str]) -> dict[str, str]:
-    """Return *env* with dispatcher-only Kanban variables removed."""
-    cleaned = dict(env)
-    for key in KANBAN_ENV_KEYS:
-        cleaned.pop(key, None)
-    cleaned[DELEGATED_CHILD_ENV_MARKER] = "1"
-    return cleaned
-
-
-def delegated_child_subprocess_env(
-    env: Mapping[str, str] | MutableMapping[str, str] | None = None,
-) -> dict[str, str] | None:
-    """Return an env override only when delegated-child lineage must cross fork.
-
-    Most subprocess call sites historically used ``env=None`` to inherit the
-    process environment.  In a ``delegate_task`` child, inheriting as-is leaks
-    parent dispatcher ``HERMES_KANBAN_*`` vars while losing the ContextVar in
-    the new process.  This helper preserves normal ``env=None`` semantics for
-    non-delegated calls, and only materializes a scrubbed env when the lineage
-    marker must be propagated across a child-process boundary.
-    """
-    if not is_delegated_child_process_context():
-        return None if env is None else dict(env)
-
-    if env is None:
-        import os
-
-        env = os.environ
-    return scrub_kanban_env(env)
@@ -413,7 +413,6 @@ _CONTENT_POLICY_BLOCKED_PATTERNS = [
 _AUTH_PATTERNS = [
    "invalid api key",
    "invalid_api_key",
-    "gateway_auth_failed",
    "authentication",
    "unauthorized",
    "forbidden",
@@ -270,12 +270,8 @@ def _translate_tool_call_to_gemini(tool_call: Dict[str, Any]) -> Dict[str, Any]:
        }
    }
    thought_signature = _tool_call_extra_signature(tool_call)
-    # Fallback sentinel for cross-provider tool_calls (e.g. fallback from
-    # xAI/Anthropic to Gemini, where the original tool_call carries no
-    # Gemini thoughtSignature). Mirrors gemini_cloudcode_adapter.py:106.
-    # Without this, Gemini 3 thinking models reject replayed history with
-    # 400 INVALID_ARGUMENT on the missing thoughtSignature.
-    part["thoughtSignature"] = thought_signature or "skip_thought_signature_validator"
+    if thought_signature:
+        part["thoughtSignature"] = thought_signature
    return part


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


@@ -181,8 +181,6 @@ def _supports_vision_override(
    cfg: Optional[Dict[str, Any]],
    provider: str,
    model: str,
-    *,
-    requested_provider: str = "",
 ) -> Optional[bool]:
    """Resolve user-declared vision capability from config.yaml.

@@ -190,14 +188,9 @@ def _supports_vision_override(
      1. ``model.supports_vision`` (top-level shortcut for the active model)
      2. ``providers.<provider>.models.<model>.supports_vision``
         (named custom providers — ``provider`` may be the runtime-resolved
-         value ``"custom"``, the runtime's originally requested provider,
-         and/or the user-declared name under ``model.provider``; all are
-         tried. For ``custom:<name>`` syntax, the stripped ``<name>`` is also
-         tried as a provider key.)
-      2b. ``custom_providers`` (legacy list form) ``.models.<model>``
-
-    Under (2) and (2b), the per-model capability key may be written as
-    either ``supports_vision`` or the shorter ``vision`` alias; both work.
+         value ``"custom"`` and/or the user-declared name under
+         ``model.provider``; both are tried. For ``custom:<name>`` syntax,
+         the stripped ``<name>`` is also tried as a provider key.)

    Returns None when no override is set, so the caller falls through to
    models.dev. Returns False explicitly only when the user wrote a
@@ -217,30 +210,23 @@ def _supports_vision_override(
    # get rewritten to provider="custom" at runtime
    # (hermes_cli/runtime_provider.py:_resolve_named_custom_runtime), so the
    # config still holds the user-declared name under model.provider. Try
-    # both as candidate provider keys. Either identity may use the
-    # "custom:<name>" form while providers: is keyed by bare <name>.
+    # both as candidate provider keys, plus the stripped suffix from
+    # "custom:<name>" (where <name> is the key under providers:).
    config_provider = str(model_cfg.get("provider") or "").strip()
-    provider_candidates: List[str] = []
-    for candidate in (requested_provider, provider, config_provider):
-        if not candidate:
-            continue
-        provider_candidates.append(candidate)
-        if candidate.startswith("custom:"):
-            stripped_candidate = candidate[len("custom:"):]
-            if stripped_candidate:
-                provider_candidates.append(stripped_candidate)
+    # Extract the stripped name from "custom:<name>" if present
+    stripped_suffix = ""
+    if config_provider.startswith("custom:"):
+        stripped_suffix = config_provider[len("custom:"):]
    providers_raw = cfg.get("providers")
    providers_cfg: Dict[str, Any] = providers_raw if isinstance(providers_raw, dict) else {}
-    for p in dict.fromkeys(provider_candidates):
+    for p in dict.fromkeys(filter(None, (provider, config_provider, stripped_suffix))):
        entry_raw = providers_cfg.get(p)
        entry: Dict[str, Any] = entry_raw if isinstance(entry_raw, dict) else {}
        models_raw = entry.get("models")
        models_cfg: Dict[str, Any] = models_raw if isinstance(models_raw, dict) else {}
        per_model_raw = models_cfg.get(model)
        per_model: Dict[str, Any] = per_model_raw if isinstance(per_model_raw, dict) else {}
-        coerced = _coerce_capability_bool(
-            per_model.get("supports_vision", per_model.get("vision"))
-        )
+        coerced = _coerce_capability_bool(per_model.get("supports_vision"))
        if coerced is not None:
            return coerced

@@ -249,26 +235,28 @@ def _supports_vision_override(
    # may appear as the raw name or "custom:<name>" at runtime).
    custom_providers = cfg.get("custom_providers")
    if isinstance(custom_providers, list):
-        # Candidate priority matters when the CLI-selected provider differs
-        # from model.provider. Walk identities first, then config entries, so
-        # list order cannot let the persisted default shadow the live route.
-        for candidate in dict.fromkeys(provider_candidates):
-            candidate_name = candidate.strip().lower()
-            for entry_raw in custom_providers:
-                if not isinstance(entry_raw, dict):
-                    continue
-                entry_name = str(entry_raw.get("name") or "").strip().lower()
-                if entry_name != candidate_name:
-                    continue
-                models_raw = entry_raw.get("models")
-                models_cfg = models_raw if isinstance(models_raw, dict) else {}
-                per_model_raw = models_cfg.get(model)
-                per_model = per_model_raw if isinstance(per_model_raw, dict) else {}
-                coerced = _coerce_capability_bool(
-                    per_model.get("supports_vision", per_model.get("vision"))
-                )
-                if coerced is not None:
-                    return coerced
+        # Build candidate names: the provider value and the config provider
+        # value, both raw and with "custom:" prefix stripped/added.
+        candidate_names: set = set()
+        for p in filter(None, (provider, config_provider)):
+            candidate_names.add(p)
+            if p.startswith("custom:"):
+                candidate_names.add(p[len("custom:"):])
+            else:
+                candidate_names.add(f"custom:{p}")
+        for entry_raw in custom_providers:
+            if not isinstance(entry_raw, dict):
+                continue
+            entry_name = str(entry_raw.get("name") or "").strip()
+            if entry_name not in candidate_names:
+                continue
+            models_raw = entry_raw.get("models")
+            models_cfg = models_raw if isinstance(models_raw, dict) else {}
+            per_model_raw = models_cfg.get(model)
+            per_model = per_model_raw if isinstance(per_model_raw, dict) else {}
+            coerced = _coerce_capability_bool(per_model.get("supports_vision"))
+            if coerced is not None:
+                return coerced

    return None

@@ -388,8 +376,6 @@ def _lookup_supports_vision(
    provider: str,
    model: str,
    cfg: Optional[Dict[str, Any]] = None,
-    *,
-    requested_provider: str = "",
 ) -> Optional[bool]:
    """Return True/False if we can resolve caps, None if unknown.

@@ -397,34 +383,7 @@ def _lookup_supports_vision(
    (so custom/local models declared as vision-capable don't fall through to
    text routing in ``auto`` mode), then falls back to models.dev.
    """
-    # Named custom providers are canonicalized to ``provider="custom"`` by
-    # runtime resolution.  The original CLI/config name is carried in the
-    # context-local main runtime so capability lookup can still select the
-    # exact custom_providers entry.  Require an exact provider+model match:
-    # background/auxiliary lookups must never borrow another turn's identity.
-    if not requested_provider:
-        try:
-            from agent.auxiliary_client import _runtime_main_value
-
-            runtime_provider = str(
-                _runtime_main_value("provider") or ""
-            ).strip().lower()
-            runtime_model = str(_runtime_main_value("model") or "").strip()
-            lookup_provider = str(provider or "").strip().lower()
-            lookup_model = str(model or "").strip()
-            if runtime_provider == lookup_provider and runtime_model == lookup_model:
-                requested_provider = str(
-                    _runtime_main_value("requested_provider") or ""
-                ).strip()
-        except Exception:
-            pass
-
-    override = _supports_vision_override(
-        cfg,
-        provider,
-        model,
-        requested_provider=requested_provider,
-    )
+    override = _supports_vision_override(cfg, provider, model)
    if override is not None:
        return override
    if not provider or not model:
@@ -462,8 +421,6 @@ def decide_image_input_mode(
    provider: str,
    model: str,
    cfg: Optional[Dict[str, Any]],
-    *,
-    requested_provider: str = "",
 ) -> str:
    """Return ``"native"`` or ``"text"`` for the given turn.

@@ -471,7 +428,6 @@ def decide_image_input_mode(
      provider: active inference provider ID (e.g. ``"anthropic"``, ``"openrouter"``).
      model:    active model slug as it would be sent to the provider.
      cfg:      loaded config.yaml dict, or None. When None, behaves as auto.
-      requested_provider: provider identity before runtime canonicalization.
    """
    mode_cfg = "auto"
    if isinstance(cfg, dict):
@@ -488,17 +444,7 @@ def decide_image_input_mode(
    # explicit auxiliary.vision config acts as a *fallback* for text-only
    # main models — it should not preempt native vision on a model that
    # can natively inspect the pixels (issue #29135).
-    if requested_provider:
-        supports = _lookup_supports_vision(
-            provider,
-            model,
-            cfg,
-            requested_provider=requested_provider,
-        )
-    else:
-        # Keep the long-standing three-argument call contract for callers and
-        # tests that replace the capability lookup hook.
-        supports = _lookup_supports_vision(provider, model, cfg)
+    supports = _lookup_supports_vision(provider, model, cfg)
    if supports is True:
        return "native"
    if _explicit_aux_vision_override(cfg):
@@ -56,8 +56,6 @@ from pathlib import Path
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Set
 from urllib.parse import quote, unquote

-from hermes_cli._subprocess_compat import windows_hide_flags
-
 from agent.lsp.protocol import (
    ERROR_CONTENT_MODIFIED,
    ERROR_METHOD_NOT_FOUND,
@@ -296,12 +294,6 @@ class LSPClient:
        cmd = self._command
        if sys.platform == "win32":
            cmd = self._win_wrap_cmd(cmd)
-        # Suppress the cmd.exe console window that would otherwise flash
-        # every time we launch a ``.cmd``-wrapped language server
-        # (e.g. pyright-langserver.CMD) from a console-less host such as
-        # a VS Code/Zed extension running the ACP adapter.
-        # windows_hide_flags() is CREATE_NO_WINDOW on Windows, 0 on POSIX.
-        creationflags = windows_hide_flags()

        try:
            # start_new_session=True detaches the LSP server into its own
@@ -320,7 +312,6 @@ class LSPClient:
                env=env,
                cwd=self._cwd,
                start_new_session=True,
-                creationflags=creationflags,
            )
        except FileNotFoundError as e:
            raise LSPProtocolError(
@@ -35,8 +35,6 @@ import threading
 from pathlib import Path
 from typing import Any, Dict, Optional

-from hermes_cli._subprocess_compat import windows_hide_flags
-
 logger = logging.getLogger("agent.lsp.install")

 # Package-name → install-strategy hint registry.  Each entry is a
@@ -270,7 +268,6 @@ def _install_npm(
            text=True,
            timeout=300,
            stdin=subprocess.DEVNULL,
-            creationflags=windows_hide_flags(),
        )
        if proc.returncode != 0:
            logger.warning(
@@ -320,7 +317,6 @@ def _install_go(pkg: str, bin_name: str) -> Optional[str]:
            timeout=600,
            env=env,
            stdin=subprocess.DEVNULL,
-            creationflags=windows_hide_flags(),
        )
        if proc.returncode != 0:
            logger.warning(
@@ -7,36 +7,6 @@ from typing import Any, Sequence
 from agent.redact import redact_sensitive_text


-def describe_compression_lock_skip(lock_signal: Any) -> str:
-    """User-facing text for a manual /compress skipped by the compression lock.
-
-    ``lock_signal`` is ``agent._compression_skipped_due_to_lock`` (or the
-    ``holder`` carried by the TUI's ``CompressionLockHeld``): a descriptive
-    holder string when another compressor CONFIRMED holds the lock, or
-    ``True``/``None`` when acquisition failed without a confirmed holder
-    (``hermes_state.try_acquire_compression_lock`` catches ``sqlite3.Error``
-    internally and returns ``False``, so a failed acquire is NOT proof that
-    another compression is running). The two cases must be worded
-    differently: claiming "already in progress" on an unconfirmed failure
-    misdirects the user when the real problem is a broken lock subsystem.
-    """
-    holder = (
-        lock_signal
-        if isinstance(lock_signal, str) and lock_signal.strip()
-        else None
-    )
-    if holder:
-        return (
-            f"⏳ Compression already in progress for this session "
-            f"(holder: {holder}). Please wait for it to finish."
-        )
-    return (
-        "⏳ Compression skipped: could not acquire this session's "
-        "compression lock. Another compression may still be running, or "
-        "the lock check failed — try again shortly."
-    )
-
-
 def summarize_manual_compression(
    before_messages: Sequence[dict[str, Any]],
    after_messages: Sequence[dict[str, Any]],
@@ -80,17 +80,8 @@ def normalize_tool_schema(schema: Any) -> Optional[Dict[str, Any]]:
    return schema


-def memory_provider_tools_enabled(
-    enabled_toolsets: Optional[List[str]],
-    disabled_toolsets: Optional[List[str]] = None,
-    *,
-    memory_tool_present: bool = False,
-) -> bool:
+def memory_provider_tools_enabled(enabled_toolsets: Optional[List[str]]) -> bool:
    """Return whether external memory-provider tools should be exposed."""
-    if disabled_toolsets and "memory" in disabled_toolsets:
-        return False
-    if memory_tool_present:
-        return True
    if enabled_toolsets is None:
        return True
    if not enabled_toolsets:
@@ -119,10 +110,9 @@ def inject_memory_provider_tools(agent: Any) -> int:
        for tool in tools
        if isinstance(tool, dict)
    }
-    if not memory_provider_tools_enabled(
-        getattr(agent, "enabled_toolsets", None),
-        getattr(agent, "disabled_toolsets", None),
-        memory_tool_present="memory" in existing_tool_names,
+    if (
+        "memory" not in existing_tool_names
+        and not memory_provider_tools_enabled(getattr(agent, "enabled_toolsets", None))
    ):
        return 0

@@ -2201,18 +2201,11 @@ def get_model_context_length(
    # acting context, so they're ignored here.
    if (provider or "").strip().lower() == "moa":
        try:
-            from hermes_cli.config import (
-                get_compatible_custom_providers,
-                load_config,
-            )
+            from hermes_cli.config import load_config
            from hermes_cli.moa_config import resolve_moa_preset
            from hermes_cli.runtime_provider import resolve_runtime_provider

-            config = load_config()
-            effective_custom_providers = custom_providers
-            if effective_custom_providers is None:
-                effective_custom_providers = get_compatible_custom_providers(config)
-            preset = resolve_moa_preset(config.get("moa") or {}, model)
+            preset = resolve_moa_preset(load_config().get("moa") or {}, model)
            agg = preset.get("aggregator") or {}
            agg_provider = str(agg.get("provider") or "").strip()
            agg_model = str(agg.get("model") or "").strip()
@@ -2222,8 +2215,7 @@ def get_model_context_length(
                    agg_model,
                    base_url=rt.get("base_url", "") or "",
                    api_key=rt.get("api_key", "") or "",
-                    provider=rt.get("provider") or agg_provider,
-                    custom_providers=effective_custom_providers,
+                    provider=agg_provider,
                )
        except Exception:
            logger.debug("MoA aggregator context-length resolution failed", exc_info=True)
@@ -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, "
@@ -192,13 +192,7 @@ SKILLS_GUIDANCE = (
    "skill with skill_manage so you can reuse it next time.\n"
    "When using a skill and finding it outdated, incomplete, or wrong, "
    "patch it immediately with skill_manage(action='patch') — don't wait to be asked. "
-    "Skills that aren't maintained become liabilities.\n"
-    "\n"
-    "## Skill Safety Rule\n"
-    "1. **UNAVAILABLE** — If a skill placeholder contains `[SKILL_PRUNED]`, the skill content was lost in compression and is inaccessible.\n"
-    "2. **RELOAD** — Before performing any action that depends on a skill, re-check its content with `skill_view(name='...')` if it shows `[SKILL_PRUNED]`.\n"
-    "3. **WAIT** — If a skill is loading or was just pruned, wait for the reload confirmation before proceeding.\n"
-    "4. **DEDUP** — After reloading a pruned skill, **ignore any remaining `[SKILL_PRUNED]` markers for that same skill** — they are historical artifacts from previous compactions and do not need further action."
+    "Skills that aren't maintained become liabilities."
 )

 KANBAN_GUIDANCE = (
@@ -890,14 +884,7 @@ PLATFORM_HINTS = {
        "You're responding through an API server. The rendering layer is unknown — "
        "assume plain text. No markdown formatting (no asterisks, bullets, headers, "
        "code fences). Treat this like a conversation, not a document. Keep responses "
-        "brief and natural. "
-        "File/media delivery: images referenced as MEDIA:/absolute/path tags "
-        "(.png/.jpg/.jpeg/.gif/.webp/.bmp, up to 5MB) are inlined as base64 data "
-        "URLs in responses on the chat, completions, and responses endpoints. "
-        "Non-image files are NOT intercepted anywhere, and the runs endpoint "
-        "intercepts nothing — a MEDIA: tag there renders as literal text exposing "
-        "a raw host filesystem path. For those cases, state the plain file path "
-        "in your response text instead of a MEDIA: tag."
+        "brief and natural."
    ),
    "webui": (
        "You are in the Hermes WebUI, a browser-based chat interface. "
@@ -453,8 +453,8 @@ def reload_skills() -> Dict[str, Any]:
            }

        ``description`` is the skill's full SKILL.md frontmatter
-        ``description:`` field. Note: the system prompt skill index
-        truncates this to the first 57 chars; see ``extract_skill_description``.
+        ``description:`` field — the same string the system prompt renders
+        as ``    - name: description`` for pre-existing skills.
    """
    # Snapshot pre-reload state (name -> description) from the current
    # slash-command cache. Using dicts lets the post-rescan diff carry
@@ -779,31 +779,18 @@ def resolve_skill_config_values(

 # ── Description extraction ────────────────────────────────────────────────

-SKILL_PROMPT_DESC_LIMIT = 60
-
-
-def _normalize_skill_description(frontmatter: Dict[str, Any]) -> str:
-    """Normalize a skill's description field for comparison/truncation."""
-    raw_desc = frontmatter.get("description", "")
-    return str(raw_desc).strip().strip("'\"") if raw_desc else ""
-

 def extract_skill_description(frontmatter: Dict[str, Any]) -> str:
-    """Extract a system-prompt-length description from parsed frontmatter."""
-    desc = _normalize_skill_description(frontmatter)
-    if not desc:
+    """Extract a truncated description from parsed frontmatter."""
+    raw_desc = frontmatter.get("description", "")
+    if not raw_desc:
        return ""
-    if len(desc) > SKILL_PROMPT_DESC_LIMIT:
-        return desc[:SKILL_PROMPT_DESC_LIMIT - 3] + "..."
+    desc = str(raw_desc).strip().strip("'\"")
+    if len(desc) > 60:
+        return desc[:57] + "..."
    return desc


-def is_skill_description_truncated_for_prompt(frontmatter: Dict[str, Any]) -> bool:
-    """True when the description will be truncated in the system prompt skill index."""
-    desc = _normalize_skill_description(frontmatter)
-    return len(desc) > SKILL_PROMPT_DESC_LIMIT
-
-
 # ── File iteration ────────────────────────────────────────────────────────


@@ -127,10 +127,6 @@ class CodexAppServerClient:
        # Codex emits tracing to stderr; default WARN keeps it quiet for users.
        spawn_env.setdefault("RUST_LOG", "warn")

-        # Hide the console the codex child would otherwise flash on Windows
-        # (#56747). Hide-only — stdio pipes stay intact for the app-server wire.
-        from hermes_cli._subprocess_compat import windows_hide_flags
-
        self._proc = subprocess.Popen(
            cmd,
            stdin=subprocess.PIPE,
@@ -138,7 +134,6 @@ class CodexAppServerClient:
            stderr=subprocess.PIPE,
            bufsize=0,
            env=spawn_env,
-            creationflags=windows_hide_flags(),
        )
        self._next_id = 1
        self._pending: dict[int, _Pending] = {}
@@ -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,18 +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,
-    compression_skipped_due_to_lock,
-    conversation_history_after_compression,
-)
-from agent.context_engine import automatic_compaction_status_message
+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 (
@@ -262,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."""
@@ -377,7 +336,6 @@ def build_turn_context(
        set_runtime_main(
            getattr(agent, "provider", "") or "",
            getattr(agent, "model", "") or "",
-            requested_provider=getattr(agent, "requested_provider", "") or "",
            base_url=getattr(agent, "base_url", "") or "",
            api_key=getattr(agent, "api_key", "") or "",
            api_mode=getattr(agent, "api_mode", "") or "",
@@ -621,93 +579,12 @@ 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",
-                )
-                _idle_status = automatic_compaction_status_message(
-                    _compressor,
-                    phase="idle",
-                    default_message=IDLE_COMPACTION_STATUS_TEMPLATE.format(
-                        idle_seconds=int(_idle_gap), tokens=_idle_tokens
-                    ),
-                    approx_tokens=_idle_tokens,
-                    idle_seconds=int(_idle_gap),
-                    model=agent.model,
-                )
-                if _idle_status:
-                    agent._emit_status(_idle_status)
-                _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, conversation_history
-                    )
-                    # 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
    # issue #27405 (a few very large messages slipping past the count gate).
    _preflight_compressed = False
    _preflight_compression_blocked = False
-    agent._turn_received_provider_response = False
-    agent._turn_preflight_display_snapshot = None
    if agent.compression_enabled and _should_run_preflight_estimate(
        messages,
        agent.context_compressor.protect_first_n,
@@ -720,21 +597,6 @@ def build_turn_context(
            tools=agent.tools or None,
        )
        _compressor = agent.context_compressor
-        # getattr guard: minimal compressor doubles (SimpleNamespace in the
-        # engine-preflight tests) and plugin context engines lack this
-        # ContextCompressor-only method — absence means no snapshot, and the
-        # finalizer's rollback stays disarmed for the turn (display-only).
-        _snapshot_fn = getattr(
-            _compressor, "snapshot_preflight_display_tokens", None
-        )
-        if callable(_snapshot_fn):
-            _snapshot_val = _snapshot_fn()
-            # Type pin: MagicMock compressors return truthy Mock objects —
-            # only a real int snapshot may arm the interrupted-turn rollback.
-            if isinstance(_snapshot_val, int) and not isinstance(
-                _snapshot_val, bool
-            ):
-                agent._turn_preflight_display_snapshot = _snapshot_val
        _defer_preflight = getattr(
            _compressor,
            "should_defer_preflight_to_real_usage",
@@ -768,8 +630,6 @@ def build_turn_context(
            lambda: None,
        )()

-        _should_compress_now = False
-        _compress_block_reason = None
        if _preflight_deferred:
            logger.info(
                "Skipping preflight compression: rough estimate ~%s >= %s, "
@@ -785,42 +645,14 @@ def build_turn_context(
                int(_compression_cooldown.get("remaining_seconds", 0.0)),
                agent.session_id or "none",
            )
-            if _preflight_tokens >= _compressor.threshold_tokens:
-                # Context is over threshold but compression is blocked by the
-                # summary-LLM cooldown — surface a warning (see block below).
-                _cooldown_secs = _compression_cooldown.get("remaining_seconds", 0.0)
-                _compress_block_reason = f"cooldown:{_cooldown_secs:.0f}"
        elif _codex_native_auto:
            logger.info(
                "Skipping Hermes preflight compression for codex app-server "
                "(mode=%s); Hermes will not start thread compaction here.",
                getattr(agent, "codex_app_server_auto_compaction", "native"),
            )
-        else:
-            _should_compress_now = _compressor.should_compress(_preflight_tokens)
-            if not _should_compress_now:
-                # Context is over threshold but compression is blocked
-                # (summary-LLM cooldown or anti-thrashing). Ask should_compress_info
-                # for the human-readable reason so we can surface a warning below.
-                # getattr guard: minimal compressor doubles (SimpleNamespace in
-                # the engine-preflight tests) and older plugin engines lack the
-                # method — absence means no block reason, no warning.
-                _info = getattr(_compressor, "should_compress_info", None)
-                if callable(_info):
-                    try:
-                        _compress_block_reason = _info(_preflight_tokens)[1]
-                    except Exception:
-                        _compress_block_reason = None
-        if _should_compress_now:
+        elif _compressor.should_compress(_preflight_tokens):
            _preflight_compressed = True
-            # Compression is actually running (block cleared / was never
-            # blocked) — reset the dedup so a future blocked-over-threshold
-            # turn can warn again. Real session boundary.
-            # getattr guard: test doubles built via object.__new__ lack the
-            # method (gateway test-double pitfall) — treat absence as no-op.
-            _clear_warn = getattr(agent, "_clear_context_overflow_warn", None)
-            if callable(_clear_warn):
-                _clear_warn()
            logger.info(
                "Preflight compression: ~%s tokens >= %s threshold (model %s, ctx %s)",
                f"{_preflight_tokens:,}",
@@ -828,20 +660,11 @@ def build_turn_context(
                agent.model,
                f"{_compressor.context_length:,}",
            )
-            _preflight_status = automatic_compaction_status_message(
-                _compressor,
-                phase="preflight",
-                default_message=PREFLIGHT_COMPRESSION_STATUS_TEMPLATE.format(
-                    tokens=_preflight_tokens,
-                    threshold=_compressor.threshold_tokens,
-                ),
-                approx_tokens=_preflight_tokens,
-                threshold_tokens=_compressor.threshold_tokens,
-                context_length=_compressor.context_length,
-                model=agent.model,
+            agent._emit_status(
+                f"📦 Preflight compression: ~{_preflight_tokens:,} tokens "
+                f">= {_compressor.threshold_tokens:,} threshold. "
+                "This may take a moment."
            )
-            if _preflight_status:
-                agent._emit_status(_preflight_status)
            # Preflight passes honor the same configured per-turn cap
            # (compression.max_attempts) as the loop's compression sites;
            # default 3 preserves the prior hardcoded behavior.
@@ -851,29 +674,10 @@ def build_turn_context(
            for _pass in range(_max_preflight_passes):
                _orig_len = len(messages)
                _orig_tokens = _preflight_tokens
-                _preflight_input = messages
                messages, active_system_prompt = agent._compress_context(
                    messages, system_message, approx_tokens=_preflight_tokens,
                    task_id=effective_task_id,
                )
-                if (
-                    messages is _preflight_input
-                    and compression_skipped_due_to_lock(agent)
-                ):
-                    # #69870 lock-skip: another path holds this session's
-                    # compression lock, so the pass no-oped. That is a
-                    # temporary DEFER, not proof the transcript cannot
-                    # compress — do NOT arm the insufficient-progress
-                    # blocker (the loop's error handlers must keep their
-                    # provider-proven retry budget) and stop preflight
-                    # passes for this turn; the lock winner is shrinking
-                    # the same session concurrently.
-                    logger.info(
-                        "Preflight compression deferred: compression lock "
-                        "held by another path (session %s)",
-                        agent.session_id or "none",
-                    )
-                    break
                # Re-estimate now so size-only compression (same row count,
                # lower token count — e.g. summarising tool outputs) is
                # recognised as progress instead of being misread as
@@ -889,7 +693,7 @@ def build_turn_context(
                    _preflight_compression_blocked = True
                    break  # Cannot compress further: neither rows nor tokens moved
                conversation_history = conversation_history_after_compression(
-                    agent, messages, conversation_history
+                    agent, messages
                )
                agent._empty_content_retries = 0
                agent._thinking_prefill_retries = 0
@@ -911,100 +715,6 @@ def build_turn_context(
                        f"{_preflight_tokens:,}",
                    )
                    break
-        elif _compress_block_reason:
-            # Context is already over the compression threshold, but compression
-            # is blocked (summary LLM cooldown or anti-thrashing). Without a
-            # signal the session keeps growing until the model silently stops
-            # answering — the conversation hits the hard provider token limit
-            # with no explanation. Surface a deduped warning so the user can
-            # take action (/new or /compress) instead of hitting a silent hang.
-            agent._warn_context_overflow_blocked(
-                _compress_block_reason,
-                _preflight_tokens,
-                _compressor.threshold_tokens,
-            )
-        else:
-            # Sub-threshold and unblocked — allow the overflow warning to fire
-            # again next time the context is over threshold but blocked.
-            # getattr guard: test doubles built via object.__new__ lack the
-            # method (gateway test-double pitfall) — treat absence as no-op.
-            _clear_warn = getattr(agent, "_clear_context_overflow_warn", None)
-            if callable(_clear_warn):
-                _clear_warn()
-            # Engine maintenance only when NO skip-branch fired: a failure
-            # cooldown, deferred estimate, or codex-native route must keep
-            # the engine hook un-consulted (#20316 contract — the cooldown
-            # exists precisely because compression recently failed).
-            if _compression_cooldown or _preflight_deferred or _codex_native_auto:
-                _engine_preflight = None
-            else:
-                _engine_preflight = getattr(
-                    _compressor, "should_compress_preflight", None
-                )
-            # ── Engine-driven sub-threshold preflight maintenance (#20316) ──
-            # None of the threshold-path branches fired (not deferred, no
-            # failure cooldown, not codex-native, and should_compress() said
-            # the request is under pressure). Context engines that override
-            # ``should_compress_preflight()`` (e.g. LCM-style incremental
-            # leaf-chunk compaction) can still request deferred maintenance
-            # below the token threshold. The default
-            # ``ContextEngine.should_compress_preflight()`` returns False, so
-            # the built-in ``ContextCompressor`` path is byte-identical.
-            #
-            # Attempt-cap integration: the engine gets exactly ONE
-            # ``compress()`` pass per turn. It is mutually exclusive with the
-            # threshold multi-pass loop above (if/elif), so turn-start
-            # preflight passes stay bounded by the resolved
-            # ``compression.max_attempts`` cap (floor 1) in every case.
-            #
-            # No-op-blocking integration: a sub-threshold engine pass that
-            # no-ops says nothing about over-threshold compressibility, so it
-            # must neither set nor clear ``_preflight_compression_blocked``
-            # (#64382) — and being in the ``else`` arm it can never run after
-            # the threshold loop has proven a retry ineffective.
-            # (resolved above, gated on no skip-branch having fired)
-            _wants_engine_preflight = False
-            if callable(_engine_preflight):
-                try:
-                    _wants_engine_preflight = bool(_engine_preflight(messages))
-                except Exception as _preflight_exc:
-                    # A buggy engine must never break an otherwise-healthy
-                    # turn: swallow at debug level and skip maintenance.
-                    logger.debug(
-                        "should_compress_preflight raised %s; skipping "
-                        "engine-driven preflight maintenance",
-                        _preflight_exc,
-                    )
-                    _wants_engine_preflight = False
-            if _wants_engine_preflight:
-                logger.info(
-                    "Engine-driven preflight maintenance: %s requested "
-                    "compress() at ~%s tokens (below %s threshold)",
-                    getattr(_compressor, "name", type(_compressor).__name__),
-                    f"{_preflight_tokens:,}",
-                    f"{getattr(_compressor, 'threshold_tokens', 0):,}",
-                )
-                _engine_input = messages
-                messages, active_system_prompt = agent._compress_context(
-                    messages, system_message, approx_tokens=_preflight_tokens,
-                    task_id=effective_task_id,
-                )
-                # ``_compress_context`` returns the INPUT list object on every
-                # skip path (per-session lock held elsewhere, cooldown,
-                # anti-thrash breaker, codex-native routing) and an engine may
-                # legitimately no-op. Only re-baseline the flush history and
-                # re-anchor the user row after a REAL compaction — a skip must
-                # leave the turn's bookkeeping untouched.
-                if messages is not _engine_input:
-                    _preflight_compressed = True
-                    conversation_history = conversation_history_after_compression(
-                        agent, messages
-                    )
-                    agent._empty_content_retries = 0
-                    agent._thinking_prefill_retries = 0
-                    agent._last_content_with_tools = None
-                    agent._last_content_tools_all_housekeeping = False
-                    agent._mute_post_response = False

    if _preflight_compressed:
        # Compression rebuilt the list (tail messages are fresh compaction
@@ -201,36 +201,6 @@ def finalize_turn(
        )
    )

-    # Preflight can seed the display count before the provider receives the
-    # request. Roll that estimate back only when an interrupt wins the race
-    # before any successful provider response. Compaction state remains owned
-    # by the real-usage/post-compaction path, including its ``-1`` sentinel.
-    # Guard rules (test-double density on this path is high):
-    #  - snapshot is type-pinned to a real int — MagicMock agents auto-create
-    #    truthy Mock attributes that must never arm the rollback;
-    #  - the received-response flag is pinned to ``is not True`` — its real
-    #    domain is True/False, and only a literal True means a provider
-    #    response completed;
-    #  - the compressor method gets a getattr+callable guard — SimpleNamespace
-    #    compressor doubles and plugin context engines lack it.
-    _preflight_snapshot = getattr(
-        agent, "_turn_preflight_display_snapshot", None
-    )
-    if (
-        interrupted is True
-        and isinstance(_preflight_snapshot, int)
-        and not isinstance(_preflight_snapshot, bool)
-        and getattr(agent, "_turn_received_provider_response", False) is not True
-        and getattr(agent, "context_compressor", None) is not None
-    ):
-        _rollback_fn = getattr(
-            agent.context_compressor,
-            "rollback_interrupted_preflight_display_tokens",
-            None,
-        )
-        if callable(_rollback_fn):
-            _rollback_fn(_preflight_snapshot)
-
    # Post-loop cleanup must never lose the response.  Trajectory save,
    # resource teardown, and session persistence all touch fallible
    # surfaces — file I/O / JSON serialization (_save_trajectory), remote
@@ -525,34 +495,6 @@ def finalize_turn(
        except Exception as exc:
            logger.warning("post_llm_call hook failed: %s", exc)

-    # Context engine observation hook: notify the active engine that this
-    # turn has finished, with the finalized transcript. Complements the
-    # per-request select_context() hook (selection before the request;
-    # observation after the turn). No-op default, fail-open.
-    try:
-        from agent.conversation_loop import _notify_context_engine_turn_complete
-        # Forward the turn's canonical usage when the host has it. The loop
-        # stashes the most recent API response's usage dict (the same
-        # canonical buckets fed to ``update_from_response``) on the agent as
-        # ``_last_turn_usage``. It is ``None`` on turns that never reached a
-        # provider response (early failure / interrupt), which is exactly the
-        # contract: real usage when available, ``None`` otherwise.
-        _turn_usage = getattr(agent, "_last_turn_usage", None)
-        _notify_context_engine_turn_complete(
-            agent,
-            messages,
-            usage=_turn_usage,
-            logger=logger,
-            turn_id=turn_id,
-            task_id=effective_task_id,
-            api_call_count=api_call_count,
-            interrupted=interrupted,
-            failed=failed,
-            turn_exit_reason=_turn_exit_reason,
-        )
-    except Exception as exc:
-        logger.warning("on_turn_complete notification failed: %s", exc)
-
    # Extract reasoning from the CURRENT turn only.  Walk backwards
    # but stop at the user message that started this turn — anything
    # earlier is from a prior turn and must not leak into the reasoning
@@ -683,7 +625,4 @@ def finalize_turn(
    except Exception as exc:
        logger.warning("on_session_end hook failed: %s", exc)

-    agent._turn_preflight_display_snapshot = None
-    agent._turn_received_provider_response = False
-
    return result
@@ -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.
@@ -60,12 +60,10 @@ def _db_path() -> Path:


 def _connect() -> sqlite3.Connection:
-    from hermes_state import apply_wal_with_fallback
-
    path = _db_path()
    path.parent.mkdir(parents=True, exist_ok=True)
    conn = sqlite3.connect(path)
-    apply_wal_with_fallback(conn, db_label="verification_evidence.db")
+    conn.execute("PRAGMA journal_mode=WAL")
    conn.execute("PRAGMA busy_timeout=5000")
    conn.row_factory = sqlite3.Row
    _ensure_schema(conn)
@@ -13,7 +13,7 @@
    "tauri:build": "tauri build",
    "tauri:build:debug": "tauri build --debug",
    "typecheck": "tsc -p . --noEmit",
-    "check": "npm run typecheck && npm run lint",
+    "check": "npm run typecheck",
    "lint": "eslint src/",
    "lint:fix": "eslint src/ --fix",
    "fix": "npm run lint:fix"
@@ -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,147 +0,0 @@
-/**
- * E2E regression: desktop resume must hide agent-only transcript rows.
- *
- * Compaction handoffs are active user rows because the model needs them for
- * context continuity. They are not authored chat content, so the desktop
- * transcript must never display them after a real compressor-generated resume.
- */
-
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-import { expect, test } from './test'
-
-import {
-  type MockBackendFixture,
-  buildAppEnv,
-  createSandbox,
-  launchDesktop,
-  waitForAppReady,
-  writeEnvFile,
-  writeMockProviderConfig,
-} from './fixtures'
-import {
-  MOCK_REPLY,
-  startMockServer,
-  VERIFICATION_STOP_TEXT,
-  VERIFICATION_STOP_TRIGGER,
-} from './mock-server'
-import { RealSessionBuilder } from './real-session-builder'
-
-const SESSION_TITLE = 'E2E Hidden History Messages'
-const VISIBLE_USER_TEXT = 'E2E_VISIBLE_USER_HISTORY'
-const VISIBLE_POST_COMPACTION_TEXT = 'E2E_VISIBLE_POST_COMPACTION_HISTORY'
-const COMPACTION_TRIGGER_PADDING = ' force real context compression'.repeat(600)
-
-async function setupSeededMockBackend(): Promise<MockBackendFixture> {
-  const mock = await startMockServer()
-  const sandbox = createSandbox('hidden-history')
-  writeMockProviderConfig(sandbox.hermesHome, mock.url)
-  fs.appendFileSync(
-    path.join(sandbox.hermesHome, 'config.yaml'),
-    '\ncompression:\n  threshold_tokens: 1\n',
-    'utf8',
-  )
-  writeEnvFile(sandbox.hermesHome)
-  const builder = await RealSessionBuilder.start(sandbox.hermesHome)
-  try {
-    await builder.createSession({
-      title: SESSION_TITLE,
-      turns: [
-        `${VISIBLE_USER_TEXT}${COMPACTION_TRIGGER_PADDING}`,
-        VISIBLE_POST_COMPACTION_TEXT,
-      ],
-    })
-  } finally {
-    await builder.close()
-  }
-
-  const { app, page } = await launchDesktop(buildAppEnv(sandbox))
-
-  return {
-    app,
-    page,
-    mock,
-    mockUrl: mock.url,
-    sandbox,
-    cleanup: async () => {
-      await app.close().catch(() => undefined)
-      await mock.close()
-      sandbox.cleanup()
-    },
-  }
-}
-
-test('resume hides real context-compaction handoffs', async ({}, testInfo) => {
-  const fixture = await setupSeededMockBackend()
-
-  try {
-    const { page } = fixture
-    await waitForAppReady(fixture, 120_000)
-
-    const sessionRow = page
-      .locator('[data-slot="sidebar"] button')
-      .filter({ hasText: SESSION_TITLE })
-      .first()
-    await sessionRow.click()
-
-    const transcript = page.locator('[data-slot="aui_thread-viewport"]')
-    await expect(transcript).toContainText(VISIBLE_USER_TEXT)
-    await expect(transcript).toContainText(VISIBLE_POST_COMPACTION_TEXT)
-    await expect(transcript).toContainText(MOCK_REPLY)
-    await expect(transcript).not.toContainText('[CONTEXT COMPACTION — REFERENCE ONLY]')
-    await page.screenshot({ path: testInfo.outputPath('hidden-history-resume.png') })
-  } finally {
-    await fixture.cleanup()
-  }
-})
-
-test('live verify-on-stop continuations stay out of the transcript', async ({}, testInfo) => {
-  const sandbox = createSandbox('live-verification-nudge')
-  const projectRoot = path.join(sandbox.root, 'project')
-  const changedFile = path.join(projectRoot, 'e2e-verification-target.py')
-  fs.mkdirSync(projectRoot)
-  fs.writeFileSync(
-    path.join(projectRoot, 'pyproject.toml'),
-    '[project]\nname = "e2e-verification-project"\nversion = "0.0.0"\n',
-    'utf8',
-  )
-
-  const mock = await startMockServer({ verificationWritePath: changedFile })
-  writeMockProviderConfig(sandbox.hermesHome, mock.url)
-  fs.appendFileSync(path.join(sandbox.hermesHome, 'config.yaml'), '\nagent:\n  verify_on_stop: true\n', 'utf8')
-  writeEnvFile(sandbox.hermesHome)
-  const { app, page } = await launchDesktop(buildAppEnv(sandbox))
-  const fixture: MockBackendFixture = {
-    app,
-    page,
-    mock,
-    mockUrl: mock.url,
-    sandbox,
-    cleanup: async () => {
-      await app.close().catch(() => undefined)
-      await mock.close()
-      sandbox.cleanup()
-    },
-  }
-
-  try {
-    await waitForAppReady(fixture, 120_000)
-    const composer = page.locator('[contenteditable="true"]').first()
-    await composer.click()
-    await composer.type(VERIFICATION_STOP_TRIGGER)
-    await page.keyboard.press('Enter')
-
-    const transcript = page.locator('[data-slot="aui_thread-viewport"]')
-    await expect(transcript).toContainText(VERIFICATION_STOP_TEXT, { timeout: 60_000 })
-    await expect.poll(
-      () => mock.receivedPrompts.some(prompt => prompt.includes('[System: You edited code in this turn')),
-      { timeout: 30_000 },
-    ).toBe(true)
-    expect(fs.existsSync(changedFile), 'The scripted write_file call should edit only the sandbox project').toBe(true)
-    await expect(transcript).not.toContainText('[System: You edited code in this turn')
-    await page.screenshot({ path: testInfo.outputPath('live-verification-nudge.png') })
-  } finally {
-    await fixture.cleanup()
-  }
-})
@@ -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,239 +0,0 @@
-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'
-import { RealSessionBuilder } from './real-session-builder'
-
-const DESKTOP_ROOT = path.resolve(import.meta.dirname, '..')
-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'
-const HISTORY_TURNS = Array.from(
-  { length: 27 },
-  (_, index) => `E2E persisted user message ${index * 2}: audit the compatibility matrix`,
-)
-
-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 builder = await RealSessionBuilder.start(sandbox.hermesHome)
-  try {
-    await builder.createSession({ title: SESSION_TITLE, turns: HISTORY_TURNS })
-  } finally {
-    await builder.close()
-  }
-
-  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)
-      const initialMockReplyCount = await textNodeOccurrences(fixture.page, MOCK_REPLY)
-      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 add exactly one transcript row',
-      ).toBe(initialMockReplyCount + 1)
-    })
-  }
-})
@@ -15,282 +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
-/** Absolute sandbox path written by the verify-on-stop scripted tool call. */
-verificationWritePath?: 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
-
-/** Per-server counter for the verify-on-stop script. */
-let _verificationStopIndex = 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
-  _verificationStopIndex = 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'
-
-/**
- * Drives a real code edit followed by two finish attempts. Hermes should add
- * its synthetic verify-on-stop continuation after each finish attempt until
- * the bounded verifier gives up. The mock's request capture proves the nudge
- * reached the model; desktop must never render it as chat content.
- */
-function verificationStopScript(writePath: string): ScriptedTurn[] {
-  return [
-  {
-    text: 'I will make the requested code change.',
-    toolCalls: [{
-      name: 'write_file',
-      args: {
-        path: writePath,
-        content: 'def changed_by_e2e():\n    return "changed"\n',
-      },
-    }],
-  },
-  { text: 'The code edit is complete.' },
-  { text: 'I cannot provide fresh verification evidence for that edit.' },
-  ]
-}
-
-export const VERIFICATION_STOP_TRIGGER = 'E2E_VERIFY_ON_STOP_TRIGGER'
-export const VERIFICATION_STOP_TEXT = 'I cannot provide fresh verification evidence for that edit.'
-
-/**
- * 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.
@@ -340,143 +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 isVerificationStopTrigger = messages.some(
-            message => typeof message?.content === 'string' && message.content.includes(VERIFICATION_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 (isVerificationStopTrigger) {
-            const script = verificationStopScript(options.verificationWritePath ?? 'e2e-verification-target.py')
-            const turn = script[_verificationStopIndex] ?? script[script.length - 1]
-            _verificationStopIndex++
-            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,
+                },
+              }),
+            )
          }
        })

@@ -507,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) => {
@@ -526,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,119 +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()
-
-  await composer.click()
-  await composer.type(text, { delay: 5 })
-  await page.keyboard.press('Enter')
-}
-
-async function queue(page: Page, text: string): Promise<void> {
-  const composer = page.locator('[contenteditable="true"]').first()
-
-  await composer.click()
-  await composer.type(text, { delay: 5 })
-  await page.keyboard.press('Control+Enter')
-}
-
-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!
-
-    await send(page, ACTIVE_PROMPT)
-    await mock.waitForHeldStream()
-    await queue(page, QUEUED_PROMPT)
-    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,226 +0,0 @@
-import { type ChildProcessWithoutNullStreams, spawn } from 'node:child_process'
-import * as path from 'node:path'
-import { createInterface } from 'node:readline'
-
-const DESKTOP_ROOT = path.resolve(import.meta.dirname, '..')
-const REPO_ROOT = path.resolve(DESKTOP_ROOT, '..', '..')
-const DEFAULT_TIMEOUT_MS = 60_000
-
-interface JsonRpcError {
-  code?: number
-  message?: string
-}
-
-interface JsonRpcFrame {
-  error?: JsonRpcError
-  id?: number
-  method?: string
-  params?: {
-    payload?: unknown
-    session_id?: string
-    type?: string
-  }
-  result?: unknown
-}
-
-interface CreatedSession {
-  session_id: string
-  stored_session_id: string
-}
-
-export interface RealSessionSpec {
-  /** Human-visible sidebar title, persisted by the first completed turn. */
-  title: string
-  /** Each item becomes one real user prompt followed by the mock provider's reply. */
-  turns: readonly string[]
-}
-
-export interface RealSession {
-  /** Runtime-only TUI session id, valid only while the builder process is alive. */
-  runtimeId: string
-  /** Durable SessionDB id that desktop resumes after the builder exits. */
-  sessionId: string
-}
-
-/**
- * Creates durable desktop session history through the real TUI gateway and
- * AIAgent loop, using the E2E mock provider configured in `hermesHome`.
- *
- * This intentionally uses the shipped stdio JSON-RPC transport instead of
- * importing SessionDB or launching Electron. The desktop's WebSocket backend
- * dispatches the same `tui_gateway.server` methods.
- */
-export class RealSessionBuilder {
-  private readonly child: ChildProcessWithoutNullStreams
-  private nextRequestId = 0
-  private readonly pending = new Map<number, { reject: (reason: Error) => void; resolve: (value: unknown) => void }>()
-  private readonly events: JsonRpcFrame[] = []
-  private readonly eventWaiters: Array<{
-    predicate: (frame: JsonRpcFrame) => boolean
-    reject: (reason: Error) => void
-    resolve: (frame: JsonRpcFrame) => void
-  }> = []
-  private readonly stderr: string[] = []
-  private closed = false
-
-  private constructor(hermesHome: string) {
-    this.child = spawn('uv', ['run', '--active', '--no-sync', 'python', '-m', 'tui_gateway.entry'], {
-      cwd: REPO_ROOT,
-      env: {
-        ...process.env,
-        HERMES_HOME: hermesHome,
-        PYTHONPATH: REPO_ROOT,
-      },
-      stdio: 'pipe',
-    })
-
-    createInterface({ input: this.child.stdout }).on('line', line => this.handleLine(line))
-    createInterface({ input: this.child.stderr }).on('line', line => {
-      this.stderr.push(line)
-      if (this.stderr.length > 80) this.stderr.shift()
-    })
-    this.child.once('error', error => this.failAll(new Error(`real-session gateway failed to start: ${error.message}`)))
-    this.child.once('exit', (code, signal) => {
-      if (!this.closed) {
-        this.failAll(new Error(`real-session gateway exited unexpectedly (${signal ?? code ?? 'unknown'}):\n${this.stderr.join('\n')}`))
-      }
-    })
-  }
-
-  static async start(hermesHome: string): Promise<RealSessionBuilder> {
-    const builder = new RealSessionBuilder(hermesHome)
-    await builder.waitForEvent(frame => frame.params?.type === 'gateway.ready')
-    return builder
-  }
-
-  async createSession(spec: RealSessionSpec): Promise<RealSession> {
-    if (spec.turns.length === 0) {
-      throw new Error('RealSessionBuilder requires at least one turn so the real agent creates a durable session row')
-    }
-
-    const created = await this.request<CreatedSession>('session.create', {
-      cols: 120,
-      cwd: REPO_ROOT,
-      source: 'desktop',
-      title: spec.title,
-    })
-    const runtimeId = requireString(created, 'session_id')
-    const sessionId = requireString(created, 'stored_session_id')
-
-    for (const text of spec.turns) {
-      const completion = this.waitForEvent(
-        frame => frame.params?.type === 'message.complete' && frame.params.session_id === runtimeId,
-      )
-      await this.request('prompt.submit', { session_id: runtimeId, text })
-      const frame = await completion
-      const status = readString(frame.params?.payload, 'status')
-      if (status !== 'complete') {
-        throw new Error(`real session turn failed with status ${status ?? 'unknown'}: ${JSON.stringify(frame.params?.payload)}`)
-      }
-    }
-
-    await this.request('session.close', { session_id: runtimeId })
-    return { runtimeId, sessionId }
-  }
-
-  async close(): Promise<void> {
-    if (this.closed) return
-    this.closed = true
-    this.child.stdin.end()
-    await new Promise<void>(resolve => {
-      const timeout = setTimeout(() => {
-        this.child.kill('SIGTERM')
-        resolve()
-      }, 5_000)
-      this.child.once('exit', () => {
-        clearTimeout(timeout)
-        resolve()
-      })
-    })
-  }
-
-  private request<T = unknown>(method: string, params: Record<string, unknown>): Promise<T> {
-    const id = ++this.nextRequestId
-    return this.withTimeout(new Promise<T>((resolve, reject) => {
-      this.pending.set(id, { resolve: value => resolve(value as T), reject })
-      this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`, error => {
-        if (error) {
-          this.pending.delete(id)
-          reject(error)
-        }
-      })
-    }), `request ${method}`)
-  }
-
-  private waitForEvent(predicate: (frame: JsonRpcFrame) => boolean): Promise<JsonRpcFrame> {
-    const index = this.events.findIndex(predicate)
-    if (index >= 0) {
-      return Promise.resolve(this.events.splice(index, 1)[0])
-    }
-    return this.withTimeout(new Promise<JsonRpcFrame>((resolve, reject) => {
-      this.eventWaiters.push({ predicate, resolve, reject })
-    }), 'gateway event')
-  }
-
-  private handleLine(line: string): void {
-    let frame: JsonRpcFrame
-    try {
-      frame = JSON.parse(line) as JsonRpcFrame
-    } catch {
-      return
-    }
-
-    if (typeof frame.id === 'number') {
-      const pending = this.pending.get(frame.id)
-      if (!pending) return
-      this.pending.delete(frame.id)
-      if (frame.error) {
-        pending.reject(new Error(`JSON-RPC error ${frame.error.code ?? 'unknown'}: ${frame.error.message ?? 'unknown error'}`))
-      } else {
-        pending.resolve(frame.result)
-      }
-      return
-    }
-
-    if (frame.method !== 'event') return
-    const waiter = this.eventWaiters.find(candidate => candidate.predicate(frame))
-    if (!waiter) {
-      this.events.push(frame)
-      return
-    }
-    this.eventWaiters.splice(this.eventWaiters.indexOf(waiter), 1)
-    waiter.resolve(frame)
-  }
-
-  private withTimeout<T>(promise: Promise<T>, operation: string): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error(`Timed out after ${DEFAULT_TIMEOUT_MS / 1000}s waiting for ${operation}:\n${this.stderr.join('\n')}`)), DEFAULT_TIMEOUT_MS)
-      promise.then(value => {
-        clearTimeout(timer)
-        resolve(value)
-      }, error => {
-        clearTimeout(timer)
-        reject(error)
-      })
-    })
-  }
-
-  private failAll(error: Error): void {
-    for (const pending of this.pending.values()) pending.reject(error)
-    this.pending.clear()
-    for (const waiter of this.eventWaiters) waiter.reject(error)
-    this.eventWaiters.length = 0
-  }
-}
-
-function readString(value: unknown, key: string): string | undefined {
-  if (!value || typeof value !== 'object') return undefined
-  const candidate = (value as Record<string, unknown>)[key]
-  return typeof candidate === 'string' ? candidate : undefined
-}
-
-function requireString(value: unknown, key: string): string {
-  const candidate = readString(value, key)
-  if (!candidate) throw new Error(`Gateway response omitted required ${key}: ${JSON.stringify(value)}`)
-  return candidate
-}
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Seed a Hermes state.db with a session exported from a real conversation.
+
+Usage: seed_session_db.py <state_db_path> <fixture_json_path>
+
+Creates the database with the full SessionDB schema (if it doesn't exist)
+and imports the session from the JSON fixture. Uses the real
+SessionDB.import_sessions() so the data shape matches what the desktop
+backend expects.
+"""
+import json
+import sys
+from pathlib import Path
+
+# Add the repo root to sys.path so we can import hermes_state.
+# The script is invoked from apps/desktop/e2e/ — repo root is ../../..
+repo_root = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(repo_root))
+
+from hermes_state import SessionDB  # noqa: E402
+
+
+def main():
+    if len(sys.argv) != 3:
+        print(f"Usage: {sys.argv[0]} <state_db_path> <fixture_json_path>", file=sys.stderr)
+        sys.exit(1)
+
+    db_path = Path(sys.argv[1])
+    fixture_path = Path(sys.argv[2])
+
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(fixture_path, "r", encoding="utf-8") as f:
+        session_data = json.load(f)
+
+    db = SessionDB(db_path=db_path)
+    result = db.import_sessions([session_data])
+
+    if not result.get("ok"):
+        print(f"Import failed: {result}", file=sys.stderr)
+        sys.exit(1)
+
+    imported = result.get("imported", 0)
+    skipped = result.get("skipped", 0)
+    errors = result.get("errors", [])
+
+    if errors:
+        print(f"Import had errors: {errors}", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Seeded {imported} session(s), skipped {skipped} → {db_path}")
+    db.close()
+
+
+if __name__ == "__main__":
+    main()
@@ -1,151 +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.
-    // The payload must cross threshold_tokens (22k) on its OWN weight
-    // (~12k tokens) on top of the system prompt. Do not shrink it: at
-    // repeat(500) the trigger only worked because the ambient system prompt
-    // (skills index + tool schemas) happened to carry it over the line, and
-    // a 160-token skills-index cleanup on main broke the test for a day.
-    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(1500))
-    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,434 +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 { expect, test } from './test'
-
-import {
-  type MockBackendFixture,
-  waitForAppReady,
-  createSandbox,
-  writeMockProviderConfig,
-  writeEnvFile,
-  buildAppEnv,
-  launchDesktop,
-} from './fixtures'
-import { startMockServer } from './mock-server'
-import { RealSessionBuilder } from './real-session-builder'
-
-const SESSION_TITLE = 'E2E Warm Resume Jitter Test'
-/** 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 the user turns for a real session. The mock provider produces the
- * assistant side of each pair through the normal AIAgent persistence path.
- */
-function generateSessionTurns(): string[] {
-  const rng = mulberry32(RNG_SEED)
-  const turns: string[] = []
-
-  for (let i = 0; i < MESSAGE_COUNT / 2; i++) {
-    turns.push(gibberish(rng))
-    gibberish(rng)
-  }
-
-  return turns
-}
-
-/**
- * Set up a mock-backend sandbox with a real persisted session in state.db.
- *
- * Unlike the shared `setupMockBackend()`, this variant creates the session
- * through the real stdio gateway before launching desktop so the session is
- * visible in the sidebar on first load.
- */
-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. Produce all 16 user/assistant pairs through the real TUI gateway,
-  // AIAgent, mock provider, and SessionDB persistence path before desktop starts.
-  const builder = await RealSessionBuilder.start(sandbox.hermesHome)
-  try {
-    await builder.createSession({ title: SESSION_TITLE, turns: generateSessionTurns() })
-  } finally {
-    await builder.close()
-  }
-
-  // 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 }
@@ -1,54 +0,0 @@
-import assert from 'node:assert/strict'
-
-import { test } from 'vitest'
-
-import { findGitBash } from './find-git-bash'
-
-const yes = () => true
-const no = () => false
-
-test('HERMES_GIT_BASH_PATH override takes precedence', () => {
-  const result = findGitBash({
-    isWindows: true,
-    env: { HERMES_GIT_BASH_PATH: 'D:\\CustomGit\\bin\\bash.exe' },
-    fileExists: yes,
-    findOnPath: () => null
-  })
-
-  assert.equal(result, 'D:\\CustomGit\\bin\\bash.exe')
-})
-
-test('HERMES_GIT_BASH_PATH invalid path falls through to candidates', () => {
-  const env = {
-    HERMES_GIT_BASH_PATH: 'X:\\Missing\\bash.exe',
-    LOCALAPPDATA: 'C:\\Users\\test\\AppData\\Local',
-    ProgramFiles: 'C:\\Program Files',
-    'ProgramFiles(x86)': 'C:\\Program Files (x86)'
-  }
-
-  const fileExists = (p: string) => p !== 'X:\\Missing\\bash.exe' && p.includes('Program Files\\Git\\bin\\bash.exe')
-  const result = findGitBash({ isWindows: true, env, fileExists, findOnPath: () => null })
-  assert.equal(result, 'C:\\Program Files\\Git\\bin\\bash.exe')
-})
-
-test('HERMES_GIT_BASH_PATH empty string is ignored', () => {
-  const result = findGitBash({
-    isWindows: true,
-    env: { HERMES_GIT_BASH_PATH: '', LOCALAPPDATA: '' },
-    fileExists: no,
-    findOnPath: () => 'C:\\msys64\\usr\\bin\\bash.exe'
-  })
-
-  assert.equal(result, 'C:\\msys64\\usr\\bin\\bash.exe')
-})
-
-test('non-Windows uses findOnPath', () => {
-  const result = findGitBash({
-    isWindows: false,
-    env: {},
-    fileExists: no,
-    findOnPath: () => '/usr/bin/bash'
-  })
-
-  assert.equal(result, '/usr/bin/bash')
-})
@@ -1,67 +0,0 @@
-import path from 'node:path'
-
-export interface GitBashOptions {
-  isWindows: boolean
-  env: Record<string, string | undefined>
-  fileExists: (filePath: string) => boolean
-  findOnPath?: (command: string) => string | null
-}
-
-/**
- * Locate bash.exe on Windows.
- * Resolution order (first match wins):
- *   1. HERMES_GIT_BASH_PATH env var override
- *   2. PortableGit under %LOCALAPPDATA%\hermes\git\ (install.ps1)
- *   3. Standard Git for Windows install locations
- *   4. %LOCALAPPDATA%\Programs\Git\ (user-scoped)
- *   5. bash on PATH
- */
-export function findGitBash(opts: GitBashOptions): string | null {
-  const { isWindows, env, fileExists, findOnPath } = opts
-
-  if (!isWindows) {
-    return findOnPath ? findOnPath('bash') : null
-  }
-
-  // Respect HERMES_GIT_BASH_PATH if set (mirrors tools/environments/local.py:_find_bash).
-  const gitBashPath = env.HERMES_GIT_BASH_PATH
-
-  if (gitBashPath && fileExists(gitBashPath)) {
-    return gitBashPath
-  }
-
-  const localAppData = env.LOCALAPPDATA || ''
-  const candidates: string[] = []
-
-  // Candidate paths are Windows paths regardless of host platform (tests run
-  // on POSIX CI hosts too), so join with win32 semantics explicitly.
-  const joinWin = path.win32.join
-
-  if (localAppData) {
-    candidates.push(joinWin(localAppData, 'hermes', 'git', 'bin', 'bash.exe'))
-    candidates.push(joinWin(localAppData, 'hermes', 'git', 'usr', 'bin', 'bash.exe'))
-  }
-
-  candidates.push(joinWin(env['ProgramFiles'] || 'C:\\Program Files', 'Git', 'bin', 'bash.exe'))
-  candidates.push(joinWin(env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', 'Git', 'bin', 'bash.exe'))
-
-  if (localAppData) {
-    candidates.push(joinWin(localAppData, 'Programs', 'Git', 'bin', 'bash.exe'))
-  }
-
-  for (const candidate of candidates) {
-    if (fileExists(candidate)) {
-      return candidate
-    }
-  }
-
-  if (findOnPath) {
-    const onPath = findOnPath('bash')
-
-    if (onPath) {
-      return onPath
-    }
-  }
-
-  return null
-}
@@ -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'
@@ -78,9 +78,21 @@ import {
 } from './desktop-uninstall'
 import { installEmbedReferer } from './embed-referer'
 import { createEventDeduper } from './event-dedupe'
-import { findGitBash as _findGitBash } from './find-git-bash'
 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,
@@ -117,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'
@@ -1916,16 +1919,48 @@ function findSystemPython() {
  return null
 }

-// findGitBash — locate bash.exe on Windows. Resolves HERMES_GIT_BASH_PATH
-// first (mirrors tools/environments/local.py:_find_bash), then PortableGit,
-// standard install locations, and finally PATH.
+// findGitBash — locate bash.exe on Windows. Hermes' terminal tool requires
+// bash (POSIX shell), and on Windows that's almost always Git for Windows'
+// bundled Git Bash. We check the same set of locations tools/environments/
+// local.py:_find_bash() checks at runtime, so a positive result here means
+// the agent will be able to start a terminal too.
+//
+// On non-Windows hosts bash is part of the OS and this just returns the
+// first bash on PATH.
 function findGitBash() {
-  return _findGitBash({
-    isWindows: IS_WINDOWS,
-    env: process.env,
-    fileExists,
-    findOnPath
-  })
+  if (!IS_WINDOWS) {
+    return findOnPath('bash')
+  }
+
+  // install.ps1 drops PortableGit at %LOCALAPPDATA%\hermes\git\... — checked
+  // first so users who installed via install.ps1 are detected before we
+  // start probing system-wide locations.
+  const localAppData = process.env.LOCALAPPDATA || ''
+  const candidates = []
+
+  if (localAppData) {
+    candidates.push(path.join(localAppData, 'hermes', 'git', 'bin', 'bash.exe'))
+    candidates.push(path.join(localAppData, 'hermes', 'git', 'usr', 'bin', 'bash.exe'))
+  }
+
+  // Standard Git for Windows install locations.
+  candidates.push(path.join(process.env['ProgramFiles'] || 'C:\\Program Files', 'Git', 'bin', 'bash.exe'))
+  candidates.push(path.join(process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', 'Git', 'bin', 'bash.exe'))
+
+  if (localAppData) {
+    candidates.push(path.join(localAppData, 'Programs', 'Git', 'bin', 'bash.exe'))
+  }
+
+  for (const candidate of candidates) {
+    if (fileExists(candidate)) {
+      return candidate
+    }
+  }
+
+  // Last resort — bash on PATH (covers WSL bash, MSYS2, custom installs).
+  // On WSL hosts findOnPath itself filters out Windows-binary paths via
+  // isWindowsBinaryPathInWsl, so we won't hand back a wsl.exe shim either.
+  return findOnPath('bash')
 }

 function getVenvPython(venvRoot) {
@@ -3533,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}`,
@@ -5820,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)

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

    if (!ticket || typeof ticket !== 'string') {
@@ -6430,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
    }
@@ -8923,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 }
@@ -8946,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) {
@@ -8956,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",
@@ -54,14 +50,10 @@
    "test:desktop:platforms": "vitest run --project electron",
    "test": "vitest run",
    "preview": "node scripts/assert-root-install.mjs && vite preview --host 127.0.0.1 --port 4174",
-    "check:test:desktop:platforms": "npm run test:desktop:platforms",
-    "check:test:ui": "npm run test:ui",
-    "check:test:desktop:all": "npm run test:desktop:all",
-    "check:lint": "npm run typecheck && npm run lint",
-    "check": "npm run check:lint && npm run check:test:ui && npm run test:desktop:platforms && 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"
+    "check": "npm run typecheck && npm run test && npm run test:desktop:all",
+    "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 Enter for Steer', async () => {
-    renderControls({ busy: true, busyAction: 'steer' })
-
-    await expectShortcutTooltip('Steer the current run', '↵')
-  })
-
-  it('shows Ctrl+Enter for Queue', async () => {
-    renderControls({ busy: true, busyAction: 'queue' })
-
-    await expectShortcutTooltip('Queue message', 'Ctrl+↵')
-  })
-})
@@ -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.queue" 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,26 +127,9 @@ export function ComposerControls({
          </Button>
        </Tip>
      ) : (
-        <Tip
-          label={
-            busy ? (
-              <TipKeybindLabel
-                actionId={
-                  busyAction === 'steer'
-                    ? 'composer.steer'
-                    : busyAction === 'queue'
-                      ? 'composer.queue'
-                      : '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"
@@ -139,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,7 +1,7 @@
 import { useCallback, useEffect, useRef, useState } from 'react'

 import { useI18n } from '@/i18n'
-import { chatMessageText, collectUnspokenTurnSpeech } from '@/lib/chat-messages'
+import { chatMessageText } from '@/lib/chat-messages'
 import { triggerHaptic } from '@/lib/haptics'
 import { resetBrowseState } from '@/store/composer-input-history'
 import { notifyError } from '@/store/notifications'
@@ -60,7 +60,6 @@ export function useComposerVoice({
    onTranscribeAudio
  })

-  /** Auto-speak selector: the latest unspoken reply only — a backlog collapses to the newest. */
  const pendingResponse = () => {
    const messages = $messages.get()
    const last = messages.findLast(m => m.role === 'assistant' && !m.hidden)
@@ -82,13 +81,6 @@ export function useComposerVoice({
    }
  }

-  /**
-   * Voice-conversation selector: every unspoken assistant bubble of the turn,
-   * in order — narration interims AND the final answer, not just whichever
-   * bubble happens to be last. See `collectUnspokenTurnSpeech`.
-   */
-  const pendingTurnResponse = () => collectUnspokenTurnSpeech($messages.get(), lastSpokenIdRef.current)
-
  const consumePendingResponse = () => {
    const messages = $messages.get()
    const last = messages.findLast(m => m.role === 'assistant' && !m.hidden)
@@ -116,7 +108,7 @@ export function useComposerVoice({
    onFatalError: () => setVoiceConversationActive(false),
    onSubmit: submitVoiceTurn,
    onTranscribeAudio,
-    pendingResponse: pendingTurnResponse
+    pendingResponse
  })

  // The `composer.voice` hotkey (Ctrl+B) toggles the conversation. Starting
@@ -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,
@@ -587,22 +578,14 @@ export function ChatBar({
      return
    }

-    // Cmd/Ctrl+Enter queues a follow-up while a turn runs. Plain Enter steers
-    // a text-only draft, so both live-turn actions stay reachable by keyboard.
+    // Cmd/Ctrl+Enter is reserved for steering the live run — never a send.
+    // Steer when there's a steerable draft, otherwise swallow it so it can't
+    // surprise-send. (Plain Enter still queues while busy / sends when idle.)
    if (event.key === 'Enter' && (event.metaKey || event.ctrlKey) && !event.shiftKey) {
      event.preventDefault()

-      if (busy && !disabled) {
-        // As with plain Enter, source the just-typed content from the DOM so a
-        // fast keypress cannot queue a stale draft.
-        const editorText = editorRef.current ? composerPlainText(editorRef.current) : draftRef.current
-
-        if (editorText !== draftRef.current) {
-          draftRef.current = editorText
-          setComposerText(editorText)
-        }
-
-        queueDraft()
+      if (canSteer) {
+        steerDraft()
      }

      return
@@ -738,6 +721,7 @@ export function ChatBar({
      autoSpeak={autoSpeak}
      busy={busy}
      busyAction={busyAction}
+      canSteer={canSteer}
      canSubmit={canSubmit}
      compactModelPill={poppedOut || compactPill}
      conversation={{
@@ -753,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))
--- 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