diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 456fa8f2831..322481ae8b3 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -63,9 +63,10 @@ CI enforces this for `src/preload/` and `src/shared/`.
 
 Each pull request should follow [`.github/pull_request_template.md`](./pull_request_template.md). In particular:
 
+- if you are an outside contributor, link the issue your PR addresses
 - open with an ELI5 of the change (plain language paragraph; the PR title is the one-liner)
 - explain what changed and why, and stay focused on a single topic when possible
-- for any UI or interaction change, attach **before and after** screenshots (or short videos); if there is no visual change, say `No visual change` and why
+- for any UI or interaction change, attach **before and after** screenshots (or short videos); if there is no visual or interaction change, write `N/A` and briefly explain why
 - include high-quality tests when behavior changes or bug fixes warrant them
 - include a brief code review summary from your AI coding agent that explicitly checks cross-platform compatibility, SSH/remote/local compatibility, supported agent and integration compatibility, performance risk, UI quality when applicable, and basic security risk
 - mention any platform-specific, remote/SSH-specific, agent-specific, integration-specific, or git-provider-specific behavior and testing notes
diff --git a/.github/scripts/check-root-directory-entries.mjs b/.github/scripts/check-root-directory-entries.mjs
index 5b63326691d..a428c8cc090 100644
--- a/.github/scripts/check-root-directory-entries.mjs
+++ b/.github/scripts/check-root-directory-entries.mjs
@@ -13,9 +13,8 @@ function readRootEntries(sha) {
   return stdout.split('\0').filter(Boolean)
 }
 
-// Why: the Cloud workspace import is the one reviewed root addition; it stays
-// listed until it lands on main, after which the base tree carries it.
-const REVIEWED_ROOT_ENTRIES = new Set(['cloud'])
+// These reviewed additions stay listed until the base tree carries them.
+const REVIEWED_ROOT_ENTRIES = new Set(['cloud', 'opencode.json'])
 
 function checkRootDirectoryEntries(argv) {
   if (argv.length !== 2) {
diff --git a/.github/workflows/cloud-deploy-relay-asia-topology.yml b/.github/workflows/cloud-deploy-relay-asia-topology.yml
index 07fbc68056e..3e8929376be 100644
--- a/.github/workflows/cloud-deploy-relay-asia-topology.yml
+++ b/.github/workflows/cloud-deploy-relay-asia-topology.yml
@@ -78,6 +78,7 @@ jobs:
             production:production-gce-c30) ;;
             production:production-gce-c31) ;;
             production:production-gce-c32,production-gce-c33) target_region=us-central1 ;;
+            production:production-gce-c34) ;;
             *) echo "cell-ids do not match the reviewed environment topology" >&2; exit 1 ;;
           esac
           echo "TARGET_REGION=${target_region}" >> "${GITHUB_ENV}"
diff --git a/.github/workflows/cloud-deploy-relay-production-same-cap-job.yml b/.github/workflows/cloud-deploy-relay-production-same-cap-job.yml
index af66e918386..913b6a24b17 100644
--- a/.github/workflows/cloud-deploy-relay-production-same-cap-job.yml
+++ b/.github/workflows/cloud-deploy-relay-production-same-cap-job.yml
@@ -194,7 +194,7 @@ jobs:
               EXPECTED_REGION=us-central1
               EXPECTED_DATABASE_POOL_MAX=
               ;;
-            c27|c28|c29|c30|c31)
+            c27|c28|c29|c30|c31|c34)
               EXPECTED_HARD_CAP=3000
               EXPECTED_REGION=asia-east2
               EXPECTED_DATABASE_POOL_MAX=16
diff --git a/.github/workflows/mobile.yml b/.github/workflows/mobile.yml
index ae695b8e3eb..78047f09d2e 100644
--- a/.github/workflows/mobile.yml
+++ b/.github/workflows/mobile.yml
@@ -120,8 +120,6 @@ jobs:
         background: true
         run: node node_modules/typescript/bin/tsc --noEmit
 
-      - wait: production-types
-
       # Why a ratchet and not the raw typecheck: mobile/tsconfig.json excludes test files, so until
       # tsconfig.test.json existed nothing checked them, and at introduction 127 of the 632 had
       # drifted. This fails when a test file that checks today stops checking, when a test leaves
@@ -129,6 +127,8 @@ jobs:
       - name: Typecheck tests (ratchet)
         run: node scripts/check-tests-typecheck-ratchet.mjs
 
+      - wait: production-types
+
       # This includes the bridged replay of the whole recording corpus, which used to be a second
       # step of its own behind RPC_FOUNDATION_BRIDGE=1. A gate nobody can forget to set is the point:
       # it fails when a divergence class grows, when a divergence lands in no class at all, or when
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index b370dff9929..ed9a25732bb 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -440,8 +440,12 @@ jobs:
 
   git_compatibility:
     name: Git compatibility
-    needs: [code_paths]
-    if: needs.code_paths.outputs.git_compatibility == 'true'
+    needs: [code_paths, preflight]
+    if: >-
+      !cancelled() &&
+      needs.code_paths.result == 'success' &&
+      needs.code_paths.outputs.git_compatibility == 'true' &&
+      needs.preflight.result == 'success'
     runs-on: ubuntu-latest
 
     steps:
@@ -509,8 +513,12 @@ jobs:
   # repair stops happening. Pinned because the binary is the thing expected to drift.
   codex_index_heal_contract:
     name: Codex index-heal contract
-    needs: [code_paths]
-    if: needs.code_paths.outputs.codex_index_heal_contract == 'true'
+    needs: [code_paths, preflight]
+    if: >-
+      !cancelled() &&
+      needs.code_paths.result == 'success' &&
+      needs.code_paths.outputs.codex_index_heal_contract == 'true' &&
+      needs.preflight.result == 'success'
     # Why ARM: @openai/codex ships @openai/codex-linux-arm64.
     runs-on: ubuntu-24.04-arm
     env:
@@ -575,8 +583,12 @@ jobs:
 
   xterm_patch_sync:
     name: xterm patch sync
-    needs: [code_paths]
-    if: needs.code_paths.outputs.xterm_patch_sync == 'true'
+    needs: [code_paths, preflight]
+    if: >-
+      !cancelled() &&
+      needs.code_paths.result == 'success' &&
+      needs.code_paths.outputs.xterm_patch_sync == 'true' &&
+      needs.preflight.result == 'success'
     # Why ARM: the patch check rebuilds 4 packages x 2 builds and byte-compares against the
     # checked-in bundles. Those were generated on Linux x64 and reproduce byte-for-byte on
     # darwin-arm64, so the output is neither host-arch nor host-OS dependent.
@@ -604,8 +616,12 @@ jobs:
 
   shell_contracts:
     name: shell contracts
-    needs: [code_paths]
-    if: needs.code_paths.outputs.shell_contracts == 'true'
+    needs: [code_paths, preflight]
+    if: >-
+      !cancelled() &&
+      needs.code_paths.result == 'success' &&
+      needs.code_paths.outputs.shell_contracts == 'true' &&
+      needs.preflight.result == 'success'
     # Why ARM: fish 4.x is published for noble/arm64 and zsh is in the arm64 archive.
     runs-on: ubuntu-24.04-arm
     # Why: this job's cost is almost entirely package download, and a stalled mirror has
@@ -758,8 +774,12 @@ jobs:
   # would pay for it on every shard to run one file in whichever shard it landed in.
   orcad_browser:
     name: orcad browser provider
-    needs: [code_paths]
-    if: needs.code_paths.outputs.orcad_browser == 'true'
+    needs: [code_paths, preflight]
+    if: >-
+      !cancelled() &&
+      needs.code_paths.result == 'success' &&
+      needs.code_paths.outputs.orcad_browser == 'true' &&
+      needs.preflight.result == 'success'
     runs-on: ubuntu-latest
 
     steps:
@@ -811,7 +831,7 @@ jobs:
       # in this job loads node-pty.
       - uses: ./.github/actions/install-node-dependencies
         with:
-          native-runtime: node
+          native-runtime: none
           cache-dependency-path: |
             pnpm-lock.yaml
             mobile/pnpm-lock.yaml
@@ -872,8 +892,12 @@ jobs:
 
   cross-version-wire:
     name: cross-version wire compatibility
-    needs: [code_paths]
-    if: needs.code_paths.outputs.cross-version-wire == 'true'
+    needs: [code_paths, preflight]
+    if: >-
+      !cancelled() &&
+      needs.code_paths.result == 'success' &&
+      needs.code_paths.outputs.cross-version-wire == 'true' &&
+      needs.preflight.result == 'success'
     # Why ARM: source-only: tagged checkout plus in-process vitest, no docker or browser.
     runs-on: ubuntu-24.04-arm
 
@@ -916,8 +940,12 @@ jobs:
 
   managed_hook_node18:
     name: managed hooks on Node 18
-    needs: [code_paths]
-    if: needs.code_paths.outputs.managed_hook_node18 == 'true'
+    needs: [code_paths, preflight]
+    if: >-
+      !cancelled() &&
+      needs.code_paths.result == 'success' &&
+      needs.code_paths.outputs.managed_hook_node18 == 'true' &&
+      needs.preflight.result == 'success'
     # Why ARM: Node 18 publishes linux-arm64; the per-platform runtime files are read as data.
     runs-on: ubuntu-24.04-arm
 
@@ -1263,8 +1291,19 @@ jobs:
 
   e2e:
     name: e2e
-    needs: code_paths
-    if: needs.code_paths.outputs.e2e_should_run == 'true'
+    needs: [code_paths, preflight]
+    if: >-
+      !cancelled() &&
+      needs.code_paths.result == 'success' &&
+      needs.code_paths.outputs.e2e_should_run == 'true' &&
+      (
+        needs.preflight.result == 'success' ||
+        (
+          needs.preflight.result == 'skipped' &&
+          needs.code_paths.outputs.static_analysis == 'false' &&
+          needs.code_paths.outputs.typecheck == 'false'
+        )
+      )
     # Why: reusable e2e.yml only checkouts, builds, and uploads artifacts.
     permissions:
       contents: read
diff --git a/.github/workflows/ssh-windows-hosts.yml b/.github/workflows/ssh-windows-hosts.yml
index 8afae35ca12..f822dd9a53d 100644
--- a/.github/workflows/ssh-windows-hosts.yml
+++ b/.github/workflows/ssh-windows-hosts.yml
@@ -84,6 +84,17 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
+          # Keep complete server/test trees; missing future imports fail the unchanged builds.
+          sparse-checkout: |
+            .github
+            config
+            native
+            resources
+            tests
+            src/main
+            src/shared
+            src/relay
+            src/types
       - name: Self-test the provisioning scripts before touching the machine
         shell: pwsh
         run: |
diff --git a/.github/workflows/terminal-ime-e2e.yml b/.github/workflows/terminal-ime-e2e.yml
index 168280f9ac2..a99e045e4b9 100644
--- a/.github/workflows/terminal-ime-e2e.yml
+++ b/.github/workflows/terminal-ime-e2e.yml
@@ -5,12 +5,21 @@ on:
   # change is worth a real ibus session. A pull_request trigger here would run it on every PR.
   workflow_call:
   workflow_dispatch:
+    inputs:
+      diagnose_wayland_input:
+        description: Capture passive Wayland input diagnostics while running both native lanes
+        required: false
+        type: boolean
+        default: false
   schedule:
     - cron: '30 9 * * *'
 
 permissions:
   contents: read
 
+env:
+  ORCA_BACKGROUND_LAUNCH: '1'
+
 jobs:
   linux-x11:
     name: Linux X11 terminal IME
@@ -98,6 +107,7 @@ jobs:
       - name: Run native Wayland Hangul terminating digit
         env:
           SKIP_BUILD: '1'
+          ORCA_E2E_WAYLAND_INPUT_DIAGNOSTICS: ${{ inputs.diagnose_wayland_input && '1' || '' }}
         run: node config/scripts/run-terminal-ibus-hangul-e2e.mjs --nested-wayland
       - name: Upload Wayland terminal IME evidence
         if: always()
diff --git a/cloud/apps/relay/src/assignment-cleanup-steps.test.ts b/cloud/apps/relay/src/assignment-cleanup-steps.test.ts
index 0e5eac13e31..38fbb105580 100644
--- a/cloud/apps/relay/src/assignment-cleanup-steps.test.ts
+++ b/cloud/apps/relay/src/assignment-cleanup-steps.test.ts
@@ -16,6 +16,7 @@ function stubStore(overrides: Partial<AssignmentCleanupStore> = {}) {
     abortExpiredRegionalRehomes: method('abortExpiredRegionalRehomes'),
     reapRegionalRehomeAttempts: method('reapRegionalRehomeAttempts'),
     releaseExpiredActivityLeases: method('releaseExpiredActivityLeases'),
+    pruneReleasedControlReservations: method('pruneReleasedControlReservations'),
     releaseExpiredActivity: method('releaseExpiredActivity'),
     releaseExpiredRegionPreferences: method('releaseExpiredRegionPreferences'),
     evacuateDeadCells: method('evacuateDeadCells'),
@@ -43,6 +44,7 @@ describe('assignment cleanup steps', () => {
       'abortExpiredRegionalRehomes',
       'reapRegionalRehomeAttempts',
       'releaseExpiredActivityLeases',
+      'pruneReleasedControlReservations',
       'releaseExpiredActivity',
       'releaseExpiredRegionPreferences',
       'evacuateDeadCells'
diff --git a/cloud/apps/relay/src/assignment-cleanup-steps.ts b/cloud/apps/relay/src/assignment-cleanup-steps.ts
index 31e25be3688..9edd7044313 100644
--- a/cloud/apps/relay/src/assignment-cleanup-steps.ts
+++ b/cloud/apps/relay/src/assignment-cleanup-steps.ts
@@ -1,9 +1,9 @@
 import { runRelayBackgroundOperation } from './relay-background-operation.js'
 
-// The eleven periodic assignment sweeps the director runs every 30s. Each step
+// The twelve periodic assignment sweeps the director runs every 30s. Each step
 // re-derives its state from the database and is idempotent, so they carry no
 // intra-tick ordering dependency — which is what makes per-step isolation
-// sound: one failing sweep costs one tick of itself, never the other ten.
+// sound: one failing sweep costs one tick of itself, never the other eleven.
 // (A single poisoned rehome row once silenced the whole chained form
 // fleet-wide.) Sweep failures are logged, never fed into the rehome worker's
 // dispatch-failure budget: a sweep exception is not a dispatch failure and
@@ -17,6 +17,7 @@ export type AssignmentCleanupStore = {
   abortExpiredRegionalRehomes(): Promise<unknown>
   reapRegionalRehomeAttempts(): Promise<unknown>
   releaseExpiredActivityLeases(): Promise<unknown>
+  pruneReleasedControlReservations(): Promise<unknown>
   releaseExpiredActivity(): Promise<unknown>
   releaseExpiredRegionPreferences(): Promise<unknown>
   evacuateDeadCells(): Promise<unknown>
@@ -34,6 +35,10 @@ function assignmentCleanupSteps(
     ['abort-expired-regional-rehomes', () => assignments.abortExpiredRegionalRehomes()],
     ['reap-regional-rehome-attempts', () => assignments.reapRegionalRehomeAttempts()],
     ['release-expired-activity-leases', () => assignments.releaseExpiredActivityLeases()],
+    [
+      'prune-released-control-reservations',
+      () => assignments.pruneReleasedControlReservations()
+    ],
     ['release-expired-activity', () => assignments.releaseExpiredActivity()],
     ['release-expired-region-preferences', () => assignments.releaseExpiredRegionPreferences()],
     ['evacuate-dead-cells', () => assignments.evacuateDeadCells()]
diff --git a/cloud/apps/relay/src/assignment-store.ts b/cloud/apps/relay/src/assignment-store.ts
index e9e9d7b507c..14c3e50a0dc 100644
--- a/cloud/apps/relay/src/assignment-store.ts
+++ b/cloud/apps/relay/src/assignment-store.ts
@@ -1,4 +1,5 @@
 import { createDrainMigrationRowLookup } from './drain-migration-row-lookup.js'
+import { HeapWindowReaper } from './heap-window-reaper.js'
 import {
   selectIdleRegionalRehomes,
   type IdleRegionalRehomeCandidate,
@@ -498,6 +499,19 @@ export class RelayHomeCellUnavailableError extends Error {
 // never return otherwise starves connection headroom fleet-wide and turns
 // every placement into relay_capacity_exhausted.
 const LATE_ARRIVAL_DEBT_RETENTION_MS = 10 * 60 * 1_000
+// A released reservation is read by nothing: every reader filters it out by state, and the only
+// statement that still touches it is the per-host lock, which just makes that lock set longer. A day
+// is margin for forensics, not for reads.
+export const RELEASED_CONTROL_RESERVATION_RETENTION_MS = 24 * 60 * 60 * 1_000
+// ~27 rows per page, so a statement deletes a few hundred rows at most. With ~9 director ticks a
+// minute the row cap is ~5M rows a day: the 13.7M-row backlog drains over about three days, and a
+// walk that finds nothing reads ~1 MB a tick.
+const RELEASED_CONTROL_RESERVATION_REAP_BUDGET = {
+  pagesPerStatement: 16,
+  maxPagesPerTick: 128,
+  maxRowsPerTick: 400,
+  budgetMs: 250
+}
 const CELL_FENCE_TTL_MS = 5 * 60 * 1_000
 const CELL_FENCE_ATTEMPT_TTL_MS = 60 * 60 * 1_000
 const CELL_DRAIN_SEND_PERMIT_MS = 30_000
@@ -541,6 +555,11 @@ export class RelayAssignmentStore {
   private readonly admissionSelector: RelayCellAdmissionSelector
   private readonly migrationCellRegistrar: RelayMigrationCellRegistrar
   private readonly activityQueue = new AssignmentIdentityQueue()
+  private readonly releasedReservationReaper = new HeapWindowReaper(
+    'relay_control_connection_reservations',
+    `state = 'released' AND released_at <= ?`,
+    RELEASED_CONTROL_RESERVATION_REAP_BUDGET
+  )
   private assignmentTail: Promise<void> = Promise.resolve()
 
   constructor(
@@ -2944,6 +2963,10 @@ export class RelayAssignmentStore {
   async evacuateDeadCells(limit = 100): Promise<number> {
     if (!this.requireLiveCells) return 0
     const cutoff = this.now() - this.heartbeatTtlMs
+    const cellIds = await this.deadCellEvacuationCandidates(cutoff)
+    // Why: without a candidate cell the host query below walks every assignment by primary key to
+    // return nothing (574 ms per call in production, from stale existing-only cells it can never act on).
+    if (cellIds.length === 0) return 0
     const rows = await this.database.query(
       `SELECT assignment.user_id, assignment.relay_host_id, assignment.cell_id
        FROM relay_assignments assignment
@@ -3006,8 +3029,9 @@ export class RelayAssignmentStore {
              AND fence.expires_at > ?
            )
          )
+         AND assignment.cell_id IN (${cellIds.map(() => '?').join(', ')})
        ORDER BY assignment.user_id, assignment.relay_host_id LIMIT ?`,
-      [1, cutoff, this.now(), this.now(), limit]
+      [1, cutoff, this.now(), this.now(), ...cellIds, limit]
     )
     let moved = 0
     for (const row of rows) {
@@ -3034,6 +3058,43 @@ export class RelayAssignmentStore {
     return moved
   }
 
+  // The cell-level half of evacuateDeadCells' predicate, so it is a superset: every cell the host
+  // query could act on is here, and only the per-host pin checks are left out.
+  private async deadCellEvacuationCandidates(cutoff: number): Promise<string[]> {
+    const now = this.now()
+    const rows = await this.database.query(
+      `SELECT cell.cell_id
+       FROM relay_cells cell
+       LEFT JOIN relay_cell_committed_fences committed ON committed.cell_id = cell.cell_id
+       LEFT JOIN relay_cell_fence_attempts attempt ON attempt.attempt_id = committed.attempt_id
+       LEFT JOIN relay_cell_fences fence ON fence.cell_id = cell.cell_id
+       LEFT JOIN relay_cell_runtime runtime ON runtime.cell_id = cell.cell_id
+       WHERE (runtime.cell_id IS NULL OR runtime.ready != ? OR runtime.last_heartbeat_at <= ?)
+         AND (
+           (
+             cell.enabled = 1
+             AND NOT EXISTS (
+               SELECT 1 FROM relay_cell_connection_limits limits
+               WHERE limits.cell_id = cell.cell_id
+             )
+           )
+           OR (
+             cell.enabled = 0
+             AND attempt.completed_at IS NOT NULL
+             AND attempt.aborted_at IS NULL
+             AND committed.cell_incarnation = runtime.cell_incarnation
+             AND fence.cell_incarnation = committed.cell_incarnation
+             AND committed.attested_at >= runtime.last_heartbeat_at
+             AND committed.expires_at > ?
+             AND fence.expires_at > ?
+           )
+         )
+       ORDER BY cell.cell_id`,
+      [1, cutoff, now, now]
+    )
+    return rows.map((row) => text(row, 'cell_id'))
+  }
+
   async configureCell(
     cell: RelayCellConfig,
     admission: boolean | CellAdmissionState
@@ -7158,6 +7219,12 @@ export class RelayAssignmentStore {
     return aborted
   }
 
+  async pruneReleasedControlReservations(): Promise<number> {
+    return await this.releasedReservationReaper.reap(this.database, [
+      this.now() - RELEASED_CONTROL_RESERVATION_RETENTION_MS
+    ])
+  }
+
   async releaseExpiredActivityLeases(): Promise<number> {
     const now = this.now()
     await this.database.query(
diff --git a/cloud/apps/relay/src/credential-cleanup-sweep-postgres.test.ts b/cloud/apps/relay/src/credential-cleanup-sweep-postgres.test.ts
index 45f38326d3a..1736959bd3f 100644
--- a/cloud/apps/relay/src/credential-cleanup-sweep-postgres.test.ts
+++ b/cloud/apps/relay/src/credential-cleanup-sweep-postgres.test.ts
@@ -1,6 +1,11 @@
 import pg from 'pg'
 import { afterAll, beforeEach, describe, expect, it } from 'vitest'
-import { RelayCredentialStore, type RelayIdentity } from './credential-store.js'
+import {
+  AUDIT_EVENT_RETENTION_MS,
+  CONFIRM_RESULT_RETENTION_MS,
+  RelayCredentialStore,
+  type RelayIdentity
+} from './credential-store.js'
 import { openRelayDatabase, type RelayDatabase } from './database.js'
 
 // The outage this guards against: the credential cleanup ran every 30s in all 23 cells and both
@@ -169,9 +174,9 @@ describePostgres('credential cleanup against PostgreSQL', () => {
     await database.query(`ANALYZE relay_connection_bases`)
 
     const reaper = await plan(
-      `DELETE FROM relay_connection_bases WHERE ctid IN (
+      `DELETE FROM relay_connection_bases WHERE ctid = ANY(ARRAY(
          SELECT ctid FROM relay_connection_bases WHERE active = ? AND deadline <= ? LIMIT 5000
-       )`,
+       ))`,
       [0, NOW - DAY_MS]
     )
 
@@ -280,4 +285,55 @@ describePostgres('credential cleanup against PostgreSQL', () => {
       { state: 'invalidated', total: '3' }
     ])
   })
+
+  it('plans the audit reaper off relay_audit_events_at when most rows are past retention', async () => {
+    // Unordered, a LIMIT with this many matches is cheapest as a sequential scan from page 0, which
+    // in production would reread every retained row once the oldest pages are reaped.
+    await database.query(
+      `INSERT INTO relay_audit_events (id, at, type, user_id, relay_host_id, detail_json)
+       SELECT 'old-' || n, ?, 'resume-confirmed', ?, ?, '{}' FROM generate_series(1, 20000) AS n`,
+      [NOW - AUDIT_EVENT_RETENTION_MS - DAY_MS, identity.userId, identity.relayHostId]
+    )
+    await database.query(`ANALYZE relay_audit_events`)
+
+    const reaper = await plan(
+      `DELETE FROM relay_audit_events WHERE ctid = ANY(ARRAY(
+         SELECT ctid FROM relay_audit_events WHERE at <= ? ORDER BY at LIMIT 5000
+       ))`,
+      [NOW - AUDIT_EVENT_RETENTION_MS]
+    )
+
+    expect(reaper).toContain('relay_audit_events_at')
+    expect(reaper).not.toContain('Seq Scan on relay_audit_events')
+  })
+
+  it('reaps old confirm results and audit events and keeps the ones inside retention', async () => {
+    await database.query(
+      `INSERT INTO relay_confirm_results
+       (user_id, relay_host_id, req_id, basis_conn_id, tuple_json, result_json, committed_at)
+       SELECT ?, ?, 'old-' || n, 'basis-1', '{}', '{}', ? FROM generate_series(1, 200) AS n`,
+      [identity.userId, identity.relayHostId, NOW - CONFIRM_RESULT_RETENTION_MS - 1]
+    )
+    await database.query(
+      `INSERT INTO relay_confirm_results
+       (user_id, relay_host_id, req_id, basis_conn_id, tuple_json, result_json, committed_at)
+       VALUES (?, ?, 'recent', 'basis-1', '{}', '{}', ?)`,
+      [identity.userId, identity.relayHostId, NOW - DAY_MS]
+    )
+    await database.query(
+      `INSERT INTO relay_audit_events (id, at, type, user_id, relay_host_id, detail_json)
+       VALUES ('old', ?, 'resume-confirmed', ?, ?, '{}'), ('recent', ?, 'resume-confirmed', ?, ?, '{}')`,
+      [
+        NOW - AUDIT_EVENT_RETENTION_MS - 1, identity.userId, identity.relayHostId,
+        NOW - DAY_MS, identity.userId, identity.relayHostId
+      ]
+    )
+
+    await store.cleanup()
+
+    expect(await database.query(`SELECT req_id FROM relay_confirm_results`)).toEqual([
+      { req_id: 'recent' }
+    ])
+    expect(await database.query(`SELECT id FROM relay_audit_events`)).toEqual([{ id: 'recent' }])
+  })
 })
diff --git a/cloud/apps/relay/src/credential-store-cleanup.test.ts b/cloud/apps/relay/src/credential-store-cleanup.test.ts
index ba9e7be7475..7d0e70a41dd 100644
--- a/cloud/apps/relay/src/credential-store-cleanup.test.ts
+++ b/cloud/apps/relay/src/credential-store-cleanup.test.ts
@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { RelayCredentialStore, type RelayIdentity } from './credential-store.js'
+import {
+  AUDIT_EVENT_RETENTION_MS,
+  CONFIRM_RESULT_RETENTION_MS,
+  RelayCredentialStore,
+  type RelayIdentity
+} from './credential-store.js'
 import { openInMemoryRelayDatabase, type RelayDatabase } from './database.js'
 
 const identity: RelayIdentity = { userId: 'user-1', relayHostId: 'abcdefghijklmnop' }
@@ -71,6 +76,29 @@ async function insertDirectAuthorization(
   )
 }
 
+async function insertConfirmResult(
+  database: RelayDatabase,
+  result: { reqId: string; committedAt: number }
+): Promise<void> {
+  await database.query(
+    `INSERT INTO relay_confirm_results
+     (user_id, relay_host_id, req_id, basis_conn_id, tuple_json, result_json, committed_at)
+     VALUES (?, ?, ?, 'basis-1', '{}', '{}', ?)`,
+    [identity.userId, identity.relayHostId, result.reqId, result.committedAt]
+  )
+}
+
+async function insertAuditEvent(
+  database: RelayDatabase,
+  event: { id: string; at: number }
+): Promise<void> {
+  await database.query(
+    `INSERT INTO relay_audit_events (id, at, type, user_id, relay_host_id, detail_json)
+     VALUES (?, ?, 'resume-confirmed', ?, ?, '{}')`,
+    [event.id, event.at, identity.userId, identity.relayHostId]
+  )
+}
+
 async function remainingIds(database: RelayDatabase, table: string, column: string): Promise<string[]> {
   const rows = await database.query(`SELECT ${column} FROM ${table} ORDER BY ${column}`)
   return rows.map((row) => String(row[column]))
@@ -294,4 +322,46 @@ describe('credential cleanup invite reaper', () => {
     expect(await remainingIds(database, 'relay_direct_authorizations', 'direct_auth_id')).toEqual([])
     await database.close()
   })
+
+  it('reaps confirm results and audit events only past their retention windows', async () => {
+    const database = await openInMemoryRelayDatabase()
+    const store = new RelayCredentialStore(database, () => NOW)
+    await insertConfirmResult(database, { reqId: 'confirm-old', committedAt: NOW - CONFIRM_RESULT_RETENTION_MS })
+    await insertConfirmResult(database, {
+      reqId: 'confirm-recent',
+      committedAt: NOW - CONFIRM_RESULT_RETENTION_MS + 1
+    })
+    await insertAuditEvent(database, { id: 'audit-old', at: NOW - AUDIT_EVENT_RETENTION_MS })
+    await insertAuditEvent(database, { id: 'audit-recent', at: NOW - AUDIT_EVENT_RETENTION_MS + 1 })
+
+    await store.cleanup()
+
+    expect(await remainingIds(database, 'relay_confirm_results', 'req_id')).toEqual(['confirm-recent'])
+    expect(await remainingIds(database, 'relay_audit_events', 'id')).toEqual(['audit-recent'])
+    await database.close()
+  })
+
+  it('still replays a confirm result inside retention', async () => {
+    // The one reader: a retried confirm on the same basis gets the stored answer back.
+    const database = await openInMemoryRelayDatabase()
+    const store = new RelayCredentialStore(database, () => NOW)
+    await database.query(
+      `INSERT INTO relay_confirm_results
+       (user_id, relay_host_id, req_id, basis_conn_id, tuple_json, result_json, committed_at)
+       VALUES (?, ?, 'confirm-1', 'basis-1', '{}', ?, ?)`,
+      [identity.userId, identity.relayHostId, JSON.stringify({ v: 1, reqId: 'confirm-1' }), NOW - DAY_MS]
+    )
+
+    await store.cleanup()
+
+    expect(
+      await store.confirmResume({
+        ...identity,
+        reqId: 'confirm-1',
+        basisConnId: 'basis-1',
+        owningControlGeneration: 1
+      })
+    ).toEqual({ v: 1, reqId: 'confirm-1' })
+    await database.close()
+  })
 })
diff --git a/cloud/apps/relay/src/credential-store.ts b/cloud/apps/relay/src/credential-store.ts
index 8d1281bb3c5..8d17ba623f3 100644
--- a/cloud/apps/relay/src/credential-store.ts
+++ b/cloud/apps/relay/src/credential-store.ts
@@ -6,6 +6,7 @@ import {
   type DeviceResumeConfirmed
 } from '@orca-cloud/relay-contract'
 import type { RelayDatabase, SqlRow } from './database.js'
+import { HeapWindowReaper } from './heap-window-reaper.js'
 
 const CREDENTIAL_GRACE_MS = 24 * 60 * 60 * 1000
 // Released desktops validate invite expiry against their own clock with zero
@@ -20,9 +21,23 @@ const TERMINAL_INVITE_RETENTION_MS = 7 * 24 * 60 * 60 * 1000
 // active/unconsumed AND inside its deadline, and every deadline is set at most 30s past insert, so
 // a settled row can never authorize anything again. A day is margin for forensics, not for reads.
 const INACTIVE_AUTHORIZATION_RETENTION_MS = 24 * 60 * 60 * 1000
+// A stored confirm result only answers a retry of the same request on the same connection basis,
+// and a different basis is refused as a tuple mismatch; a basis lives for one phone connection. A
+// week matches the pairing support window above.
+export const CONFIRM_RESULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000
+// Nothing in the relay reads audit events back; 90 days covers support and incident questions.
+export const AUDIT_EVENT_RETENTION_MS = 90 * 24 * 60 * 60 * 1000
 // Bounded so one cycle cannot hold row locks or grow WAL without limit; the backlog drains over
 // however many cycles it takes.
 const REAP_BATCH_ROWS = 5000
+// ~14 rows per page. With ~9 director ticks a minute the row cap is ~3M rows a day, so the 7.4M-row
+// backlog drains over two to three days; a walk that finds nothing reads ~1 MB a tick.
+const CONFIRM_RESULT_REAP_BUDGET = {
+  pagesPerStatement: 16,
+  maxPagesPerTick: 128,
+  maxRowsPerTick: 250,
+  budgetMs: 250
+}
 
 export type RelayIdentity = { userId: string; relayHostId: string }
 export type CredentialReservation = RelayIdentity & {
@@ -81,6 +96,13 @@ function string(row: SqlRow, field: string): string {
 }
 
 export class RelayCredentialStore {
+  // committed_at has no index, so a LIMIT delete would plan as a sequential scan of the whole table.
+  private readonly confirmResultReaper = new HeapWindowReaper(
+    'relay_confirm_results',
+    'committed_at <= ?',
+    CONFIRM_RESULT_REAP_BUDGET
+  )
+
   constructor(
     private readonly database: RelayDatabase,
     private readonly now: () => number = Date.now
@@ -680,16 +702,29 @@ export class RelayCredentialStore {
       'consumed_at IS NOT NULL AND consumed_at <= ?',
       [now - INACTIVE_AUTHORIZATION_RETENTION_MS]
     )
+    await this.confirmResultReaper.reap(this.database, [now - CONFIRM_RESULT_RETENTION_MS])
+    // Ordered so the plan walks relay_audit_events_at from its oldest entry: unordered, a LIMIT
+    // can plan as a sequential scan that rereads the retained rows before reaching the old ones.
+    await this.reapBatch('relay_audit_events', 'at <= ?', [now - AUDIT_EVENT_RETENTION_MS], 'at')
   }
 
   // ctid/rowid, not the primary key: the physical address lets the delete re-find exactly the batch
-  // the subquery located instead of re-matching the predicate per row.
-  private async reapBatch(table: string, predicate: string, params: unknown[]): Promise<void> {
-    const address = this.database.dialect === 'sqlite' ? 'rowid' : 'ctid'
+  // the subquery located instead of re-matching the predicate per row. On Postgres an array of TIDs,
+  // not `IN`: IN can plan as a hash join over a sequential scan of the whole table.
+  private async reapBatch(
+    table: string,
+    predicate: string,
+    params: unknown[],
+    orderBy?: string
+  ): Promise<void> {
+    const sqlite = this.database.dialect === 'sqlite'
+    const address = sqlite ? 'rowid' : 'ctid'
+    const order = orderBy ? `ORDER BY ${orderBy} ` : ''
+    const batch = `SELECT ${address} FROM ${table} WHERE ${predicate} ${order}LIMIT ${REAP_BATCH_ROWS}`
     await this.database.query(
-      `DELETE FROM ${table} WHERE ${address} IN (
-         SELECT ${address} FROM ${table} WHERE ${predicate} LIMIT ${REAP_BATCH_ROWS}
-       )`,
+      sqlite
+        ? `DELETE FROM ${table} WHERE rowid IN (${batch})`
+        : `DELETE FROM ${table} WHERE ctid = ANY(ARRAY(${batch}))`,
       params
     )
   }
diff --git a/cloud/apps/relay/src/database.test.ts b/cloud/apps/relay/src/database.test.ts
index 0c987f95d40..bfeff59c69f 100644
--- a/cloud/apps/relay/src/database.test.ts
+++ b/cloud/apps/relay/src/database.test.ts
@@ -68,7 +68,6 @@ describe('relay database', () => {
       'relay_cell_connection_runtime',
       'relay_cell_connection_snapshots',
       'relay_cell_drain_attempt_states',
-      'relay_cell_drain_attempts',
       'relay_cell_drain_recovery_attempts',
       'relay_cell_fence_apply_invocations',
       'relay_cell_fence_attempts',
@@ -80,7 +79,6 @@ describe('relay database', () => {
       'relay_cell_runtime',
       'relay_cells',
       'relay_confirm_results',
-      'relay_confirmable_splices',
       'relay_connection_bases',
       'relay_control_capabilities',
       'relay_control_connection_reservations',
@@ -88,7 +86,6 @@ describe('relay database', () => {
       'relay_direct_authorizations',
       'relay_install_results',
       'relay_invites',
-      'relay_migration_leases',
       'relay_post_drain_migration_pins',
       'relay_rate_windows',
       'relay_region_decisions',
diff --git a/cloud/apps/relay/src/database.ts b/cloud/apps/relay/src/database.ts
index 6a8a1fc202a..dbc5e88df8c 100644
--- a/cloud/apps/relay/src/database.ts
+++ b/cloud/apps/relay/src/database.ts
@@ -94,6 +94,10 @@ export interface RelayDatabase {
 // Constraint swaps are matched by NAME in pg_constraint, never by body, because the CHECK list is
 // generated from REGION_LIST. Changing a constraint's definition under the same name therefore does
 // nothing on boot: an operator drops it, and the next boot adds the current definition back.
+// relay_confirmable_splices, relay_cell_drain_attempts and relay_migration_leases are no longer
+// created; nothing ever wrote them. Databases that have them keep them empty until a drop is safe:
+// an older image still creates them at boot, and a drop racing that CREATE can fail its schema step.
+// Account erasure in orca-cloud must be deployed with retired-table support (orca-cloud#493) first.
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS relay_invites (
   user_id TEXT NOT NULL,
@@ -154,19 +158,6 @@ CREATE TABLE IF NOT EXISTS relay_install_results (
   PRIMARY KEY (user_id, relay_host_id, relay_device_id, req_id)
 );
 
-CREATE TABLE IF NOT EXISTS relay_confirmable_splices (
-  basis_conn_id TEXT PRIMARY KEY,
-  user_id TEXT NOT NULL,
-  relay_host_id TEXT NOT NULL,
-  owning_control_generation BIGINT NOT NULL,
-  relay_device_id TEXT NOT NULL,
-  accepted_credential_version BIGINT NOT NULL,
-  accepted_as TEXT NOT NULL,
-  confirm_deadline BIGINT NOT NULL,
-  active BIGINT NOT NULL,
-  created_at BIGINT NOT NULL
-);
-
 CREATE TABLE IF NOT EXISTS relay_connection_bases (
   basis_conn_id TEXT PRIMARY KEY,
   user_id TEXT NOT NULL,
@@ -507,15 +498,6 @@ CREATE TABLE IF NOT EXISTS relay_cell_fence_apply_invocations (
 CREATE INDEX IF NOT EXISTS relay_cell_fence_apply_invocations_attempt
   ON relay_cell_fence_apply_invocations(attempt_id, started_at);
 
-CREATE TABLE IF NOT EXISTS relay_cell_drain_attempts (
-  cell_id TEXT PRIMARY KEY,
-  cell_incarnation TEXT NOT NULL,
-  planned_grace_ms BIGINT NOT NULL,
-  attempted_at BIGINT NOT NULL,
-  retry_after BIGINT NOT NULL,
-  recover_forward_attempted_at BIGINT
-);
-
 CREATE TABLE IF NOT EXISTS relay_cell_drain_attempt_states (
   attempt_id TEXT PRIMARY KEY,
   cell_id TEXT NOT NULL,
@@ -605,17 +587,6 @@ CREATE TABLE IF NOT EXISTS relay_rate_windows (
 CREATE INDEX IF NOT EXISTS relay_rate_windows_started
   ON relay_rate_windows(window_started_at);
 
-CREATE TABLE IF NOT EXISTS relay_migration_leases (
-  user_id TEXT NOT NULL,
-  relay_host_id TEXT NOT NULL,
-  source_cell_id TEXT NOT NULL,
-  target_cell_id TEXT NOT NULL,
-  assignment_epoch BIGINT NOT NULL,
-  expires_at BIGINT NOT NULL,
-  completed_at BIGINT,
-  PRIMARY KEY (user_id, relay_host_id, assignment_epoch)
-);
-
 CREATE TABLE IF NOT EXISTS relay_assignment_migrations (
   user_id TEXT NOT NULL,
   relay_host_id TEXT NOT NULL,
@@ -741,7 +712,6 @@ const POSTGRES_TRANSACTION_PHASES = [
   ['relay_region_rehome_', 'regional-rehome'],
   ['relay_assignment_activity_leases', 'activity-lease'],
   ['relay_assignment_migration', 'migration'],
-  ['relay_migration_leases', 'migration'],
   ['relay_post_drain_migration_pins', 'migration'],
   ['relay_cell_connection_runtime', 'cell-runtime'],
   ['relay_cell_connection_snapshots', 'cell-runtime'],
@@ -753,7 +723,6 @@ const POSTGRES_TRANSACTION_PHASES = [
   ['relay_admission_selector', 'admission'],
   ['relay_cell_admission', 'admission'],
   ['relay_control_connection_reservations', 'connection'],
-  ['relay_confirmable_splices', 'connection'],
   ['relay_connection_bases', 'connection'],
   ['relay_direct_authorizations', 'connection'],
   ['relay_confirm_results', 'connection'],
diff --git a/cloud/apps/relay/src/dead-cell-evacuation-precheck.test.ts b/cloud/apps/relay/src/dead-cell-evacuation-precheck.test.ts
new file mode 100644
index 00000000000..c7958a5b5a7
--- /dev/null
+++ b/cloud/apps/relay/src/dead-cell-evacuation-precheck.test.ts
@@ -0,0 +1,154 @@
+import pg from 'pg'
+import { afterAll, afterEach, describe, expect, it } from 'vitest'
+import { RelayAssignmentStore } from './assignment-store.js'
+import type { RelayCellConfig } from './config.js'
+import {
+  openInMemoryRelayDatabase,
+  openRelayDatabase,
+  type RelayDatabase,
+  type SqlRow
+} from './database.js'
+
+// The sweep's host query walked every assignment by primary key to return nothing while stale
+// existing-only cells sat in the fleet. These pin that a fleet with nothing to evacuate never
+// reaches it, and that a cell the sweep can act on still does, on both dialects.
+const databaseUrl = process.env.ORCA_RELAY_TEST_POSTGRES_URL
+const schema = 'relay_dead_cell_precheck_test'
+const HOST_QUERY = 'FROM relay_assignments assignment'
+const CELLS: RelayCellConfig[] = [
+  { id: 'cell-a', url: 'https://relay-a.example.com', capacityRequests: 10 },
+  { id: 'cell-b', url: 'https://relay-b.example.com', capacityRequests: 10 }
+]
+
+class RecordingDatabase implements RelayDatabase {
+  readonly statements: string[] = []
+
+  constructor(private readonly delegate: RelayDatabase) {}
+
+  get dialect() {
+    return this.delegate.dialect
+  }
+
+  async query(sql: string, params: unknown[] = []): Promise<SqlRow[]> {
+    this.statements.push(sql)
+    return await this.delegate.query(sql, params)
+  }
+
+  async queryLocked(...args: Parameters<RelayDatabase['queryLocked']>): Promise<SqlRow[]> {
+    return await this.delegate.queryLocked(...args)
+  }
+
+  async transaction<T>(operation: (transaction: RelayDatabase) => Promise<T>): Promise<T> {
+    return await this.delegate.transaction(operation)
+  }
+
+  async close(): Promise<void> {
+    await this.delegate.close()
+  }
+}
+
+function scopedUrl(): string {
+  const url = new URL(databaseUrl!)
+  url.searchParams.set('options', `-c search_path=${schema}`)
+  return url.toString()
+}
+
+async function onAdmin(sql: string): Promise<void> {
+  const client = new pg.Client({ connectionString: databaseUrl })
+  await client.connect()
+  try {
+    await client.query(sql)
+  } finally {
+    await client.end()
+  }
+}
+
+const dialects: [string, () => Promise<RelayDatabase>][] = [
+  ['sqlite', openInMemoryRelayDatabase],
+  ...(databaseUrl
+    ? [
+        [
+          'postgres',
+          async () => {
+            await onAdmin(`DROP SCHEMA IF EXISTS ${schema} CASCADE`)
+            await onAdmin(`CREATE SCHEMA ${schema}`)
+            return await openRelayDatabase({ databaseUrl: scopedUrl(), dataDir: '' })
+          }
+        ] as [string, () => Promise<RelayDatabase>]
+      ]
+    : [])
+]
+
+describe.each(dialects)('dead-cell evacuation pre-check (%s)', (_dialect, open) => {
+  let database: RelayDatabase | undefined
+
+  afterEach(async () => {
+    await database?.close()
+    database = undefined
+  })
+
+  afterAll(async () => {
+    if (databaseUrl) await onAdmin(`DROP SCHEMA IF EXISTS ${schema} CASCADE`)
+  })
+
+  async function setup(now: () => number) {
+    database = await open()
+    const recording = new RecordingDatabase(database)
+    const store = new RelayAssignmentStore(recording, now, {
+      requireLiveCells: true,
+      heartbeatTtlMs: 45_000
+    })
+    await store.reconcileCells(CELLS)
+    return { store, recording }
+  }
+
+  async function heartbeat(store: RelayAssignmentStore, cell: RelayCellConfig): Promise<void> {
+    await store.recordCellHeartbeat({
+      cellId: cell.id,
+      cellUrl: cell.url,
+      cellIncarnation: '11111111-1111-4111-8111-111111111111',
+      startedAt: 50,
+      ready: true,
+      observedRequests: 0
+    })
+  }
+
+  it('skips the host query when the only dead cell is unfenced and existing-only', async () => {
+    let now = 100
+    const { store, recording } = await setup(() => now)
+    for (const cell of CELLS) await heartbeat(store, cell)
+    const identity = { userId: 'user-a', relayHostId: 'host000000000001' }
+    await store.setCellEnabled('cell-b', false)
+    expect(await store.assign(identity)).toMatchObject({ cellId: 'cell-a' })
+    await store.setCellEnabled('cell-b', true)
+    await store.setCellEnabled('cell-a', false)
+    now += 45_001
+    await heartbeat(store, CELLS[1]!)
+    recording.statements.length = 0
+
+    expect(await store.evacuateDeadCells()).toBe(0)
+    expect(recording.statements.some((sql) => sql.includes(HOST_QUERY))).toBe(false)
+    expect(
+      await database!.query(`SELECT cell_id FROM relay_assignments WHERE user_id = ?`, [
+        identity.userId
+      ])
+    ).toEqual([{ cell_id: 'cell-a' }])
+  })
+
+  it('still evacuates hosts from a dead uncapped cell that admits', async () => {
+    let now = 100
+    const { store, recording } = await setup(() => now)
+    for (const cell of CELLS) await heartbeat(store, cell)
+    const identity = { userId: 'user-a', relayHostId: 'host000000000001' }
+    await store.setCellEnabled('cell-b', false)
+    expect(await store.assign(identity)).toMatchObject({ cellId: 'cell-a' })
+    await store.setCellEnabled('cell-b', true)
+    now += 45_001
+    await heartbeat(store, CELLS[1]!)
+    recording.statements.length = 0
+
+    expect(await store.evacuateDeadCells()).toBe(1)
+    expect(recording.statements.some((sql) => sql.includes(HOST_QUERY))).toBe(true)
+    expect((await store.resolve(identity))?.cellId).toBe('cell-b')
+  })
+})
diff --git a/cloud/apps/relay/src/dead-relay-tables-postgres.test.ts b/cloud/apps/relay/src/dead-relay-tables-postgres.test.ts
new file mode 100644
index 00000000000..101570c782e
--- /dev/null
+++ b/cloud/apps/relay/src/dead-relay-tables-postgres.test.ts
@@ -0,0 +1,83 @@
+import pg from 'pg'
+import { afterAll, describe, expect, it } from 'vitest'
+import { openRelayDatabase } from './database.js'
+
+// Three tables were created at every boot and never written. The schema stops creating them, and
+// a database that already has them must still boot, because they stay until a separate drop.
+const databaseUrl = process.env.ORCA_RELAY_TEST_POSTGRES_URL
+const describePostgres = databaseUrl ? describe : describe.skip
+const schema = 'relay_dead_tables_test'
+const DEAD_TABLES = [
+  'relay_confirmable_splices',
+  'relay_cell_drain_attempts',
+  'relay_migration_leases'
+]
+
+function scopedUrl(): string {
+  const url = new URL(databaseUrl!)
+  url.searchParams.set('options', `-c search_path=${schema}`)
+  return url.toString()
+}
+
+async function onScoped<T>(operation: (client: pg.Client) => Promise<T>): Promise<T> {
+  const client = new pg.Client({ connectionString: scopedUrl() })
+  await client.connect()
+  try {
+    return await operation(client)
+  } finally {
+    await client.end()
+  }
+}
+
+async function resetSchema(): Promise<void> {
+  const client = new pg.Client({ connectionString: databaseUrl })
+  await client.connect()
+  try {
+    await client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`)
+    await client.query(`CREATE SCHEMA ${schema}`)
+  } finally {
+    await client.end()
+  }
+}
+
+async function existingDeadTables(): Promise<string[]> {
+  return await onScoped(async (client) => {
+    const rows = await client.query(
+      `SELECT table_name FROM information_schema.tables
+       WHERE table_schema = $1 AND table_name = ANY($2) ORDER BY table_name`,
+      [schema, DEAD_TABLES]
+    )
+    return rows.rows.map((row) => String(row.table_name))
+  })
+}
+
+describePostgres('removed relay tables against PostgreSQL', () => {
+  afterAll(async () => {
+    const client = new pg.Client({ connectionString: databaseUrl })
+    await client.connect()
+    await client.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`)
+    await client.end()
+  })
+
+  it('does not create the removed tables on a fresh database', async () => {
+    await resetSchema()
+    const database = await openRelayDatabase({ databaseUrl: scopedUrl(), dataDir: '' })
+    await database.close()
+
+    expect(await existingDeadTables()).toEqual([])
+  })
+
+  it('boots on a database an older image created, leaving those tables alone', async () => {
+    await resetSchema()
+    await onScoped(async (client) => {
+      await client.query(`CREATE TABLE relay_confirmable_splices (basis_conn_id TEXT PRIMARY KEY)`)
+      await client.query(`CREATE TABLE relay_cell_drain_attempts (cell_id TEXT PRIMARY KEY)`)
+      await client.query(`CREATE TABLE relay_migration_leases (user_id TEXT NOT NULL)`)
+    })
+
+    const database = await openRelayDatabase({ databaseUrl: scopedUrl(), dataDir: '' })
+    await database.close()
+
+    expect(await existingDeadTables()).toEqual([...DEAD_TABLES].sort())
+  })
+})
diff --git a/cloud/apps/relay/src/heap-window-reaper.ts b/cloud/apps/relay/src/heap-window-reaper.ts
new file mode 100644
index 00000000000..3e7a1dd74cf
--- /dev/null
+++ b/cloud/apps/relay/src/heap-window-reaper.ts
@@ -0,0 +1,90 @@
+import { performance } from 'node:perf_hooks'
+import type { RelayDatabase, SqlRow } from './database.js'
+
+export type HeapWindowReapBudget = {
+  // Pages one DELETE may visit, so its row locks and WAL stay a few hundred rows.
+  pagesPerStatement: number
+  // Pages one tick may visit while it finds nothing to delete.
+  maxPagesPerTick: number
+  // Rows one tick deletes before it stops; this is what paces a backlog over days.
+  maxRowsPerTick: number
+  budgetMs: number
+}
+
+// Why a TID range and not `WHERE <retention> LIMIT n`: these tables have no index on their
+// retention column, so the planner answers LIMIT with a sequential scan from page 0 (production
+// EXPLAIN, 2026-10-04). That scan gets longer every tick as the reaped head of the heap empties.
+// A TID range bounds each statement to its own pages whatever the table holds.
+export class HeapWindowReaper {
+  private nextPage: number | undefined
+
+  constructor(
+    private readonly table: string,
+    private readonly predicate: string,
+    private readonly budget: HeapWindowReapBudget,
+    private readonly random: () => number = Math.random,
+    private readonly clock: () => number = () => performance.now()
+  ) {}
+
+  async reap(database: RelayDatabase, params: unknown[]): Promise<number> {
+    if (database.dialect !== 'postgres') {
+      return changes(
+        await database.query(
+          `DELETE FROM ${this.table} WHERE rowid IN (
+             SELECT rowid FROM ${this.table} WHERE ${this.predicate}
+             LIMIT ${this.budget.maxRowsPerTick}
+           )`,
+          params
+        )
+      )
+    }
+    const pages = await heapPages(database, this.table)
+    if (pages === 0) return 0
+    // A random first page: every director runs this sweep, and walks that all start at page 0
+    // after a rollout would read the same pages in lockstep.
+    let page = this.nextPage ?? Math.floor(this.random() * pages)
+    const startedAt = this.clock()
+    let scanned = 0
+    let deleted = 0
+    while (
+      scanned < this.budget.maxPagesPerTick &&
+      deleted < this.budget.maxRowsPerTick &&
+      this.clock() - startedAt < this.budget.budgetMs
+    ) {
+      if (page >= pages) page = 0
+      const end = Math.min(page + this.budget.pagesPerStatement, pages)
+      // SKIP LOCKED: a row some request holds is left for a later pass rather than waited on.
+      // `= ANY(ARRAY(...))`, not `IN (...)`: IN can plan as a hash join over a sequential scan of
+      // the whole table; an array of TIDs is always a TID scan.
+      deleted += changes(
+        await database.query(
+          `DELETE FROM ${this.table} WHERE ctid = ANY(ARRAY(
+             SELECT ctid FROM ${this.table}
+             WHERE ctid >= CAST(? AS tid) AND ctid < CAST(? AS tid) AND ${this.predicate}
+             FOR UPDATE SKIP LOCKED
+           ))`,
+          [`(${page},0)`, `(${end},0)`, ...params]
+        )
+      )
+      scanned += end - page
+      page = end
+    }
+    this.nextPage = page
+    return deleted
+  }
+}
+
+async function heapPages(database: RelayDatabase, table: string): Promise<number> {
+  const row = (
+    await database.query(
+      `SELECT pg_relation_size(CAST(? AS regclass)) / current_setting('block_size')::bigint
+         AS pages`,
+      [table]
+    )
+  )[0]
+  return Number(row?.pages ?? 0)
+}
+
+function changes(rows: SqlRow[]): number {
+  return Number(rows[0]?.changes ?? 0)
+}
diff --git a/cloud/apps/relay/src/postgres-drain-send-locking.test.ts b/cloud/apps/relay/src/postgres-drain-send-locking.test.ts
index 024bf46db5e..26eec5013b0 100644
--- a/cloud/apps/relay/src/postgres-drain-send-locking.test.ts
+++ b/cloud/apps/relay/src/postgres-drain-send-locking.test.ts
@@ -42,9 +42,6 @@ describePostgres('PostgreSQL drain-send locking', () => {
       `DELETE FROM relay_control_connection_reservations WHERE user_id = ?`,
       [identity.userId]
     )
-    await database.query(`DELETE FROM relay_migration_leases WHERE user_id = ?`, [
-      identity.userId
-    ])
     await database.query(`DELETE FROM relay_assignment_activity_leases WHERE user_id = ?`, [
       identity.userId
     ])
diff --git a/cloud/apps/relay/src/released-reservation-prune.test.ts b/cloud/apps/relay/src/released-reservation-prune.test.ts
new file mode 100644
index 00000000000..9dc81c32391
--- /dev/null
+++ b/cloud/apps/relay/src/released-reservation-prune.test.ts
@@ -0,0 +1,236 @@
+import pg from 'pg'
+import { afterAll, afterEach, describe, expect, it } from 'vitest'
+import {
+  RelayAssignmentStore,
+  RELEASED_CONTROL_RESERVATION_RETENTION_MS
+} from './assignment-store.js'
+import {
+  openInMemoryRelayDatabase,
+  openRelayDatabase,
+  type RelayDatabase
+} from './database.js'
+import { HeapWindowReaper } from './heap-window-reaper.js'
+
+// Released reservations were never deleted: 13.7M rows and 9 GB in production, every one of them
+// still locked by each placement of its host. These pin what the prune may take and how it walks.
+const databaseUrl = process.env.ORCA_RELAY_TEST_POSTGRES_URL
+const describePostgres = databaseUrl ? describe : describe.skip
+const schema = 'relay_released_reservation_prune_test'
+const NOW = 100 * 24 * 60 * 60 * 1_000
+const STALE = NOW - RELEASED_CONTROL_RESERVATION_RETENTION_MS
+const PREDICATE = `state = 'released' AND released_at <= ?`
+
+function scopedUrl(): string {
+  const url = new URL(databaseUrl!)
+  url.searchParams.set('options', `-c search_path=${schema}`)
+  return url.toString()
+}
+
+async function onAdmin(sql: string): Promise<void> {
+  const client = new pg.Client({ connectionString: databaseUrl })
+  await client.connect()
+  try {
+    await client.query(sql)
+  } finally {
+    await client.end()
+  }
+}
+
+async function openPostgres(): Promise<RelayDatabase> {
+  await onAdmin(`DROP SCHEMA IF EXISTS ${schema} CASCADE`)
+  await onAdmin(`CREATE SCHEMA ${schema}`)
+  return await openRelayDatabase({ databaseUrl: scopedUrl(), dataDir: '' })
+}
+
+async function insertReservation(
+  database: RelayDatabase,
+  id: string,
+  state: string,
+  releasedAt: number | null
+): Promise<void> {
+  await database.query(
+    `INSERT INTO relay_control_connection_reservations
+     (reservation_id, idempotency_key, user_id, relay_host_id, assignment_epoch,
+      cell_id, state, created_at, timeout_at, released_at, updated_at)
+     VALUES (?, ?, 'user-1', 'host000000000001', 1, 'cell-a', ?, 1, 1, ?, 1)`,
+    [id, id, state, releasedAt]
+  )
+}
+
+async function remainingIds(database: RelayDatabase): Promise<string[]> {
+  const rows = await database.query(
+    `SELECT reservation_id FROM relay_control_connection_reservations ORDER BY reservation_id`
+  )
+  return rows.map((row) => String(row.reservation_id))
+}
+
+const dialects: [string, () => Promise<RelayDatabase>][] = [
+  ['sqlite', openInMemoryRelayDatabase],
+  ...(databaseUrl ? [['postgres', openPostgres] as [string, () => Promise<RelayDatabase>]] : [])
+]
+
+describe.each(dialects)('released reservation prune (%s)', (_dialect, open) => {
+  let database: RelayDatabase | undefined
+
+  afterEach(async () => {
+    await database?.close()
+    database = undefined
+  })
+
+  afterAll(async () => {
+    if (databaseUrl) await onAdmin(`DROP SCHEMA IF EXISTS ${schema} CASCADE`)
+  })
+
+  it('deletes only released rows older than the retention window', async () => {
+    database = await open()
+    await insertReservation(database, 'a-old-released', 'released', STALE - 1)
+    await insertReservation(database, 'b-edge-released', 'released', STALE)
+    await insertReservation(database, 'c-fresh-released', 'released', STALE + 1)
+    await insertReservation(database, 'd-reserved', 'reserved', null)
+    await insertReservation(database, 'e-debt', 'late-arrival-debt', null)
+    await insertReservation(database, 'f-claimed', 'claimed', null)
+    // A row that once was released and came back is judged by its state, not its timestamp.
+    await insertReservation(database, 'g-claimed-old-release', 'claimed', STALE - 1)
+    const store = new RelayAssignmentStore(database, () => NOW)
+
+    expect(await store.pruneReleasedControlReservations()).toBe(2)
+    expect(await remainingIds(database)).toEqual([
+      'c-fresh-released',
+      'd-reserved',
+      'e-debt',
+      'f-claimed',
+      'g-claimed-old-release'
+    ])
+  })
+})
+
+describePostgres('heap window reaper against PostgreSQL', () => {
+  let database: RelayDatabase
+  // 200 rows of this shape fill about two pages; 6,000 spread the table over ~60 pages.
+  const ROWS = 6_000
+
+  afterEach(async () => {
+    await database?.close()
+  })
+
+  afterAll(async () => {
+    await onAdmin(`DROP SCHEMA IF EXISTS ${schema} CASCADE`)
+  })
+
+  async function seed(): Promise<number> {
+    database = await openPostgres()
+    // Every third row is still live, so each page holds rows the walk must keep.
+    await database.query(
+      `INSERT INTO relay_control_connection_reservations
+       (reservation_id, idempotency_key, user_id, relay_host_id, assignment_epoch,
+        cell_id, state, created_at, timeout_at, released_at, updated_at)
+       SELECT 'r-' || lpad(n::text, 6, '0'), 'r-' || n, 'user-1', 'host000000000001', 1,
+              'cell-a', CASE WHEN n % 3 = 0 THEN 'claimed' ELSE 'released' END,
+              1, 1, CASE WHEN n % 3 = 0 THEN NULL ELSE 1 END, 1
+       FROM generate_series(1, ?) AS n`,
+      [ROWS]
+    )
+    const pages = (
+      await database.query(
+        `SELECT pg_relation_size('relay_control_connection_reservations') / 8192 AS pages`
+      )
+    )[0]!
+    return Number(pages.pages)
+  }
+
+  it('stops each tick at its row cap and drains the backlog over later ticks', async () => {
+    const pages = await seed()
+    expect(pages).toBeGreaterThan(20)
+    const reaper = new HeapWindowReaper(
+      'relay_control_connection_reservations',
+      PREDICATE,
+      { pagesPerStatement: 2, maxPagesPerTick: 1_000, maxRowsPerTick: 300, budgetMs: 60_000 },
+      () => 0.5
+    )
+
+    const first = await reaper.reap(database, [NOW])
+    // One statement past the cap at most: two pages of this shape hold well under 300 rows.
+    expect(first).toBeGreaterThanOrEqual(300)
+    expect(first).toBeLessThan(600)
+
+    let ticks = 1
+    while ((await reaper.reap(database, [NOW])) > 0) ticks += 1
+    expect(ticks).toBeGreaterThan(5)
+    const left = await database.query(
+      `SELECT state, COUNT(*) AS rows FROM relay_control_connection_reservations GROUP BY state`
+    )
+    expect(left).toEqual([{ state: 'claimed', rows: String(ROWS / 3) }])
+  })
+
+  it('wraps from the end of the heap back to its first page', async () => {
+    const pages = await seed()
+    // Starts on the last page, so every other page is reached only after the wrap.
+    const reaper = new HeapWindowReaper(
+      'relay_control_connection_reservations',
+      PREDICATE,
+      { pagesPerStatement: 4, maxPagesPerTick: pages + 4, maxRowsPerTick: 1_000_000, budgetMs: 60_000 },
+      () => (pages - 1) / pages
+    )
+
+    await reaper.reap(database, [NOW])
+
+    expect(
+      await database.query(
+        `SELECT COUNT(*) AS rows FROM relay_control_connection_reservations
+         WHERE state = 'released'`
+      )
+    ).toEqual([{ rows: '0' }])
+  })
+
+  it('skips a row a request holds instead of waiting for it', async () => {
+    await seed()
+    const holder = new pg.Client({ connectionString: scopedUrl() })
+    await holder.connect()
+    try {
+      await holder.query('BEGIN')
+      await holder.query(
+        `SELECT reservation_id FROM relay_control_connection_reservations
+         WHERE reservation_id = 'r-000001' FOR UPDATE`
+      )
+      const reaper = new HeapWindowReaper(
+        'relay_control_connection_reservations',
+        PREDICATE,
+        { pagesPerStatement: 1_000, maxPagesPerTick: 1_000, maxRowsPerTick: 1_000_000, budgetMs: 60_000 },
+        () => 0
+      )
+
+      // The pool's lock_timeout would fail this statement if it waited on the held row.
+      expect(await reaper.reap(database, [NOW])).toBe((ROWS * 2) / 3 - 1)
+      expect(
+        await database.query(
+          `SELECT reservation_id FROM relay_control_connection_reservations
+           WHERE state = 'released'`
+        )
+      ).toEqual([{ reservation_id: 'r-000001' }])
+    } finally {
+      await holder.query('ROLLBACK')
+      await holder.end()
+    }
+  })
+
+  it('plans each statement as a TID range scan, never a sequential scan', async () => {
+    await seed()
+    await database.query('ANALYZE relay_control_connection_reservations')
+    const client = new pg.Client({ connectionString: scopedUrl() })
+    await client.connect()
+    try {
+      const plan = await client.query(
+        `EXPLAIN DELETE FROM relay_control_connection_reservations WHERE ctid = ANY(ARRAY(
+           SELECT ctid FROM relay_control_connection_reservations
+           WHERE ctid >= CAST($1 AS tid) AND ctid < CAST($2 AS tid) AND ${PREDICATE.replace('?', '$3')}
+           FOR UPDATE SKIP LOCKED))`,
+        ['(0,0)', '(16,0)', NOW]
+      )
+      const text = plan.rows.map((row) => String(row['QUERY PLAN'])).join('\n')
+      expect(text).toContain('Tid Range Scan')
+      expect(text).not.toContain('Seq Scan')
+    } finally {
+      await client.end()
+    }
+  })
+})
diff --git a/cloud/dev/scripts/operate-relay-asia-admission.mjs b/cloud/dev/scripts/operate-relay-asia-admission.mjs
index d5736db3ed2..c79323a9b39 100644
--- a/cloud/dev/scripts/operate-relay-asia-admission.mjs
+++ b/cloud/dev/scripts/operate-relay-asia-admission.mjs
@@ -21,7 +21,7 @@ const SHAPES = {
     domain: 'relay.onorca.dev',
     allCells: [
       'production-gce-c27', 'production-gce-c28', 'production-gce-c29', 'production-gce-c30',
-      'production-gce-c31', 'production-gce-c32', 'production-gce-c33'
+      'production-gce-c31', 'production-gce-c32', 'production-gce-c33', 'production-gce-c34'
     ],
     // The launch set was registered together; each later cell registers alone beside it.
     registrationWaves: [
@@ -29,8 +29,10 @@ const SHAPES = {
       ['production-gce-c30'],
       ['production-gce-c31'],
       ['production-gce-c32'],
-      ['production-gce-c33']
+      ['production-gce-c33'],
+      ['production-gce-c34']
     ],
+    // C34 is a migration-only spare: no promotion wave until a reviewed change adds one.
     promotionWaves: [
       ['production-gce-c27'],
       ['production-gce-c28', 'production-gce-c29'],
diff --git a/cloud/dev/scripts/operate-relay-asia-admission.test.mjs b/cloud/dev/scripts/operate-relay-asia-admission.test.mjs
index ac5aa89ba9f..a1b8eb3853c 100644
--- a/cloud/dev/scripts/operate-relay-asia-admission.test.mjs
+++ b/cloud/dev/scripts/operate-relay-asia-admission.test.mjs
@@ -553,11 +553,13 @@ test('accepts only reviewed Asia admission waves', () => {
     ['rollback', 'production-gce-c30'],
     ['rollback', 'production-gce-c31'],
     ['rollback', 'production-gce-c27,production-gce-c28,production-gce-c29'],
-    ['rollback', 'production-gce-c27,production-gce-c28,production-gce-c29,production-gce-c30,production-gce-c31,production-gce-c32,production-gce-c33'],
+    ['rollback', 'production-gce-c27,production-gce-c28,production-gce-c29,production-gce-c30,production-gce-c31,production-gce-c32,production-gce-c33,production-gce-c34'],
     ...['production-gce-c32', 'production-gce-c33'].flatMap((cellId) => [
       'inspect', 'verify', 'register', 'registered', 'promote', 'recover-promotion', 'rollback'
     ].map((mode) => [mode, cellId])),
-    ['inspect', 'production-gce-c27,production-gce-c28,production-gce-c29,production-gce-c30,production-gce-c31,production-gce-c32,production-gce-c33']
+    ...['inspect', 'verify', 'register', 'registered', 'rollback']
+      .map((mode) => [mode, 'production-gce-c34']),
+    ['inspect', 'production-gce-c27,production-gce-c28,production-gce-c29,production-gce-c30,production-gce-c31,production-gce-c32,production-gce-c33,production-gce-c34']
   ]
   for (const [mode, cellIds] of accepted) {
     assert.deepEqual(
@@ -586,7 +588,12 @@ test('accepts only reviewed Asia admission waves', () => {
     ['promote', 'production-gce-c27,production-gce-c30'],
     ['promote', 'production-gce-c28,production-gce-c29,production-gce-c30'],
     ['promote', 'production-gce-c30,production-gce-c31'],
+    // The C34 spare stays migration-only: no reviewed promotion wave names it.
     ['promote', 'production-gce-c34'],
+    ['recover-promotion', 'production-gce-c34'],
+    ['register', 'production-gce-c33,production-gce-c34'],
+    ['inspect', 'production-gce-c27,production-gce-c28,production-gce-c29,production-gce-c30,production-gce-c31,production-gce-c32,production-gce-c33'],
+    ['rollback', 'production-gce-c27,production-gce-c28,production-gce-c29,production-gce-c30,production-gce-c31,production-gce-c32,production-gce-c33'],
     ['rollback', 'production-gce-c27,production-gce-c30'],
     ['rollback', 'production-gce-c30,production-gce-c31'],
     ['rollback', 'production-gce-c27,production-gce-c28,production-gce-c29,production-gce-c30'],
@@ -648,6 +655,29 @@ test('registers C31 alone beside the general C27-C30', async () => {
   assert.deepEqual(subject.selector().membership.general, general)
 })
 
+test('registers the C34 spare alone as migration-only in asia-east2', async () => {
+  const general = [...launchCells, 'production-gce-c30', 'production-gce-c31']
+  const subject = harness({
+    generation: 17,
+    membership: {
+      existingOnly: [],
+      migrationOnly: [],
+      general: [...general, 'production-gce-c32', 'production-gce-c33']
+    }
+  })
+  const result = await operateRelayAsiaAdmission({
+    environment: 'production', mode: 'register', cells: ['production-gce-c34'],
+    expectedGeneration: 17, imageDigest: digest, attemptId: 'asia_register_c34', token: 'not-logged'
+  }, subject)
+  const request = subject.requests.find(({ path }) => path.endsWith('/add-migration-cells'))
+  assert.deepEqual(request.body.cells, [{
+    cellId: 'production-gce-c34', cellUrl: 'https://c34.relay.onorca.dev', region: 'asia-east2',
+    capacityRequests: 6_000, connectionHardCap: 3_000, connectionUnobservedBound: 60
+  }])
+  assert.deepEqual(result.states, { 'production-gce-c34': 'migration-only' })
+  assert.equal(subject.selector().membership.general.includes('production-gce-c34'), false)
+})
+
 const usRegions = { 'production-gce-c32': 'us-central1', 'production-gce-c33': 'us-central1' }
 
 test('registers C32 and C33 one at a time in us-central1 at the Asia shape', async () => {
diff --git a/cloud/dev/scripts/prepare-relay-asia-topology-input.mjs b/cloud/dev/scripts/prepare-relay-asia-topology-input.mjs
index 5d00dbacf1a..6bbb65c50ce 100644
--- a/cloud/dev/scripts/prepare-relay-asia-topology-input.mjs
+++ b/cloud/dev/scripts/prepare-relay-asia-topology-input.mjs
@@ -20,7 +20,8 @@ const SHAPES = {
       'production-gce-c30': 'asia-east2-a',
       'production-gce-c31': 'asia-east2-b',
       'production-gce-c32': 'us-central1-a',
-      'production-gce-c33': 'us-central1-b'
+      'production-gce-c33': 'us-central1-b',
+      'production-gce-c34': 'asia-east2-c'
     },
     // The launch set, then each later additive cell; a plan targets one wave, never live cells.
     waves: [
@@ -28,7 +29,8 @@ const SHAPES = {
       ['production-gce-c30'],
       ['production-gce-c31'],
       // Declared together, so they plan together: a lone C32 plan would hit C33's missing template.
-      ['production-gce-c32', 'production-gce-c33']
+      ['production-gce-c32', 'production-gce-c33'],
+      ['production-gce-c34']
     ]
   }
 }
diff --git a/cloud/dev/scripts/prepare-relay-asia-topology-input.test.mjs b/cloud/dev/scripts/prepare-relay-asia-topology-input.test.mjs
index 0790560a318..906c8bb1ace 100644
--- a/cloud/dev/scripts/prepare-relay-asia-topology-input.test.mjs
+++ b/cloud/dev/scripts/prepare-relay-asia-topology-input.test.mjs
@@ -14,7 +14,8 @@ const productionCells = () => Object.fromEntries([
   [30, 'asia-east2-a'],
   [31, 'asia-east2-b'],
   [32, 'us-central1-a'],
-  [33, 'us-central1-b']
+  [33, 'us-central1-b'],
+  [34, 'asia-east2-c']
 ].map(([ordinal, zone]) => [`production-gce-c${ordinal}`, {
     hostname: `c${ordinal}`, region: zone.slice(0, -2), zone,
     machine_type: 'e2-standard-4', boot_disk_gb: 30,
@@ -57,6 +58,14 @@ test('accepts the additive C31 wave in the next zone of the rotation', () => {
   assert.equal(result.relay_gce_cells['production-gce-c31'].zone, 'asia-east2-b')
 })
 
+test('accepts the additive C34 spare wave in asia-east2-c at the Asia pool', () => {
+  const result = prepareRelayAsiaTopologyInput({ existingCells: productionCells(),
+    existingAdditionalRegions: additionalRegions, environment: 'production',
+    cellIds: 'production-gce-c34', image })
+  assert.equal(result.relay_gce_cells['production-gce-c34'].zone, 'asia-east2-c')
+  assert.equal(result.relay_gce_cells['production-gce-c34'].database_pool_max, 16)
+})
+
 test('accepts the additive US C32+C33 wave at the default pool only', () => {
   const cellIds = 'production-gce-c32,production-gce-c33'
   for (const [cellId, zone] of [
@@ -103,7 +112,8 @@ test('matches every committed production Asia cell entry', () => {
     'production-gce-c27,production-gce-c28,production-gce-c29',
     'production-gce-c30',
     'production-gce-c31',
-    'production-gce-c32,production-gce-c33'
+    'production-gce-c32,production-gce-c33',
+    'production-gce-c34'
   ]) {
     const committedImage = committed[wave.split(',')[0]].image
     assert.doesNotThrow(() => prepareRelayAsiaTopologyInput({
@@ -116,8 +126,8 @@ test('matches every committed production Asia cell entry', () => {
     environment: 'production', cellIds: 'production-gce-c30',
     image
   }), /differs from the reviewed topology/)
-  // The US cells launch on the newest digest, the one C31 launched on.
-  for (const cellId of ['production-gce-c32', 'production-gce-c33']) {
+  // The US cells and the C34 spare launch on the newest cell digest, the one C31 launched on.
+  for (const cellId of ['production-gce-c32', 'production-gce-c33', 'production-gce-c34']) {
     assert.equal(committed[cellId].image, committed['production-gce-c31'].image, cellId)
   }
 })
@@ -152,7 +162,8 @@ test('rejects an uncommitted subnet or cell, partial wave, wrong image, and drif
     'production-gce-c30,production-gce-c31',
     'production-gce-c32',
     'production-gce-c33',
-    'production-gce-c34'
+    'production-gce-c33,production-gce-c34',
+    'production-gce-c35'
   ]) {
     assert.throws(() => prepareRelayAsiaTopologyInput({
       existingCells: productionCells(), existingAdditionalRegions: additionalRegions,
diff --git a/cloud/dev/scripts/prepare-relay-production-capacity-canary.test.mjs b/cloud/dev/scripts/prepare-relay-production-capacity-canary.test.mjs
index b53dbe40d26..d643f2e2178 100644
--- a/cloud/dev/scripts/prepare-relay-production-capacity-canary.test.mjs
+++ b/cloud/dev/scripts/prepare-relay-production-capacity-canary.test.mjs
@@ -101,7 +101,9 @@ describe('production Relay capacity cell admission', () => {
       // Migration-only canaries: the US-only capacity rollout never touches them either.
       'production-gce-c17', 'production-gce-c18',
       // US cells at the Asia shape: the 1,000-cap capacity rollout never touches them.
-      'production-gce-c32', 'production-gce-c33'
+      'production-gce-c32', 'production-gce-c33',
+      // The migration-only Asia spare.
+      'production-gce-c34'
     ]) {
       const hostname = cellId.slice('production-gce-'.length)
       assert.deepEqual(parseProductionCapacityCellArguments([
@@ -118,7 +120,7 @@ describe('production Relay capacity cell admission', () => {
         paceWindowMs: 0
       })
     }
-    for (const cellId of ['production-gce-c12', 'production-gce-c34']) {
+    for (const cellId of ['production-gce-c12', 'production-gce-c35']) {
       const hostname = cellId.slice('production-gce-'.length)
       assert.throws(() => parseProductionCapacityCellArguments([
         '--director-origin', 'https://relay.onorca.dev',
diff --git a/cloud/dev/scripts/probe-relay-rehome-trust.mjs b/cloud/dev/scripts/probe-relay-rehome-trust.mjs
index 32ac89e4e6d..79dddc7e921 100644
--- a/cloud/dev/scripts/probe-relay-rehome-trust.mjs
+++ b/cloud/dev/scripts/probe-relay-rehome-trust.mjs
@@ -2,9 +2,9 @@ import { pathToFileURL } from 'node:url'
 import { fetchAdminOnceMore } from './relay-admin-transient-retry.mjs'
 
 // Every cell that carries the rehome identity: the eighteen US cells and the
-// five asia-east2 cells that drain mis-homed hosts back the other way.
+// six asia-east2 cells that drain mis-homed hosts back the other way.
 const PRODUCTION_CELL =
-  /^production-gce-c(?:7|8|9|10|13|14|15|16|19|20|21|22|23|24|25|26|27|28|29|30|31|32|33)$/
+  /^production-gce-c(?:7|8|9|10|13|14|15|16|19|20|21|22|23|24|25|26|27|28|29|30|31|32|33|34)$/
 const DIRECTOR_ORIGIN = 'https://relay.onorca.dev'
 
 export function parseRehomeTrustProbeArguments(argv, environment = process.env) {
diff --git a/cloud/dev/scripts/probe-relay-rehome-trust.test.mjs b/cloud/dev/scripts/probe-relay-rehome-trust.test.mjs
index 932fa450112..c7d8b5e5d4b 100644
--- a/cloud/dev/scripts/probe-relay-rehome-trust.test.mjs
+++ b/cloud/dev/scripts/probe-relay-rehome-trust.test.mjs
@@ -116,7 +116,7 @@ test('fails when both trust-probe attempts return a transient 503', async () =>
 test('approves the asia-east2 and US 3,000 rehome sources and still rejects unlisted cells', () => {
   for (const cellId of [
     'production-gce-c27', 'production-gce-c28', 'production-gce-c29', 'production-gce-c30',
-    'production-gce-c31', 'production-gce-c32', 'production-gce-c33'
+    'production-gce-c31', 'production-gce-c32', 'production-gce-c33', 'production-gce-c34'
   ]) {
     const parsed = parseRehomeTrustProbeArguments(
       argv.map((value) => (value === 'production-gce-c7' ? cellId : value)),
@@ -124,7 +124,7 @@ test('approves the asia-east2 and US 3,000 rehome sources and still rejects unli
     )
     assert.equal(parsed.cellId, cellId)
   }
-  for (const cellId of ['production-gce-c1', 'production-gce-c17', 'production-gce-c34']) {
+  for (const cellId of ['production-gce-c1', 'production-gce-c17', 'production-gce-c35']) {
     assert.throws(
       () =>
         parseRehomeTrustProbeArguments(
@@ -183,7 +183,7 @@ test('approves exactly the committed production rehome source cells', () => {
   const sources = new Set(
     [...tfvars.slice(start, tfvars.indexOf(']', start)).matchAll(/"([^"]+)"/g)].map(([, cell]) => cell)
   )
-  assert.ok(sources.has('production-gce-c33'))
+  assert.ok(sources.has('production-gce-c34'))
   for (let ordinal = 1; ordinal <= 40; ordinal++) {
     const cellId = `production-gce-c${ordinal}`
     const approved = (() => {
diff --git a/cloud/dev/scripts/relay-asia-topology-workflow.test.mjs b/cloud/dev/scripts/relay-asia-topology-workflow.test.mjs
index 0a59d8d9939..8a6eba98b69 100644
--- a/cloud/dev/scripts/relay-asia-topology-workflow.test.mjs
+++ b/cloud/dev/scripts/relay-asia-topology-workflow.test.mjs
@@ -50,7 +50,8 @@ test('accepts only the reviewed Asia topology waves', () => {
       'production:production-gce-c27,production-gce-c28,production-gce-c29',
       'production:production-gce-c30',
       'production:production-gce-c31',
-      'production:production-gce-c32,production-gce-c33'
+      'production:production-gce-c32,production-gce-c33',
+      'production:production-gce-c34'
     ]
   )
 })
diff --git a/cloud/dev/scripts/relay-cloud-sql-connection-budget.test.mjs b/cloud/dev/scripts/relay-cloud-sql-connection-budget.test.mjs
index bade8de8f52..bc68bf49c69 100644
--- a/cloud/dev/scripts/relay-cloud-sql-connection-budget.test.mjs
+++ b/cloud/dev/scripts/relay-cloud-sql-connection-budget.test.mjs
@@ -7,12 +7,12 @@ import {
 } from './relay-cloud-sql-connection-budget.mjs'
 
 test('production shared consumers keep allowance and reserve below the ceiling', () => {
-  // cells: 22 pools at 10 (220, C32/C33 included) + the five asia-east2 pools at 16 (80).
+  // cells: 22 pools at 10 (220, C32/C33 included) + the six asia-east2 pools at 16 (96).
   const report = readRelayCloudSqlConnectionBudget()
 
-  assert.deepEqual(report.consumers, { cells: 300, directors: 15, auth: 20, api: 50 })
-  assert.deepEqual(report.asia, { cells: 5, poolMax: 16 })
-  assert.equal(report.configuredMaximum, 385)
+  assert.deepEqual(report.consumers, { cells: 316, directors: 15, auth: 20, api: 50 })
+  assert.deepEqual(report.asia, { cells: 6, poolMax: 16 })
+  assert.equal(report.configuredMaximum, 401)
   assert.equal(report.rolloutOverlap.relayDirectorCandidate, 30)
   assert.equal(report.rolloutOverlap.apiCandidate, 65)
   assert.equal(report.rolloutOverlap.authCandidate, 35)
@@ -22,10 +22,10 @@ test('production shared consumers keep allowance and reserve below the ceiling',
   assert.equal(report.maintenanceAdminAllowance, 5)
   assert.equal(report.explicitReserve, 10)
   assert.equal(report.usableCeiling, 490)
-  assert.equal(report.operatingMaximum, 455)
-  assert.equal(report.remainingWithinUsableCeiling, 35)
-  assert.equal(report.budgetedTotal, 465)
-  assert.equal(report.unallocated, 35)
+  assert.equal(report.operatingMaximum, 471)
+  assert.equal(report.remainingWithinUsableCeiling, 19)
+  assert.equal(report.budgetedTotal, 481)
+  assert.equal(report.unallocated, 19)
   assert.equal(report.withinBudget, true)
 })
 
diff --git a/cloud/dev/scripts/relay-production-same-cap-wave.mjs b/cloud/dev/scripts/relay-production-same-cap-wave.mjs
index 8d13c761f54..7313ce627d6 100644
--- a/cloud/dev/scripts/relay-production-same-cap-wave.mjs
+++ b/cloud/dev/scripts/relay-production-same-cap-wave.mjs
@@ -4,9 +4,9 @@ import { requireSameEvidenceCode } from './relay-evidence-code-provenance.mjs'
 
 // Migration-only by policy: zero hosts and no reservation, so a wave rolls one without
 // displacing anybody. It enters and must leave migration-only, never general.
-// C32 and C33 stay here until each one's canary promotes it; that follow-up moves it to general.
+// C34 is an Asia spare that stays migration-only by policy.
 export const SAME_CAP_MIGRATION_ONLY_CELLS = [
-  'production-gce-c17', 'production-gce-c18', 'production-gce-c32', 'production-gce-c33'
+  'production-gce-c17', 'production-gce-c18', 'production-gce-c34'
 ]
 
 export const SAME_CAP_CELLS = [
@@ -15,7 +15,7 @@ export const SAME_CAP_CELLS = [
   'production-gce-c19', 'production-gce-c20', 'production-gce-c21', 'production-gce-c22',
   'production-gce-c23', 'production-gce-c24', 'production-gce-c25', 'production-gce-c26',
   'production-gce-c27', 'production-gce-c28', 'production-gce-c29', 'production-gce-c30',
-  'production-gce-c31',
+  'production-gce-c31', 'production-gce-c32', 'production-gce-c33',
   ...SAME_CAP_MIGRATION_ONLY_CELLS
 ]
 
diff --git a/cloud/dev/scripts/relay-production-same-cap-wave.test.mjs b/cloud/dev/scripts/relay-production-same-cap-wave.test.mjs
index 8aa4ffb4c4b..c8d5ccb4f2b 100644
--- a/cloud/dev/scripts/relay-production-same-cap-wave.test.mjs
+++ b/cloud/dev/scripts/relay-production-same-cap-wave.test.mjs
@@ -63,7 +63,7 @@ test('requires one canary or a bounded reviewed batch', () => {
     rollbackDigest,
     confirmation: `ROLL_RELAY_SAME_CAP ${targetDigest} production-gce-c31`
   }).cells, ['production-gce-c31'])
-  for (const cellId of ['production-gce-c32', 'production-gce-c33']) {
+  for (const cellId of ['production-gce-c32', 'production-gce-c33', 'production-gce-c34']) {
     assert.deepEqual(validateSameCapWave({
       mode: 'canary-apply',
       cellIds: cellId,
@@ -74,10 +74,10 @@ test('requires one canary or a bounded reviewed batch', () => {
   }
   assert.throws(() => validateSameCapWave({
     mode: 'canary-apply',
-    cellIds: 'production-gce-c34',
+    cellIds: 'production-gce-c35',
     targetDigest,
     rollbackDigest,
-    confirmation: `ROLL_RELAY_SAME_CAP ${targetDigest} production-gce-c34`
+    confirmation: `ROLL_RELAY_SAME_CAP ${targetDigest} production-gce-c35`
   }), /cells/)
 })
 
@@ -123,12 +123,16 @@ test('the wave workflow chains exactly ten serial cell jobs', () => {
   assert.doesNotMatch(dispatch, /\n  cell_11:/)
 })
 
-test('lists C32 and C33 as migration-only beside C17 and C18 until their canaries promote them', () => {
-  assert.deepEqual(SAME_CAP_MIGRATION_ONLY_CELLS, [
-    'production-gce-c17', 'production-gce-c18', 'production-gce-c32', 'production-gce-c33'
-  ])
-  assert.equal(SAME_CAP_CELLS.includes('production-gce-c30'), true)
-  assert.equal(SAME_CAP_CELLS.includes('production-gce-c31'), true)
+test('lists the C34 spare as migration-only beside C17 and C18, and C30-C33 as general', () => {
+  assert.deepEqual(
+    SAME_CAP_MIGRATION_ONLY_CELLS,
+    ['production-gce-c17', 'production-gce-c18', 'production-gce-c34']
+  )
+  for (const cellId of [
+    'production-gce-c30', 'production-gce-c31', 'production-gce-c32', 'production-gce-c33'
+  ]) {
+    assert.equal(SAME_CAP_CELLS.includes(cellId), true, cellId)
+  }
 })
 
 test('rolls the migration-only cells but never mixes the two classes in one wave', () => {
@@ -194,15 +198,28 @@ test('rolls the migration-only cells but never mixes the two classes in one wave
     confirmation: `ROLL_RELAY_SAME_CAP ${targetDigest} ${c31Mixed}`,
     canaryRunId: '42'
   }), /all general or all migration-only/)
-  // Until its canary promotes it, a same-cap restore must hand a US 3,000 cell back isolated.
-  assert.equal(entryAdmission('production-gce-c32'), 'migration-only')
-  const usUnpromoted = 'production-gce-c26,production-gce-c32'
-  assert.throws(() => validateSameCapWave({
+  // C32 and C33 are general since their 2026-10-01 promotions: they roll beside US 1k cells,
+  // isolate and restore (delta 2), and never share a wave with C17/C18.
+  for (const cellId of ['production-gce-c32', 'production-gce-c33']) {
+    assert.equal(entryAdmission(cellId), 'general', cellId)
+    assert.equal(selectorWaveDelta(cellId), 2, cellId)
+  }
+  const usPromoted = 'production-gce-c26,production-gce-c32,production-gce-c33'
+  assert.deepEqual(validateSameCapWave({
     mode: 'batch-apply',
-    cellIds: usUnpromoted,
+    cellIds: usPromoted,
     targetDigest,
     rollbackDigest,
-    confirmation: `ROLL_RELAY_SAME_CAP ${targetDigest} ${usUnpromoted}`,
+    confirmation: `ROLL_RELAY_SAME_CAP ${targetDigest} ${usPromoted}`,
+    canaryRunId: '42'
+  }).cells, ['production-gce-c26', 'production-gce-c32', 'production-gce-c33'])
+  const usMixed = 'production-gce-c32,production-gce-c17'
+  assert.throws(() => validateSameCapWave({
+    mode: 'batch-apply',
+    cellIds: usMixed,
+    targetDigest,
+    rollbackDigest,
+    confirmation: `ROLL_RELAY_SAME_CAP ${targetDigest} ${usMixed}`,
     canaryRunId: '42'
   }), /all general or all migration-only/)
   // A mixed wave has no single selector delta for its later cells to offset from.
diff --git a/cloud/dev/scripts/relay-same-cap-script-census.test.mjs b/cloud/dev/scripts/relay-same-cap-script-census.test.mjs
index 27c52c401ce..7f27742ce3f 100644
--- a/cloud/dev/scripts/relay-same-cap-script-census.test.mjs
+++ b/cloud/dev/scripts/relay-same-cap-script-census.test.mjs
@@ -263,7 +263,7 @@ describe('same-cap roll scripts accept every same-cap cell', () => {
       assert.equal(String(cellShape(cellId).cap), tfvarsHardCap(cellId), cellId)
     }
     assert.equal(resolveCellShape('production-gce-c12').status, 1)
-    assert.equal(resolveCellShape('production-gce-c34').status, 1)
+    assert.equal(resolveCellShape('production-gce-c35').status, 1)
   })
 
 
@@ -275,11 +275,10 @@ describe('same-cap roll scripts accept every same-cap cell', () => {
     const trusted = SAME_CAP_CELLS.filter((cell) => REHOME_SOURCE_CELLS.has(cell))
     // Only a declared rehome source may roll at a trusted protocol at all; the job refuses
     // the rest before it plans, and the next test covers them at protocol 0.
-    // C32 and C33 are already rehome sources but stay migration-only until their canaries.
-    const unpromotedSources = ['production-gce-c32', 'production-gce-c33']
+    // The C34 spare is a rehome source that stays migration-only.
     assert.deepEqual(
       SAME_CAP_CELLS.filter((cell) => !REHOME_SOURCE_CELLS.has(cell)),
-      SAME_CAP_MIGRATION_ONLY_CELLS.filter((cell) => !unpromotedSources.includes(cell))
+      SAME_CAP_MIGRATION_ONLY_CELLS.filter((cell) => cell !== 'production-gce-c34')
     )
     for (const [cellId, protocol] of trusted.flatMap((cell) => [[cell, 1], [cell, 3]])) {
       const { cap, pool } = cellShape(cellId)
diff --git a/cloud/dev/scripts/validate-relay-asia-topology-plan.mjs b/cloud/dev/scripts/validate-relay-asia-topology-plan.mjs
index 084960d396b..adcb7807fba 100644
--- a/cloud/dev/scripts/validate-relay-asia-topology-plan.mjs
+++ b/cloud/dev/scripts/validate-relay-asia-topology-plan.mjs
@@ -24,14 +24,16 @@ const CELL_SHAPES = {
       'production-gce-c30': 'asia-east2-a',
       'production-gce-c31': 'asia-east2-b',
       'production-gce-c32': 'us-central1-a',
-      'production-gce-c33': 'us-central1-b'
+      'production-gce-c33': 'us-central1-b',
+      'production-gce-c34': 'asia-east2-c'
     },
     waves: [
       ['production-gce-c27', 'production-gce-c28', 'production-gce-c29'],
       ['production-gce-c30'],
       ['production-gce-c31'],
       // Declared together, so they plan together: a lone C32 plan would hit C33's missing template.
-      ['production-gce-c32', 'production-gce-c33']
+      ['production-gce-c32', 'production-gce-c33'],
+      ['production-gce-c34']
     ]
   },
   staging: {
diff --git a/cloud/dev/scripts/validate-relay-asia-topology-plan.test.mjs b/cloud/dev/scripts/validate-relay-asia-topology-plan.test.mjs
index 0e9f6e0a6a2..a4838aba046 100644
--- a/cloud/dev/scripts/validate-relay-asia-topology-plan.test.mjs
+++ b/cloud/dev/scripts/validate-relay-asia-topology-plan.test.mjs
@@ -161,6 +161,18 @@ test('accepts the additive production C31 wave only in asia-east2-b', () => {
   )
 })
 
+test('accepts the additive production C34 spare wave only in asia-east2-c', () => {
+  const c34Config = { ...productionConfig, cells: ['production-gce-c34'] }
+  assert.deepEqual(
+    validateRelayAsiaTopologyPlan({ resource_changes: productionWavePlan('c34', 'asia-east2-c') }, c34Config),
+    { environment: 'production', cells: ['production-gce-c34'], changes: 4 }
+  )
+  assert.throws(
+    () => validateRelayAsiaTopologyPlan({ resource_changes: productionWavePlan('c34') }, c34Config),
+    /fixed-one Asia MIG shape/
+  )
+})
+
 // A US cell joins the root region: no additional-region network, no region label or line, and
 // the default pool emits no line, exactly as the startup template renders a root-region cell.
 function usCellPlan(hostname, zone) {
@@ -269,7 +281,8 @@ test('accepts only a reviewed Asia topology wave', () => {
     'production-gce-c27,production-gce-c28,production-gce-c29',
     'production-gce-c29,production-gce-c27,production-gce-c28',
     'production-gce-c30',
-    'production-gce-c31'
+    'production-gce-c31',
+    'production-gce-c34'
   ]) {
     assert.doesNotThrow(
       () => parseRelayAsiaTopologyPlanArguments(argv('production', cellIds, productionImage)),
@@ -286,7 +299,8 @@ test('accepts only a reviewed Asia topology wave', () => {
     'production-gce-c32',
     'production-gce-c33',
     'production-gce-c32,production-gce-c33,production-gce-c34',
-    'production-gce-c34'
+    'production-gce-c33,production-gce-c34',
+    'production-gce-c35'
   ]) {
     assert.throws(
       () => parseRelayAsiaTopologyPlanArguments(argv('production', cellIds, productionImage)),
diff --git a/cloud/docs/relay-workflows.md b/cloud/docs/relay-workflows.md
index b214389e6b2..0d2e501f1f1 100644
--- a/cloud/docs/relay-workflows.md
+++ b/cloud/docs/relay-workflows.md
@@ -215,7 +215,19 @@ promote while a same-cap restore has just returned an empty general US cell: the
 would land there and the canary would roll the new cell back. Both cells are declared rehome
 sources and sit in the same-cap migration-only list until each one's canary promotes it, then move
 to the general list. The shadow gate's fleet pool list tracks the 16-connection Asia pools, so
-whether a US cell belongs there is decided at promotion, not assumed.
+whether a US cell belongs there is decided at promotion, not assumed. Both were promoted to general
+on 2026-10-01, so the same-cap job now rolls them as general cells. They stay out of the fleet pool
+list because their pool is the US default of 10.
+
+C34 is an Asia spare at the C31 shape in `asia-east2-c`, so the six Asia cells spread 2/2/2. It is
+its own topology wave and registers alone as migration-only, then the director is configured with
+`cell-ids` set to C34. It has no promotion wave: the Asia admission script and workflow refuse
+`promote` for it, and placement and regional rehome select only general cells. It is a
+migration-only landing zone that only an explicit evacuation or migration naming it can target.
+Do not name it in the multi-target `promote-general-cell` or `retire-migration-cell` modes, which
+accept any migration-only cell. It is a declared rehome source, sits in the same-cap migration-only
+list, and stays out of the fleet pool list. Promoting it later takes its own reviewed change adding a
+promotion wave and canary entry.
 Rollback returns
 Asia cells to migration-only; it does not destroy the network or use
 existing-only. The production topology dispatch remains unavailable until the
diff --git a/cloud/infra/terraform/README.md b/cloud/infra/terraform/README.md
index cf447a88dd2..70001984c7b 100644
--- a/cloud/infra/terraform/README.md
+++ b/cloud/infra/terraform/README.md
@@ -332,7 +332,7 @@ cell templates/MIGs/backends, and exact shared URL-map host additions. It
 rejects deletes, replacements, loss of an existing host route, US-resource
 changes, and unrelated drift. Do not add production C27-C29 until the
 compatible image has been published and each entry can pin its immutable
-digest. A later cell, such as C30 or C31, is its own reviewed wave. The shared URL map
+digest. A later cell, such as C30, C31 or the C34 spare, is its own reviewed wave. The shared URL map
 pulls every live cell into its plan, so the workflow plans each live cell at the
 image its state template already serves, and the validator rejects any change
 to a cell outside the wave. US C32 and C33 use the same workflow at the same
diff --git a/cloud/infra/terraform/environments/production.tfvars b/cloud/infra/terraform/environments/production.tfvars
index baed00d496d..a3521914b20 100644
--- a/cloud/infra/terraform/environments/production.tfvars
+++ b/cloud/infra/terraform/environments/production.tfvars
@@ -450,6 +450,21 @@ relay_gce_cells = {
     connection_hard_cap         = 3000
     connection_unobserved_bound = 60
   }
+  # Asia spare: registered migration-only as a drain landing zone; c completes the 2/2/2 zone spread.
+  "production-gce-c34" = {
+    hostname                    = "c34"
+    region                      = "asia-east2"
+    zone                        = "asia-east2-c"
+    machine_type                = "e2-standard-4"
+    boot_disk_gb                = 30
+    boot_image                  = "https://www.googleapis.com/compute/v1/projects/cos-cloud/global/images/cos-stable-121-18867-528-21"
+    capacity_requests           = 6000
+    database_pool_max           = 16 # 176 ms from us-central1 Postgres saturates 10 (94-156 waiters).
+    image                       = "us-central1-docker.pkg.dev/onorca-cloud/orca-cloud/relay@sha256:f30b5cb1ec52b6b6145efecfa1b8be9e3d309403beffd8abcc64197a2087e269"
+    initially_enabled           = false
+    connection_hard_cap         = 3000
+    connection_unobserved_bound = 60
+  }
 }
 
 relay_region_rehome_source_cell_ids = [
@@ -476,7 +491,8 @@ relay_region_rehome_source_cell_ids = [
   "production-gce-c30",
   "production-gce-c31",
   "production-gce-c32",
-  "production-gce-c33"
+  "production-gce-c33",
+  "production-gce-c34"
 ]
 
 # Slack #orca-relay-alerts, created out of band on 2026-08-05. Declared here because an apply
diff --git a/config/localization-audit.md b/config/localization-audit.md
index 77a0e15bd57..1bb39bf2017 100644
--- a/config/localization-audit.md
+++ b/config/localization-audit.md
@@ -95,9 +95,9 @@ not invoke tools that can overwrite an entire target catalog.
 
 The coverage gate compares current candidates against
 `config/localization-coverage-allowlist.json`. The committed allowlist is
-small (10 reviewed entries — one test fixture title, five non-English
-language-name search keywords, and four reviewed product-name search
-keywords): new candidates fail the check and must be localized or added with
+small (11 reviewed entries — six non-English language-name search keywords,
+four reviewed product-name search keywords, and one non-UI `label` placement
+prop): new candidates fail the check and must be localized or added with
 a reviewed reason in the same change.
 
 The script scans `src/renderer/src` by default. That is the primary UI surface.
diff --git a/config/localization-coverage-allowlist.json b/config/localization-coverage-allowlist.json
index 0918ed3a513..93d984594af 100644
--- a/config/localization-coverage-allowlist.json
+++ b/config/localization-coverage-allowlist.json
@@ -1,36 +1,15 @@
 [
   {
-    "filePath": "src/renderer/src/components/automations/automations-page-fixtures.ts",
-    "kind": "object-property:title",
-    "text": "Nightly #1",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/automations/automations-page-fixtures.ts",
-    "kind": "object-property:label",
-    "text": "Hermes",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/sidebar/worktree-card-meta-row.tsx",
-    "kind": "jsx-attribute:label",
-    "text": "sidebar",
+    "filePath": "src/renderer/src/components/settings/appearance-search.ts",
+    "kind": "object-property:keywords",
+    "text": "Idioma",
     "dynamic": false,
     "count": 1
   },
   {
     "filePath": "src/renderer/src/components/settings/appearance-search.ts",
     "kind": "object-property:keywords",
-    "text": "语言",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/appearance-search.ts",
-    "kind": "object-property:keywords",
-    "text": "語言",
+    "text": "Langue",
     "dynamic": false,
     "count": 1
   },
@@ -51,24 +30,17 @@
   {
     "filePath": "src/renderer/src/components/settings/appearance-search.ts",
     "kind": "object-property:keywords",
-    "text": "Idioma",
+    "text": "語言",
     "dynamic": false,
     "count": 1
   },
   {
     "filePath": "src/renderer/src/components/settings/appearance-search.ts",
     "kind": "object-property:keywords",
-    "text": "Langue",
+    "text": "语言",
     "dynamic": false,
     "count": 1
   },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-advanced-platform-search.ts",
-    "kind": "object-property:keywords",
-    "text": "Ghostty",
-    "dynamic": false,
-    "count": 2
-  },
   {
     "filePath": "src/renderer/src/components/settings/terminal-advanced-platform-search.ts",
     "kind": "object-property:keywords",
@@ -77,11 +49,11 @@
     "count": 2
   },
   {
-    "filePath": "src/renderer/src/components/settings/terminal-pane-appearance-search.ts",
+    "filePath": "src/renderer/src/components/settings/terminal-advanced-platform-search.ts",
     "kind": "object-property:keywords",
     "text": "Ghostty",
     "dynamic": false,
-    "count": 1
+    "count": 2
   },
   {
     "filePath": "src/renderer/src/components/settings/terminal-pane-appearance-search.ts",
@@ -91,317 +63,16 @@
     "count": 1
   },
   {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:title",
-    "text": "Default shell",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:description",
-    "text": "Shell used for new terminal panes",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
+    "filePath": "src/renderer/src/components/settings/terminal-pane-appearance-search.ts",
     "kind": "object-property:keywords",
-    "text": "shell",
+    "text": "Ghostty",
     "dynamic": false,
     "count": 1
   },
   {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "terminal",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "fish",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "zsh",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "bash",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "nushell",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "default",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-attribute:title",
-    "text": "Terminal shell",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-attribute:description",
-    "text": "Choose what Orca opens for new local terminal panes.",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-attribute:ariaLabel",
-    "text": "Terminal shell",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:label",
-    "text": "System shell (",
-    "dynamic": true,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:label",
-    "text": "Custom shell",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-attribute:placeholder",
-    "text": "fish, nu, or /bin/zsh",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-attribute:aria-label",
-    "text": "Custom shell executable",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-text",
-    "text": "Enter a shell name on PATH or an executable path. Orca starts it as a login shell.",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-text",
-    "text": ". Switch to System shell or choose an executable on this host.",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "arguments",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "args",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "login",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "wrapper",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:keywords",
-    "text": "rcfile",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-text",
-    "text": "Advanced",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-text",
-    "text": "Shell arguments",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-expression",
-    "text": "Starts the shell as a login shell with -l.",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-expression",
-    "text": "Enter one argument per line. Leave it empty to pass no arguments.",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-attribute:ariaLabel",
-    "text": "Shell argument mode",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:label",
-    "text": "-l (default)",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "object-property:label",
-    "text": "Custom args",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-attribute:placeholder",
-    "text": "--rcfile /path/to/rcfile",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/TerminalPane.tsx",
-    "kind": "jsx-attribute:aria-label",
-    "text": "Shell arguments, one per line",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:title",
-    "text": "Terminal shell",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:description",
-    "text": "Shell and arguments used for new local interactive terminal panes",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "shell",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "terminal",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "fish",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "zsh",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "bash",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "nushell",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "arguments",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "args",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "login",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "wrapper",
-    "dynamic": false,
-    "count": 1
-  },
-  {
-    "filePath": "src/renderer/src/components/settings/terminal-search.ts",
-    "kind": "object-property:keywords",
-    "text": "rcfile",
+    "filePath": "src/renderer/src/components/sidebar/worktree-card-meta-row.tsx",
+    "kind": "jsx-attribute:label",
+    "text": "sidebar",
     "dynamic": false,
     "count": 1
   }
diff --git a/config/oxlint-anti-slop.json b/config/oxlint-anti-slop.json
index d951695a339..3a38be8e4a0 100644
--- a/config/oxlint-anti-slop.json
+++ b/config/oxlint-anti-slop.json
@@ -65,6 +65,13 @@
         "anti-slop/no-module-mocking": "off"
       }
     },
+    // Test-only side effect for explicit RPC registries; real catalog tests never import it.
+    {
+      "files": ["**/src/main/runtime/rpc/unused-default-rpc-methods.test-fixture.ts"],
+      "rules": {
+        "anti-slop/no-module-mocking": "off"
+      }
+    },
     // The exemptions below are file-scoped rather than inline `oxlint-disable` comments
     // because the root lint scan does not load this plugin, so an inline directive naming
     // an anti-slop rule always reads back as an unused directive there.
diff --git a/config/reliability-gates.jsonc b/config/reliability-gates.jsonc
index faf844b5137..642918a992c 100644
--- a/config/reliability-gates.jsonc
+++ b/config/reliability-gates.jsonc
@@ -948,7 +948,7 @@
       "invariant": "One structured-send operation id causes at most one provider dispatch. A recorded or transport-ambiguous send reuses that id across retry, caller reconnect, client remount, and journal recovery; only a terminal rejection may rotate to a first delivery.",
       "oracle": "Inject adapter acknowledgement loss, RPC response loss, caller replacement, logical-client close after response, auth recovery with a written request, missing journal submissions, legacy pending rows, stale fences, operation expiry, mobile remount, and durable-journal capacity. Assert one provider dispatch or one operation id for every ambiguous retry, fresh identity only after rejection, and no eviction of ambiguous mobile ids.",
       "commands": [
-        "ORCA_BACKGROUND_LAUNCH=1 pnpm test src/shared/agent-session-operation-ledger.test.ts src/shared/structured-agent-session-send-disposition.test.ts src/main/runtime/agent-session-operation-admission.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-send.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-delivery.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts src/main/runtime/orchestration/structured-pointer-operation-id.test.ts src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx src/renderer/src/lib/launch-structured-agent-session.test.ts",
+        "ORCA_BACKGROUND_LAUNCH=1 pnpm test src/shared/agent-session-operation-ledger.test.ts src/shared/structured-agent-session-send-disposition.test.ts src/main/runtime/agent-session-operation-admission.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-send.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-delivery.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts src/main/runtime/orchestration/structured-pointer-operation-id.test.ts src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.probe.test.tsx src/renderer/src/lib/launch-structured-agent-session.test.ts",
         "ORCA_BACKGROUND_LAUNCH=1 pnpm --dir mobile test ../mobile/src/session/mobile-native-chat-image-attachment.test.ts ../mobile/src/session/use-mobile-native-chat-image-attachments.test.ts ../mobile/src/session/mobile-structured-send-operation-journal.test.ts ../mobile/src/session/mobile-structured-send-delivery.test.ts ../mobile/src/session/use-mobile-structured-agent-session-send.test.tsx ../mobile/src/session/use-mobile-structured-agent-session.test.tsx ../mobile/src/transport/mobile-relay-rpc-session.test.ts ../mobile/src/transport/rpc-client-delivery-ambiguity.test.ts ../mobile/src/transport/stable-logical-rpc-client.test.ts"
       ],
       "testFiles": [
@@ -963,6 +963,7 @@
         "src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx",
         "src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx",
         "src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx",
+        "src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.probe.test.tsx",
         "src/renderer/src/lib/launch-structured-agent-session.test.ts",
         "mobile/src/session/mobile-native-chat-image-attachment.test.ts",
         "mobile/src/session/use-mobile-native-chat-image-attachments.test.ts",
@@ -1033,13 +1034,13 @@
       ],
       "evidenceRuns": [
         {
-          "date": "2026-09-12",
+          "date": "2026-10-04",
           "runner": "local",
           "platform": "macos",
-          "command": "ORCA_BACKGROUND_LAUNCH=1 pnpm test src/shared/agent-session-operation-ledger.test.ts src/shared/structured-agent-session-send-disposition.test.ts src/main/runtime/agent-session-operation-admission.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-send.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-delivery.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts src/main/runtime/orchestration/structured-pointer-operation-id.test.ts src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx src/renderer/src/lib/launch-structured-agent-session.test.ts",
+          "command": "ORCA_BACKGROUND_LAUNCH=1 pnpm test src/shared/agent-session-operation-ledger.test.ts src/shared/structured-agent-session-send-disposition.test.ts src/main/runtime/agent-session-operation-admission.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-send.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-delivery.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts src/main/runtime/orchestration/structured-pointer-operation-id.test.ts src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.probe.test.tsx src/renderer/src/lib/launch-structured-agent-session.test.ts",
           "result": "passed",
-          "durationSeconds": 22.1,
-          "summary": "Thirteen focused host, shared, renderer, and orchestration files passed 148 tests."
+          "durationSeconds": 42.3,
+          "summary": "Thirteen focused host, shared, renderer, and orchestration files passed 197 tests after the delivery probe tests moved to their own file."
         },
         {
           "date": "2026-09-12",
@@ -16958,15 +16959,38 @@
       "invariant": "Hidden-output restore, snapshot replay, metadata-only replay, and clear-before-replay must preserve order and never overlay stale bytes on newer live terminal output; restoring a snapshot onto an already-dirty pane must yield a buffer exactly equal to the snapshot frame.",
       "oracle": "Apply snapshots onto adversarially dirty pane states (already on the alternate screen, stale content occupying cells the new frame leaves blank, scrollback present, wide glyphs, revived sessions with restarted PTY seq counters) and assert exact buffer equality with the snapshot frame; fault injection interleaves hidden chunks, live output, metadata-only replay, and clear-before-replay, then asserts ordered terminal buffer content, clear decisions, and replay diagnostics. Marker-presence checks are not acceptable evidence on restore paths.",
       "commands": [
-        "pnpm exec vitest run --config config/vitest.config.ts src/renderer/src/components/terminal-pane/pty-connection-hidden-backlog-snapshot.test.ts src/renderer/src/components/terminal-pane/pty-connection-hidden-output-restore.test.ts src/renderer/src/components/terminal-pane/pty-connection-stalled-hidden-restore.test.ts src/renderer/src/components/terminal-pane/pty-connection-replay-payload-handling.test.ts"
+        "pnpm exec vitest run --config config/vitest.config.ts src/renderer/src/components/terminal-pane/pty-connection-hidden-backlog-snapshot.test.ts src/renderer/src/components/terminal-pane/pty-connection-hidden-output-restore.test.ts src/renderer/src/components/terminal-pane/pty-connection-stalled-hidden-restore.test.ts src/renderer/src/components/terminal-pane/pty-connection-replay-payload-handling.test.ts",
+        "pnpm exec vitest run --config config/vitest.config.ts src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-replay.test.ts src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-host-chain.test.ts"
       ],
       "testFiles": [
         "src/renderer/src/components/terminal-pane/pty-connection-hidden-backlog-snapshot.test.ts",
         "src/renderer/src/components/terminal-pane/pty-connection-hidden-output-restore.test.ts",
         "src/renderer/src/components/terminal-pane/pty-connection-stalled-hidden-restore.test.ts",
-        "src/renderer/src/components/terminal-pane/pty-connection-replay-payload-handling.test.ts"
+        "src/renderer/src/components/terminal-pane/pty-connection-replay-payload-handling.test.ts",
+        "src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-replay.test.ts",
+        "src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-host-chain.test.ts"
       ],
       "assertionRefs": [
+        {
+          "file": "src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-replay.test.ts",
+          "assertions": [
+            "repaints a pushed image exactly and keeps the history the TUI covers",
+            "keeps the pane's history when the host screen has another grid",
+            "keeps history unduplicated when a pushed image also carries history",
+            "paints the whole image when the TUI started while hidden",
+            "reads the pane buffer after a queued alt-screen entry parses",
+            "repaints from the normal buffer once the host TUI has exited",
+            "clears a raw byte replay in place on the alt screen",
+            "paints a requested image from an exited TUI exactly over an alt screen"
+          ]
+        },
+        {
+          "file": "src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-host-chain.test.ts",
+          "assertions": [
+            "keeps the covered history for a live TUI exactly as the host holds it",
+            "repaints from the normal buffer once the host TUI has exited"
+          ]
+        },
         {
           "file": "src/renderer/src/components/terminal-pane/pty-connection-hidden-backlog-snapshot.test.ts",
           "assertions": [
diff --git a/config/scripts/agent-status-hot-path-benchmark.test.ts b/config/scripts/agent-status-hot-path-benchmark.ts
similarity index 88%
rename from config/scripts/agent-status-hot-path-benchmark.test.ts
rename to config/scripts/agent-status-hot-path-benchmark.ts
index ece89b89d50..310de6723fb 100644
--- a/config/scripts/agent-status-hot-path-benchmark.test.ts
+++ b/config/scripts/agent-status-hot-path-benchmark.ts
@@ -8,10 +8,14 @@
  * Counting passes patch `Map`/`Set`/`Object.assign`/`Object.values`, which deoptimizes them, so
  * counts and timings are taken in separate passes and never from the same run.
  *
+ * Run: ORCA_BACKGROUND_LAUNCH=1 pnpm exec vitest run --config config/vitest.agent-status-benchmark.config.ts
+ *
  * Scale mirrors the reporting user rather than the 100-worktree fixture in
  * docs/reference/renderer-agent-status-performance.md: 423 worktrees, 634 terminal tabs.
  */
 import { writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import { describe, expect, it } from 'vitest'
 import type { AppState } from '@/store/types'
 import type { AgentStatusBatchUpdate } from '@/store/slices/agent-status'
@@ -23,6 +27,7 @@ import {
   TEST_REPO
 } from '@/store/slices/store-test-helpers'
 import { makePaneKey } from '../../src/shared/stable-pane-id'
+import { getDefaultSettings } from '../../src/shared/constants'
 import {
   createAgentStatusPaneRoutingIndex,
   resolvePaneKeyFromRoutingIndex
@@ -39,25 +44,24 @@ const counters = { maps: 0, sets: 0, tabComparisons: 0 }
 
 const NativeMap = globalThis.Map
 const NativeSet = globalThis.Set
-const nativeArrayIterator = Array.prototype[Symbol.iterator]
 
 function withAllocationCounting<T>(run: () => T): T {
   class CountingMap<K, V> extends NativeMap<K, V> {
-    constructor(entries?: readonly (readonly [K, V])[] | null) {
+    constructor(entries?: Iterable<readonly [K, V]> | null) {
       super(entries)
       counters.maps += 1
     }
   }
   class CountingSet<V> extends NativeSet<V> {
-    constructor(values?: readonly V[] | null) {
+    constructor(values?: Iterable<V> | null) {
       super(values)
       counters.sets += 1
     }
   }
   counters.maps = 0
   counters.sets = 0
-  globalThis.Map = CountingMap as unknown as MapConstructor
-  globalThis.Set = CountingSet as unknown as SetConstructor
+  globalThis.Map = CountingMap
+  globalThis.Set = CountingSet
   try {
     return run()
   } finally {
@@ -68,34 +72,33 @@ function withAllocationCounting<T>(run: () => T): T {
 
 /** Tab list whose iteration is observable, so the nested-loop resolver's comparisons are countable. */
 class CountingTabList<T> extends Array<T> {
-  [Symbol.iterator](): IterableIterator<T> {
-    const inner = nativeArrayIterator.call(this) as IterableIterator<T>
-    const wrapped: IterableIterator<T> = {
-      next: () => {
-        const result = inner.next()
-        if (!result.done) {
-          counters.tabComparisons += 1
-        }
-        return result
-      },
-      [Symbol.iterator]: () => wrapped
+  [Symbol.iterator](): ArrayIterator<T> {
+    const iterator = super[Symbol.iterator]()
+    const next = iterator.next.bind(iterator)
+    iterator.next = (...args) => {
+      const result = next(...args)
+      if (!result.done) {
+        counters.tabComparisons += 1
+      }
+      return result
     }
-    return wrapped
+    return iterator
   }
 }
 
 function buildFixture(countTabIteration: boolean) {
   const store = createTestStore()
+  const settings = store.getState().settings ?? getDefaultSettings(tmpdir())
   const tabsByWorktree: AppState['tabsByWorktree'] = {}
   const unifiedTabsByWorktree: AppState['unifiedTabsByWorktree'] = {}
-  const worktrees = []
+  const worktrees: ReturnType<typeof makeWorktree>[] = []
   const paneKeys: string[] = []
   const owners: { tabId: string; worktreeId: string }[] = []
   for (let index = 0; index < WORKTREES; index += 1) {
     const worktreeId = `wt-${index}`
     worktrees.push(makeWorktree({ id: worktreeId, repoId: TEST_REPO.id }))
-    const tabs = []
-    const unified = []
+    const tabs: ReturnType<typeof makeTab>[] = []
+    const unified: ReturnType<typeof makeUnifiedTab>[] = []
     for (let tab = 0; tab < (index % 2 === 0 ? 1 : 2); tab += 1) {
       const tabId = `tab-${index}-${tab}`
       tabs.push(makeTab({ id: tabId, worktreeId, title: `Terminal ${index}-${tab}` }))
@@ -110,9 +113,7 @@ function buildFixture(countTabIteration: boolean) {
       paneKeys.push(makePaneKey(tabId, LEAF_ID))
       owners.push({ tabId, worktreeId })
     }
-    tabsByWorktree[worktreeId] = countTabIteration
-      ? (CountingTabList.from(tabs) as unknown as typeof tabs)
-      : tabs
+    tabsByWorktree[worktreeId] = countTabIteration ? CountingTabList.from(tabs) : tabs
     unifiedTabsByWorktree[worktreeId] = unified
   }
   store.setState({
@@ -122,8 +123,8 @@ function buildFixture(countTabIteration: boolean) {
     unifiedTabsByWorktree,
     terminalLayoutsByTabId: {},
     setGeneratedTabTitlesFromAgentPrompts: () => {},
-    settings: { ...store.getState().settings, tabAutoGenerateTitle: false }
-  } as Partial<AppState>)
+    settings: { ...settings, tabAutoGenerateTitle: false }
+  })
   return { store, paneKeys, owners }
 }
 
@@ -141,7 +142,7 @@ function per1k(value: number): number {
 function runIndexedRouting(store: ReturnType<typeof createTestStore>, paneKeys: string[]): void {
   for (let event = 0; event < EVENTS; event += 1) {
     if (event % BATCH_SIZE === 0) {
-      store.setState({ agentStatusEpoch: event } as Partial<AppState>)
+      store.setState({ agentStatusEpoch: event })
     }
     const index = createAgentStatusPaneRoutingIndex(store.getState())
     resolvePaneKeyFromRoutingIndex(index, paneKeys[event % paneKeys.length])
@@ -287,7 +288,8 @@ describe('agent-status hot path benchmark', () => {
     }
 
     const outputPath =
-      process.env.ORCA_AGENT_STATUS_BENCH_OUTPUT ?? '/tmp/agent-status-hot-path-benchmark.json'
+      process.env.ORCA_AGENT_STATUS_BENCH_OUTPUT ??
+      join(tmpdir(), 'agent-status-hot-path-benchmark.json')
     writeFileSync(
       outputPath,
       `${JSON.stringify({ worktrees: WORKTREES, events: EVENTS, report }, null, 2)}\n`
diff --git a/config/scripts/check-root-directory-entries.test.mjs b/config/scripts/check-root-directory-entries.test.mjs
index 6de07a053c7..57da7adbd95 100644
--- a/config/scripts/check-root-directory-entries.test.mjs
+++ b/config/scripts/check-root-directory-entries.test.mjs
@@ -114,6 +114,17 @@ describe('root directory guard', () => {
     expect(result.status).toBe(0)
   })
 
+  it('allows the reviewed repository OpenCode permission config', () => {
+    const fixture = makeFixture()
+    const head = commitFiles(fixture.root, [
+      ['opencode.json', '{"permission":{"*":{"*":"allow"}}}\n']
+    ])
+
+    const result = runGuard({ ...fixture, head })
+
+    expect(result.status).toBe(0)
+  })
+
   it('rejects a new top-level directory', () => {
     const fixture = makeFixture()
     const head = commitFiles(fixture.root, [['new-folder/file.txt', 'too prominent\n']])
diff --git a/config/scripts/ci-background-step-barriers.test.mjs b/config/scripts/ci-background-step-barriers.test.mjs
index e005c60b989..d8ac8fd1c1f 100644
--- a/config/scripts/ci-background-step-barriers.test.mjs
+++ b/config/scripts/ci-background-step-barriers.test.mjs
@@ -96,13 +96,13 @@ describe('CI background step barriers', () => {
     expect(steps.findIndex((step) => step.id === 'changed-code-quality')).toBeGreaterThan(install)
   })
 
-  it('serializes mobile pnpm entrypoints before allocating test workers', () => {
+  it('joins independent mobile typechecks before allocating test workers', () => {
     const steps = mobile.jobs.verify.steps
     assertJoinedBefore(steps, 'production-types', (step) => step.name === 'Test')
     const ratchet = steps.findIndex((step) => step.name === 'Typecheck tests (ratchet)')
     const join = steps.findIndex((step) => step.wait === 'production-types')
     expect(steps[ratchet].background).toBeUndefined()
-    expect(ratchet).toBeGreaterThan(join)
+    expect(ratchet).toBeLessThan(join)
   })
 
   it('waits for WebKit and the bundle before any browser tests', () => {
diff --git a/config/scripts/ci-shard-timings.json b/config/scripts/ci-shard-timings.json
index 73d0226943b..34ba98f2566 100644
--- a/config/scripts/ci-shard-timings.json
+++ b/config/scripts/ci-shard-timings.json
@@ -5375,7 +5375,7 @@
       "src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-restore-signal-equivalence.test.tsx": 552,
       "src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-scrollbar-drag.test.ts": 59,
       "src/renderer/src/components/editor/conflict-review-file-tree-windowing.test.tsx": 2238,
-      "src/renderer/src/components/editor/csv-parse.test.ts": 122,
+      "src/renderer/src/components/editor/csv/csv-parse.test.ts": 122,
       "src/renderer/src/components/editor/details-markdown-html.test.ts": 99,
       "src/renderer/src/components/editor/diff-editor-hide-unchanged-options.test.ts": 35,
       "src/renderer/src/components/editor/diff-editor-line-number-options.test.ts": 48,
diff --git a/config/scripts/locale-ko-key-overrides.json b/config/scripts/locale-ko-key-overrides.json
index b0f99275b43..6f4948712dd 100644
--- a/config/scripts/locale-ko-key-overrides.json
+++ b/config/scripts/locale-ko-key-overrides.json
@@ -2342,9 +2342,6 @@
   "auto.components.settings.MobileEmulatorSettingsPane.ae1612c58c": {
     "ko": "가용성"
   },
-  "auto.components.settings.MobilePane.35100bca5d": {
-    "ko": "휴대폰에서 terminals을 사용하는 동안 Orca는 휴대폰 화면에 맞게 terminals을 축소합니다. 앱을 닫거나 다른 곳으로 전환하면 terminals이 휴대폰 크기로 유지되는지(대화형 CLI 도구가 리플로우되지 않음) 또는 데스크탑으로 다시 크기가 조정되는지 여부가 제어됩니다. 배너에서 '이 terminals 복원' 또는 '모든 terminals 복원'을 사용해 언제든지 수동으로 크기를 조정할 수 있습니다."
-  },
   "auto.components.settings.MobileSettingsPane.b0088412a1": {
     "ko": "또는 다음에서 Android APK를 받으세요"
   },
@@ -4886,12 +4883,6 @@
   "auto.components.terminal.pane.CloseTerminalDialog.stop_command_title": {
     "ko": "실행 중인 명령을 중지할까요?"
   },
-  "auto.components.terminal.pane.MobileDriverOverlay.54f7d6f69d": {
-    "ko": "모든 terminals 제어권 가져오기"
-  },
-  "auto.components.terminal.pane.MobileDriverOverlay.faa367dc74": {
-    "ko": "휴대폰이 이 화면을 휴대폰 크기로 남겨 두었습니다"
-  },
   "auto.components.terminal.pane.TerminalContextMenu.c2f0b72b8d": {
     "ko": "삽입"
   },
diff --git a/config/scripts/mobile-typecheck-workflow.test.mjs b/config/scripts/mobile-typecheck-workflow.test.mjs
index 0ab57ad858f..f234b538df5 100644
--- a/config/scripts/mobile-typecheck-workflow.test.mjs
+++ b/config/scripts/mobile-typecheck-workflow.test.mjs
@@ -23,7 +23,7 @@ describe('mobile verification command ownership', () => {
     }
   })
 
-  it('finishes installation and joins production types before checking test types', () => {
+  it('finishes installation and joins both independent typechecks before tests', () => {
     const installIndex = steps.findIndex((step) => step.name === 'Install dependencies')
     const productionIndex = steps.findIndex((step) => step.name === 'Typecheck')
     const ratchetIndex = steps.findIndex((step) => step.name === 'Typecheck tests (ratchet)')
@@ -36,7 +36,10 @@ describe('mobile verification command ownership', () => {
     expect(steps[productionIndex].background).toBe(true)
     expect(productionIndex).toBeLessThan(ratchetIndex)
     expect(waitIndex).toBeGreaterThan(productionIndex)
-    expect(waitIndex).toBeLessThan(ratchetIndex)
-    expect(ratchetIndex).toBeLessThan(testIndex)
+    expect(ratchetIndex).toBeLessThan(waitIndex)
+    expect(waitIndex).toBeLessThan(testIndex)
+    expect(steps[waitIndex].if).toBeUndefined()
+    expect(steps[productionIndex]['continue-on-error'] ?? false).toBe(false)
+    expect(steps[ratchetIndex]['continue-on-error'] ?? false).toBe(false)
   })
 })
diff --git a/config/scripts/mobile-web-app-working-spinner-render.test.mjs b/config/scripts/mobile-web-app-working-spinner-render.test.mjs
new file mode 100644
index 00000000000..3ac7cdd2e37
--- /dev/null
+++ b/config/scripts/mobile-web-app-working-spinner-render.test.mjs
@@ -0,0 +1,145 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { chromium } from 'playwright-core'
+import { buildMobileWebAppBundle } from './build-mobile-web-app-bundle.mjs'
+import { mobileWebAppDependenciesPresent } from './mobile-web-app-bundle-dependencies.mjs'
+import { MOBILE_WEB_APP_ROUTE_ROOT } from './mobile-web-app-route-manifest.mjs'
+import {
+  createBundleServer,
+  installShellDouble,
+  projectDir,
+  readBridgeFaultGrant,
+  readBridgeProtocolVersion,
+  readShellCsp
+} from './mobile-web-app-render-harness.mjs'
+import { LAYOUT_SOURCE } from './mobile-web-app-terminal-probe-route.mjs'
+
+/**
+ * The working rings keep turning on the page. Each is a one-second rotation loop; a loop that
+ * stops after its first turn reads `rotate(360deg)` from then on.
+ */
+
+const ROUTE = `/${MOBILE_WEB_APP_ROUTE_ROOT}/working-spinner-probe`
+const SAMPLE_SECONDS = [1.3, 1.8, 2.4]
+const bundles = mobileWebAppDependenciesPresent()
+const describeRender = bundles ? describe : describe.skip
+
+function probeRouteSource({ spinnerModule, dotModule }) {
+  return `import { View } from 'react-native'
+import { AgentSpinner } from ${JSON.stringify(spinnerModule)}
+import { AgentStateDot } from ${JSON.stringify(dotModule)}
+
+export default function WorkingSpinnerProbeRoute() {
+  globalThis.__orcaWorkingSpinnerProbe = true
+  return (
+    <View style={{ padding: 24, gap: 24 }}>
+      <View nativeID="working-spinner"><AgentSpinner status="working" /></View>
+      <View nativeID="working-dot"><AgentStateDot state="working" /></View>
+    </View>
+  )
+}
+`
+}
+
+let browser = null
+let origin = null
+let scratch = null
+let server = null
+
+beforeAll(async () => {
+  if (!bundles) {
+    return
+  }
+  const componentsDir = join(projectDir, 'mobile', 'src', 'components')
+  const cspHeader = await readShellCsp()
+  scratch = await mkdtemp(join(tmpdir(), 'orca-mobile-web-working-spinner-'))
+  const appDir = join(scratch, 'app')
+  const routeDir = join(appDir, MOBILE_WEB_APP_ROUTE_ROOT)
+  await mkdir(routeDir, { recursive: true })
+  await writeFile(join(routeDir, '_layout.tsx'), LAYOUT_SOURCE)
+  await writeFile(
+    join(routeDir, 'working-spinner-probe.tsx'),
+    probeRouteSource({
+      spinnerModule: join(componentsDir, 'AgentSpinner'),
+      dotModule: join(componentsDir, 'AgentStateDot')
+    })
+  )
+  const built = await buildMobileWebAppBundle({
+    appDir,
+    outDir: join(scratch, 'bundle'),
+    pageRoutes: [{ pathname: ROUTE, grants: [] }]
+  })
+  const served = await createBundleServer({ outDir: built.outDir, cspHeader })
+  server = served.server
+  origin = served.origin
+  const executablePath = process.env.ORCA_MOBILE_WEB_RENDER_BROWSER
+  browser = await chromium.launch({ headless: true, ...(executablePath ? { executablePath } : {}) })
+}, 600_000)
+
+afterAll(async () => {
+  await browser?.close()
+  server?.close()
+  if (scratch) {
+    await rm(scratch, { recursive: true, force: true })
+  }
+})
+
+async function openProbe() {
+  const faultGrant = await readBridgeFaultGrant()
+  const page = await browser.newPage({ viewport: { width: 390, height: 844 } })
+  await page.addInitScript(installShellDouble, {
+    version: await readBridgeProtocolVersion(),
+    sessionId: 'working-spinner-session',
+    buildId: 'working-spinner-build',
+    route: { pathname: ROUTE, params: {} },
+    host: { id: 'spinner-host', name: 'Spinner Host', endpoint: 'ws://spinner', lastConnected: 1 },
+    storage: {},
+    faultGrant,
+    grants: [faultGrant],
+    pageRoutes: [ROUTE],
+    replies: {}
+  })
+  const errors = []
+  page.on('pageerror', (error) => errors.push(`${error.name}: ${error.message}`))
+  await page.goto(`${origin}/`, { waitUntil: 'load' })
+  await page.waitForFunction(
+    () =>
+      globalThis.__orcaWorkingSpinnerProbe !== undefined ||
+      (globalThis.__orcaRenderCheckFaults ?? []).length > 0,
+    { timeout: 60_000, polling: 100 }
+  )
+  expect(await page.evaluate(() => globalThis.__orcaRenderCheckFaults ?? [])).toEqual([])
+  return { errors, page }
+}
+
+/** The rotating ring is the only element under each wrapper that carries an inline transform. */
+const readRotations = (page) =>
+  page.evaluate(() =>
+    ['working-spinner', 'working-dot'].map(
+      (id) =>
+        [...document.querySelectorAll(`#${id} *`)].find((node) => node.style.transform)?.style
+          .transform ?? null
+    )
+  )
+
+describeRender('working rings on the page', () => {
+  it('keeps both rings turning past the first second', async () => {
+    const { errors, page } = await openProbe()
+    const started = Date.now()
+    const samples = []
+    for (const seconds of SAMPLE_SECONDS) {
+      await page.waitForTimeout(Math.max(0, started + seconds * 1000 - Date.now()))
+      samples.push(await readRotations(page))
+    }
+    for (const ring of [0, 1]) {
+      const angles = samples.map((sample) => sample[ring])
+      expect(new Set(angles).size, `ring ${ring} after 1.3 s: ${angles.join(', ')}`).toBe(
+        angles.length
+      )
+    }
+    expect(errors).toEqual([])
+    await page.close()
+  }, 300_000)
+})
diff --git a/config/scripts/pr-auxiliary-preflight-admission.test.mjs b/config/scripts/pr-auxiliary-preflight-admission.test.mjs
new file mode 100644
index 00000000000..2dd82ad5d26
--- /dev/null
+++ b/config/scripts/pr-auxiliary-preflight-admission.test.mjs
@@ -0,0 +1,143 @@
+import { readFileSync } from 'node:fs'
+import { runInNewContext } from 'node:vm'
+import { describe, expect, it } from 'vitest'
+import { parse } from 'yaml'
+import { classifyPrJobs } from './pr-code-change-scope.mjs'
+
+const workflow = parse(readFileSync('.github/workflows/pr.yml', 'utf8'))
+const routes = [
+  ['git_compatibility', 'src/shared/git-capability-cache.ts'],
+  ['codex_index_heal_contract', 'src/main/codex/codex-session-index-heal.ts'],
+  ['xterm_patch_sync', 'config/patches/xterm-upstream.json'],
+  ['shell_contracts', 'src/main/pty/pty-manager.ts'],
+  ['orcad_browser', 'src/main/orcad/orcad-browser-provider.ts'],
+  ['cross-version-wire', 'src/shared/orchestration-rpc-contract.ts'],
+  ['managed_hook_node18', 'src/shared/agent-hook-status.ts']
+]
+
+function evaluate(expression, context) {
+  return runInNewContext(
+    expression
+      .replace(/^\$\{\{\s*|\s*\}\}$/g, '')
+      .replaceAll('.cross-version-wire', '["cross-version-wire"]'),
+    context
+  )
+}
+
+function routedOutputs(files, reused) {
+  const scope = classifyPrJobs(files)
+  const context = {
+    steps: {
+      readiness: { outputs: { reused } },
+      filter: {
+        outputs: Object.fromEntries(
+          Object.entries(scope).map(([key, value]) => [key, String(value)])
+        )
+      }
+    }
+  }
+  return Object.fromEntries(
+    ['test', 'static_analysis', 'typecheck', ...routes.map(([job]) => job)].map((name) => [
+      name,
+      String(evaluate(workflow.jobs.code_paths.outputs[name], context))
+    ])
+  )
+}
+
+describe.each(routes)('%s preflight admission', (jobName, changedFile) => {
+  const job = workflow.jobs[jobName]
+
+  it('waits for the detector and physical preflight job', () => {
+    expect(job.needs).toEqual(['code_paths', 'preflight'])
+    expect(job.if).toContain('!cancelled()')
+    expect(job['continue-on-error']).toBeUndefined()
+  })
+
+  it.each([
+    { name: 'all prerequisites pass', admitted: true },
+    { name: 'preflight fails', preflight: 'failure', admitted: false },
+    { name: 'preflight is cancelled', preflight: 'cancelled', admitted: false },
+    { name: 'preflight skips', preflight: 'skipped', admitted: false },
+    { name: 'preflight result is missing', preflight: '', admitted: false },
+    { name: 'preflight is unfinished', preflight: null, admitted: false },
+    { name: 'detector fails', detector: 'failure', admitted: false },
+    { name: 'detector is cancelled', detector: 'cancelled', admitted: false },
+    { name: 'detector skips', detector: 'skipped', admitted: false },
+    { name: 'detector result is missing', detector: '', admitted: false },
+    { name: 'detector is unfinished', detector: null, admitted: false },
+    { name: 'route is unselected', selected: 'false', admitted: false },
+    { name: 'route is missing', selected: '', admitted: false },
+    { name: 'route is absent', selected: null, admitted: false },
+    { name: 'route is unknown', selected: 'unknown', admitted: false },
+    { name: 'workflow is cancelled', cancelled: true, admitted: false }
+  ])('evaluates the actual workflow condition: $name', (scenario) => {
+    const admitted = evaluate(job.if, {
+      cancelled: () => scenario.cancelled ?? false,
+      needs: {
+        code_paths: {
+          result: scenario.detector === undefined ? 'success' : (scenario.detector ?? undefined),
+          outputs: {
+            [jobName]: scenario.selected === undefined ? 'true' : (scenario.selected ?? undefined)
+          }
+        },
+        preflight: {
+          result: scenario.preflight === undefined ? 'success' : (scenario.preflight ?? undefined)
+        }
+      }
+    })
+    expect(admitted).toBe(scenario.admitted)
+  })
+
+  it.each([
+    { files: [] },
+    { files: ['package.json'] },
+    { files: ['.github/workflows/pr.yml'] },
+    { files: [changedFile] }
+  ])(
+    'requires unit work and preflight whenever the real classifier selects $files',
+    ({ files }) => {
+      const selected = routedOutputs(files, 'false')
+      expect(selected[jobName]).toBe('true')
+      expect(selected.test).toBe('true')
+      expect(selected.static_analysis).toBe('true')
+      expect(selected.typecheck).toBe('true')
+    }
+  )
+
+  it.each(['true', 'false', undefined])(
+    'honors the actual readiness-masked output when reuse is %s',
+    (reused) => {
+      const outputs = routedOutputs([changedFile], reused)
+      expect(outputs[jobName]).toBe(String(reused !== 'true'))
+      expect(outputs.test).toBe(String(reused !== 'true'))
+      const admitted = evaluate(job.if, {
+        cancelled: () => false,
+        needs: { code_paths: { result: 'success', outputs }, preflight: { result: 'success' } }
+      })
+      expect(admitted).toBe(reused !== 'true')
+    }
+  )
+})
+
+it.each([
+  { files: ['README.md'] },
+  { files: ['mobile/src/App.tsx'] },
+  { files: ['mobile/package.json'] },
+  { files: ['cloud/apps/relay/src/index.ts'] }
+])('does not add preflight consumers to a no-unit diff: $files', ({ files }) => {
+  const outputs = routedOutputs(files, 'false')
+  expect(outputs.test).toBe('false')
+  for (const [name] of routes) {
+    expect(outputs[name], name).toBe('false')
+  }
+})
+
+it('keeps the mobile-only bundle job in the first wave', () => {
+  const mobile = workflow.jobs.mobile_web_app
+  expect(mobile.needs).toEqual(['code_paths'])
+  expect(mobile.if).toBe("needs.code_paths.outputs.mobile_web_app == 'true'")
+  expect(classifyPrJobs(['mobile/src/App.tsx'])).toMatchObject({
+    test: false,
+    mobile_web_app: true
+  })
+})
diff --git a/config/scripts/pr-code-change-scope.test.mjs b/config/scripts/pr-code-change-scope.test.mjs
index 9bcc7974513..8b6bb23b8e8 100644
--- a/config/scripts/pr-code-change-scope.test.mjs
+++ b/config/scripts/pr-code-change-scope.test.mjs
@@ -626,12 +626,8 @@ describe('PR Checks skip wiring', () => {
     for (const jobName of expensiveJobs.filter(
       (jobName) => !['test', 'static_analysis', 'typecheck'].includes(jobName)
     )) {
-      expect(prWorkflow.jobs[jobName].needs, jobName).toEqual(
-        ['package', 'package_windows'].includes(jobName)
-          ? ['code_paths', 'preflight']
-          : ['code_paths']
-      )
-      expect(prWorkflow.jobs[jobName].if, jobName).toBe(
+      expect(prWorkflow.jobs[jobName].needs, jobName).toEqual(['code_paths', 'preflight'])
+      expect(prWorkflow.jobs[jobName].if, jobName).toContain(
         `needs.code_paths.outputs.${jobName} == 'true'`
       )
     }
diff --git a/config/scripts/pr-e2e-gate-contract.test.mjs b/config/scripts/pr-e2e-gate-contract.test.mjs
index c661327a40a..f9fe2d7d732 100644
--- a/config/scripts/pr-e2e-gate-contract.test.mjs
+++ b/config/scripts/pr-e2e-gate-contract.test.mjs
@@ -109,8 +109,8 @@ describe('PR E2E gate contract', () => {
     // Why: without this the job could lose its filter and run on every PR — the
     // cost the path filter exists to avoid — while the gate assertions above
     // stay green.
-    expect(prWorkflow.jobs.e2e.needs).toBe('code_paths')
-    expect(prWorkflow.jobs.e2e.if).toBe("needs.code_paths.outputs.e2e_should_run == 'true'")
+    expect(prWorkflow.jobs.e2e.needs).toEqual(['code_paths', 'preflight'])
+    expect(prWorkflow.jobs.e2e.if).toContain("needs.code_paths.outputs.e2e_should_run == 'true'")
     expect(prWorkflow.jobs.code_paths.outputs.e2e_should_run).toBe(
       '${{ steps.e2e_filter.outputs.should_run }}'
     )
diff --git a/config/scripts/pr-preflight-gates.test.mjs b/config/scripts/pr-preflight-gates.test.mjs
index 250ea94ffe8..4be1aa2b740 100644
--- a/config/scripts/pr-preflight-gates.test.mjs
+++ b/config/scripts/pr-preflight-gates.test.mjs
@@ -69,6 +69,113 @@ it('requires physical preflight success before publishing shards and admitting c
   expect(workflow.jobs.verify.needs).not.toContain('typecheck')
 })
 
+it.each([
+  { name: 'both phases succeed', phases: ['true', 'true'], result: 'success', admitted: true },
+  { name: 'static-only succeeds', phases: ['true', 'false'], result: 'success', admitted: true },
+  { name: 'type-only succeeds', phases: ['false', 'true'], result: 'success', admitted: true },
+  { name: 'static-only fails', phases: ['true', 'false'], result: 'failure', admitted: false },
+  { name: 'type-only fails', phases: ['false', 'true'], result: 'failure', admitted: false },
+  { name: 'both phases fail', phases: ['true', 'true'], result: 'failure', admitted: false },
+  { name: 'preflight is cancelled', result: 'cancelled', admitted: false },
+  { name: 'preflight is unfinished', result: undefined, admitted: false },
+  { name: 'both phases unselected', phases: ['false', 'false'], result: 'skipped', admitted: true },
+  { name: 'required static skips', phases: ['true', 'false'], result: 'skipped', admitted: false },
+  {
+    name: 'required compiler skips',
+    phases: ['false', 'true'],
+    result: 'skipped',
+    admitted: false
+  },
+  { name: 'both required phases skip', result: 'skipped', admitted: false },
+  {
+    name: 'unselected preflight fails',
+    phases: ['false', 'false'],
+    result: 'failure',
+    admitted: false
+  },
+  {
+    name: 'static selection missing',
+    phases: [undefined, 'false'],
+    result: 'skipped',
+    admitted: false
+  },
+  {
+    name: 'compiler selection missing',
+    phases: ['false', undefined],
+    result: 'skipped',
+    admitted: false
+  },
+  { name: 'selection unknown', phases: ['', 'false'], result: 'skipped', admitted: false },
+  {
+    name: 'docs have no route',
+    phases: ['false', 'false'],
+    result: 'skipped',
+    route: 'false',
+    admitted: false
+  },
+  { name: 'source has no route', result: 'success', route: 'false', admitted: false },
+  { name: 'route missing', result: 'success', route: '', admitted: false },
+  { name: 'path detection fails', result: 'success', pathsResult: 'failure', admitted: false },
+  { name: 'path detection skips', result: 'skipped', pathsResult: 'skipped', admitted: false },
+  { name: 'workflow cancelled after success', result: 'success', cancelled: true, admitted: false },
+  {
+    name: 'workflow cancelled with unselected phases',
+    phases: ['false', 'false'],
+    result: 'skipped',
+    cancelled: true,
+    admitted: false
+  }
+])('admits advisory E2E only after eligible preflight: $name', (scenario) => {
+  const [static_analysis, typecheck] = scenario.phases ?? ['true', 'true']
+  expect(workflow.jobs.e2e.needs).toEqual(['code_paths', 'preflight'])
+  const admitted = runInNewContext(workflow.jobs.e2e.if, {
+    cancelled: () => scenario.cancelled ?? false,
+    needs: {
+      code_paths: {
+        result: scenario.pathsResult ?? 'success',
+        outputs: { static_analysis, typecheck, e2e_should_run: scenario.route ?? 'true' }
+      },
+      preflight: { result: scenario.result }
+    }
+  })
+  expect(admitted).toBe(scenario.admitted)
+})
+
+it.each(['true', 'false'])(
+  'preserves advisory E2E on ready-for-review only with proven required-check reuse: %s',
+  (reused) => {
+    const scope = classifyPrJobs(['src/main/runtime/orca-runtime.ts'])
+    const context = {
+      steps: {
+        readiness: { outputs: { reused } },
+        filter: {
+          outputs: Object.fromEntries(
+            Object.entries(scope).map(([key, value]) => [key, String(value)])
+          )
+        },
+        e2e_filter: { outputs: { should_run: 'true' } }
+      }
+    }
+    const outputs = Object.fromEntries(
+      ['static_analysis', 'typecheck', 'e2e_should_run'].map((name) => [
+        name,
+        String(runInNewContext(workflow.jobs.code_paths.outputs[name].slice(3, -2), context))
+      ])
+    )
+    expect(outputs).toEqual({
+      static_analysis: reused === 'true' ? 'false' : 'true',
+      typecheck: reused === 'true' ? 'false' : 'true',
+      e2e_should_run: 'true'
+    })
+    const needs = { code_paths: { result: 'success', outputs }, preflight: { result: 'skipped' } }
+    expect(runInNewContext(preflight.if, { needs })).toBe(reused !== 'true')
+    expect(runInNewContext(workflow.jobs.e2e.if, { needs, cancelled: () => false })).toBe(
+      reused === 'true'
+    )
+    expect(workflow.jobs.verify.needs).not.toContain('e2e')
+  }
+)
+
 it('pins every foreground and background step to its selected phase', () => {
   const staticPhase = "needs.code_paths.outputs.static_analysis == 'true'"
   const typePhase = "needs.code_paths.outputs.typecheck == 'true'"
diff --git a/config/scripts/run-terminal-ibus-hangul-e2e.mjs b/config/scripts/run-terminal-ibus-hangul-e2e.mjs
index dead1c42f13..57d97cc2fb4 100644
--- a/config/scripts/run-terminal-ibus-hangul-e2e.mjs
+++ b/config/scripts/run-terminal-ibus-hangul-e2e.mjs
@@ -178,7 +178,10 @@ async function runInsideSession(evidenceDir) {
         ['--nested', '--wayland', `--wayland-display=${process.env.WAYLAND_DISPLAY}`],
         {
           detached: true,
-          env: process.env,
+          env:
+            process.env.ORCA_E2E_WAYLAND_INPUT_DIAGNOSTICS === '1'
+              ? { ...process.env, WAYLAND_DEBUG: 'server' }
+              : process.env,
           stdio: ['ignore', windowManagerLogFd, windowManagerLogFd]
         }
       )
@@ -275,10 +278,9 @@ async function runInsideSession(evidenceDir) {
             : {}),
           ORCA_E2E_FORWARD_APP_LOGS: '1',
           ORCA_E2E_NATIVE_IBUS_HANGUL: '1',
+          ORCA_E2E_NATIVE_IBUS_XVFB: '1',
           [IME_ENGAGEMENT_RECEIPT_ENV]: receiptPath,
-          // Why: native IBus key injection only reaches a window the window manager
-          // has focused, so this run opts out of the background-launch policy.
-          ORCA_E2E_FOREGROUND: '1'
+          ORCA_BACKGROUND_LAUNCH: '1'
         },
         stdio: 'inherit'
       }
diff --git a/config/scripts/terminal-ime-e2e-workflow.test.mjs b/config/scripts/terminal-ime-e2e-workflow.test.mjs
index cb12839a2af..4bf684d8984 100644
--- a/config/scripts/terminal-ime-e2e-workflow.test.mjs
+++ b/config/scripts/terminal-ime-e2e-workflow.test.mjs
@@ -12,8 +12,13 @@ describe('terminal IME e2e workflow', () => {
 
   it('runs only on schedule or manual dispatch', () => {
     expect(workflow.on.pull_request).toBeUndefined()
-    expect(workflow.on.workflow_dispatch).toBeNull()
+    expect(workflow.on.workflow_dispatch.inputs.diagnose_wayland_input).toMatchObject({
+      required: false,
+      type: 'boolean',
+      default: false
+    })
     expect(workflow.on.schedule).toEqual([{ cron: '30 9 * * *' }])
+    expect(workflow.env.ORCA_BACKGROUND_LAUNCH).toBe('1')
   })
 
   it('installs native IBus Hangul and X11 input tools', () => {
diff --git a/config/scripts/terminal-ime-engagement-receipt.mjs b/config/scripts/terminal-ime-engagement-receipt.mjs
index 8f0732908c1..5dcb91d599a 100644
--- a/config/scripts/terminal-ime-engagement-receipt.mjs
+++ b/config/scripts/terminal-ime-engagement-receipt.mjs
@@ -14,7 +14,8 @@ export const IME_ENGAGEMENT_RECEIPT_ENV = 'ORCA_E2E_IME_ENGAGEMENT_RECEIPT'
 export const EXPECTED_NATIVE_IME_TESTS = [
   'forwards the issue exact-byte sequence without loss or duplication',
   'forwards the issue sentence stress sequence without leaked ASCII',
-  'a digit typed right after a Hangul syllable reaches the pty'
+  'a digit typed right after a Hangul syllable reaches the pty',
+  'confirms native Hangul notes before a deliberate Enter saves'
 ]
 
 function parseReceipts(text) {
diff --git a/config/scripts/terminal-ime-engagement-receipt.test.mjs b/config/scripts/terminal-ime-engagement-receipt.test.mjs
index 613abc2ffae..8f9bdfa47d4 100644
--- a/config/scripts/terminal-ime-engagement-receipt.test.mjs
+++ b/config/scripts/terminal-ime-engagement-receipt.test.mjs
@@ -4,7 +4,7 @@ import {
   verifyImeEngagementReceipts
 } from './terminal-ime-engagement-receipt.mjs'
 
-const [firstTest, secondTest, thirdTest] = EXPECTED_NATIVE_IME_TESTS
+const [firstTest, secondTest, thirdTest, notesTest] = EXPECTED_NATIVE_IME_TESTS
 
 function receipt(test, overrides = {}) {
   return JSON.stringify({
@@ -20,7 +20,7 @@ describe('verifyImeEngagementReceipts', () => {
   it('accepts a run where every expected test observed real composition', () => {
     expect(
       verifyImeEngagementReceipts(
-        `${receipt(firstTest)}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n`
+        `${receipt(firstTest)}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n${receipt(notesTest, { onDataChunks: 0 })}\n`
       )
     ).toEqual([])
   })
@@ -38,19 +38,34 @@ describe('verifyImeEngagementReceipts', () => {
   it('rejects a partial run where only one test reached the engine', () => {
     expect(verifyImeEngagementReceipts(`${receipt(firstTest)}\n`)).toEqual([
       `no engagement receipt for "${secondTest}" — it was skipped, filtered out, or renamed`,
-      `no engagement receipt for "${thirdTest}" — it was skipped, filtered out, or renamed`
+      `no engagement receipt for "${thirdTest}" — it was skipped, filtered out, or renamed`,
+      `no engagement receipt for "${notesTest}" — it was skipped, filtered out, or renamed`
     ])
   })
 
   it('requires the digit receipt even when both original native tests passed', () => {
-    expect(verifyImeEngagementReceipts(`${receipt(firstTest)}\n${receipt(secondTest)}\n`)).toEqual([
+    expect(
+      verifyImeEngagementReceipts(
+        `${receipt(firstTest)}\n${receipt(secondTest)}\n${receipt(notesTest, { onDataChunks: 0 })}\n`
+      )
+    ).toEqual([
       `no engagement receipt for "${thirdTest}" — it was skipped, filtered out, or renamed`
     ])
   })
 
+  it('requires the Notes receipt even when the terminal scenarios passed', () => {
+    expect(
+      verifyImeEngagementReceipts(
+        `${receipt(firstTest)}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n`
+      )
+    ).toEqual([
+      `no engagement receipt for "${notesTest}" — it was skipped, filtered out, or renamed`
+    ])
+  })
+
   it('rejects a run that typed keys but never opened a composition', () => {
     const problems = verifyImeEngagementReceipts(
-      `${receipt(firstTest, { compositionStart: 0 })}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n`
+      `${receipt(firstTest, { compositionStart: 0 })}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n${receipt(notesTest, { onDataChunks: 0 })}\n`
     )
     expect(problems).toEqual([
       `"${firstTest}" recorded no compositionstart — the IME never engaged`
@@ -59,7 +74,7 @@ describe('verifyImeEngagementReceipts', () => {
 
   it('rejects a composition that produced no Hangul, which a latin passthrough would satisfy', () => {
     const problems = verifyImeEngagementReceipts(
-      `${receipt(firstTest, { hangulComposition: 0 })}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n`
+      `${receipt(firstTest, { hangulComposition: 0 })}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n${receipt(notesTest, { onDataChunks: 0 })}\n`
     )
     expect(problems).toEqual([
       `"${firstTest}" recorded no Hangul composition data — the engine produced no syllables`
@@ -68,7 +83,7 @@ describe('verifyImeEngagementReceipts', () => {
 
   it('rejects a renamed test rather than counting it toward coverage', () => {
     const problems = verifyImeEngagementReceipts(
-      `${receipt(firstTest)}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n${receipt('some new scenario')}\n`
+      `${receipt(firstTest)}\n${receipt(secondTest)}\n${receipt(thirdTest)}\n${receipt(notesTest, { onDataChunks: 0 })}\n${receipt('some new scenario')}\n`
     )
     expect(problems).toEqual([
       'unexpected engagement receipt for "some new scenario" — update EXPECTED_NATIVE_IME_TESTS'
@@ -77,7 +92,7 @@ describe('verifyImeEngagementReceipts', () => {
 
   it('reports a truncated receipt rather than parsing around it', () => {
     const problems = verifyImeEngagementReceipts(
-      `${receipt(firstTest)}\n{"test":"trunc\n${receipt(secondTest)}\n${receipt(thirdTest)}\n`
+      `${receipt(firstTest)}\n{"test":"trunc\n${receipt(secondTest)}\n${receipt(thirdTest)}\n${receipt(notesTest, { onDataChunks: 0 })}\n`
     )
     expect(problems).toEqual(['malformed receipt line: {"test":"trunc'])
   })
diff --git a/config/vitest.agent-status-benchmark.config.ts b/config/vitest.agent-status-benchmark.config.ts
new file mode 100644
index 00000000000..4bd0561d0ed
--- /dev/null
+++ b/config/vitest.agent-status-benchmark.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig } from 'vitest/config'
+import baseConfig from './vitest.config'
+
+export default defineConfig({
+  ...baseConfig,
+  test: {
+    ...baseConfig.test,
+    include: ['config/scripts/agent-status-hot-path-benchmark.ts'],
+    fileParallelism: false,
+    retry: 0
+  }
+})
diff --git a/docs/assets/readme-downloads.svg b/docs/assets/readme-downloads.svg
index 3f3cf232ad1..8d69c2e1d64 100644
--- a/docs/assets/readme-downloads.svg
+++ b/docs/assets/readme-downloads.svg
@@ -1,5 +1,5 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="106" height="20" role="img" aria-label="downloads: 91m">
-  <title>downloads: 91m</title>
+<svg xmlns="http://www.w3.org/2000/svg" width="106" height="20" role="img" aria-label="downloads: 93m">
+  <title>downloads: 93m</title>
   <linearGradient id="s" x2="0" y2="100%">
     <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
     <stop offset="1" stop-opacity=".1"/>
@@ -15,7 +15,7 @@
   <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="11">
     <text x="37" y="15" fill="#010101" fill-opacity=".3">downloads</text>
     <text x="37" y="14">downloads</text>
-    <text x="90" y="15" fill="#010101" fill-opacity=".3">91m</text>
-    <text x="90" y="14">91m</text>
+    <text x="90" y="15" fill="#010101" fill-opacity=".3">93m</text>
+    <text x="90" y="14">93m</text>
   </g>
 </svg>
diff --git a/docs/reference/ci-runner-efficiency.md b/docs/reference/ci-runner-efficiency.md
index 58cef59dde5..611ef54b8cb 100644
--- a/docs/reference/ci-runner-efficiency.md
+++ b/docs/reference/ci-runner-efficiency.md
@@ -2383,3 +2383,203 @@ These screens reject the examined changes; they do not establish that every
 future optimization is exhausted. Shorter admitted jobs and one shared preflight
 reduce demand on the existing runner allowance. They do not increase that
 allowance or prove lower queue delay under different account traffic.
+
+## October 5 remaining import, diagnostic and checkout work
+
+The [hosted comparison](https://github.com/stablyai/orca/actions/runs/37247027814)
+used three alternating pairs per treatment at source
+`b18b174cd463f852051dc22adc8478b82dee4d1f`. Focused tests ran as fresh one-worker
+processes on the four-core, 16 GB Linux ARM runner with Node 24.21.0, pnpm 12.8.1
+and Vitest 4.1.11; persisted transforms and Node compile caches were disabled.
+
+| Work                                              | Original median | Candidate median | Median paired saving |
+| ------------------------------------------------- | --------------- | ---------------- | -------------------- |
+| Real incumbent-process test file                  | 16.478s         | 5.976s           | 10.520s              |
+| Commentable-line lifecycle test file              | 9.595s          | 6.880s           | 2.714s               |
+| Agent-status diagnostic plus semantic test cohort | 11.547s         | 8.235s           | 3.361s               |
+| Windows x64 SSH checkout                          | 22.052s         | 16.884s          | 5.020s               |
+| Windows ARM SSH checkout                          | 46.758s         | 33.910s          | 13.456s              |
+
+The incumbent cases own distinct sockets, shim directories and process groups.
+Running them concurrently preserves all nine outcomes and every real five-second
+lsof deadline. Both original and candidate still reject an unreaped helper and
+false claims of clean enumeration. Fault receipts prove the actual modified probe
+was imported and all owned helpers, groups, sockets and directories were cleaned.
+The Windows platform gate retains all nine skips.
+
+The renderer lifecycle tests keep their six original bodies and real decorator,
+zone and model behavior. Only the unrelated saved-note delivery menu is replaced
+by a typed throwing facade. Its cleanup assertion rejects unexpected use. Actual
+faults in memoization, value-equal refreshes and model replacement still fail their
+original assertions; a real menu call fails the facade and the cleanup guard.
+
+The agent-status benchmark reports counters and timings but asserts only a
+nonempty status map and positive elapsed time. It remains available through
+`ORCA_BACKGROUND_LAUNCH=1 pnpm exec vitest run --config config/vitest.agent-status-benchmark.config.ts`.
+Ordinary discovery removes exactly that reporting test. Its 15 meaningful routing,
+index-retention and batch cases remain unchanged. Three real production faults
+pass the old reporting test and fail those retained contracts. Manual execution
+preserves its JSON schema and all nine deterministic counters at 423 worktrees,
+634 tabs and 1,000 events.
+
+Windows SSH hosts retain complete main, shared, relay, type, configuration,
+native, resource and test trees, plus root files. Six actual checkouts per
+architecture pinned candidate source `ce69b84d675b0a8b4763b03329c9d6549ac723f1`;
+all 16,568 retained files match the full checkout's contents, modes and index.
+The original 5,209 required inputs and six further inputs added by the source
+rebase are present. Local full/sparse builds match 54 generated artifacts;
+explicit test discovery is identical. Missing imported source, a named test or a
+required descriptor still fails. Full Windows native/provisioning lanes remain
+a separate qualification gate.
+
+Test timings exclude dependency setup, checkout and queues. Checkout timings
+include the action and shell/runner observation boundaries but exclude later
+builds and provisioning. These scoped savings must not be summed or treated as
+measured changes to full-shard occupancy or PR latency.
+
+## October 5 mobile typecheck overlap
+
+The [hosted comparison](https://github.com/stablyai/orca/actions/runs/37249591578)
+ran three alternating pairs on the four-core, 16 GB Linux ARM runner, with Node
+24.21.0 and TypeScript 6.0.3. The production compiler and test-typecheck ratchet
+use installed tools after dependency installation. Both resolved compiler
+programs have `noEmit: true`, with no incremental, composite or build-info writes.
+The change moves the existing unconditional production join after the foreground
+ratchet and before tests; it changes no compiler command or failure policy.
+
+| Complete typecheck stage | Original serial | Overlapped |
+| ------------------------ | --------------- | ---------- |
+| Pair 1                   | 68.284s         | 41.582s    |
+| Pair 2, reversed order   | 65.385s         | 41.042s    |
+| Pair 3                   | 64.240s         | 40.418s    |
+| Median                   | 65.385s         | 41.042s    |
+
+The median paired saving is 24.343 seconds, or 37.2% of this stage. The stage
+bracket includes native background/wait boundaries and observation overhead,
+but excludes dependency installation and the later test suite. All six stages
+preserve the three workers' compiler/ratchet verdicts and stdout/stderr hashes.
+The test compiler's existing diagnostics remain subject to the unchanged
+ratchet. Neither compiler attempted native loading or recorded filesystem
+mutations. Maximum aggregate owned-process RSS sampled every 200 milliseconds
+was 5.137 GiB; this is a sampled value rather than a kernel peak. The ratchet now
+runs even when the concurrently running production compiler later fails.
+
+Two real, independent type faults still prevent tests from starting. The
+production fault preserves the unaffected ratchet and child output; the test
+fault preserves the production output and fails the ratchet. Their explicit
+control receipts pass even though their intentionally failing jobs are allowed
+to finish collecting evidence.
+
+The separate [external cancellation control](https://github.com/stablyai/orca/actions/runs/37251289372)
+held the two real installed compiler entrypoints before checking, while retaining
+the production-background/ratchet-foreground topology. All three owned workers
+were observed alive 14.275 seconds before the cancellation request. Both native
+step outcomes became cancelled, tests did not start, and the runner's final
+cleanup log names all three exact worker PIDs. The attempted earlier assertion
+of PID absence failed: GitHub performs orphan cleanup after the always-tail
+observer and artifact upload. Post-cleanup absence was not observed and is not
+claimed. This control supplies no compiler-completion or timing measurement.
+
+## October 5 explicit RPC registry test setup
+
+The [hosted comparison](https://github.com/stablyai/orca/actions/runs/37251277897)
+ran three alternating pairs of the complete 156-file mixed cohort on source
+`d1e08ddd666e3099fc51c79f01f0305f5162186d`, using four workers on the four-core
+Linux ARM runner, Node 24.21.0, pnpm 12.8.1 and Vitest 4.1.11. Persisted module
+transforms and Node compile caches were disabled. All 153 candidate test files
+pass explicit method lists to their dispatchers. A shared throwing fixture
+prevents those tests from loading the unused default method catalog and rejects
+any accidental iteration of it. The three real catalog subjects remain
+unchanged and run beside the candidate subjects in every arm.
+
+| Complete cohort process | Original | Candidate | Paired saving |
+| ----------------------- | -------- | --------- | ------------- |
+| Pair 1                  | 142.184s | 89.238s   | 52.946s       |
+| Pair 2, reversed order  | 142.833s | 88.933s   | 53.900s       |
+| Pair 3                  | 141.274s | 90.186s   | 51.088s       |
+| Median                  | 142.184s | 89.238s   | 52.946s       |
+
+The median paired saving is 37.2% of this fixed cohort. All six arms preserve
+the complete ordered ledger, including duplicate parameterized case names:
+1,469 passes and one existing setup-dependent skip, totaling 1,470 outcomes.
+The real catalog subjects contribute 63 of those cases. Candidate bodies and
+assertions are unchanged. One file at its line limit uses the dispatch method's
+parameter type in place of its equivalent type-only import; its emitted code
+matches the measured candidate.
+
+Seventeen control invocations preserve actual terminal-handler fault detection,
+reject unexpected default-catalog consumption, and still detect a missing real
+catalog registration. A plain consumption counter prevents global mock-history
+resets from erasing the guard; actual `clearAllMocks` and `resetAllMocks` controls
+demonstrate that distinction and preserve unrelated call history. The isolated
+driver restores all source files after success, faults and a real cancellation.
+Independent review also confirms all 153 candidate sources, the fixture, three
+catalog subjects and declared qualification inputs survive the rebase unchanged.
+
+These are fresh-process wall times for this cohort, excluding dependency setup,
+queues and other test shards. They do not measure full-shard balance, total PR
+runner demand, or a change to the dashboard's PR runtime percentiles.
+
+## October 5 fused terminal cursor row scans
+
+Readiness checks repeatedly read terminal rows to recognize composer text.
+The shared reader now collects undimmed text and the first visible glyph's style
+in one pass. The cursor suffix remains a separate scan; dim glyph attributes,
+empty cells, wide characters and wrapped spaces keep their existing behavior.
+No grid data is retained between calls.
+
+The [hosted comparison](https://github.com/stablyai/orca/actions/runs/37263358478)
+used source `1bec53ceb23b5f296a38ffa0e085778d32fc7849`, Linux ARM,
+Node 24.21.0, pnpm 12.8.1 and one worker. All six fresh processes ran the same
+49-case readiness census module, with separate empty Vite caches, filesystem
+transform caching disabled and Node compile caching disabled.
+
+| Complete focused process | Original | Candidate | Paired saving |
+| ------------------------ | -------- | --------- | ------------- |
+| Pair 1                   | 66.412s  | 60.464s   | 5.948s        |
+| Pair 2, reversed order   | 66.880s  | 61.061s   | 5.819s        |
+| Pair 3                   | 68.056s  | 65.821s   | 2.234s        |
+
+The median paired saving is 5.819 seconds, or 8.7% of this fixed workload.
+All 294 timed case outcomes passed. Separate qualification preserves complete
+context/composer outputs on 98 recordings and the logical cursor/projection
+outputs of all 192 Runtime census cases. Nine actual scanner faults fail the
+intended assertions; the 89-case IME/composer slice also passes. Blank-row tests
+bound cell reads to 72 instead of the original 132 for a 12-column, five-row grid,
+with and without a reusable cell adapter.
+
+The raw timer-driven polling trace differed and was excluded from equivalence
+evidence. Logical per-frame output captures match; no raw polling-count equality
+is claimed. These measurements exclude setup, queues and other modules and do
+not establish a change in full-shard balance, PR percentiles or runner demand.
+
+## October 5 Qoder test import guards
+
+The direct Qoder Runtime tests now import the existing unused-default-RPC guard
+before their Runtime fixture. Their complete test bodies remain unchanged.
+The guard rejects an unexpected registry access instead of loading the full
+default-method graph. The three real registry catalogs remain unmocked.
+
+The [hosted comparison](https://github.com/stablyai/orca/actions/runs/37266875139)
+used fixed source `1bec53ceb23b5f296a38ffa0e085778d32fc7849`, Linux ARM,
+Node 24.21.0, pnpm 12.8.1 and four isolated fork workers. Every fresh process ran
+both Qoder files and all three catalogs: 85 cases across five files. Each invocation
+used a distinct empty Vite cache, with results, filesystem transform and Node
+compile caching disabled. All 510 timed outcomes passed.
+
+| Complete five-file process | Original | Candidate | Paired saving |
+| -------------------------- | -------- | --------- | ------------- |
+| Pair 1                     | 17.677s  | 16.323s   | 1.354s        |
+| Pair 2, reversed order     | 16.827s  | 16.021s   | 0.806s        |
+| Pair 3                     | 17.324s  | 16.211s   | 1.113s        |
+
+The median paired saving is 1.113 seconds, or 6.4% of this fixed workload.
+Separate actual faults in retained launch recipes, Qoder command selection and
+method registration fail the same intended assertions before and after the
+imports. Generated launch IDs and shifted stack lines differ in the raw failure
+messages; they were preserved and are not claimed byte-identical.
+
+The single hosted trial occupied 134 runner-seconds including all six samples,
+shared setup and upload. That is trial cost, not a production saving. These
+focused process measurements do not establish full-shard savings, PR runtime
+percentiles, queue relief or a change in the organization's runner allowance.
diff --git a/docs/reference/ime-regression-checklist.md b/docs/reference/ime-regression-checklist.md
index f7c7c2bed78..bad36127dd5 100644
--- a/docs/reference/ime-regression-checklist.md
+++ b/docs/reference/ime-regression-checklist.md
@@ -100,3 +100,47 @@ Each fix must pass all of these checks:
   regenerate its bundle patch and lockfile together.
 - Prefer deterministic replay or state-transition tests. Native evidence is a
   second layer, never a substitute for regression coverage.
+
+## Enter in application text fields (#25035)
+
+Use `Input`, `Textarea`, or `CommandInput` for styled fields. Existing unstyled
+fields with keyboard actions use `ImeInput` / `ImeTextarea` from
+`lib/ime-text-field.tsx`; those preserve the DOM element, styles, refs, and
+composition callbacks. They share `useImeEnterGestureOwnership` and keep
+IME-owned keys out of both field actions and bubbling form/menu shortcuts.
+Overlay primitives also reject IME-marked Escape in document capture, where
+field-level propagation guards cannot intercept dismissal.
+Do not add a second tracker at a call site already using a guarded field.
+Native Chat and the File Explorer inline name field retain their existing
+trackers because they also own specialized composition or element lifetimes.
+
+Required cases:
+
+- `isComposing`, `keyCode: 229` without `isComposing`, and `Process/229` must
+  never submit, choose a suggestion, or dismiss the field.
+- The unmarked Enter redispatch stays owned on either side of keyup, including
+  a `Process/229` release. A
+  subsequent ordinary typing/navigation key ends that carry immediately;
+  hidden renderers may defer animation frames, and typing a filename suffix
+  must not cause the next deliberate Enter to disappear.
+- Composition callbacks, blur, refs, and keyed remount cleanup still work.
+  Normal Enter, modifier submits, and Shift+Enter newlines remain available.
+- Test the actual shared field when a consumer delegates IME handling to it;
+  a mock that replaces `CommandInput` with a raw input removes the protection.
+
+`ime-text-field.test.tsx` covers primitives, raw fields, parent handlers, and
+command selection. File Explorer component tests cover all three operations
+and input replacement. `file-explorer-ime-enter.spec.ts` drives Chromium
+composition in New File, New Folder, and Rename in a folder workspace, then
+checks the complete name in the Explorer and on disk, with both continued typing
+and a redispatch followed by deliberate Enter. Overlay tests cover IME Escape
+and ordinary dismissal; Markdown tests preserve an unmarked save shortcut while
+composition state lingers. These are CDP event
+contracts, not native OS keyboard evidence.
+
+The audit also covers settings and title fields, issue/review creation and
+pickers, comments and annotations, search fields, Native Chat questions,
+notebook execution shortcuts, and Markdown menu handlers. Terminal input keeps
+its existing xterm/PTY ownership; mobile native fields use `onSubmitEditing`
+instead of desktop DOM keydown actions. Remote workspaces use the same renderer
+fields; file-operation routing and mixed-version wire contracts are unchanged.
diff --git a/docs/site/content/docs/cli/orchestration.mdx b/docs/site/content/docs/cli/orchestration.mdx
index d83d27836cf..88355cb8c82 100644
--- a/docs/site/content/docs/cli/orchestration.mdx
+++ b/docs/site/content/docs/cli/orchestration.mdx
@@ -44,7 +44,7 @@ orca orchestration worker-start --task <taskId> --worktree new-child --name bill
 orca orchestration worker-start --task <taskId> --worktree current --agent claude --model <opaque-model-id> --effort high --json
 ```
 
-`--agent` takes any Orca agent ID enabled on the worker server, for example `claude`, `codex`, `cursor`, `antigravity`, `muse`, `opencode`, or `opencode2`. `--model` accepts opaque provider model IDs for Claude, Codex, Cursor, Antigravity, and Muse (for example `--agent muse --model muse-spark-1.3`); other agents, including opencode, run the model from their own config. `--effort` requires `--model` and only applies when that agent/model supports the level. Neither flag can combine with `--terminal` (reuse an existing pane). Overrides apply to that launch only and show under `launch.requested` / `launch.effective` in the start receipt. Federated starts need a worker host that advertises launch-preference support.
+`--agent` takes any Orca agent ID enabled on the worker server, for example `claude`, `codex`, `cursor`, `antigravity`, `muse`, `opencode`, or `opencode2`. `--model` accepts opaque provider model IDs for Claude, Codex, Cursor, Antigravity, and Muse (for example `--agent muse --model muse-spark-1.3`); OpenCode accepts a per-launch model only in an existing worktree, when the execution host verifies its CLI version and model availability; OpenCode effort remains unsupported. Other agents run the model from their own config. `--effort` requires `--model` and only applies when that agent/model supports the level. Neither flag can combine with `--terminal` (reuse an existing pane). Overrides apply to that launch only and show under `launch.requested` / `launch.effective` in the start receipt. Federated starts need a worker host that advertises launch-preference support.
 
 Wait for completions (process every message in a Delivery, then ack):
 
diff --git a/mobile/app/terminal-settings.tsx b/mobile/app/terminal-settings.tsx
index 1b9ce53fa41..4720705bf91 100644
--- a/mobile/app/terminal-settings.tsx
+++ b/mobile/app/terminal-settings.tsx
@@ -279,7 +279,7 @@ export default function TerminalSettingsScreen() {
           While you&apos;re using a terminal on your phone, Orca shrinks it to fit your screen. When
           you close the app or switch away, this controls whether it stays at phone size (so
           interactive CLI tools don&apos;t reflow) or resizes back to your desktop. You can always
-          use Restore this terminal or Restore all terminals on the banner to resize manually.
+          use Restore on the desktop banner to resize manually.
         </Text>
 
         {hosts.length === 0 ? (
diff --git a/mobile/src/agent-history/MobileAgentSessionHistoryPanel.tsx b/mobile/src/agent-history/MobileAgentSessionHistoryPanel.tsx
index dde5593278e..e3e13505134 100644
--- a/mobile/src/agent-history/MobileAgentSessionHistoryPanel.tsx
+++ b/mobile/src/agent-history/MobileAgentSessionHistoryPanel.tsx
@@ -1,13 +1,4 @@
-import { optionalSettingsRead } from '../transport/settings-read-operations'
-import { interpretOrThrowRefusalMessage } from '../transport/rpc-refusal-message'
-import { rpcPayloadMember } from '../transport/rpc-reader-payload'
-import { readAcceptedResumeList } from './resume-metadata-lists'
-import {
-  resumeFolderWorkspaceListRead,
-  resumeProjectGroupListRead,
-  resumeRepoListRead,
-  resumeWorktreeListRead
-} from './mobile-agent-history-operations'
+import { loadMobileResumeMetadata } from './mobile-agent-history-resume-metadata'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { ActivityIndicator, Pressable, Text, TextInput, View } from 'react-native'
 import { SafeAreaView } from 'react-native-safe-area-context'
@@ -15,22 +6,17 @@ import { useRouteHandoff } from '../navigation/route-handoff'
 import { ChevronLeft, RefreshCw } from 'lucide-react-native'
 import { colors } from '../theme/mobile-theme'
 import { useHostClient } from '../transport/client-context'
-import type { RpcClient } from '../transport/rpc-client'
-import { readMobileRuntimeHostPlatform } from '../transport/mobile-runtime-host-platform'
 import { worktreeCatalogRead } from '../worktree/worktree-catalog-operations'
 import { getWorktreeLabel } from '../session/worktree-label'
 import {
   buildMobileAiVaultResumeLaunch,
   createMobileAiVaultResumeMutationRegistry,
+  readMobileAiVaultResumeHost,
   readMobileRuntimeTerminalWindowsShell,
   resolveMobileAiVaultResumePlatform,
-  resumeAiVaultSessionInTerminal,
-  type MobileAiVaultResumeSettings
+  resumeAiVaultSessionInTerminal
 } from '../session/ai-vault-resume-launch'
-import {
-  prepareMobileAiVaultSessionResume,
-  RESUME_RPC_TIMEOUT_MS
-} from '../session/ai-vault-resume-preparation'
+import { prepareMobileAiVaultSessionResume } from '../session/ai-vault-resume-preparation'
 import { triggerError, triggerSuccess } from '../platform/haptics'
 import type { AiVaultScope, AiVaultSession } from '../../../src/shared/ai-vault-types'
 import type { Worktree } from '../worktree/workspace-list-types'
@@ -38,15 +24,11 @@ import { useMobileAgentHistoryState } from './use-mobile-agent-history-state'
 import { buildMobileAgentHistorySections } from './agent-history-sections'
 import { shouldShowMobileCurrentWorktreeBadge } from './agent-history-current-worktree-badge'
 import { MobileAgentSessionHistoryList } from './MobileAgentSessionHistoryList'
-import {
-  resolveMobileAiVaultSessionResumeTarget,
-  type MobileAiVaultResumeFolderWorkspace,
-  type MobileAiVaultResumeProjectGroup,
-  type MobileAiVaultResumeRepo
-} from './agent-history-resume-target'
+import { resolveMobileAiVaultSessionResumeTarget } from './agent-history-resume-target'
 import { buildMobileAgentHistoryResumeActionState } from './agent-history-session-card'
 import { styles } from './agent-history-styles'
 import { useNow } from '../hooks/use-now'
+import { useMobileResumeOperationOwnership } from './use-mobile-resume-operation-ownership'
 
 export type MobileAgentSessionHistoryPanelProps = {
   hostId: string
@@ -69,6 +51,12 @@ export function MobileAgentSessionHistoryPanel({
   // screen, and the session it resumes into is a native route the shell has to push.
   const router = useRouteHandoff()
   const { client, state: connState } = useHostClient(hostId)
+  const claimResumeOwnership = useMobileResumeOperationOwnership(
+    hostId,
+    worktreeId,
+    client,
+    connState
+  )
   const [worktrees, setWorktrees] = useState<Worktree[]>([])
   const [worktreesLoaded, setWorktreesLoaded] = useState(false)
   const [query, setQuery] = useState('')
@@ -147,8 +135,8 @@ export function MobileAgentSessionHistoryPanel({
     [sessions, query, scope, scopeFilterPaths, activeWorktreePath, now]
   )
 
-  const hostPlatform = useMemo(
-    () => readMobileRuntimeHostPlatform(hostStatusResult),
+  const resumeHost = useMemo(
+    () => readMobileAiVaultResumeHost(hostStatusResult),
     [hostStatusResult]
   )
   const hostTerminalWindowsShell = useMemo(
@@ -177,6 +165,7 @@ export function MobileAgentSessionHistoryPanel({
         return
       }
 
+      const assertCurrentOwner = claimResumeOwnership()
       resumeLaunchInFlightRef.current = true
       setResumingSessionId(session.id)
       setResumeMessage(null)
@@ -188,6 +177,7 @@ export function MobileAgentSessionHistoryPanel({
           settings,
           worktrees: freshWorktrees
         } = await loadMobileResumeMetadata(client)
+        assertCurrentOwner()
         const target = resolveMobileAiVaultSessionResumeTarget({
           session,
           activeWorktreeId: worktreeId,
@@ -207,7 +197,7 @@ export function MobileAgentSessionHistoryPanel({
 
         const platform = resolveMobileAiVaultResumePlatform(
           target.targetStatus,
-          hostPlatform,
+          resumeHost.platform,
           target.workspacePath,
           target.terminalPlatform
         )
@@ -218,18 +208,31 @@ export function MobileAgentSessionHistoryPanel({
         }
 
         const preparedSession = await prepareMobileAiVaultSessionResume(client, session)
+        assertCurrentOwner()
         const launch = buildMobileAiVaultResumeLaunch({
           session: preparedSession,
           hostPlatform: platform,
           hostTerminalWindowsShell,
           settings
         })
-        await resumeAiVaultSessionInTerminal(client, target.worktreeId, {
-          ...launch,
-          clientMutationId: resumeMutationRegistryRef.current.claim(session.id)
-        })
+        await resumeAiVaultSessionInTerminal(
+          client,
+          target.worktreeId,
+          {
+            ...launch,
+            hostCapabilities: resumeHost.capabilities,
+            clientMutationId: resumeMutationRegistryRef.current.claim(session.id)
+          },
+          assertCurrentOwner
+        )
         resumeMutationRegistryRef.current.releaseOnSuccess(session.id)
         triggerSuccess()
+        // The host accepted the resume; a cutover now only stops navigation.
+        try {
+          assertCurrentOwner()
+        } catch {
+          return
+        }
         setResumeMessage('Agent session queued.')
         router.push(
           `/h/${encodeURIComponent(hostId)}/session/${encodeURIComponent(target.worktreeId)}` as Parameters<
@@ -248,11 +251,12 @@ export function MobileAgentSessionHistoryPanel({
       client,
       connState,
       hostId,
-      hostPlatform,
+      resumeHost,
       hostTerminalWindowsShell,
       router,
       worktreeId,
-      worktrees
+      worktrees,
+      claimResumeOwnership
     ]
   )
 
@@ -377,57 +381,6 @@ export function MobileAgentSessionHistoryPanel({
 const EMPTY_SESSIONS: AiVaultSession[] = []
 const EMPTY_ISSUES: { agent: AiVaultSession['agent']; path: string; message: string }[] = []
 
-async function loadMobileResumeMetadata(client: RpcClient): Promise<{
-  repos: MobileAiVaultResumeRepo[]
-  folderWorkspaces: MobileAiVaultResumeFolderWorkspace[]
-  projectGroups: MobileAiVaultResumeProjectGroup[]
-  settings: MobileAiVaultResumeSettings | null
-  worktrees: Worktree[] | null
-}> {
-  // Why: repo.list can enrich repo remote identities, so fetch resume-only
-  // metadata after explicit user intent instead of delaying history browsing.
-  // timeoutMs: without it a socket drop parks these on the reconnect waiter
-  // for minutes, pinning the resume spinner (see RESUME_RPC_TIMEOUT_MS).
-  const [repoReply, folderWorkspaceReply, projectGroupReply, settingsReply, worktreeReply] =
-    await Promise.all([
-      resumeRepoListRead.request(client, undefined, { timeoutMs: RESUME_RPC_TIMEOUT_MS }),
-      resumeFolderWorkspaceListRead
-        .request(client, undefined, { timeoutMs: RESUME_RPC_TIMEOUT_MS })
-        .catch(() => null),
-      resumeProjectGroupListRead
-        .request(client, undefined, { timeoutMs: RESUME_RPC_TIMEOUT_MS })
-        .catch(() => null),
-      optionalSettingsRead
-        .request(client, undefined, { timeoutMs: RESUME_RPC_TIMEOUT_MS })
-        .catch(() => null),
-      resumeWorktreeListRead
-        .request(client, { limit: 10000 }, { timeoutMs: RESUME_RPC_TIMEOUT_MS })
-        .catch(() => null)
-    ])
-  const repoResult = interpretOrThrowRefusalMessage(
-    () => resumeRepoListRead.interpret(repoReply),
-    'Unable to load workspace metadata.'
-  )
-  const folderWorkspaceResult =
-    folderWorkspaceReply && resumeFolderWorkspaceListRead.interpret(folderWorkspaceReply)
-  const projectGroupResult =
-    projectGroupReply && resumeProjectGroupListRead.interpret(projectGroupReply)
-  const settingsResult = settingsReply ? optionalSettingsRead.interpret(settingsReply) : null
-  const settings = settingsResult?.accepted
-    ? // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: Preserve the established response shape at this boundary.
-      (settingsResult.value as MobileAiVaultResumeSettings | null | undefined)
-    : null
-  const worktreeResult = worktreeReply && resumeWorktreeListRead.interpret(worktreeReply)
-  return {
-    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: Preserve the established response shape at this boundary.
-    repos: (rpcPayloadMember(repoResult, 'repos') as MobileAiVaultResumeRepo[] | undefined) ?? [],
-    folderWorkspaces: readAcceptedResumeList(folderWorkspaceResult, 'folderWorkspaces') ?? [],
-    projectGroups: readAcceptedResumeList(projectGroupResult, 'groups') ?? [],
-    settings: settings ?? null,
-    worktrees: readAcceptedResumeList(worktreeResult, 'worktrees') ?? null
-  }
-}
-
 function createMobileAiVaultResumeMutationId(sessionId: string): string {
   const sessionPart = sessionId.replace(/[^a-zA-Z0-9_.:-]/g, '_').slice(0, 64) || 'session'
   const randomPart = Math.random().toString(36).slice(2, 10)
diff --git a/mobile/src/agent-history/agent-history-current-host-capability.test.tsx b/mobile/src/agent-history/agent-history-current-host-capability.test.tsx
new file mode 100644
index 00000000000..51d4a91f955
--- /dev/null
+++ b/mobile/src/agent-history/agent-history-current-host-capability.test.tsx
@@ -0,0 +1,196 @@
+import { createElement } from 'react'
+import { act, create, type ReactTestRenderer } from 'react-test-renderer'
+import { expect, it, vi } from 'vitest'
+import type { RpcClient } from '../transport/rpc-client'
+import type { ConnectionState, RpcResponse } from '../transport/types'
+import type { Worktree } from '../worktree/workspace-list-types'
+import { QODER_OWNED_TERMINAL_CREATE_CAPABILITY } from '../../../src/shared/qoder-terminal-create-capability'
+
+const connection = vi.hoisted((): { client: RpcClient | null; state: ConnectionState } => ({
+  client: null,
+  state: 'connected'
+}))
+vi.mock('../transport/client-context', () => ({
+  useHostClient: () => connection,
+  useForceReconnect: () => vi.fn()
+}))
+import {
+  useMobileAgentHistoryState,
+  type MobileAgentHistoryState
+} from './use-mobile-agent-history-state'
+import {
+  buildMobileAiVaultResumeLaunch,
+  readMobileAiVaultResumeHost,
+  resumeAiVaultSessionInTerminal
+} from '../session/ai-vault-resume-launch'
+
+function fakeClient(sendRequest: RpcClient['sendRequest'], generation?: () => number): RpcClient {
+  return {
+    sendRequest,
+    subscribe: () => () => {},
+    updateTerminalSubscriptionViewport: () => {},
+    getState: () => connection.state,
+    getReconnectAttempt: () => 0,
+    getLastConnectedAt: () => null,
+    onStateChange: () => () => {},
+    notifyForeground: () => {},
+    close: () => {},
+    ...(generation ? { getGeneration: generation } : {})
+  }
+}
+
+it.each([
+  'host/client replacement',
+  'host replacement',
+  'same-client generation',
+  'legacy-client reconnect'
+])('requires current host evidence before owned resume: %s', async (scenario) => {
+  const cap = QODER_OWNED_TERMINAL_CREATE_CAPABILITY
+  const worktrees: Worktree[] = []
+  const observed: { current: MobileAgentHistoryState | null } = { current: null }
+  const rendered: { tree: ReactTestRenderer | null } = { tree: null }
+  let generation = 1
+  let hostId = 'owned-host-a'
+  const read = () => {
+    if (!observed.current) {
+      throw new Error('missing history state')
+    }
+    return observed.current
+  }
+  function Probe() {
+    observed.current = useMobileAgentHistoryState({
+      hostId,
+      worktreeId: 'owned-worktree',
+      worktrees,
+      worktreesLoaded: true
+    })
+    return null
+  }
+  const firstStatus: RpcResponse = {
+    id: 'owned-reply',
+    ok: true,
+    result: { hostPlatform: 'darwin', capabilities: ['aiVault.v1', cap] }
+  }
+  const initialSend = vi.fn<RpcClient['sendRequest']>(async (method) =>
+    method === 'status.get'
+      ? firstStatus
+      : { id: 'owned-reply', ok: true, result: { sessions: [], issues: [] } }
+  )
+  const initialClient = fakeClient(
+    initialSend,
+    scenario === 'legacy-client reconnect' ? undefined : () => generation
+  )
+  connection.client = initialClient
+  connection.state = 'connected'
+  await act(async () => {
+    rendered.tree = create(createElement(Probe))
+  })
+  try {
+    expect(read().screenState.kind).toBe('ready')
+    expect(readMobileAiVaultResumeHost(read().hostStatusResult).capabilities).toContain(cap)
+    let resolveRetired: (reply: RpcResponse) => void = () => {}
+    const retiredStatus = new Promise<RpcResponse>((resolve) => {
+      resolveRetired = resolve
+    })
+    initialSend.mockImplementation(async () => retiredStatus)
+    let refresh: Promise<void> | undefined
+    await act(async () => {
+      refresh = read().onRefresh()
+    })
+    let resolveStatus: (reply: RpcResponse) => void = () => {}
+    const pendingStatus = new Promise<RpcResponse>((resolve) => {
+      resolveStatus = resolve
+    })
+    const currentSend = vi.fn<RpcClient['sendRequest']>(async (method) => {
+      if (method === 'status.get') {
+        return pendingStatus
+      }
+      if (method === 'session.tabs.createTerminal') {
+        return {
+          id: 'owned-reply',
+          ok: true,
+          result: {
+            tab: { type: 'terminal', id: 'owned-tab', terminal: 'owned-pty', title: 'Terminal' }
+          }
+        }
+      }
+      if (method === 'terminal.send') {
+        return { id: 'owned-reply', ok: true, result: { send: { accepted: true } } }
+      }
+      return { id: 'owned-reply', ok: true, result: { sessions: [], issues: [] } }
+    })
+    let currentClient = initialClient
+    if (scenario === 'host/client replacement') {
+      currentClient = fakeClient(currentSend, () => 2)
+      connection.client = currentClient
+      hostId = 'owned-host-b'
+    } else {
+      initialSend.mockImplementation(currentSend)
+      if (scenario === 'host replacement') {
+        hostId = 'owned-host-b'
+      } else if (scenario === 'same-client generation') {
+        generation = 2
+      } else {
+        connection.state = 'reconnecting'
+        await act(async () => {
+          rendered.tree?.update(createElement(Probe))
+        })
+        connection.state = 'connected'
+      }
+    }
+    await act(async () => {
+      rendered.tree?.update(createElement(Probe))
+    })
+    expect(read().screenState.kind).toBe('ready')
+    const launch = buildMobileAiVaultResumeLaunch({
+      session: {
+        agent: 'qoder',
+        sessionId: 'owned-session',
+        cwd: '/owned/workspace',
+        codexHome: null
+      },
+      hostPlatform: 'darwin'
+    })
+    await act(async () => {
+      resolveRetired(firstStatus)
+      await refresh
+    })
+    const pendingHost = readMobileAiVaultResumeHost(read().hostStatusResult)
+    expect(pendingHost.capabilities?.includes(cap) ?? false).toBe(false)
+    await resumeAiVaultSessionInTerminal(currentClient, 'owned-worktree', {
+      ...launch,
+      hostCapabilities: pendingHost.capabilities,
+      clientMutationId: 'pending-probe-resume'
+    })
+    const firstCreate = currentSend.mock.calls.find(
+      ([method]) => method === 'session.tabs.createTerminal'
+    )
+    expect(firstCreate?.[1]).not.toHaveProperty('command')
+    expect(currentSend.mock.calls.map(([method]) => method)).toContain('terminal.send')
+    await act(async () => {
+      resolveStatus({
+        id: 'owned-reply',
+        ok: true,
+        result: { hostPlatform: 'linux', capabilities: ['aiVault.v1', cap] }
+      })
+    })
+    expect(readMobileAiVaultResumeHost(read().hostStatusResult)).toEqual({
+      platform: 'linux',
+      capabilities: ['aiVault.v1', cap]
+    })
+    currentSend.mockClear()
+    await resumeAiVaultSessionInTerminal(currentClient, 'owned-worktree', {
+      ...launch,
+      hostCapabilities: readMobileAiVaultResumeHost(read().hostStatusResult).capabilities,
+      clientMutationId: 'current-probe-resume'
+    })
+    expect(
+      currentSend.mock.calls.find(([method]) => method === 'session.tabs.createTerminal')?.[1]
+    ).toEqual(expect.objectContaining({ command: launch.command }))
+    expect(currentSend.mock.calls.map(([method]) => method)).not.toContain('terminal.send')
+  } finally {
+    await act(async () => {
+      rendered.tree?.unmount()
+    })
+  }
+})
diff --git a/mobile/src/agent-history/agent-history-pending-resume-ownership.test.tsx b/mobile/src/agent-history/agent-history-pending-resume-ownership.test.tsx
new file mode 100644
index 00000000000..ecfdd4bae9c
--- /dev/null
+++ b/mobile/src/agent-history/agent-history-pending-resume-ownership.test.tsx
@@ -0,0 +1,350 @@
+import { expect, it, vi } from 'vitest'
+import React from 'react'
+import type { AiVaultSession } from '../../../src/shared/ai-vault-types'
+import { CreateTerminalTab } from '../../../src/shared/rpc-contract/session-tabs-schemas-params'
+import type { RpcClient } from '../transport/rpc-client'
+import type { ConnectionState, RpcResponse } from '../transport/types'
+import { createFakeRpcClient } from '../mobile-web-shell/bridge-host-test-fakes'
+import { act, create, type ReactTestRenderer } from 'react-test-renderer'
+const state = vi.hoisted(
+  (): {
+    generation: number
+    client: RpcClient | null
+    connection: ConnectionState
+    legacy: boolean
+    completedBoundary: boolean
+    session: AiVaultSession | null
+    onResume?: (session: AiVaultSession) => Promise<void>
+  } => ({
+    generation: 1,
+    client: null,
+    connection: 'connected',
+    legacy: false,
+    completedBoundary: false,
+    session: null
+  })
+)
+vi.mock('react-native', () => ({
+  ActivityIndicator: 'ActivityIndicator',
+  Pressable: 'Pressable',
+  RefreshControl: 'RefreshControl',
+  SectionList: 'SectionList',
+  Text: 'Text',
+  TextInput: 'TextInput',
+  View: 'View',
+  Platform: { OS: 'web', select: (choices: Record<string, unknown>) => choices.web },
+  AppState: { currentState: 'active', addEventListener: () => ({ remove() {} }) },
+  StyleSheet: { create: (value: unknown) => value, hairlineWidth: 1 }
+}))
+vi.mock('react-native-safe-area-context', () => ({
+  SafeAreaView: 'SafeAreaView',
+  useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 })
+}))
+vi.mock('react-native-svg', () => ({ default: 'Svg', Path: 'Path' }))
+vi.mock('lucide-react-native', () => ({ ChevronLeft: 'Icon', Play: 'Icon', RefreshCw: 'Icon' }))
+const notifications = vi.hoisted(() => ({ error: vi.fn(), success: vi.fn(), push: vi.fn() }))
+vi.mock('../platform/haptics', () => ({
+  triggerError: notifications.error,
+  triggerSuccess: notifications.success
+}))
+vi.mock('../components/MobileAgentIcon', () => ({ MobileAgentIcon: () => null }))
+vi.mock('../navigation/route-handoff', () => ({
+  useRouteHandoff: () => ({ push: notifications.push, back: vi.fn(), canGoBack: () => false })
+}))
+vi.mock('../transport/client-context', () => ({
+  useHostClient: () => ({ client: state.client, state: state.connection }),
+  useForceReconnect: () => vi.fn()
+}))
+vi.mock('./use-mobile-agent-history-state', () => ({
+  useMobileAgentHistoryState: () => ({
+    scope: 'workspace',
+    screenState: { kind: 'ready', sessions: [state.session], issues: [] },
+    refreshing: false,
+    hostStatusResult:
+      state.generation === 1
+        ? {
+            hostPlatform: 'darwin',
+            capabilities: state.legacy ? [] : ['aiVault.v1', 'session.tabs.qoderOwnedCreate.v1']
+          }
+        : state.completedBoundary
+          ? { hostPlatform: 'darwin', capabilities: [] }
+          : null,
+    activeWorktreePath: '/owned/workspace',
+    scopeFilterPaths: ['/owned/workspace'],
+    onSelectScope: vi.fn(),
+    onRefresh: vi.fn(),
+    retry: vi.fn()
+  })
+}))
+vi.mock('./MobileAgentSessionHistoryList', () => ({
+  MobileAgentSessionHistoryList: (props: {
+    onResume: (session: AiVaultSession) => Promise<void>
+  }) => {
+    state.onResume = props.onResume
+    return null
+  }
+}))
+import { MobileAgentSessionHistoryPanel } from './MobileAgentSessionHistoryPanel'
+
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true })
+it.each([
+  ['stable', 'metadata'],
+  ['generation', 'metadata'],
+  ['generation without render', 'metadata'],
+  ['client', 'metadata'],
+  ['host', 'metadata'],
+  ['legacy reconnect', 'metadata'],
+  ['unmount', 'metadata'],
+  ['stable', 'preparation'],
+  ['generation', 'preparation'],
+  ['disconnect', 'preparation'],
+  ['stable', 'terminal creation'],
+  ['generation', 'terminal creation'],
+  ['stable', 'accepted send'],
+  ['generation', 'accepted send'],
+  ['generation without render', 'accepted send'],
+  ['host', 'accepted send'],
+  ['unmount', 'accepted send'],
+  ['generation', 'owned create accepted']
+])('pending resume keeps its owner: %s during %s', async (scenario, boundary) => {
+  const cutover = scenario !== 'stable'
+  let hostId = 'owned-host'
+  notifications.error.mockClear()
+  notifications.success.mockClear()
+  notifications.push.mockClear()
+  state.legacy = boundary === 'accepted send'
+  state.completedBoundary = state.legacy || boundary === 'owned create accepted'
+  state.generation = 1
+  state.connection = 'connected'
+  state.session = {
+    id: 'qoder:owned-session',
+    executionHostId: 'local',
+    agent: 'qoder',
+    sessionId: 'owned-session',
+    title: 'Owned session',
+    cwd: '/owned/workspace',
+    branch: null,
+    model: null,
+    filePath: '/owned/qoder-session.json',
+    codexHome: null,
+    createdAt: null,
+    updatedAt: null,
+    modifiedAt: '2026-10-04T00:00:00.000Z',
+    messageCount: 2,
+    totalTokens: 10,
+    previewMessages: [],
+    queuedMessageCount: 0,
+    subagentTranscriptCount: 0,
+    resumeCommand: '',
+    subagent: null
+  }
+  if (boundary === 'preparation' || boundary === 'terminal creation') {
+    state.session.agent = 'codex'
+    state.session.codexHome = '/Users/ada/Library/Application Support/orca/codex-runtime-home/home'
+  }
+  const worktrees = [
+    {
+      worktreeId: 'owned-worktree',
+      repoId: 'owned-repo',
+      repo: 'Owned',
+      path: '/owned/workspace',
+      branch: 'main',
+      displayName: 'Owned',
+      liveTerminalCount: 0,
+      hasAttachedPty: false,
+      preview: '',
+      unread: false,
+      isPinned: false,
+      linkedPR: null
+    }
+  ]
+  const calls: { method: string; params: unknown; generation: number }[] = []
+  let rejectOptional: (error: Error) => void = () => {}
+  let resolveOptional: (reply: RpcResponse) => void = () => {}
+  const pendingOptional = new Promise<RpcResponse>((resolve, reject) => {
+    rejectOptional = reject
+    resolveOptional = resolve
+  })
+  const sendRequest: RpcClient['sendRequest'] = vi.fn<RpcClient['sendRequest']>(
+    async (method, params) => {
+      calls.push({ method, params, generation: state.generation })
+      if (method === 'repo.list') {
+        return {
+          id: 'owned-reply',
+          ok: true,
+          result: { repos: [{ id: 'owned-repo', path: '/owned/workspace', connectionId: null }] }
+        }
+      }
+      if (method === 'folderWorkspace.list') {
+        return boundary === 'metadata'
+          ? pendingOptional
+          : { id: 'owned-reply', ok: true, result: { workspaces: [] } }
+      }
+      if (method === 'aiVault.prepareSessionResume') {
+        return boundary === 'preparation'
+          ? pendingOptional
+          : { id: 'owned-reply', ok: true, result: { useRealCodexHome: true } }
+      }
+      if (method === 'projectGroup.list') {
+        return { id: 'owned-reply', ok: true, result: { groups: [] } }
+      }
+      if (method === 'worktree.ps') {
+        return { id: 'owned-reply', ok: true, result: { worktrees } }
+      }
+      if (method === 'settings.get') {
+        return { id: 'owned-reply', ok: true, result: {} }
+      }
+      if (method === 'session.tabs.createTerminal') {
+        return boundary === 'terminal creation' || boundary === 'owned create accepted'
+          ? pendingOptional
+          : {
+              id: 'owned-reply',
+              ok: true,
+              result: {
+                tab: { type: 'terminal', id: 'owned-tab', terminal: 'owned-pty', title: 'Terminal' }
+              }
+            }
+      }
+      if (method === 'terminal.send') {
+        if (boundary === 'accepted send') {
+          return pendingOptional
+        }
+        return { id: 'owned-reply', ok: true, result: { send: { accepted: true } } }
+      }
+      throw new Error(`Unexpected method ${method}`)
+    }
+  )
+  const client = {
+    ...createFakeRpcClient(
+      scenario === 'legacy reconnect' ? {} : { getGeneration: () => state.generation }
+    ),
+    sendRequest
+  }
+  state.client = client
+  const rendered: { tree: ReactTestRenderer | null } = { tree: null }
+  let resume: Promise<void> | undefined
+  const panel = () =>
+    React.createElement(
+      React.StrictMode,
+      null,
+      React.createElement(MobileAgentSessionHistoryPanel, { hostId, worktreeId: 'owned-worktree' })
+    )
+  await act(async () => {
+    rendered.tree = create(panel())
+  })
+  try {
+    await act(async () => {
+      if (!rendered.tree) {
+        throw new Error('missing panel')
+      }
+      if (!state.session || !state.onResume) {
+        throw new Error('missing resume callback')
+      }
+      resume = state.onResume(state.session)
+    })
+    expect(calls.some((call) => call.method === 'repo.list')).toBe(true)
+    expect(calls.some((call) => call.method === 'folderWorkspace.list')).toBe(true)
+    if (
+      boundary === 'terminal creation' ||
+      boundary === 'owned create accepted' ||
+      boundary === 'accepted send'
+    ) {
+      expect(calls.some((call) => call.method === 'session.tabs.createTerminal')).toBe(true)
+    }
+    if (boundary === 'preparation') {
+      expect(calls.some((call) => call.method === 'aiVault.prepareSessionResume')).toBe(true)
+    }
+    if (scenario === 'generation' || scenario === 'generation without render') {
+      state.generation = 2
+    }
+    if (scenario === 'client') {
+      state.client = { ...createFakeRpcClient(), sendRequest }
+    }
+    if (scenario === 'host') {
+      hostId = 'replacement-host'
+    }
+    if (scenario === 'legacy reconnect' || scenario === 'disconnect') {
+      state.connection = 'reconnecting'
+      await act(async () => {
+        rendered.tree?.update(panel())
+      })
+      if (scenario === 'legacy reconnect') {
+        state.connection = 'connected'
+      }
+    }
+    if (scenario === 'unmount') {
+      await act(async () => {
+        rendered.tree?.unmount()
+      })
+    } else if (scenario !== 'generation without render' && cutover) {
+      await act(async () => {
+        rendered.tree?.update(panel())
+      })
+    }
+    await act(async () => {
+      if (boundary === 'terminal creation' || boundary === 'owned create accepted') {
+        resolveOptional({
+          id: 'owned-reply',
+          ok: true,
+          result: {
+            tab: { type: 'terminal', id: 'owned-tab', terminal: 'owned-pty', title: 'Terminal' }
+          }
+        })
+      } else if (boundary === 'accepted send') {
+        resolveOptional({ id: 'owned-reply', ok: true, result: { send: { accepted: true } } })
+      } else if (boundary === 'preparation' && !cutover) {
+        resolveOptional({ id: 'owned-reply', ok: true, result: { useRealCodexHome: true } })
+      } else {
+        rejectOptional(new Error('client_disconnected'))
+      }
+      await resume
+    })
+    const createCall = calls.find((call) => call.method === 'session.tabs.createTerminal')
+    if (boundary === 'accepted send' || boundary === 'owned create accepted') {
+      expect(createCall).toBeDefined()
+      expect(calls.filter((call) => call.method === 'terminal.send')).toHaveLength(
+        state.legacy ? 1 : 0
+      )
+      const completion = {
+        errors: notifications.error.mock.calls.length,
+        successes: notifications.success.mock.calls.length,
+        navigations: notifications.push.mock.calls.length
+      }
+      if (scenario !== 'unmount') {
+        await act(async () => {
+          if (!state.session || !state.onResume) {
+            throw new Error('missing retry')
+          }
+          await state.onResume(state.session)
+        })
+        const creates = calls.filter((call) => call.method === 'session.tabs.createTerminal')
+        expect(creates).toHaveLength(2)
+        const originalCreate = CreateTerminalTab.parse(createCall?.params)
+        const retryCreate = CreateTerminalTab.parse(creates[1].params)
+        expect(originalCreate.clientMutationId).toEqual(expect.any(String))
+        expect(retryCreate.clientMutationId).toEqual(expect.any(String))
+        expect(retryCreate.clientMutationId).not.toBe(originalCreate.clientMutationId)
+      }
+      expect(completion).toEqual({ errors: 0, successes: 1, navigations: cutover ? 0 : 1 })
+    } else if (cutover) {
+      if (boundary === 'terminal creation') {
+        expect(createCall).toBeDefined()
+      } else {
+        expect(createCall).toBeUndefined()
+      }
+      expect(calls.some((call) => call.method === 'terminal.send')).toBe(false)
+    } else {
+      expect(createCall, JSON.stringify(calls)).toBeDefined()
+      if (boundary === 'metadata') {
+        expect(createCall?.params).toEqual(
+          expect.objectContaining({ command: expect.stringContaining('owned-session') })
+        )
+      } else {
+        expect(createCall?.params).not.toHaveProperty('command')
+        expect(calls.some((call) => call.method === 'terminal.send')).toBe(true)
+      }
+    }
+  } finally {
+    await act(async () => rendered.tree?.unmount())
+  }
+})
diff --git a/mobile/src/agent-history/mobile-agent-history-resume-metadata.ts b/mobile/src/agent-history/mobile-agent-history-resume-metadata.ts
new file mode 100644
index 00000000000..5b09eddb703
--- /dev/null
+++ b/mobile/src/agent-history/mobile-agent-history-resume-metadata.ts
@@ -0,0 +1,70 @@
+import { optionalSettingsRead } from '../transport/settings-read-operations'
+import { interpretOrThrowRefusalMessage } from '../transport/rpc-refusal-message'
+import { rpcPayloadMember } from '../transport/rpc-reader-payload'
+import { readAcceptedResumeList } from './resume-metadata-lists'
+import {
+  resumeFolderWorkspaceListRead,
+  resumeProjectGroupListRead,
+  resumeRepoListRead,
+  resumeWorktreeListRead
+} from './mobile-agent-history-operations'
+import type { RpcClient } from '../transport/rpc-client'
+import type { Worktree } from '../worktree/workspace-list-types'
+import type { MobileAiVaultResumeSettings } from '../session/ai-vault-resume-launch'
+import { RESUME_RPC_TIMEOUT_MS } from '../session/ai-vault-resume-preparation'
+import type {
+  MobileAiVaultResumeRepo,
+  MobileAiVaultResumeFolderWorkspace,
+  MobileAiVaultResumeProjectGroup
+} from './agent-history-resume-target'
+
+export async function loadMobileResumeMetadata(client: RpcClient): Promise<{
+  repos: MobileAiVaultResumeRepo[]
+  folderWorkspaces: MobileAiVaultResumeFolderWorkspace[]
+  projectGroups: MobileAiVaultResumeProjectGroup[]
+  settings: MobileAiVaultResumeSettings | null
+  worktrees: Worktree[] | null
+}> {
+  // Why: repo.list can enrich repo remote identities, so fetch resume-only
+  // metadata after explicit user intent instead of delaying history browsing.
+  // timeoutMs: without it a socket drop parks these on the reconnect waiter
+  // for minutes, pinning the resume spinner (see RESUME_RPC_TIMEOUT_MS).
+  const [repoReply, folderWorkspaceReply, projectGroupReply, settingsReply, worktreeReply] =
+    await Promise.all([
+      resumeRepoListRead.request(client, undefined, { timeoutMs: RESUME_RPC_TIMEOUT_MS }),
+      resumeFolderWorkspaceListRead
+        .request(client, undefined, { timeoutMs: RESUME_RPC_TIMEOUT_MS })
+        .catch(() => null),
+      resumeProjectGroupListRead
+        .request(client, undefined, { timeoutMs: RESUME_RPC_TIMEOUT_MS })
+        .catch(() => null),
+      optionalSettingsRead
+        .request(client, undefined, { timeoutMs: RESUME_RPC_TIMEOUT_MS })
+        .catch(() => null),
+      resumeWorktreeListRead
+        .request(client, { limit: 10000 }, { timeoutMs: RESUME_RPC_TIMEOUT_MS })
+        .catch(() => null)
+    ])
+  const repoResult = interpretOrThrowRefusalMessage(
+    () => resumeRepoListRead.interpret(repoReply),
+    'Unable to load workspace metadata.'
+  )
+  const folderWorkspaceResult =
+    folderWorkspaceReply && resumeFolderWorkspaceListRead.interpret(folderWorkspaceReply)
+  const projectGroupResult =
+    projectGroupReply && resumeProjectGroupListRead.interpret(projectGroupReply)
+  const settingsResult = settingsReply ? optionalSettingsRead.interpret(settingsReply) : null
+  const settings = settingsResult?.accepted
+    ? // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: Preserve the established response shape at this boundary.
+      (settingsResult.value as MobileAiVaultResumeSettings | null | undefined)
+    : null
+  const worktreeResult = worktreeReply && resumeWorktreeListRead.interpret(worktreeReply)
+  return {
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: Preserve the established response shape at this boundary.
+    repos: (rpcPayloadMember(repoResult, 'repos') as MobileAiVaultResumeRepo[] | undefined) ?? [],
+    folderWorkspaces: readAcceptedResumeList(folderWorkspaceResult, 'folderWorkspaces') ?? [],
+    projectGroups: readAcceptedResumeList(projectGroupResult, 'groups') ?? [],
+    settings: settings ?? null,
+    worktrees: readAcceptedResumeList(worktreeResult, 'worktrees') ?? null
+  }
+}
diff --git a/mobile/src/agent-history/use-mobile-agent-history-state.ts b/mobile/src/agent-history/use-mobile-agent-history-state.ts
index d69262acff6..f73ec61a8a1 100644
--- a/mobile/src/agent-history/use-mobile-agent-history-state.ts
+++ b/mobile/src/agent-history/use-mobile-agent-history-state.ts
@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useHostClient, useForceReconnect } from '../transport/client-context'
+import type { RpcClient } from '../transport/rpc-client'
 import { connectionRetryAction } from '../transport/connection-retry-action'
 import type {
   AiVaultScanIssue,
@@ -43,7 +44,20 @@ export function useMobileAgentHistoryState(params: MobileAgentHistoryStateParams
   const forceReconnect = useForceReconnect()
   const [scope, setScope] = useState<AiVaultScope>('workspace')
   const [screenState, setScreenState] = useState<AgentHistoryScreenState>({ kind: 'loading' })
-  const [hostStatusResult, setHostStatusResult] = useState<unknown>(null)
+  const clientGeneration = client?.getGeneration?.() ?? 0
+  const [hostStatusProbe, setHostStatusProbe] = useState<{
+    hostId: string
+    client: RpcClient
+    generation: number
+    result: unknown
+  } | null>(null)
+  const hostStatusResult =
+    connState === 'connected' &&
+    hostStatusProbe?.hostId === hostId &&
+    hostStatusProbe.client === client &&
+    hostStatusProbe.generation === clientGeneration
+      ? hostStatusProbe.result
+      : null
   const [refreshing, setRefreshing] = useState(false)
   const generationRef = useRef(0)
   const mountedRef = useRef(true)
@@ -72,10 +86,14 @@ export function useMobileAgentHistoryState(params: MobileAgentHistoryStateParams
     async (options: { scope: AiVaultScope; force: boolean }): Promise<void> => {
       const generation = generationRef.current + 1
       generationRef.current = generation
-      const isCurrent = () => mountedRef.current && generationRef.current === generation
+      const isCurrent = () =>
+        mountedRef.current &&
+        generationRef.current === generation &&
+        (client?.getGeneration?.() ?? 0) === clientGeneration
 
       if (!client || connState !== 'connected') {
         if (isCurrent()) {
+          setHostStatusProbe(null)
           // Why: keep the stale list visible through transient reconnects
           // (connState flips re-run the load effect) instead of tearing it
           // down to a full-screen error, matching the host list screen.
@@ -98,7 +116,7 @@ export function useMobileAgentHistoryState(params: MobileAgentHistoryStateParams
           () => agentHistoryHostStatusRead.interpret(statusReply),
           'Unable to reach host'
         )
-        setHostStatusResult(status)
+        setHostStatusProbe({ hostId, client, generation: clientGeneration, result: status })
         if (!status.capabilities?.includes(MOBILE_AI_VAULT_CAPABILITY)) {
           setScreenState({ kind: 'unsupported' })
           return
@@ -140,11 +158,11 @@ export function useMobileAgentHistoryState(params: MobileAgentHistoryStateParams
           return
         }
         const message = err instanceof Error ? err.message : 'Unable to load agent sessions'
-        setHostStatusResult(null)
+        setHostStatusProbe(null)
         setScreenState({ kind: 'error', message })
       }
     },
-    [activeWorktree, client, connState, worktrees, worktreesLoaded]
+    [activeWorktree, client, clientGeneration, connState, hostId, worktrees, worktreesLoaded]
   )
 
   // Initial + reconnect load. Why: scope switches reuse the host's 15s cache
diff --git a/mobile/src/agent-history/use-mobile-resume-operation-ownership.ts b/mobile/src/agent-history/use-mobile-resume-operation-ownership.ts
new file mode 100644
index 00000000000..bf93486483d
--- /dev/null
+++ b/mobile/src/agent-history/use-mobile-resume-operation-ownership.ts
@@ -0,0 +1,37 @@
+import { useCallback, useLayoutEffect, useMemo, useRef } from 'react'
+import type { RpcClient } from '../transport/rpc-client'
+import type { ConnectionState } from '../transport/types'
+
+export function useMobileResumeOperationOwnership(
+  hostId: string,
+  worktreeId: string,
+  client: RpcClient | null,
+  connection: ConnectionState
+) {
+  const generation = client?.getGeneration?.()
+  const owner = useMemo(
+    () => ({ hostId, worktreeId, client, connection, generation }),
+    [hostId, worktreeId, client, connection, generation]
+  )
+  const currentOwner = useRef<typeof owner | null>(owner)
+  useLayoutEffect(() => {
+    currentOwner.current = owner
+    return () => {
+      currentOwner.current = null
+    }
+  }, [owner])
+  return useCallback(
+    () => () => {
+      if (
+        currentOwner.current !== owner ||
+        owner.connection !== 'connected' ||
+        !owner.client ||
+        owner.client.getState() !== 'connected' ||
+        owner.client.getGeneration?.() !== owner.generation
+      ) {
+        throw new Error('Host connection changed. Retry resume.')
+      }
+    },
+    [owner]
+  )
+}
diff --git a/mobile/src/components/AgentSpinner.tsx b/mobile/src/components/AgentSpinner.tsx
index c05e5d2a489..38e4674d53d 100644
--- a/mobile/src/components/AgentSpinner.tsx
+++ b/mobile/src/components/AgentSpinner.tsx
@@ -1,7 +1,7 @@
-import { useEffect, useRef } from 'react'
 import { Activity } from 'lucide-react-native'
-import { Animated, Easing, StyleSheet, View } from 'react-native'
+import { Animated, StyleSheet, View } from 'react-native'
 import type { AgentWorkingMode } from '../../../src/shared/agent-status-types'
+import { useWorkingRingRotation } from './use-working-ring-rotation'
 
 type WorktreeStatus = 'working' | 'active' | 'permission' | 'done' | 'inactive'
 
@@ -26,24 +26,8 @@ export function AgentSpinner({
   status: WorktreeStatus
   workingMode?: AgentWorkingMode
 }) {
-  const spinValue = useRef(new Animated.Value(0)).current
   const monitoring = status === 'working' && workingMode === 'monitoring'
-
-  useEffect(() => {
-    if (status === 'working' && !monitoring) {
-      const animation = Animated.loop(
-        Animated.timing(spinValue, {
-          toValue: 1,
-          duration: 1000,
-          easing: Easing.linear,
-          useNativeDriver: true
-        })
-      )
-      animation.start()
-      return () => animation.stop()
-    }
-    spinValue.setValue(0)
-  }, [monitoring, status, spinValue])
+  const rotate = useWorkingRingRotation(status === 'working' && !monitoring)
 
   const color = STATUS_COLORS[status] ?? STATUS_COLORS.inactive
 
@@ -56,10 +40,6 @@ export function AgentSpinner({
   }
 
   if (status === 'working') {
-    const rotate = spinValue.interpolate({
-      inputRange: [0, 1],
-      outputRange: ['0deg', '360deg']
-    })
     return (
       <View style={styles.wrapper}>
         <Animated.View style={[styles.spinner, { borderColor: color, transform: [{ rotate }] }]} />
diff --git a/mobile/src/components/AgentStateDot.tsx b/mobile/src/components/AgentStateDot.tsx
index 6912f6c1b2a..0450afa8166 100644
--- a/mobile/src/components/AgentStateDot.tsx
+++ b/mobile/src/components/AgentStateDot.tsx
@@ -1,8 +1,8 @@
-import { useEffect, useRef } from 'react'
 import { Activity } from 'lucide-react-native'
-import { Animated, Easing, StyleSheet, View } from 'react-native'
+import { Animated, StyleSheet, View } from 'react-native'
 import type { AgentDotState } from '../worktree/agent-row-display'
 import { colors } from '../theme/mobile-theme'
+import { useWorkingRingRotation } from './use-working-ring-rotation'
 
 // Per-agent state indicator, 1:1 with desktop AgentStateDot
 // (src/renderer/src/components/AgentStateDot.tsx): yellow spinner for 'working',
@@ -22,27 +22,9 @@ const DOT_COLORS: Record<Exclude<AgentDotState, 'working' | 'monitoring'>, strin
 const WORKING_COLOR = '#eab308'
 
 export function AgentStateDot({ state }: { state: AgentDotState }) {
-  const spinValue = useRef(new Animated.Value(0)).current
-
-  useEffect(() => {
-    if (state === 'working') {
-      const animation = Animated.loop(
-        Animated.timing(spinValue, {
-          toValue: 1,
-          duration: 1000,
-          easing: Easing.linear,
-          useNativeDriver: true
-        })
-      )
-      animation.start()
-      return () => animation.stop()
-    }
-    spinValue.setValue(0)
-    return undefined
-  }, [state, spinValue])
+  const rotate = useWorkingRingRotation(state === 'working')
 
   if (state === 'working') {
-    const rotate = spinValue.interpolate({ inputRange: [0, 1], outputRange: ['0deg', '360deg'] })
     return (
       <View style={styles.wrapper}>
         <Animated.View style={[styles.spinner, { transform: [{ rotate }] }]} />
diff --git a/mobile/src/components/MobileMarkdown.file-links.test.ts b/mobile/src/components/MobileMarkdown.file-links.test.ts
index 28a3155203a..c2243cd6cc3 100644
--- a/mobile/src/components/MobileMarkdown.file-links.test.ts
+++ b/mobile/src/components/MobileMarkdown.file-links.test.ts
@@ -7,6 +7,7 @@ const openURL = vi.fn(() => Promise.resolve())
 
 vi.mock('react-native', () => ({
   Linking: { openURL: (url: string) => openURL(url) },
+  Platform: { OS: 'ios' },
   Pressable: 'Pressable',
   ScrollView: 'ScrollView',
   StyleSheet: { create: (styles: unknown) => styles, hairlineWidth: 1 },
diff --git a/mobile/src/components/MobileMarkdown.tsx b/mobile/src/components/MobileMarkdown.tsx
index 3e3d7a8b906..0022daf8d73 100644
--- a/mobile/src/components/MobileMarkdown.tsx
+++ b/mobile/src/components/MobileMarkdown.tsx
@@ -1,5 +1,6 @@
 import { openExternalLink } from '../platform/external-link'
 import { createMarkdownInlineMatcher, type MarkdownInlineMatch } from './markdown-inline-matcher'
+import { INLINE_TEXT_SELECTION } from './inline-text-selection'
 import { MobileSelectableText } from './MobileSelectableText'
 import {
   Fragment,
@@ -33,6 +34,8 @@ type Props = {
   fallback?: string
   /** Enables iOS range selection for native-chat transcript prose. */
   rangeSelectable?: boolean
+  /** Forward long presses from interactive Android transcript spans to the message. */
+  onLongPress?: () => void
   /** Multiplier for prose font size (paragraphs, lists, quotes). Defaults to 1;
    *  the chat view passes >1 so agent prose reads larger than the compact base. */
   textScale?: number
@@ -47,11 +50,28 @@ const MAX_TABLE_ROWS = 40
 const MAX_TABLE_COLUMNS = 8
 /** Prose base size — passed to MermaidDiagram fallback mono text. */
 const MERMAID_BASE = 13
-const MarkdownTextContext = createContext<ComponentType<TextProps>>(NativeText)
+type MarkdownTextSetup = {
+  TextComponent: ComponentType<TextProps>
+  /** Disable native selection only within the Android transcript. */
+  androidTranscript: boolean
+  onLongPress?: () => void
+}
+const MarkdownTextContext = createContext<MarkdownTextSetup>({
+  TextComponent: NativeText,
+  androidTranscript: false
+})
 
 function MarkdownText(props: TextProps): React.JSX.Element {
-  const TextComponent = useContext(MarkdownTextContext)
-  return createElement(TextComponent, props)
+  const { TextComponent, androidTranscript, onLongPress } = useContext(MarkdownTextContext)
+  if (!androidTranscript) {
+    return createElement(TextComponent, props)
+  }
+  // Override selection without changing the nested spans' inherited behavior.
+  return createElement(TextComponent, {
+    ...props,
+    ...(props.selectable === true ? { selectable: false } : {}),
+    ...(onLongPress && props.onPress ? { onLongPress } : {})
+  })
 }
 
 // Web/mail hrefs open the system handler; file-target hrefs (file: URIs and
@@ -215,6 +235,9 @@ function MobileMarkdownContent({
   textScale = 1,
   onOpenFile
 }: Props) {
+  // Interactive children own their touches and must forward the row action.
+  const setup = useContext(MarkdownTextContext)
+  const rowLongPress = setup.androidTranscript ? setup.onLongPress : undefined
   const text = content?.trim() ?? ''
   const previewText = useMemo(() => normalizeMobileMarkdownPreviewHtml(text), [text])
   const blocks = useMemo(() => parseMobileMarkdown(previewText), [previewText])
@@ -288,6 +311,7 @@ function MobileMarkdownContent({
               key={index}
               style={styles.imageFrame}
               onPress={() => openMarkdownHref(block.url, onOpenFile)}
+              onLongPress={rowLongPress}
             >
               <NativeText style={styles.link}>{block.alt || 'Open image'}</NativeText>
               <NativeText style={styles.imageCaption} numberOfLines={1}>
@@ -380,9 +404,19 @@ function MobileMarkdownContent({
 }
 
 function MobileMarkdownInner(props: Props): React.JSX.Element | null {
-  const TextComponent = props.rangeSelectable ? MobileSelectableText : NativeText
+  const { rangeSelectable = false, onLongPress } = props
+  // Other Markdown surfaces retain their existing selection behavior.
+  const androidTranscript = rangeSelectable && !INLINE_TEXT_SELECTION
+  const setup = useMemo<MarkdownTextSetup>(
+    () => ({
+      TextComponent: rangeSelectable && !androidTranscript ? MobileSelectableText : NativeText,
+      androidTranscript,
+      ...(onLongPress ? { onLongPress } : {})
+    }),
+    [rangeSelectable, androidTranscript, onLongPress]
+  )
   return (
-    <MarkdownTextContext.Provider value={TextComponent}>
+    <MarkdownTextContext.Provider value={setup}>
       <MobileMarkdownContent {...props} />
     </MarkdownTextContext.Provider>
   )
diff --git a/mobile/src/components/PickerModal.tsx b/mobile/src/components/PickerModal.tsx
index 9456307091f..45b6593c09f 100644
--- a/mobile/src/components/PickerModal.tsx
+++ b/mobile/src/components/PickerModal.tsx
@@ -15,6 +15,7 @@ export type PickerOption<T extends string = string> = {
 type Props<T extends string = string> = {
   visible: boolean
   title: string
+  subtitle?: string
   options: PickerOption<T>[]
   selected: T
   onSelect: (value: T) => void
@@ -32,6 +33,7 @@ type PickerModalContentProps<T extends string = string> = Pick<
 export function PickerModal<T extends string = string>({
   visible,
   title,
+  subtitle,
   options,
   selected,
   onSelect,
@@ -44,6 +46,7 @@ export function PickerModal<T extends string = string>({
     <BottomDrawer visible={visible} onClose={onClose} onAfterClose={onAfterClose} zIndex={zIndex}>
       <View style={styles.header}>
         <Text style={styles.title}>{title}</Text>
+        {subtitle ? <Text style={styles.subtitle}>{subtitle}</Text> : null}
       </View>
 
       <PickerModalContent
@@ -130,6 +133,11 @@ const styles = StyleSheet.create({
     fontWeight: '500',
     color: colors.textMuted
   },
+  subtitle: {
+    fontSize: 11,
+    color: colors.textMuted,
+    marginTop: 2
+  },
   group: {
     backgroundColor: colors.bgPanel,
     borderRadius: 12,
diff --git a/mobile/src/components/agent-monitoring-indicators.test.ts b/mobile/src/components/agent-monitoring-indicators.test.ts
index 16c453b27cf..90b4d3acbe3 100644
--- a/mobile/src/components/agent-monitoring-indicators.test.ts
+++ b/mobile/src/components/agent-monitoring-indicators.test.ts
@@ -32,6 +32,7 @@ vi.mock('react-native', () => ({
     timing: animationTiming
   },
   Easing: { linear: 'linear' },
+  Platform: { OS: 'ios' },
   StyleSheet: { create: <T>(styles: T) => styles },
   View: 'View'
 }))
@@ -87,6 +88,22 @@ describe('mobile monitoring indicators', () => {
     expect(animationLoop).toHaveBeenCalledOnce()
   })
 
+  it('keeps the native driver for both working rings on native', async () => {
+    await act(async () => {
+      renderer = create(
+        createElement('View', null, [
+          createElement(AgentSpinner, { key: 'spinner', status: 'working' }),
+          createElement(AgentStateDot, { key: 'dot', state: 'working' })
+        ])
+      )
+    })
+
+    expect(animationTiming).toHaveBeenCalledTimes(2)
+    for (const call of animationTiming.mock.calls) {
+      expect(call).toEqual([expect.anything(), expect.objectContaining({ useNativeDriver: true })])
+    }
+  })
+
   it.each([
     // A user's Stop is not news: muted, never the fault red a failure draws.
     ['interrupted', colors.textMuted],
diff --git a/mobile/src/components/inline-text-selection.test.ts b/mobile/src/components/inline-text-selection.test.ts
new file mode 100644
index 00000000000..72fcad28afe
--- /dev/null
+++ b/mobile/src/components/inline-text-selection.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('react-native', () => ({ Platform: { OS: 'android' } }))
+
+const { INLINE_TEXT_SELECTION, inlineTextSelectionAllowed } =
+  await import('./inline-text-selection')
+
+describe('inline text selection policy', () => {
+  it('keeps inline selection everywhere but Android', () => {
+    expect(inlineTextSelectionAllowed('ios')).toBe(true)
+    expect(inlineTextSelectionAllowed('web')).toBe(true)
+    expect(inlineTextSelectionAllowed('android')).toBe(false)
+  })
+
+  it('resolves the running platform once', () => {
+    expect(INLINE_TEXT_SELECTION).toBe(false)
+  })
+})
diff --git a/mobile/src/components/inline-text-selection.ts b/mobile/src/components/inline-text-selection.ts
new file mode 100644
index 00000000000..9e9165709a1
--- /dev/null
+++ b/mobile/src/components/inline-text-selection.ts
@@ -0,0 +1,8 @@
+import { Platform } from 'react-native'
+
+// Android double-tap selection can mistake successive scroll flicks for word selection.
+export function inlineTextSelectionAllowed(os: string): boolean {
+  return os !== 'android'
+}
+
+export const INLINE_TEXT_SELECTION = inlineTextSelectionAllowed(Platform.OS)
diff --git a/mobile/src/components/mobile-markdown-android-selection.test.tsx b/mobile/src/components/mobile-markdown-android-selection.test.tsx
new file mode 100644
index 00000000000..9567ae796bb
--- /dev/null
+++ b/mobile/src/components/mobile-markdown-android-selection.test.tsx
@@ -0,0 +1,88 @@
+import { createElement } from 'react'
+import { act, create, type ReactTestInstance, type ReactTestRenderer } from 'react-test-renderer'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { MobileMarkdown } from './MobileMarkdown'
+
+// Why Android here: the sibling selectable test runs as iOS and proves prose IS selectable there;
+// this one proves the transcript carries no selectable span on Android, where a selectable
+// TextView selects words while the transcript scrolls — and that other surfaces are untouched.
+vi.mock('react-native', () => ({
+  Linking: { openURL: () => Promise.resolve() },
+  Platform: { OS: 'android' },
+  Pressable: 'Pressable',
+  ScrollView: 'ScrollView',
+  StyleSheet: { create: (styles: unknown) => styles, hairlineWidth: 1 },
+  Text: 'Text',
+  View: 'View'
+}))
+
+vi.mock('./pr-sidebar/MermaidDiagram', () => ({ MermaidDiagram: 'MermaidDiagram' }))
+
+const CONTENT = [
+  '# Heading',
+  'A paragraph with **bold**, `code` and https://example.com/link.',
+  '> quoted',
+  '- item one',
+  '| a | b |',
+  '| - | - |',
+  '| 1 | 2 |',
+  '```',
+  'fenced()',
+  '```'
+].join('\n')
+
+describe('MobileMarkdown on Android', () => {
+  let renderer: ReactTestRenderer | null = null
+
+  afterEach(() => {
+    act(() => renderer?.unmount())
+    renderer = null
+  })
+
+  function render(props: Parameters<typeof MobileMarkdown>[0]): ReactTestInstance[] {
+    act(() => {
+      renderer = create(createElement(MobileMarkdown, props))
+    })
+    return renderer!.root.findAll((node) => String(node.type) === 'Text')
+  }
+
+  const tappable = (nodes: ReactTestInstance[]) =>
+    nodes.filter((node) => typeof node.props.onPress === 'function')
+
+  it('renders the transcript with no selectable span, leaving untouched spans alone', () => {
+    const all = render({ content: CONTENT, rangeSelectable: true })
+    expect(all.length).toBeGreaterThan(5)
+    expect(all.filter((node) => node.props.selectable === true)).toHaveLength(0)
+    // Inline spans (bold, code, links) never asked for selection; writing `false` onto them
+    // would map to `userSelect: none` on the web, so the gate must leave them alone.
+    const links = tappable(all)
+    expect(links.length).toBeGreaterThan(0)
+    for (const node of links) {
+      expect(node.props.selectable).toBeUndefined()
+    }
+  })
+
+  it('routes a long press on a tappable span or image to the row, so neither swallows it', () => {
+    const onLongPress = vi.fn()
+    const content = `${CONTENT}\n\n![diagram](https://example.com/diagram.png)`
+    const all = render({ content, rangeSelectable: true, onLongPress })
+    const links = tappable(all)
+    expect(links.length).toBeGreaterThan(0)
+    for (const node of links) {
+      expect(node.props.onLongPress).toBe(onLongPress)
+    }
+    expect(all.filter((node) => !node.props.onPress && node.props.onLongPress)).toHaveLength(0)
+    const images = renderer!.root.findAll(
+      (node) => String(node.type) === 'Pressable' && typeof node.props.onPress === 'function'
+    )
+    expect(images.length).toBeGreaterThan(0)
+    for (const node of images) {
+      expect(node.props.onLongPress).toBe(onLongPress)
+    }
+  })
+
+  it('keeps other surfaces (task comments, previews) selectable as before', () => {
+    const all = render({ content: CONTENT })
+    expect(all.filter((node) => node.props.selectable === true).length).toBeGreaterThan(0)
+  })
+})
diff --git a/mobile/src/components/mobile-markdown-mermaid-routing.test.ts b/mobile/src/components/mobile-markdown-mermaid-routing.test.ts
index c89dfa00853..833064ee3fc 100644
--- a/mobile/src/components/mobile-markdown-mermaid-routing.test.ts
+++ b/mobile/src/components/mobile-markdown-mermaid-routing.test.ts
@@ -5,6 +5,7 @@ import { MobileMarkdown } from './MobileMarkdown'
 
 vi.mock('react-native', () => ({
   Linking: { openURL: vi.fn() },
+  Platform: { OS: 'ios' },
   Pressable: 'Pressable',
   ScrollView: 'ScrollView',
   StyleSheet: { create: <T>(styles: T) => styles, hairlineWidth: 1 },
diff --git a/mobile/src/components/mobile-markdown-selectable.test.tsx b/mobile/src/components/mobile-markdown-selectable.test.tsx
index 2b42fc70715..d581a9ebb5f 100644
--- a/mobile/src/components/mobile-markdown-selectable.test.tsx
+++ b/mobile/src/components/mobile-markdown-selectable.test.tsx
@@ -5,6 +5,7 @@ import { MobileMarkdown } from './MobileMarkdown'
 
 vi.mock('react-native', () => ({
   Linking: { openURL: () => Promise.resolve() },
+  Platform: { OS: 'ios' },
   Pressable: 'Pressable',
   ScrollView: 'ScrollView',
   StyleSheet: { create: (styles: unknown) => styles, hairlineWidth: 1 },
diff --git a/mobile/src/components/use-working-ring-rotation.ts b/mobile/src/components/use-working-ring-rotation.ts
new file mode 100644
index 00000000000..b78b223e991
--- /dev/null
+++ b/mobile/src/components/use-working-ring-rotation.ts
@@ -0,0 +1,27 @@
+import { useEffect, useRef } from 'react'
+import { Animated, Easing, Platform } from 'react-native'
+
+/** The working ring's rotation: one turn per second while `active`, reset to 0 otherwise. */
+export function useWorkingRingRotation(active: boolean): Animated.AnimatedInterpolation<string> {
+  const spinValue = useRef(new Animated.Value(0)).current
+
+  useEffect(() => {
+    if (active) {
+      const animation = Animated.loop(
+        Animated.timing(spinValue, {
+          toValue: 1,
+          duration: 1000,
+          easing: Easing.linear,
+          // Why: web has no native driver, so a loop over a native-driver timing plays it once.
+          useNativeDriver: Platform.OS !== 'web'
+        })
+      )
+      animation.start()
+      return () => animation.stop()
+    }
+    spinValue.setValue(0)
+    return undefined
+  }, [active, spinValue])
+
+  return spinValue.interpolate({ inputRange: [0, 1], outputRange: ['0deg', '360deg'] })
+}
diff --git a/mobile/src/host-screen/host-screen-overlays.tsx b/mobile/src/host-screen/host-screen-overlays.tsx
index 8399d516136..2a14df7fdee 100644
--- a/mobile/src/host-screen/host-screen-overlays.tsx
+++ b/mobile/src/host-screen/host-screen-overlays.tsx
@@ -12,7 +12,8 @@ import { hostNewWorktreeSessionRoute } from '../host-route-action-state'
 import { getWorktreeRowIdentity } from '../worktree/worktree-host-row-identity'
 import {
   WORKSPACE_GROUP_OPTIONS as GROUP_OPTIONS,
-  WORKSPACE_SORT_OPTIONS as SORT_OPTIONS
+  WORKSPACE_SORT_OPTIONS as SORT_OPTIONS,
+  WORKSPACE_VIEW_SHARED_NOTE
 } from '../worktree/workspace-list-picker-options'
 import { isWorktreePinned } from '../worktree/workspace-list-sections'
 import { hostScreenStyles as styles } from './host-screen-styles'
@@ -37,6 +38,7 @@ export function HostScreenOverlays({ controller }: { controller: HostScreenContr
       <PickerModal
         visible={state.showSortPicker}
         title="Sort By"
+        subtitle={WORKSPACE_VIEW_SHARED_NOTE}
         options={SORT_OPTIONS}
         selected={state.sortMode}
         onSelect={settings.handleSortChange}
@@ -46,6 +48,7 @@ export function HostScreenOverlays({ controller }: { controller: HostScreenContr
       <PickerModal
         visible={state.showGroupPicker}
         title="Group By"
+        subtitle={WORKSPACE_VIEW_SHARED_NOTE}
         options={GROUP_OPTIONS}
         selected={state.groupMode}
         onSelect={settings.handleGroupChange}
@@ -54,7 +57,10 @@ export function HostScreenOverlays({ controller }: { controller: HostScreenContr
 
       <BottomDrawer visible={state.showFilterModal} onClose={() => state.setShowFilterModal(false)}>
         <View style={styles.filterModalHeader}>
-          <Text style={styles.filterModalTitle}>Filter</Text>
+          <View style={styles.filterModalHeading}>
+            <Text style={styles.filterModalTitle}>Filter</Text>
+            <Text style={styles.filterModalSubtitle}>{WORKSPACE_VIEW_SHARED_NOTE}</Text>
+          </View>
           {settings.activeFilterCount > 0 && (
             <Pressable onPress={settings.clearFilters}>
               <Text style={styles.clearFiltersText}>Clear filters</Text>
diff --git a/mobile/src/host-screen/host-screen-secondary-styles.ts b/mobile/src/host-screen/host-screen-secondary-styles.ts
index af14aa2b97a..7f6c4f3f65c 100644
--- a/mobile/src/host-screen/host-screen-secondary-styles.ts
+++ b/mobile/src/host-screen/host-screen-secondary-styles.ts
@@ -47,11 +47,19 @@ export const hostScreenSecondaryStyles = StyleSheet.create({
     paddingHorizontal: spacing.xs,
     marginBottom: spacing.md
   },
+  filterModalHeading: {
+    flexShrink: 1
+  },
   filterModalTitle: {
     fontSize: 15,
     fontWeight: '600',
     color: colors.textPrimary
   },
+  filterModalSubtitle: {
+    fontSize: 11,
+    color: colors.textMuted,
+    marginTop: 2
+  },
   clearFiltersText: {
     fontSize: 13,
     color: colors.textSecondary
diff --git a/mobile/src/host-screen/host-show-pinned-in-groups.test.ts b/mobile/src/host-screen/host-show-pinned-in-groups.test.ts
new file mode 100644
index 00000000000..29e6c8db826
--- /dev/null
+++ b/mobile/src/host-screen/host-show-pinned-in-groups.test.ts
@@ -0,0 +1,135 @@
+import { createElement } from 'react'
+import { act, create } from 'react-test-renderer'
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('expo-router', () => ({ useFocusEffect: () => {} }))
+vi.mock('../cache/worktree-cache', () => ({
+  getCachedWorktrees: () => null,
+  setCachedWorktrees: () => {}
+}))
+vi.mock('../storage/preferences', () => ({
+  loadPinnedIds: async () => new Set(),
+  savePinnedIds: async () => {}
+}))
+vi.mock('../transport/host-store', () => ({
+  loadHosts: async () => [],
+  updateLastConnected: async () => {}
+}))
+vi.mock('../worktree/host-worktree-refresh', () => ({ startHostWorktreeRefresh: () => () => {} }))
+vi.mock('../transport/use-worktree-resync', () => ({
+  useWorktreeResync: () => ({ refreshing: false, onRefresh: async () => {} })
+}))
+
+import type { RpcClient } from '../transport/rpc-client'
+import { FakeSession } from '../transport/mobile-endpoint-supervisor-test-fakes'
+import type { RpcResponse } from '../transport/types'
+import { useHostScreenIdentity } from './use-host-screen-identity'
+import { useHostWorktreeCatalog } from './use-host-worktree-catalog'
+
+function settingsReply(settings: unknown): RpcResponse {
+  return { id: 'reply', ok: true, result: { settings }, _meta: { runtimeId: 'runtime' } }
+}
+
+const noop = () => {}
+
+type ClientRef = { current: RpcClient | null }
+
+function screenState(clientRef: ClientRef, applied: boolean[]) {
+  return {
+    clientRef,
+    fetchWorktreesInFlightRef: { current: false },
+    newWorktreeModalVisibleRef: { current: false },
+    repoMetadataFetchedAtRef: { current: 0 },
+    worktreeCatalogRef: { current: null },
+    setShowPinnedInGroups: (show: boolean) => applied.push(show),
+    ...Object.fromEntries(
+      [
+        'setActionError',
+        'setCatalogError',
+        'setError',
+        'setHostLabelById',
+        'setHostName',
+        'setHostPlatform',
+        'setHostStoredDescriptor',
+        'setLastKnownWorktrees',
+        'setOptimisticActiveWorktreeIdentity',
+        'setPinnedIds',
+        'setRepoColorsByName',
+        'setRepoHostIdByRepoId',
+        'setRepoIconsByName',
+        'setSleptIds',
+        'setWorktrees',
+        'setWorktreesLoaded'
+      ].map((setter) => [setter, noop])
+    )
+  }
+}
+
+// Mounting the embedded catalog runs its refresh, which issues the placement read.
+async function refreshWith(
+  reply: Promise<RpcResponse>,
+  onSent: (clientRef: ClientRef) => void = noop
+): Promise<boolean[]> {
+  const client = new FakeSession('connected')
+  const clientRef: ClientRef = { current: client }
+  client.sendRequest.mockImplementation(() => {
+    onSent(clientRef)
+    return reply
+  })
+  const applied: boolean[] = []
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the mount-time refresh reads clientRef and setShowPinnedInGroups; the other members are inert stubs.
+  const args = {
+    client,
+    connState: 'connected',
+    embedded: true,
+    fetchRepoMetadata: async () => {},
+    hostId: 'host-1',
+    state: screenState(clientRef, applied),
+    syncViewSettingsFromDesktop: async () => {}
+  } as unknown as Parameters<typeof useHostWorktreeCatalog>[0]
+  function Probe(): null {
+    useHostWorktreeCatalog(args)
+    return null
+  }
+  await act(async () => {
+    create(createElement(Probe))
+    await reply.catch(noop)
+  })
+  expect(client.sendRequest.mock.calls.map(([method]) => method)).toEqual(['settings.get'])
+  return applied
+}
+
+describe('the host list mirrors the desktop pinned-placement setting', () => {
+  it('applies the setting the host reports on refresh, absent reading as off', async () => {
+    const on = settingsReply({ showPinnedWorktreesInGroups: true })
+    expect(await refreshWith(Promise.resolve(on))).toEqual([true])
+    expect(await refreshWith(Promise.resolve(settingsReply({})))).toEqual([false])
+  })
+
+  it('drops a reply that lands after the screen moved to another client', async () => {
+    const on = settingsReply({ showPinnedWorktreesInGroups: true })
+    const moveOn = (clientRef: ClientRef) => {
+      clientRef.current = new FakeSession('connected')
+    }
+    expect(await refreshWith(Promise.resolve(on), moveOn)).toEqual([])
+  })
+
+  it('resets to off when the screen is reused for another host', async () => {
+    const applied: boolean[] = []
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the identity hook reads only the refs and setters screenState provides.
+    const identityState = screenState({ current: null }, applied) as unknown as Parameters<
+      typeof useHostScreenIdentity
+    >[0]['state']
+    function Probe({ hostId }: { hostId: string }): null {
+      useHostScreenIdentity({ client: null, hostId, state: identityState })
+      return null
+    }
+    const renderer = create(createElement(Probe, { hostId: 'host-1' }))
+    await act(async () => {})
+    applied.length = 0
+    await act(async () => {
+      renderer.update(createElement(Probe, { hostId: 'host-2' }))
+    })
+    expect(applied).toEqual([false])
+  })
+})
diff --git a/mobile/src/host-screen/use-host-screen-controller.ts b/mobile/src/host-screen/use-host-screen-controller.ts
index 66ab8119941..34efd5e71ac 100644
--- a/mobile/src/host-screen/use-host-screen-controller.ts
+++ b/mobile/src/host-screen/use-host-screen-controller.ts
@@ -131,6 +131,7 @@ export function useHostScreenController({
     search: state.search,
     groupMode: state.groupMode,
     pinnedIds: state.pinnedIds,
+    showPinnedInGroups: state.showPinnedInGroups,
     repoIdsByName: state.repoIdsByName,
     repoColorsByName: state.repoColorsByName,
     collapsedGroups: state.collapsedGroups,
diff --git a/mobile/src/host-screen/use-host-screen-identity.ts b/mobile/src/host-screen/use-host-screen-identity.ts
index 324f2d11c6d..25cc71eeade 100644
--- a/mobile/src/host-screen/use-host-screen-identity.ts
+++ b/mobile/src/host-screen/use-host-screen-identity.ts
@@ -26,6 +26,7 @@ export function useHostScreenIdentity(args: {
     setRepoColorsByName,
     setRepoHostIdByRepoId,
     setRepoIconsByName,
+    setShowPinnedInGroups,
     setWorktrees,
     setWorktreesLoaded
   } = state
@@ -62,6 +63,7 @@ export function useHostScreenIdentity(args: {
     setRepoHostIdByRepoId(new Map())
     setHostLabelById(new Map())
     setHostPlatform(null)
+    setShowPinnedInGroups(false)
     repoMetadataFetchedAtRef.current = 0
     // Why: useState initializer runs only on first mount, so re-seed the cache when Expo Router reuses this screen for a new hostId.
     const freshCache = hostId ? (getCachedWorktrees(hostId) as Worktree[] | null) : null
diff --git a/mobile/src/host-screen/use-host-screen-state.ts b/mobile/src/host-screen/use-host-screen-state.ts
index 8e020fba446..6625119f205 100644
--- a/mobile/src/host-screen/use-host-screen-state.ts
+++ b/mobile/src/host-screen/use-host-screen-state.ts
@@ -84,6 +84,8 @@ export function useHostScreenState(hostId: string | undefined, action: string |
   const [sleptIds, setSleptIds] = useState<Set<string>>(new Set())
   const [pinnedIds, setPinnedIds] = useState<Set<string>>(new Set())
   const [collapsedGroups, setCollapsedGroups] = useState<Set<string>>(new Set())
+  // Desktop's "Also show pinned worktrees in their original lists"; off by default.
+  const [showPinnedInGroups, setShowPinnedInGroups] = useState(false)
   // Why: ref so the ui.get merge and ui.set writes read the latest values without re-creating callbacks on every state change.
   const viewStateRef = useRef<MobileViewState>({
     groupMode: 'repo',
@@ -149,6 +151,7 @@ export function useHostScreenState(hostId: string | undefined, action: string |
     setRouteActionState,
     setSearch,
     setShowFilterModal,
+    setShowPinnedInGroups,
     setShowGroupPicker,
     setShowSearch,
     setShowSortPicker,
@@ -158,6 +161,7 @@ export function useHostScreenState(hostId: string | undefined, action: string |
     setWorktrees,
     setWorktreesLoaded,
     showFilterModal,
+    showPinnedInGroups,
     showGroupPicker,
     showSearch,
     showSortPicker,
diff --git a/mobile/src/host-screen/use-host-worktree-catalog.ts b/mobile/src/host-screen/use-host-worktree-catalog.ts
index 2fb95241a53..07ea8c4192f 100644
--- a/mobile/src/host-screen/use-host-worktree-catalog.ts
+++ b/mobile/src/host-screen/use-host-worktree-catalog.ts
@@ -4,6 +4,7 @@ import { setCachedWorktrees } from '../cache/worktree-cache'
 import type { RpcClient } from '../transport/rpc-client'
 import type { ConnectionState } from '../transport/types'
 import { RpcIncompatibleReplyError } from '../transport/rpc-incompatible-reply-error'
+import { showPinnedWorktreesInGroupsRead } from '../transport/settings-read-operations'
 import { useWorktreeResync } from '../transport/use-worktree-resync'
 import { startHostWorktreeRefresh } from '../worktree/host-worktree-refresh'
 import { areWorktreeListsEqual } from '../worktree/worktree-list-snapshot'
@@ -42,6 +43,7 @@ export function useHostWorktreeCatalog(args: {
     setLastKnownWorktrees,
     setOptimisticActiveWorktreeIdentity,
     setPinnedIds,
+    setShowPinnedInGroups,
     setSleptIds,
     setWorktrees,
     setWorktreesLoaded,
@@ -145,13 +147,36 @@ export function useHostWorktreeCatalog(args: {
     }, [])
   )
 
+  const syncShowPinnedInGroups = useCallback(async (requestClient: RpcClient) => {
+    try {
+      const reply = await showPinnedWorktreesInGroupsRead.request(requestClient)
+      if (clientRef.current !== requestClient) {
+        return
+      }
+      const read = showPinnedWorktreesInGroupsRead.interpret(reply)
+      if (read.accepted) {
+        setShowPinnedInGroups(read.value)
+      }
+    } catch {
+      // Best-effort: keep the current placement until the next focus/connect.
+    }
+  }, [])
+
   const startWorktreeRefresh = useCallback(() => {
     if (!client || connState !== 'connected') {
       return
     }
     void syncViewSettingsFromDesktop()
+    void syncShowPinnedInGroups(client)
     return startHostWorktreeRefresh({ client, fetchWorktrees, fetchRepoMetadata })
-  }, [client, connState, fetchWorktrees, fetchRepoMetadata, syncViewSettingsFromDesktop])
+  }, [
+    client,
+    connState,
+    fetchWorktrees,
+    fetchRepoMetadata,
+    syncViewSettingsFromDesktop,
+    syncShowPinnedInGroups
+  ])
 
   useFocusEffect(
     useCallback(() => {
diff --git a/mobile/src/session/MobileNativeChatMessage.android.test.ts b/mobile/src/session/MobileNativeChatMessage.android.test.ts
new file mode 100644
index 00000000000..fff2a8d9eba
--- /dev/null
+++ b/mobile/src/session/MobileNativeChatMessage.android.test.ts
@@ -0,0 +1,121 @@
+import { createElement, type ReactNode } from 'react'
+import { act, create, type ReactTestInstance, type ReactTestRenderer } from 'react-test-renderer'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+
+// Why a separate file: the sibling suite runs as iOS, where the row has no long press at all.
+// This one runs as Android and pins the wiring from the bubble's long press to the actions sheet.
+vi.mock('react-native', async () => {
+  const React = await import('react')
+  const Text = ({ children, ...props }: { children?: ReactNode }): ReactNode =>
+    React.createElement('Text', props, children)
+  return {
+    ActivityIndicator: 'ActivityIndicator',
+    Animated: {
+      Text,
+      Value: class {
+        setValue(): void {}
+      },
+      loop: (animation: unknown) => animation,
+      sequence: () => ({ start: vi.fn(), stop: vi.fn() }),
+      timing: () => ({ start: vi.fn(), stop: vi.fn() })
+    },
+    Image: 'Image',
+    Platform: { OS: 'android' },
+    Pressable: 'Pressable',
+    Text,
+    View: ({ children, ...props }: { children?: ReactNode }) =>
+      React.createElement('View', props, children),
+    StyleSheet: { create: (styles: unknown) => styles, hairlineWidth: 1 }
+  }
+})
+vi.mock('expo-clipboard', () => ({ setStringAsync: vi.fn() }))
+vi.mock('lucide-react-native', () => ({
+  ArrowUp: 'ArrowUp',
+  ChevronDown: 'ChevronDown',
+  Copy: 'Copy',
+  SquareChevronRight: 'SquareChevronRight',
+  SquareTerminal: 'SquareTerminal',
+  Wrench: 'Wrench',
+  ChevronRight: 'ChevronRight'
+}))
+vi.mock('../components/MobileMarkdown', () => ({ MobileMarkdown: 'MobileMarkdown' }))
+vi.mock('./MobileNativeChatMessageActionsSheet', () => ({
+  MobileNativeChatMessageActionsSheet: 'MessageActionsSheet'
+}))
+
+import { MobileNativeChatMessage } from './MobileNativeChatMessage'
+
+const message: NativeChatMessage = {
+  id: 'a1',
+  role: 'assistant',
+  blocks: [{ type: 'text', text: 'Read https://example.com then reply.' }],
+  timestamp: null,
+  source: 'transcript'
+}
+
+describe('MobileNativeChatMessage on Android', () => {
+  let renderer: ReactTestRenderer | null = null
+
+  afterEach(() => {
+    act(() => renderer?.unmount())
+    renderer = null
+  })
+
+  function byType(type: string): ReactTestInstance[] {
+    return renderer!.root.findAll((node) => String(node.type) === type)
+  }
+
+  it('opens the actions sheet from a long press on the bubble, and closes it again', () => {
+    act(() => {
+      renderer = create(createElement(MobileNativeChatMessage, { message }))
+    })
+    expect(byType('MessageActionsSheet')).toHaveLength(0)
+
+    const [bubble] = byType('Pressable')
+    expect(typeof bubble!.props.onLongPress).toBe('function')
+    // The markdown gets the same handler, so a link span or image under the finger opens the sheet.
+    const [markdown] = byType('MobileMarkdown')
+    expect(markdown!.props.onLongPress).toBe(bubble!.props.onLongPress)
+    expect(markdown!.props.rangeSelectable).toBe(true)
+
+    act(() => bubble!.props.onLongPress())
+    const [sheet] = byType('MessageActionsSheet')
+    expect(sheet!.props.message).toBe(message)
+
+    act(() => sheet!.props.onClose())
+    expect(byType('MessageActionsSheet')).toHaveLength(0)
+  })
+
+  it('disables inline selection for host notices too', () => {
+    act(() => {
+      renderer = create(
+        createElement(MobileNativeChatMessage, {
+          message: {
+            ...message,
+            role: 'system',
+            blocks: [{ type: 'text', text: 'fallback', presentation: 'history-item-too-large' }]
+          }
+        })
+      )
+    })
+    const texts = byType('Text').filter((node) => node.props.selectable !== undefined)
+    expect(texts).toHaveLength(1)
+    expect(texts[0]!.props.selectable).toBe(false)
+    act(() => byType('Pressable')[0]!.props.onLongPress())
+    expect(byType('MessageActionsSheet')).toHaveLength(1)
+  })
+
+  it('renders the user bubble without inline selection', () => {
+    act(() => {
+      renderer = create(
+        createElement(MobileNativeChatMessage, { message: { ...message, id: 'u1', role: 'user' } })
+      )
+    })
+    const texts = byType('Text').filter((node) => node.props.selectable !== undefined)
+    expect(texts.length).toBeGreaterThan(0)
+    for (const node of texts) {
+      expect(node.props.selectable).toBe(false)
+    }
+  })
+})
diff --git a/mobile/src/session/MobileNativeChatMessage.test.ts b/mobile/src/session/MobileNativeChatMessage.test.ts
index c8193641fef..135469d8917 100644
--- a/mobile/src/session/MobileNativeChatMessage.test.ts
+++ b/mobile/src/session/MobileNativeChatMessage.test.ts
@@ -22,6 +22,7 @@ vi.mock('react-native', async () => {
       timing: () => ({ start: vi.fn(), stop: vi.fn() })
     },
     Image: 'Image',
+    Platform: { OS: 'ios' },
     Pressable: 'Pressable',
     Text,
     View: ({ children, ...props }: { children?: unknown }) =>
@@ -40,6 +41,9 @@ vi.mock('lucide-react-native', () => ({
   ChevronRight: 'ChevronRight'
 }))
 vi.mock('../components/MobileMarkdown', () => ({ MobileMarkdown: 'MobileMarkdown' }))
+vi.mock('./MobileNativeChatMessageActionsSheet', () => ({
+  MobileNativeChatMessageActionsSheet: 'MessageActionsSheet'
+}))
 
 import { MobileNativeChatMessage } from './MobileNativeChatMessage'
 
diff --git a/mobile/src/session/MobileNativeChatMessage.tsx b/mobile/src/session/MobileNativeChatMessage.tsx
index 40635166281..83f93266d6f 100644
--- a/mobile/src/session/MobileNativeChatMessage.tsx
+++ b/mobile/src/session/MobileNativeChatMessage.tsx
@@ -1,6 +1,8 @@
 import { MobileSelectableText as Text } from '../components/MobileSelectableText'
-import { memo } from 'react'
-import { Image, Text as NativeText, View } from 'react-native'
+import { memo, useCallback, useState, type ComponentProps, type ReactNode } from 'react'
+import { Image, Text as NativeText, Pressable, View } from 'react-native'
+import { INLINE_TEXT_SELECTION } from '../components/inline-text-selection'
+import { MobileNativeChatMessageActionsSheet } from './MobileNativeChatMessageActionsSheet'
 import { splitNativeChatBlocks } from '../../../src/shared/native-chat-tool-fold'
 import { selectActiveToolCall } from '../../../src/shared/native-chat-tool-activity'
 import { isImageRefBlock, isTextBlock } from '../../../src/shared/native-chat-types'
@@ -20,17 +22,23 @@ function Prose({
   block,
   invert,
   fontScale,
-  onOpenFile
+  onOpenFile,
+  onLongPress
 }: {
   block: NativeChatBlock
   invert?: boolean
   fontScale: number
   onOpenFile?: (relativePath: string) => void
+  /** Android only: routes a long press on a link span to the row's actions sheet. */
+  onLongPress?: () => void
 }): React.JSX.Element | null {
   if (isTextBlock(block)) {
     if (isAgentSessionHostStatusPresentation(block.presentation)) {
       return (
-        <Text selectable style={[styles.hostNotice, { fontSize: TEXT_SIZE * fontScale }]}>
+        <Text
+          selectable={INLINE_TEXT_SELECTION}
+          style={[styles.hostNotice, { fontSize: TEXT_SIZE * fontScale }]}
+        >
           {AGENT_SESSION_HOST_STATUS_COPY[block.presentation]}
         </Text>
       )
@@ -39,7 +47,10 @@ function Prose({
     // markdown renderer's light-on-dark palette.
     if (invert) {
       return (
-        <Text selectable style={[styles.userText, { fontSize: TEXT_SIZE * fontScale }]}>
+        <Text
+          selectable={INLINE_TEXT_SELECTION}
+          style={[styles.userText, { fontSize: TEXT_SIZE * fontScale }]}
+        >
           {block.text}
         </Text>
       )
@@ -50,6 +61,7 @@ function Prose({
         rangeSelectable
         textScale={1.25 * fontScale}
         onOpenFile={onOpenFile}
+        onLongPress={onLongPress}
       />
     )
   }
@@ -76,6 +88,25 @@ function Prose({
   return null
 }
 
+// Keep the existing responder hierarchy on platforms with inline selection.
+function Content({
+  onLongPress,
+  style,
+  children
+}: {
+  onLongPress?: () => void
+  style: ComponentProps<typeof View>['style']
+  children: ReactNode
+}): React.JSX.Element {
+  return onLongPress ? (
+    <Pressable onLongPress={onLongPress} style={style}>
+      {children}
+    </Pressable>
+  ) : (
+    <View style={style}>{children}</View>
+  )
+}
+
 function MobileNativeChatMessageImpl({
   message,
   toolsExpanded = false,
@@ -129,6 +160,11 @@ function MobileNativeChatMessageImpl({
     !turnExpanded &&
     !toolsExpanded
   const showToolRun = tools.length > 0 && !settledToolsHidden
+  // Mount selection UI only for the message being copied.
+  const [actionsOpen, setActionsOpen] = useState(false)
+  // Keep the memoized Markdown context stable as the message streams.
+  const openActions = useCallback(() => setActionsOpen(true), [])
+  const onLongPress = INLINE_TEXT_SELECTION ? undefined : openActions
 
   const statusRow = turnStatus ? (
     <MobileNativeChatTurnStatus
@@ -144,7 +180,8 @@ function MobileNativeChatMessageImpl({
       {/* A turn with no user bubble carries its bar above its first row. */}
       {turnStatusAbove ? statusRow : null}
       <View style={[styles.row, isUser && styles.rowUser]}>
-        <View
+        <Content
+          onLongPress={onLongPress}
           style={[styles.content, isUser && styles.userBubble, isReasoning && styles.reasoning]}
         >
           {prose.map((block, index) => (
@@ -154,6 +191,7 @@ function MobileNativeChatMessageImpl({
               invert={isUser}
               fontScale={fontScale}
               onOpenFile={onOpenFile}
+              onLongPress={onLongPress}
             />
           ))}
           {showToolRun ? (
@@ -168,8 +206,14 @@ function MobileNativeChatMessageImpl({
               onOpenFile={onOpenFile}
             />
           ) : null}
-        </View>
+        </Content>
       </View>
+      {actionsOpen ? (
+        <MobileNativeChatMessageActionsSheet
+          message={message}
+          onClose={() => setActionsOpen(false)}
+        />
+      ) : null}
       {turnStatusAbove ? null : statusRow}
     </>
   )
diff --git a/mobile/src/session/MobileNativeChatMessageActionsSheet.test.tsx b/mobile/src/session/MobileNativeChatMessageActionsSheet.test.tsx
new file mode 100644
index 00000000000..34d4089af9b
--- /dev/null
+++ b/mobile/src/session/MobileNativeChatMessageActionsSheet.test.tsx
@@ -0,0 +1,126 @@
+import { createElement } from 'react'
+import { act, create, type ReactTestRenderer } from 'react-test-renderer'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+import { MobileNativeChatMessageActionsSheet } from './MobileNativeChatMessageActionsSheet'
+
+const { writeText, alert } = vi.hoisted(() => ({ writeText: vi.fn(), alert: vi.fn() }))
+vi.mock('react-native', () => ({
+  Alert: { alert },
+  ActivityIndicator: 'ActivityIndicator',
+  Modal: 'Modal',
+  Pressable: 'Pressable',
+  ScrollView: 'ScrollView',
+  Text: 'Text',
+  View: 'View',
+  StyleSheet: { create: (styles: unknown) => styles, hairlineWidth: 1 }
+}))
+vi.mock('react-native-safe-area-context', () => ({
+  useSafeAreaInsets: () => ({ top: 24, bottom: 16, left: 0, right: 0 })
+}))
+vi.mock('lucide-react-native', () => ({
+  Copy: 'Copy',
+  TextSelect: 'TextSelect',
+  X: 'X',
+  Edit3: 'Edit3',
+  Trash2: 'Trash2'
+}))
+vi.mock('../platform/clipboard', () => ({ useClipboardWriter: () => ({ writeText }) }))
+// Keep the real drawer lifecycle; only native animation completion is driven by the test.
+vi.mock('../components/mounted-bottom-drawer', () => ({ MountedBottomDrawer: 'MountedDrawer' }))
+
+const message: NativeChatMessage = {
+  id: 'reply',
+  source: 'transcript',
+  role: 'assistant',
+  timestamp: null,
+  blocks: [{ type: 'text', text: 'First words' }]
+}
+
+describe('message selection actions', () => {
+  let renderer: ReactTestRenderer | null = null
+  const onClose = vi.fn()
+  const nodes = (type: string) => renderer!.root.findAll((node) => String(node.type) === type)
+  const render = (value = message) => {
+    act(() => {
+      renderer = create(
+        createElement(MobileNativeChatMessageActionsSheet, { message: value, onClose })
+      )
+    })
+  }
+  const pressAction = (index: number) => act(() => nodes('Pressable')[index]!.props.onPress())
+  const finishClosing = () => act(() => nodes('MountedDrawer')[0]!.props.onHidden())
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    writeText.mockResolvedValue(undefined)
+  })
+  afterEach(() => act(() => renderer?.unmount()))
+
+  it('waits for drawer removal, then selects a stable snapshot while the reply streams', () => {
+    render()
+    act(() =>
+      renderer!.update(
+        createElement(MobileNativeChatMessageActionsSheet, {
+          message: {
+            ...message,
+            blocks: [{ type: 'text', text: 'First words plus streamed text' }]
+          },
+          onClose
+        })
+      )
+    )
+    pressAction(1)
+    expect(nodes('MountedDrawer')[0]!.props.visible).toBe(false)
+    expect(nodes('Modal')).toHaveLength(0)
+    expect(onClose).not.toHaveBeenCalled()
+    finishClosing()
+    expect(nodes('MountedDrawer')).toHaveLength(0)
+    expect(nodes('Modal')).toHaveLength(1)
+    const selected = nodes('Text').find((node) => node.props.selectable)
+    expect(selected?.props.children).toBe('First words')
+    act(() => nodes('Modal')[0]!.props.onRequestClose())
+    expect(onClose).toHaveBeenCalledOnce()
+  })
+
+  it('closes selection with the accessible close button', () => {
+    render()
+    pressAction(1)
+    finishClosing()
+    const close = nodes('Pressable').find((node) => node.props.accessibilityLabel === 'Close')
+    expect(close?.props.accessibilityRole).toBe('button')
+    act(() => close!.props.onPress())
+    expect(onClose).toHaveBeenCalledOnce()
+  })
+
+  it('copies prose and dismisses only after the drawer closes', () => {
+    render()
+    pressAction(0)
+    expect(writeText).toHaveBeenCalledWith('First words')
+    expect(onClose).not.toHaveBeenCalled()
+    finishClosing()
+    expect(onClose).toHaveBeenCalledOnce()
+    expect(nodes('Modal')).toHaveLength(0)
+  })
+
+  it('surfaces clipboard rejection', async () => {
+    writeText.mockRejectedValue(new Error('Clipboard unavailable'))
+    render()
+    await act(async () => pressAction(0))
+    expect(alert).toHaveBeenCalledWith('Copy failed', 'Clipboard unavailable')
+  })
+
+  it('dismisses without selecting when the drawer is cancelled', () => {
+    render()
+    act(() => nodes('MountedDrawer')[0]!.props.onClose())
+    finishClosing()
+    expect(onClose).toHaveBeenCalledOnce()
+    expect(nodes('Modal')).toHaveLength(0)
+  })
+
+  it('disables actions when the message has no copyable prose', () => {
+    render({ ...message, blocks: [{ type: 'image-ref', path: '/image.png' }] })
+    expect(nodes('Pressable').map((node) => node.props.disabled)).toEqual([true, true])
+    expect(writeText).not.toHaveBeenCalled()
+  })
+})
diff --git a/mobile/src/session/MobileNativeChatMessageActionsSheet.tsx b/mobile/src/session/MobileNativeChatMessageActionsSheet.tsx
new file mode 100644
index 00000000000..4d9cf71c6ba
--- /dev/null
+++ b/mobile/src/session/MobileNativeChatMessageActionsSheet.tsx
@@ -0,0 +1,119 @@
+import { useRef, useState } from 'react'
+import { Alert, Modal, Pressable, ScrollView, StyleSheet, Text, View } from 'react-native'
+import { useSafeAreaInsets } from 'react-native-safe-area-context'
+import { Copy, TextSelect, X } from 'lucide-react-native'
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+import { ActionSheetContent } from '../components/ActionSheetModal'
+import { BottomDrawer } from '../components/BottomDrawer'
+import { useClipboardWriter } from '../platform/clipboard'
+import { colors, spacing, typography } from '../theme/mobile-theme'
+import { nativeChatMessagePlainText } from './mobile-native-chat-message-plain-text'
+
+type Props = {
+  /** The long-pressed message. The owner mounts this only while the sheet is open. */
+  message: NativeChatMessage
+  onClose: () => void
+}
+
+export function MobileNativeChatMessageActionsSheet({
+  message,
+  onClose
+}: Props): React.JSX.Element {
+  const clipboard = useClipboardWriter()
+  const [sheetVisible, setSheetVisible] = useState(true)
+  const [selecting, setSelecting] = useState(false)
+  // Wait for the drawer to unmount before presenting another native modal.
+  const selectRequested = useRef(false)
+  // Streaming updates must not reset an active native text selection.
+  const [text] = useState(() => nativeChatMessagePlainText(message))
+  const closeSheet = () => setSheetVisible(false)
+
+  return (
+    <>
+      <BottomDrawer
+        visible={sheetVisible}
+        onClose={closeSheet}
+        onAfterClose={() => (selectRequested.current ? setSelecting(true) : onClose())}
+        dragContentToDismiss
+      >
+        <ActionSheetContent
+          onClose={closeSheet}
+          actions={[
+            {
+              label: 'Copy message',
+              icon: Copy,
+              disabled: text.length === 0,
+              onPress: () => {
+                void clipboard.writeText(text).catch((error: unknown) => {
+                  Alert.alert(
+                    'Copy failed',
+                    error instanceof Error ? error.message : 'The clipboard rejected the text.'
+                  )
+                })
+              }
+            },
+            {
+              label: 'Select text',
+              icon: TextSelect,
+              disabled: text.length === 0,
+              onPress: () => {
+                selectRequested.current = true
+              }
+            }
+          ]}
+        />
+      </BottomDrawer>
+      {selecting ? <SelectTextScreen text={text} onClose={onClose} /> : null}
+    </>
+  )
+}
+
+function SelectTextScreen({
+  text,
+  onClose
+}: {
+  text: string
+  onClose: () => void
+}): React.JSX.Element {
+  const insets = useSafeAreaInsets()
+  return (
+    <Modal visible animationType="slide" onRequestClose={onClose}>
+      <View style={[styles.screen, { paddingTop: insets.top, paddingBottom: insets.bottom }]}>
+        <View style={styles.header}>
+          <Text style={styles.title}>Select text</Text>
+          <Pressable
+            onPress={onClose}
+            hitSlop={12}
+            accessibilityLabel="Close"
+            accessibilityRole="button"
+            style={styles.close}
+          >
+            <X size={20} color={colors.textSecondary} />
+          </Pressable>
+        </View>
+        <ScrollView contentContainerStyle={styles.body}>
+          <Text selectable style={styles.text}>
+            {text}
+          </Text>
+        </ScrollView>
+      </View>
+    </Modal>
+  )
+}
+
+const styles = StyleSheet.create({
+  screen: { flex: 1, backgroundColor: colors.bgBase },
+  header: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    paddingHorizontal: spacing.lg,
+    paddingVertical: spacing.md,
+    borderBottomWidth: StyleSheet.hairlineWidth,
+    borderBottomColor: colors.borderSubtle
+  },
+  title: { color: colors.textPrimary, fontSize: typography.titleSize, fontWeight: '600' },
+  close: { padding: spacing.xs },
+  body: { padding: spacing.lg },
+  text: { color: colors.textPrimary, fontSize: typography.bodySize, lineHeight: 22 }
+})
diff --git a/mobile/src/session/MobileNativeChatTurnStatus.test.ts b/mobile/src/session/MobileNativeChatTurnStatus.test.ts
index d2069a134b2..a0393996cec 100644
--- a/mobile/src/session/MobileNativeChatTurnStatus.test.ts
+++ b/mobile/src/session/MobileNativeChatTurnStatus.test.ts
@@ -78,14 +78,15 @@ describe('MobileNativeChatTurnStatus', () => {
     expect(onToggleExpanded).toHaveBeenCalledOnce()
   })
 
-  it('heads a turn a crash cut off as failed, and a turn the user stopped as interrupted', () => {
+  // The crash's notice row explains the cut; the turn bar reads like any finished turn.
+  it('heads a turn a crash cut off as worked, and a turn the user stopped as interrupted', () => {
     const crashed = render({
       startedAt: Date.now(),
       workedSeconds: 12,
       verdict: 'interruption',
       onToggleExpanded: vi.fn()
     })
-    expect(labels(crashed.root)).toEqual(['Failed after 12s'])
+    expect(labels(crashed.root)).toEqual(['Worked for 12s'])
     act(() => crashed.unmount())
     const stopped = render({
       startedAt: Date.now(),
diff --git a/mobile/src/session/ai-vault-resume-launch.test.ts b/mobile/src/session/ai-vault-resume-launch.test.ts
index d588aea30a2..5f709d5aaf2 100644
--- a/mobile/src/session/ai-vault-resume-launch.test.ts
+++ b/mobile/src/session/ai-vault-resume-launch.test.ts
@@ -5,6 +5,7 @@ import {
   buildMobileAiVaultResumeLaunch,
   buildMobileAiVaultResumeCommand,
   createMobileAiVaultResumeMutationRegistry,
+  readMobileAiVaultResumeHost,
   readMobileRuntimeTerminalWindowsShell,
   resolveMobileAiVaultResumePlatform,
   resumeAiVaultSessionInTerminal
@@ -242,6 +243,75 @@ describe('buildMobileAiVaultResumeLaunch', () => {
 })
 
 describe('resumeAiVaultSessionInTerminal', () => {
+  it.each(['darwin', 'linux', 'win32'] as const)(
+    'lets the %s execution host select the Qoder resume command at creation',
+    async (hostPlatform) => {
+      const launch = buildMobileAiVaultResumeLaunch({
+        session: session({ agent: 'qoder', sessionId: 'same-qoder-session' }),
+        hostPlatform
+      })
+      const sendRequest = vi
+        .fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          result: { tab: { type: 'terminal', id: 'tab-1', terminal: 'pty-1', title: 'Terminal' } }
+        })
+        .mockResolvedValueOnce({ ok: true, result: { send: { accepted: true } } })
+      await resumeAiVaultSessionInTerminal({ sendRequest }, 'worktree-1', {
+        ...launch,
+        clientMutationId: 'qoder-resume',
+        hostCapabilities: ['session.tabs.qoderOwnedCreate.v1']
+      })
+      expect(sendRequest).toHaveBeenCalledTimes(1)
+      expect(sendRequest).toHaveBeenCalledWith(
+        'session.tabs.createTerminal',
+        expect.objectContaining({
+          command: launch.command,
+          launchAgent: 'qoder',
+          launchConfig: launch.launchConfig
+        }),
+        { timeoutMs: RESUME_RPC_TIMEOUT_MS }
+      )
+      expect(launch.command).toContain('same-qoder-session')
+    }
+  )
+
+  it.each(
+    [undefined, [], ['aiVault.v1']].flatMap((hostCapabilities) =>
+      (['darwin', 'linux', 'win32'] as const).map((hostPlatform) => ({
+        hostCapabilities,
+        hostPlatform
+      }))
+    )
+  )(
+    'keeps the acknowledged-create fallback on an older $hostPlatform host',
+    async ({ hostCapabilities, hostPlatform }) => {
+      const launch = buildMobileAiVaultResumeLaunch({
+        session: session({ agent: 'qoder', sessionId: 'legacy-session' }),
+        hostPlatform
+      })
+      const sendRequest = vi
+        .fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          result: { tab: { type: 'terminal', id: 'tab-1', terminal: 'pty-1', title: 'Terminal' } }
+        })
+        .mockResolvedValueOnce({ ok: true, result: { send: { accepted: true } } })
+      await resumeAiVaultSessionInTerminal({ sendRequest }, 'worktree-1', {
+        ...launch,
+        hostCapabilities,
+        clientMutationId: 'same-legacy-resume'
+      })
+      expect(sendRequest).toHaveBeenCalledTimes(2)
+      expect(sendRequest.mock.calls[0]?.[1]).not.toHaveProperty('command')
+      expect(sendRequest.mock.calls[1]).toEqual([
+        'terminal.send',
+        { terminal: 'pty-1', text: launch.command, enter: true },
+        { timeoutMs: RESUME_RPC_TIMEOUT_MS }
+      ])
+    }
+  )
+
   it('creates a fresh terminal and sends the command with Enter', async () => {
     const sendRequest = vi
       .fn()
@@ -401,3 +471,19 @@ describe('resume platform helpers', () => {
     expect(resolveMobileAiVaultResumePlatform('runtime', 'linux')).toBeNull()
   })
 })
+
+it.each([null, {}, { capabilities: 'session.tabs.qoderOwnedCreate.v1' }, { capabilities: [1] }])(
+  'does not infer safe Qoder creation from unreadable host capabilities',
+  (status) => {
+    expect(readMobileAiVaultResumeHost(status).capabilities).toBeUndefined()
+  }
+)
+
+it('reads the execution platform and advertised safe-create capability together', () => {
+  expect(
+    readMobileAiVaultResumeHost({
+      hostPlatform: 'win32',
+      capabilities: ['session.tabs.qoderOwnedCreate.v1']
+    })
+  ).toEqual({ platform: 'win32', capabilities: ['session.tabs.qoderOwnedCreate.v1'] })
+})
diff --git a/mobile/src/session/ai-vault-resume-launch.ts b/mobile/src/session/ai-vault-resume-launch.ts
index fb99f199b79..95005666872 100644
--- a/mobile/src/session/ai-vault-resume-launch.ts
+++ b/mobile/src/session/ai-vault-resume-launch.ts
@@ -21,6 +21,17 @@ import { interpretOrThrowRefusalMessage } from '../transport/rpc-refusal-message
 import { reviewTerminalCreateRun, reviewTerminalSendRun } from './mobile-review-terminal-operations'
 import type { MobileReviewTerminalTab } from './review-terminal-reply-schema'
 import type { MobileAiVaultResumeTargetStatus } from '../agent-history/agent-history-resume-target'
+import { QODER_OWNED_TERMINAL_CREATE_CAPABILITY } from '../../../src/shared/qoder-terminal-create-capability'
+import { agentHistoryHostStatusSchema } from '../agent-history/agent-history-reply-schema'
+import { readMobileRuntimeHostPlatform } from '../transport/mobile-runtime-host-platform'
+
+export function readMobileAiVaultResumeHost(statusResult: unknown) {
+  const status = agentHistoryHostStatusSchema.safeParse(statusResult)
+  return {
+    platform: readMobileRuntimeHostPlatform(statusResult),
+    capabilities: status.success ? status.data.capabilities : undefined
+  }
+}
 
 export function buildMobileAiVaultResumeCommand(args: {
   session: Pick<AiVaultSession, 'agent' | 'sessionId' | 'cwd' | 'codexHome'> &
@@ -151,14 +162,25 @@ function normalizeMobileAiVaultResumeCommandOverrides(
 export async function resumeAiVaultSessionInTerminal(
   client: RpcOperationSender,
   worktreeId: string,
-  launch: MobileAiVaultResumeLaunch & { clientMutationId?: string }
+  launch: MobileAiVaultResumeLaunch & {
+    clientMutationId?: string
+    hostCapabilities?: readonly string[]
+  },
+  assertCurrentOwner?: () => void
 ): Promise<MobileReviewTerminalTab> {
+  assertCurrentOwner?.()
+  // Qoder's execution host must select its installed executable before the resume starts.
+  const launchAtCreate =
+    launch.launchAgent === 'qoder' &&
+    Boolean(launch.clientMutationId) &&
+    launch.hostCapabilities?.includes(QODER_OWNED_TERMINAL_CREATE_CAPABILITY) === true
   // Each request is awaited outside its catch so a transport drop propagates as the original error
   // object; only a refusal is rewritten into this step's own copy.
   const created = await reviewTerminalCreateRun.request(
     client,
     {
       worktree: `id:${worktreeId}`,
+      ...(launchAtCreate ? { command: launch.command } : {}),
       ...(launch.env ? { env: launch.env } : {}),
       ...(launch.envToDelete ? { envToDelete: launch.envToDelete } : {}),
       ...(launch.launchConfig ? { launchConfig: launch.launchConfig } : {}),
@@ -175,6 +197,10 @@ export async function resumeAiVaultSessionInTerminal(
     () => reviewTerminalCreateRun.interpret(created),
     'Failed to create terminal'
   )
+  if (launchAtCreate) {
+    return terminalTab
+  }
+  assertCurrentOwner?.()
   const sent = await reviewTerminalSendRun.request(
     client,
     {
diff --git a/mobile/src/session/mobile-native-chat-message-plain-text.test.ts b/mobile/src/session/mobile-native-chat-message-plain-text.test.ts
new file mode 100644
index 00000000000..b115cab8268
--- /dev/null
+++ b/mobile/src/session/mobile-native-chat-message-plain-text.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+import { AGENT_SESSION_HOST_STATUS_COPY } from '../../../src/shared/agent-session-host-status-rows'
+import type { NativeChatBlock } from '../../../src/shared/native-chat-types'
+import { nativeChatMessagePlainText } from './mobile-native-chat-message-plain-text'
+
+describe('nativeChatMessagePlainText', () => {
+  it('joins the prose blocks, keeps their whitespace, and leaves tool calls out', () => {
+    const blocks: NativeChatBlock[] = [
+      { type: 'text', text: '  indented first line\n' },
+      { type: 'tool-call', name: 'Bash', input: { command: 'ls' } },
+      { type: 'text', text: '   \n' },
+      { type: 'text', text: 'Second, with `code`.' }
+    ]
+    expect(nativeChatMessagePlainText({ blocks })).toBe(
+      '  indented first line\n\n\nSecond, with `code`.'
+    )
+  })
+
+  it('copies the displayed host notice instead of its fallback wire text', () => {
+    expect(
+      nativeChatMessagePlainText({
+        blocks: [{ type: 'text', text: 'fallback', presentation: 'history-item-too-large' }]
+      })
+    ).toBe(AGENT_SESSION_HOST_STATUS_COPY['history-item-too-large'])
+  })
+
+  it('is empty for a message with no prose', () => {
+    expect(
+      nativeChatMessagePlainText({ blocks: [{ type: 'tool-call', name: 'Read', input: {} }] })
+    ).toBe('')
+  })
+})
diff --git a/mobile/src/session/mobile-native-chat-message-plain-text.ts b/mobile/src/session/mobile-native-chat-message-plain-text.ts
new file mode 100644
index 00000000000..40ca75dfaf6
--- /dev/null
+++ b/mobile/src/session/mobile-native-chat-message-plain-text.ts
@@ -0,0 +1,20 @@
+import {
+  AGENT_SESSION_HOST_STATUS_COPY,
+  isAgentSessionHostStatusPresentation
+} from '../../../src/shared/agent-session-host-status-rows'
+import { isTextBlock } from '../../../src/shared/native-chat-types'
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+
+/** Copy the displayed prose, excluding tool activity and image attachments. */
+export function nativeChatMessagePlainText(message: Pick<NativeChatMessage, 'blocks'>): string {
+  // Preserve indentation in code and nested lists.
+  return message.blocks
+    .filter(isTextBlock)
+    .map((block) =>
+      isAgentSessionHostStatusPresentation(block.presentation)
+        ? AGENT_SESSION_HOST_STATUS_COPY[block.presentation]
+        : block.text
+    )
+    .filter((text) => text.trim().length > 0)
+    .join('\n\n')
+}
diff --git a/mobile/src/session/use-mobile-structured-agent-session.cut-turn-notice.test.tsx b/mobile/src/session/use-mobile-structured-agent-session.cut-turn-notice.test.tsx
new file mode 100644
index 00000000000..37a29458c07
--- /dev/null
+++ b/mobile/src/session/use-mobile-structured-agent-session.cut-turn-notice.test.tsx
@@ -0,0 +1,132 @@
+import { createElement } from 'react'
+import { act, create, type ReactTestRenderer } from 'react-test-renderer'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { AgentJournalRenderItem } from '../../../src/shared/agent-session-journal-types'
+import type { AgentSessionSubscribeEvent } from '../../../src/shared/agent-session-wire'
+import type { RpcClient } from '../transport/rpc-client'
+import type { RpcResponse } from '../transport/types'
+import { useMobileStructuredAgentSession } from './use-mobile-structured-agent-session'
+
+vi.mock('@react-native-async-storage/async-storage', () => ({
+  default: { getItem: vi.fn(async () => null), setItem: vi.fn(), removeItem: vi.fn() }
+}))
+
+const SCOPE = { kind: 'turn' as const, turnItemId: 'turn-1' }
+const ITEMS: AgentJournalRenderItem[] = [
+  {
+    itemId: 'user-1',
+    revision: 0,
+    sequence: 1,
+    observedAt: 1,
+    turnScope: { kind: 'thread' },
+    body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'long job' }] }
+  },
+  {
+    itemId: 'turn-1',
+    revision: 1,
+    sequence: 2,
+    observedAt: 2,
+    turnScope: { kind: 'thread' },
+    body: {
+      kind: 'turn',
+      turnId: 'turn-1',
+      userItemId: 'user-1',
+      state: 'interrupted',
+      startedAt: 2,
+      completedAt: 9
+    }
+  },
+  {
+    itemId: 'reply-1',
+    revision: 0,
+    sequence: 3,
+    observedAt: 3,
+    turnScope: SCOPE,
+    body: { kind: 'message', role: 'assistant', blocks: [{ type: 'text', text: 'half' }] }
+  }
+]
+
+function snapshot(items: AgentJournalRenderItem[]): AgentSessionSubscribeEvent {
+  return {
+    type: 'snapshot',
+    sessionId: 'session-1',
+    fence: 3,
+    page: {
+      sessionId: 'session-1',
+      epoch: 'epoch-1',
+      fence: 3,
+      direction: 'tail',
+      items,
+      removedItemIds: [],
+      submissions: [],
+      window: {
+        oldest: { epoch: 'epoch-1', sequence: 1 },
+        newest: { epoch: 'epoch-1', sequence: 3 },
+        nextCursor: { epoch: 'epoch-1', sequence: 4 }
+      },
+      liveCursor: { epoch: 'epoch-1', sequence: 3 },
+      hasOlder: false,
+      hasNewer: false
+    }
+  }
+}
+
+describe('useMobileStructuredAgentSession transcript', () => {
+  let renderer: ReactTestRenderer | null = null
+  afterEach(() => {
+    act(() => renderer?.unmount())
+    renderer = null
+  })
+
+  it('shows a cut turn no row explains with the one notice desktop shows, in that turn', async () => {
+    let listener: ((value: unknown) => void) | null = null
+    const client: Pick<RpcClient, 'sendRequest' | 'subscribe'> = {
+      sendRequest: vi.fn(async (): Promise<RpcResponse> => ({
+        id: 'response-1',
+        ok: true,
+        result: {},
+        _meta: { runtimeId: 'runtime-1' }
+      })),
+      subscribe: vi.fn((_method: string, _params: unknown, onData: (value: unknown) => void) => {
+        listener = onData
+        return () => {}
+      })
+    }
+    const rendered: { hook: ReturnType<typeof useMobileStructuredAgentSession> | null } = {
+      hook: null
+    }
+    function Harness(): null {
+      rendered.hook = useMobileStructuredAgentSession({
+        // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the hook calls only sendRequest and subscribe, both provided.
+        client: client as RpcClient,
+        sessionId: 'session-1',
+        enabled: true,
+        connected: true,
+        hostSupport: null,
+        agent: 'codex',
+        onSendError: vi.fn()
+      })
+      return null
+    }
+    act(() => {
+      renderer = create(createElement(Harness))
+    })
+    await vi.waitFor(() => expect(listener).toEqual(expect.any(Function)))
+
+    act(() => listener?.(snapshot(ITEMS)))
+
+    await vi.waitFor(() =>
+      expect(rendered.hook?.session.messages.at(-1)).toMatchObject({
+        role: 'system',
+        blocks: [
+          {
+            text: 'Codex stopped while this response was in progress. You can continue in this conversation.',
+            tone: 'error'
+          }
+        ]
+      })
+    )
+    // The turn bars place rows by the same items, so the notice joins the cut turn.
+    expect(rendered.hook?.turnJournal.items.at(-1)).toMatchObject({ turnScope: SCOPE })
+  })
+})
diff --git a/mobile/src/session/use-mobile-structured-agent-session.ts b/mobile/src/session/use-mobile-structured-agent-session.ts
index 653d7fbaaa1..b0ecfe9832c 100644
--- a/mobile/src/session/use-mobile-structured-agent-session.ts
+++ b/mobile/src/session/use-mobile-structured-agent-session.ts
@@ -2,6 +2,8 @@ import { useCallback, useMemo, useRef } from 'react'
 import { encodeNativeChatTranscriptIdentity } from '../../../src/shared/native-chat-transcript-retention'
 import type { MobileNativeChatSendOutcome } from './mobile-native-chat-send'
 import { projectStructuredAgentSessionMessages } from '../../../src/shared/structured-agent-session-message-projection'
+import { withNativeChatCutTurnNotices } from '../../../src/shared/native-chat-cut-turn-notice'
+import { TUI_AGENT_DISPLAY_NAMES } from '../../../src/shared/tui-agent-display-names'
 import { isStructuredAgentSessionMainAgentWorking } from '../../../src/shared/structured-agent-session-main-agent-working'
 import {
   activeStructuredAgentSessionTurnId,
@@ -157,12 +159,28 @@ export function useMobileStructuredAgentSession(args: {
     onSendError
   })
 
+  // What the transcript reads, as desktop does: the journal plus the one notice a cut turn with no
+  // row gets.
+  const transcriptItems = useMemo(
+    () =>
+      withNativeChatCutTurnNotices(state.items, {
+        agentName: TUI_AGENT_DISPLAY_NAMES[agent === 'codex' ? 'codex' : 'claude']
+      }),
+    [agent, state.items]
+  )
   const messages = useMemo(
-    () => projectStructuredAgentSessionMessages(state.items, [], state.submissions),
-    [state.items, state.submissions]
+    // Off: the phone hands a rejected message back to its composer, so a row would show it twice.
+    () =>
+      projectStructuredAgentSessionMessages(transcriptItems, [], state.submissions, {
+        rejectedInPlace: false
+      }),
+    [transcriptItems, state.submissions]
   )
   const turnId = activeStructuredAgentSessionTurnId(state.items)
-  const turnTiming = useMobileStructuredAgentTurnTiming(state, turnId)
+  const turnTiming = useMobileStructuredAgentTurnTiming(
+    { ...state, items: transcriptItems },
+    turnId
+  )
   const activityText =
     selectStructuredAgentTurnActivity(state.items, turnId, state.activity)?.text ?? null
   const thinking = isStructuredAgentSessionThinking(state.items)
diff --git a/mobile/src/test-support/rpc-recording/adapters/settings-mount-adapters.ts b/mobile/src/test-support/rpc-recording/adapters/settings-mount-adapters.ts
index 5c6fe0ef14d..3de45356c27 100644
--- a/mobile/src/test-support/rpc-recording/adapters/settings-mount-adapters.ts
+++ b/mobile/src/test-support/rpc-recording/adapters/settings-mount-adapters.ts
@@ -1,16 +1,11 @@
+import type * as ResumeMetadata from '../../../agent-history/mobile-agent-history-resume-metadata'
 import type { OperationExposure } from '../operation-module-loader'
 import type { MountAdapter } from '../recording-scenario'
 import { hookMount } from '../hook-mount'
 import { observableModel, projectObservable } from '../observable-model'
 import { operationModuleLoader } from '../operation-module-loader'
 
-/** `loadMobileResumeMetadata` is module-private in the panel; exposing it beats editing pinned source. */
-export const settingsMountExposures: readonly OperationExposure[] = [
-  [
-    'MobileAgentSessionHistoryPanel.tsx',
-    '\nexports.loadMobileResumeMetadata = loadMobileResumeMetadata;'
-  ]
-]
+export const settingsMountExposures: readonly OperationExposure[] = []
 
 export function settingsMountAdapters(
   modules: ReturnType<typeof operationModuleLoader>
@@ -110,8 +105,8 @@ export function settingsMountAdapters(
       }
     },
     'settings.resume-metadata': ({ client }) => {
-      const load = modules.load(
-        'mobile/src/agent-history/MobileAgentSessionHistoryPanel.tsx'
+      const load = modules.load<typeof ResumeMetadata>(
+        'mobile/src/agent-history/mobile-agent-history-resume-metadata.ts'
       ).loadMobileResumeMetadata
       return { action: () => load(client), state: () => ({}), dispose: () => {} }
     },
diff --git a/mobile/src/transport/settings-read-operations.test.ts b/mobile/src/transport/settings-read-operations.test.ts
index 87243dee245..de288de3b6c 100644
--- a/mobile/src/transport/settings-read-operations.test.ts
+++ b/mobile/src/transport/settings-read-operations.test.ts
@@ -9,7 +9,8 @@ import {
   optionalSettingsRead,
   botOverridesRead,
   newTabSettingsRead,
-  terminalCopyTrimsGutterRead
+  terminalCopyTrimsGutterRead,
+  showPinnedWorktreesInGroupsRead
 } from './settings-read-operations'
 import type { RpcResponse } from './types'
 
@@ -110,6 +111,30 @@ describe('settings historical acceptance', () => {
     expect(terminalCopyTrimsGutterRead.interpret(refused)).toEqual({ accepted: false })
   })
 
+  it('reads pinned placement, treating an absent or malformed key as the desktop default', async () => {
+    const showFor = async (settings: unknown) =>
+      showPinnedWorktreesInGroupsRead.interpret(
+        await showPinnedWorktreesInGroupsRead.request(replyWith(success(settings)))
+      )
+    expect(await showFor({ settings: { showPinnedWorktreesInGroups: true } })).toEqual({
+      accepted: true,
+      value: true
+    })
+    expect(await showFor({ settings: { showPinnedWorktreesInGroups: false } })).toEqual({
+      accepted: true,
+      value: false
+    })
+    // A host predating the setting sends no key; the desktop default is off.
+    expect(await showFor({ settings: {} })).toEqual({ accepted: true, value: false })
+    expect(await showFor({ settings: { showPinnedWorktreesInGroups: 'true' } })).toEqual({
+      accepted: true,
+      value: false
+    })
+    expect(await showFor(null)).toEqual({ accepted: true, value: false })
+    const refused = await showPinnedWorktreesInGroupsRead.request(replyWith(refusal()))
+    expect(showPinnedWorktreesInGroupsRead.interpret(refused)).toEqual({ accepted: false })
+  })
+
   it('does not read a stale payload until its caller permits interpretation', async () => {
     const read = vi.fn(() => ({}))
     const reply = await settingsRead.request(
diff --git a/mobile/src/transport/settings-read-operations.ts b/mobile/src/transport/settings-read-operations.ts
index d33e66458d2..a2dc885795b 100644
--- a/mobile/src/transport/settings-read-operations.ts
+++ b/mobile/src/transport/settings-read-operations.ts
@@ -112,6 +112,31 @@ export const terminalCopyTrimsGutterRead = bindDeferredRpcOperation(
   })
 )
 
+const showPinnedInGroupsReader: RpcCompatibleReader<unknown, 'show-pinned-in-groups', boolean> = (
+  raw
+) => {
+  const settings = raw == null ? undefined : settingsMember(raw)
+  const show: unknown =
+    settings == null ? undefined : settingsField(settings, 'showPinnedWorktreesInGroups')
+  return {
+    compatible: true,
+    variant: 'show-pinned-in-groups',
+    // Why `=== true`: a host predating the setting sends no key; desktop's default is off.
+    value: show === true,
+    salvage: { droppedPaths: [], droppedCount: 0 }
+  }
+}
+
+export const showPinnedWorktreesInGroupsRead = bindDeferredRpcOperation(
+  defineRpcOperation({
+    name: 'settings.show-pinned-worktrees-in-groups-or-skip',
+    method: 'settings.get',
+    acceptance: 'success-result-or-skip',
+    barrier: 'after-caller-barrier',
+    read: showPinnedInGroupsReader
+  })
+)
+
 export const botOverridesRead = bindDeferredRpcOperation(
   defineRpcOperation({
     name: 'settings.bot-logins-or-skip',
diff --git a/mobile/src/worktree/mobile-workspace-lineage.ts b/mobile/src/worktree/mobile-workspace-lineage.ts
index 9ffe1d731c6..f9fa2e6d7ac 100644
--- a/mobile/src/worktree/mobile-workspace-lineage.ts
+++ b/mobile/src/worktree/mobile-workspace-lineage.ts
@@ -22,16 +22,14 @@ function hasValidLineageParent(worktree: Worktree, parent: Worktree): boolean {
   )
 }
 
-export function applyMobileWorkspaceLineage(
-  worktrees: readonly Worktree[],
-  collapsedGroups: ReadonlySet<string> = new Set()
-): Worktree[] {
-  const visibleIds = new Set(worktrees.map((worktree) => getWorktreeRowIdentity(worktree)))
+/** Children keyed by parent row identity, over valid edges between the given rows only. */
+export function getMobileWorkspaceLineageChildren(
+  worktrees: readonly Worktree[]
+): Map<string, Worktree[]> {
   const worktreeById = new Map(
     worktrees.map((worktree) => [getWorktreeRowIdentity(worktree), worktree])
   )
   const childrenByParentId = new Map<string, Worktree[]>()
-  const childIds = new Set<string>()
 
   for (const worktree of worktrees) {
     const worktreeId = getWorktreeRowIdentity(worktree)
@@ -43,17 +41,26 @@ export function applyMobileWorkspaceLineage(
     if (
       !parentIdentity ||
       parentIdentity === worktreeId ||
-      !visibleIds.has(parentIdentity) ||
       !parent ||
       !hasValidLineageParent(worktree, parent)
     ) {
       continue
     }
-    childIds.add(worktreeId)
     const children = childrenByParentId.get(parentIdentity) ?? []
     children.push(worktree)
     childrenByParentId.set(parentIdentity, children)
   }
+  return childrenByParentId
+}
+
+export function applyMobileWorkspaceLineage(
+  worktrees: readonly Worktree[],
+  collapsedGroups: ReadonlySet<string> = new Set()
+): Worktree[] {
+  const childrenByParentId = getMobileWorkspaceLineageChildren(worktrees)
+  const childIds = new Set(
+    [...childrenByParentId.values()].flat().map((worktree) => getWorktreeRowIdentity(worktree))
+  )
 
   const result: Worktree[] = []
   const emitted = new Set<string>()
diff --git a/mobile/src/worktree/use-workspace-sections.ts b/mobile/src/worktree/use-workspace-sections.ts
index d28546b80bb..0183efb78a2 100644
--- a/mobile/src/worktree/use-workspace-sections.ts
+++ b/mobile/src/worktree/use-workspace-sections.ts
@@ -22,6 +22,7 @@ export function useWorkspaceSections(args: {
   search: string
   groupMode: MobileGroupMode
   pinnedIds: Set<string>
+  showPinnedInGroups: boolean
   repoIdsByName: Map<string, string>
   repoColorsByName: Map<string, string>
   collapsedGroups: Set<string>
@@ -39,6 +40,7 @@ export function useWorkspaceSections(args: {
     search,
     groupMode,
     pinnedIds,
+    showPinnedInGroups,
     repoIdsByName,
     repoColorsByName,
     collapsedGroups,
@@ -74,7 +76,8 @@ export function useWorkspaceSections(args: {
         pinnedIds,
         repoIdsByName,
         workspaceStatuses,
-        collapsedGroups
+        collapsedGroups,
+        showPinnedInGroups
       ),
     [
       displayWorktrees,
@@ -85,7 +88,8 @@ export function useWorkspaceSections(args: {
       pinnedIds,
       repoIdsByName,
       workspaceStatuses,
-      collapsedGroups
+      collapsedGroups,
+      showPinnedInGroups
     ]
   )
 
diff --git a/mobile/src/worktree/workspace-list-picker-options.ts b/mobile/src/worktree/workspace-list-picker-options.ts
index 180d4038320..ca597ed38cc 100644
--- a/mobile/src/worktree/workspace-list-picker-options.ts
+++ b/mobile/src/worktree/workspace-list-picker-options.ts
@@ -1,6 +1,9 @@
 import type { PickerOption } from '../components/PickerModal'
 import type { MobileGroupMode, MobileSortMode } from './workspace-view-settings'
 
+// Why: the host may be headless, so the note can't promise a desktop sidebar.
+export const WORKSPACE_VIEW_SHARED_NOTE = 'Synced across your devices'
+
 export const WORKSPACE_SORT_OPTIONS: PickerOption<MobileSortMode>[] = [
   // Why: desktop and persisted state keep the `smart` key, while mobile shows the product label.
   {
@@ -11,7 +14,7 @@ export const WORKSPACE_SORT_OPTIONS: PickerOption<MobileSortMode>[] = [
   { value: 'name', label: 'Name', subtitle: 'Alphabetical by name' },
   { value: 'recent', label: 'Recent', subtitle: 'Most recent output first' },
   { value: 'repo', label: 'Repo', subtitle: 'Repository, then workspace name' },
-  { value: 'manual', label: 'Manual', subtitle: 'Server order' }
+  { value: 'manual', label: 'Manual', subtitle: 'Desktop drag order' }
 ]
 
 export const WORKSPACE_GROUP_OPTIONS: PickerOption<MobileGroupMode>[] = [
diff --git a/mobile/src/worktree/workspace-list-pinned-lineage.test.ts b/mobile/src/worktree/workspace-list-pinned-lineage.test.ts
new file mode 100644
index 00000000000..18fd225fd56
--- /dev/null
+++ b/mobile/src/worktree/workspace-list-pinned-lineage.test.ts
@@ -0,0 +1,101 @@
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import type { Worktree } from './workspace-list-sections'
+import { buildSections } from './workspace-list-sections'
+import { DEFAULT_MOBILE_WORKSPACE_STATUSES } from './mobile-workspace-statuses'
+
+function worktree(overrides: Partial<Worktree> = {}): Worktree {
+  const worktreePath = join('/tmp', 'orca', 'worktrees', 'feature')
+  return {
+    workspaceKind: 'git',
+    worktreeId: `repo-1::${worktreePath}`,
+    repoId: 'repo-1',
+    repo: 'orca',
+    branch: 'feature/mobile-parity',
+    displayName: 'feature',
+    path: worktreePath,
+    liveTerminalCount: 0,
+    hasAttachedPty: false,
+    preview: '',
+    unread: false,
+    isPinned: false,
+    linkedPR: null,
+    status: 'inactive',
+    agents: [],
+    ...overrides
+  }
+}
+
+describe('a pinned parent with an unpinned child', () => {
+  const parent = worktree({ worktreeId: 'parent', displayName: 'parent', isPinned: true })
+  const child = worktree({
+    worktreeId: 'child',
+    displayName: 'child',
+    parentWorktreeId: 'parent'
+  })
+
+  function nesting(showPinnedInGroups: boolean) {
+    const sections = buildSections(
+      [child, parent],
+      'name',
+      { filterRepoIds: new Set(), hideSleeping: false, hideDefaultBranch: false },
+      '',
+      'repo',
+      new Set(),
+      new Map(),
+      DEFAULT_MOBILE_WORKSPACE_STATUSES,
+      new Set(),
+      showPinnedInGroups
+    )
+    return sections.map((section) => ({
+      key: section.key,
+      rows: section.data.map((row) => [row.worktreeId, row.lineageDepth])
+    }))
+  }
+
+  const nested = [
+    ['parent', 0],
+    ['child', 1]
+  ]
+
+  it('moves the child into Pinned under its parent by default', () => {
+    expect(nesting(false)).toEqual([{ key: 'pinned', rows: nested }])
+  })
+
+  it('nests the child under its parent in both sections when the desktop setting is on', () => {
+    expect(nesting(true)).toEqual([
+      { key: 'pinned', rows: nested },
+      { key: 'repo:orca', rows: nested }
+    ])
+  })
+})
+
+it('follows a pin through a child hidden by search, like desktop', () => {
+  const root = worktree({ worktreeId: 'root', displayName: 'alpha-root', isPinned: true })
+  const middle = worktree({
+    worktreeId: 'middle',
+    displayName: 'middle',
+    parentWorktreeId: 'root'
+  })
+  const leaf = worktree({
+    worktreeId: 'leaf',
+    displayName: 'alpha-sub',
+    parentWorktreeId: 'middle'
+  })
+
+  const sections = buildSections(
+    [root, middle, leaf],
+    'name',
+    { filterRepoIds: new Set(), hideSleeping: false, hideDefaultBranch: false },
+    'alpha',
+    'repo',
+    new Set()
+  )
+
+  expect(
+    sections.map((section) => ({
+      key: section.key,
+      rows: section.data.map((row) => row.worktreeId)
+    }))
+  ).toEqual([{ key: 'pinned', rows: ['root', 'leaf'] }])
+})
diff --git a/mobile/src/worktree/workspace-list-sections.test.ts b/mobile/src/worktree/workspace-list-sections.test.ts
index 48227fff78f..700e6023e05 100644
--- a/mobile/src/worktree/workspace-list-sections.test.ts
+++ b/mobile/src/worktree/workspace-list-sections.test.ts
@@ -689,28 +689,68 @@ describe('buildSections', () => {
     expect(sections[0]?.data.map((worktree) => worktree.worktreeId)).toEqual(['progress'])
   })
 
-  it('keeps pinned worktrees in their canonical status group like desktop', () => {
-    const pinned = worktree({
-      worktreeId: 'pinned',
-      workspaceStatus: 'in-progress',
-      isPinned: true
-    })
+  describe.each(['none', 'repo', 'workspaceStatus', 'prStatus'] as const)(
+    'pinned placement in %s grouping',
+    (groupMode) => {
+      const sibling = worktree({ worktreeId: 'sibling', workspaceStatus: 'in-progress' })
+      const hostPinned = worktree({
+        worktreeId: 'host-pinned',
+        workspaceStatus: 'in-progress',
+        isPinned: true
+      })
+      const localPinned = worktree({ worktreeId: 'local-pinned', workspaceStatus: 'in-progress' })
+
+      function placement(showPinnedInGroups: boolean) {
+        const sections = buildSections(
+          [sibling, hostPinned, localPinned],
+          'name',
+          { filterRepoIds: new Set(), hideSleeping: false, hideDefaultBranch: false },
+          '',
+          groupMode,
+          new Set(['local-pinned']),
+          new Map(),
+          DEFAULT_MOBILE_WORKSPACE_STATUSES,
+          new Set(),
+          showPinnedInGroups
+        )
+        const ids = (keep: (key: string) => boolean) =>
+          sections
+            .filter((section) => keep(section.key))
+            .flatMap((section) => section.data.map((row) => row.worktreeId))
+            .sort()
+        return { pinned: ids((key) => key === 'pinned'), groups: ids((key) => key !== 'pinned') }
+      }
+
+      it('shows host and local pins only in Pinned by default', () => {
+        expect(placement(false)).toEqual({
+          pinned: ['host-pinned', 'local-pinned'],
+          groups: ['sibling']
+        })
+      })
+
+      it('also keeps them in their groups when the desktop setting is on', () => {
+        expect(placement(true)).toEqual({
+          pinned: ['host-pinned', 'local-pinned'],
+          groups: ['host-pinned', 'local-pinned', 'sibling']
+        })
+      })
+    }
+  )
+
+  it('drops a repo group whose only worktree is pinned, like desktop', () => {
+    const pinned = worktree({ worktreeId: 'pinned', isPinned: true })
 
     const sections = buildSections(
       [pinned],
-      'manual',
+      'name',
       { filterRepoIds: new Set(), hideSleeping: false, hideDefaultBranch: false },
       '',
-      'workspaceStatus',
+      'repo',
       new Set(),
-      new Map(),
-      DEFAULT_MOBILE_WORKSPACE_STATUSES
+      new Map([['orca', 'repo-1']])
     )
 
-    expect(withoutSectionListKeys(sections)).toEqual([
-      { key: 'pinned', title: 'Pinned', icon: 'pin', data: [pinned] },
-      { key: 'workspace-status:in-progress', title: 'In progress', data: [pinned] }
-    ])
+    expect(sections.map((section) => section.key)).toEqual(['pinned'])
   })
 
   it('renders one sorted All section when grouping is off like desktop', () => {
diff --git a/mobile/src/worktree/workspace-list-sections.ts b/mobile/src/worktree/workspace-list-sections.ts
index 16ef9ae9f5d..d231d81ba54 100644
--- a/mobile/src/worktree/workspace-list-sections.ts
+++ b/mobile/src/worktree/workspace-list-sections.ts
@@ -5,7 +5,10 @@ import {
   getMobileWorkspaceStatus,
   getMobileWorkspaceStatusGroupKey
 } from './mobile-workspace-statuses'
-import { applyMobileWorkspaceLineage } from './mobile-workspace-lineage'
+import {
+  applyMobileWorkspaceLineage,
+  getMobileWorkspaceLineageChildren
+} from './mobile-workspace-lineage'
 import { getPRGroupKey, PR_GROUP_LABELS, PR_GROUP_ORDER } from './workspace-pr-status-groups'
 import type { FilterState, Section, Worktree } from './workspace-list-types'
 import type { MobileGroupMode, MobileSortMode } from './workspace-view-settings'
@@ -19,10 +22,10 @@ function makeSection(
   key: string,
   title: string,
   data: Worktree[],
-  icon?: 'pin',
-  collapsedGroups?: ReadonlySet<string>
+  collapsedGroups: ReadonlySet<string>,
+  icon?: 'pin'
 ): Section {
-  const rows = collapsedGroups ? applyMobileWorkspaceLineage(data, collapsedGroups) : data
+  const rows = applyMobileWorkspaceLineage(data, collapsedGroups)
   return {
     key,
     title,
@@ -120,6 +123,25 @@ export function isWorktreePinned(w: Worktree, localPins: Set<string>): boolean {
   return w.isPinned || localPins.has(w.worktreeId)
 }
 
+// Visible pinned rows plus their lineage descendants, walking through filtered-out rows as desktop does.
+function getPinnedSectionIdentities(
+  worktrees: readonly Worktree[],
+  visible: readonly Worktree[],
+  pinnedIds: Set<string>
+): Set<string> {
+  const childrenByParentId = getMobileWorkspaceLineageChildren(worktrees)
+  const identities = new Set(
+    visible.filter((w) => isWorktreePinned(w, pinnedIds)).map((w) => getWorktreeRowIdentity(w))
+  )
+  // A Set iterates entries added mid-loop and ignores repeats, so this walks descendants and stops on cycles.
+  for (const identity of identities) {
+    for (const child of childrenByParentId.get(identity) ?? []) {
+      identities.add(getWorktreeRowIdentity(child))
+    }
+  }
+  return identities
+}
+
 export function buildSections(
   worktrees: Worktree[],
   sortMode: MobileSortMode,
@@ -129,24 +151,25 @@ export function buildSections(
   pinnedIds: Set<string>,
   repoIdsByName: ReadonlyMap<string, string> = new Map(),
   workspaceStatuses: readonly WorkspaceStatusDefinition[] = DEFAULT_MOBILE_WORKSPACE_STATUSES,
-  collapsedGroups: ReadonlySet<string> = new Set()
+  collapsedGroups: ReadonlySet<string> = new Set(),
+  showPinnedInGroups = false
 ): Section[] {
   const filtered = filterWorktrees(worktrees, filters, search)
   const sorted = sortWorktrees(filtered, sortMode)
 
-  const pinned = sorted.filter((w) => isWorktreePinned(w, pinnedIds))
-  // Why: desktop treats Pinned as an overlay. Keeping pinned rows in canonical
-  // groups preserves exact cross-surface order and literal section counts.
-  const canonicalGroupWorktrees = sorted
+  const pinnedIdentities = getPinnedSectionIdentities(worktrees, sorted, pinnedIds)
+  const isInPinned = (w: Worktree) => pinnedIdentities.has(getWorktreeRowIdentity(w))
+  const pinned = sorted.filter(isInPinned)
+  const canonicalGroupWorktrees = showPinnedInGroups ? sorted : sorted.filter((w) => !isInPinned(w))
 
   const sections: Section[] = []
   if (pinned.length > 0) {
-    sections.push(makeSection('pinned', 'Pinned', pinned, 'pin'))
+    sections.push(makeSection('pinned', 'Pinned', pinned, collapsedGroups, 'pin'))
   }
 
   if (groupMode === 'none') {
     if (canonicalGroupWorktrees.length > 0) {
-      sections.push(makeSection('all', 'All', canonicalGroupWorktrees, undefined, collapsedGroups))
+      sections.push(makeSection('all', 'All', canonicalGroupWorktrees, collapsedGroups))
     }
   } else if (groupMode === 'repo') {
     const byRepo = new Map<string, Worktree[]>()
@@ -177,9 +200,7 @@ export function buildSections(
     }
     for (const [repo, items] of byRepo) {
       const key = `repo:${repoIdsByName.get(repo) ?? repo}`
-      sections.push(
-        makeSection(key, repo, orderMainWorktreeFirst(items), undefined, collapsedGroups)
-      )
+      sections.push(makeSection(key, repo, orderMainWorktreeFirst(items), collapsedGroups))
     }
   } else if (groupMode === 'workspaceStatus') {
     const renderableWorkspaceStatuses = coerceMobileWorkspaceStatuses(workspaceStatuses)
@@ -201,7 +222,6 @@ export function buildSections(
             getMobileWorkspaceStatusGroupKey(status.id),
             status.label,
             items,
-            undefined,
             collapsedGroups
           )
         )
@@ -222,13 +242,7 @@ export function buildSections(
       const items = byGroup.get(groupKey)
       if (items && items.length > 0) {
         sections.push(
-          makeSection(
-            `pr:${groupKey}`,
-            PR_GROUP_LABELS[groupKey],
-            items,
-            undefined,
-            collapsedGroups
-          )
+          makeSection(`pr:${groupKey}`, PR_GROUP_LABELS[groupKey], items, collapsedGroups)
         )
       }
     }
diff --git a/mobile/src/worktree/workspace-view-settings.ts b/mobile/src/worktree/workspace-view-settings.ts
index f1d17189adc..221fa7211be 100644
--- a/mobile/src/worktree/workspace-view-settings.ts
+++ b/mobile/src/worktree/workspace-view-settings.ts
@@ -7,7 +7,7 @@ import type { WorkspaceStatusDefinition } from '../../../src/shared/worktree/typ
 import { coerceMobileWorkspaceStatuses } from './mobile-workspace-statuses'
 
 export type MobileGroupMode = 'none' | 'workspaceStatus' | 'repo' | 'prStatus'
-// Desktop sort adds 'manual'; mobile renders it but sorts by server order.
+// Desktop sort adds 'manual'; mobile orders it by the desktop's drag ranks.
 export type MobileSortMode = 'smart' | 'name' | 'recent' | 'repo' | 'manual'
 
 // Desktop PersistedUIState fields this screen syncs (a structural subset).
diff --git a/opencode.json b/opencode.json
new file mode 100644
index 00000000000..030babec933
--- /dev/null
+++ b/opencode.json
@@ -0,0 +1,17 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "*": {
+      "*": "allow"
+    },
+    "read": {
+      "*.env": "ask",
+      "*.env.*": "ask",
+      "*.env.example": "allow"
+    },
+    "external_directory": {
+      "*": "ask"
+    },
+    "doom_loop": "ask"
+  }
+}
diff --git a/skill-guides/orchestration/references/coordinator-loop.md b/skill-guides/orchestration/references/coordinator-loop.md
index aec13667645..164f91e4548 100644
--- a/skill-guides/orchestration/references/coordinator-loop.md
+++ b/skill-guides/orchestration/references/coordinator-loop.md
@@ -31,9 +31,12 @@ ORCA orchestration worker-start --task <task_id> --worktree current --agent clau
 ORCA orchestration worker-start --task <task_id> --worktree current --agent muse --model muse-spark-1.3 --json
 ```
 
-Other agents, including `opencode`, reject `--model`; they run the model set in
-their own config, so a coordinator wanting a same-model opencode worker relies
-on that config.
+OpenCode also accepts `--model` in an existing worktree when the execution host
+verifies its CLI version and model availability. Creating a new worktree with an
+OpenCode model override is unsupported; use `--worktree current` or an existing
+worktree selector, or omit `--model`. OpenCode effort is unsupported. Omit the
+model to inherit its configuration; unsupported or unknown hosts refuse the
+override explicitly.
 
 `--effort` requires `--model`; neither option combines with `--terminal`. A
 connected worker server must advertise launch-preference support before Orca
diff --git a/src/cli/bundled-skill-guides.ts b/src/cli/bundled-skill-guides.ts
index cea9256e75d..f23fe070c1f 100644
--- a/src/cli/bundled-skill-guides.ts
+++ b/src/cli/bundled-skill-guides.ts
@@ -69,10 +69,10 @@ const ORCA_PER_WORKSPACE_ENV_WINDOWS_SCRIPTS_REFERENCE_MARKDOWN = "# Windows loc
 const ORCHESTRATION_MARKDOWN = "---\nname: orchestration\ndescription: >-\n  Coordinate supervised Orca workers: threaded messages, blocking ask/reply,\n  task dispatch, worker_done/escalation waits, task DAGs, decision gates,\n  coordinator loops, and decomposing work across agents. Use `orca-cli` for full\n  ownership handoffs — \"hand off\", \"handoff\", \"handover\", \"give this to another\n  agent\", \"another worktree\" — unless asked to supervise, monitor, or coordinate\n  a DAG, and for terminal control, lightweight terminal prompts, shell commands,\n  Orca worktree management, and reading or waiting on terminals.\n---\n\n# Orca orchestration\n\nOrchestration is Orca's structured coordination layer. It records who owns work,\nwhich attempt is authoritative, and when supervised work has settled.\n\n## Outcome\n\n**Result:** every in-scope Task has one explicit outcome and every settled worker\nterminal has a next owner or cleanup decision. **Next consumer:** the user who\nrequested supervision. **Done:** all expected Dispatches have settled, every\ndelivered message was processed before acknowledgment, each settled worker was\nreused, explicitly retained, or released, and the turn ends only when the report\nto that user names, per Task, its outcome, the evidence behind it, and any\nunresolved blocker.\n\n**Safe failure:** preserve work and authority and report the state as unknown or\n`unverifiable`. Only positive proof of exit authorizes stop, abandon, or retry,\nand only an accepted settlement authorizes release. Every other observation,\nabsence included, is a checkpoint.\n\n## Classify the role\n\n| Current context                                                                                                                                | Role                    | Route                                                                          |\n| ---------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------------------------ |\n| The user explicitly asks to supervise, monitor, wait for results, track completion, coordinate a DAG, use a decision gate, or manage ask/reply | Coordinator             | Use the supervised loop below                                                  |\n| The current prompt contains a live injected preamble with Task and Dispatch IDs                                                                | Dispatched worker       | Follow the preamble and the worker obligations below                           |\n| The user asks to hand off ownership or start another agent/worktree without supervision                                                        | Handoff owner           | Use `orca-cli`; create no Run, Task, or Dispatch and do not monitor completion |\n| A message carries a legacy authority label                                                                                                     | Compatibility operator  | Load the legacy contract reference before any lifecycle mutation               |\n| No live preamble and no explicit supervision                                                                                                   | Ordinary terminal agent | Do not emit lifecycle messages; use `orca-cli` for terminal/worktree work      |\n\nModel or effort selection does not make a handoff supervised. Never substitute a\nnon-Orca subagent tool when Orca orchestration provenance was requested.\n\n## Authority and safety floor\n\n- A Run is a durable namespace and coordinator inbox; it does not schedule or\n  place workers. A Task is work. A Dispatch is one authoritative Task attempt.\n- Lifecycle authority comes from the active Dispatch, not a terminal title,\n  copied ID, old database row, provider transcript, or visible pane.\n- Workers use the exact executable, handle, Task ID, and Dispatch ID in the live\n  preamble, plus any other flag it carries. Never reconstruct, translate, or\n  broaden those arguments.\n- After remote start, address the worker by Dispatch ID. The execution host owns\n  process, filesystem, transcript, stop, and cleanup facts. Preserve the verdicts\n  `live` / `unverifiable` / `exited`; contact loss is not process death.\n- Liveness is layered: `worker-list`'s `projection.liveness` is the fleet verdict\n  for the agent; `worker-show`'s `observation.status` is PTY liveness only. A live\n  terminal can still hold a dead or stuck agent.\n- Folder workspaces are valid; never require Git or assume a worktree.\n- Clients and remote servers update independently. Treat unknown optional fields\n  as absent. A new stream operation requires advertised capability because old\n  decoders may silently drop unknown opcodes. Never fall back to local execution\n  when remote authority or capability is unproven.\n- Use the executable you used to run `skills get` for the entire run. In the\n  examples below, replace `ORCA` with it; do not create a shell variable or run\n  `ORCA` literally. If it fails, report that exact error instead of switching.\n- `ORCA status --json` shows your Orca session ID as `caller.orcaSessionId` when you have one.\n- A successful `orchestration send` proves durable enqueue; its wake or nudge is\n  best-effort attention only and does not prove the recipient read or accepted it.\n\n## Worker obligations\n\nThe injected preamble is authoritative. A dispatched worker must:\n\n1. Do only the current Task and use the preamble's `ask` command for a blocking\n   coordinator question. Never open a local question TUI the coordinator cannot\n   answer. Resume the same message ID after an ask timeout.\n2. Send heartbeats only at the cadence in the preamble. A heartbeat proves\n   liveness, not completion.\n3. Read coordinator follow-ups at each natural checkpoint — before starting a\n   new file, after a test run — and once more immediately before `worker_done`:\n   `ORCA orchestration check --terminal <your_handle> --json`.\n4. Send `worker_done` exactly once, from the dispatched terminal, with a\n   three-sentence executive summary, both lifecycle IDs, and explicit\n   `--outcome succeeded` or `--outcome failed`. Never encode failure only in prose.\n5. Append `--files-modified` and `--report-path` only with real values when\n   applicable. After `worker_done`, end the dispatched turn and idle; do not poll\n   or start new work.\n\nA direct user instruction after completion starts new user-owned work and takes\nprecedence over the idle rule. Do not reuse the settled lifecycle IDs.\n\n## Canonical supervised loop\n\nConfirm the runtime, bind one Run, and start the full independent wave before\nwaiting. `worker-start --spec` creates the Task and its attempt in one call:\n\n```text\nORCA status --json\nORCA orchestration run-create --objective \"<objective>\" --json\nORCA orchestration worker-start --spec \"<worker A task>\" --worktree current --agent codex --json\nORCA orchestration worker-start --spec \"<worker B task>\" --worktree current --agent claude --json\nORCA orchestration check --wait --types \"worker_done,escalation,question\" --timeout-ms 900000 --json\n```\n\nIf `worker-start` exits non-zero, do not relaunch. Read the receipt's\n`failedStage` and `residualResources`, then load\n`references/recovery-and-cleanup.md`.\n\nUse `task-create` plus `worker-start --task <task_id>` for planned fan-out with\ndependencies or a retry of a known Task. Use dependencies only for real ordering\nand prefer parallel waves over chains deeper than three or four steps; nested\nworkers obey the depth limit, and a new Run does not reset the caller's depth.\n\nA consuming `check` names its caller with `--terminal <handle>`, never `--from`;\nomit it inside the coordinator's own Orca terminal. It returns the bound Run's\noldest FIFO Delivery and replays that batch until acknowledged. Process every\nmessage: reply to questions, validate each `worker_done` against the expected\nactive Dispatch, and decide each settled terminal's next owner before the ack:\n\n```text\nORCA orchestration reply --id <message_id> --body \"<answer>\" --json\nORCA orchestration worker-release --dispatch <dispatch_id> --json\nORCA orchestration check --ack <delivery_id> --wait --types \"worker_done,escalation,question\" --timeout-ms 900000 --json\n```\n\nKeep waiting until every expected Dispatch settles. A timeout or empty result is\na checkpoint, not a failure. Do not stop, retry, release, or launch a duplicate\neditor without the positive proof `## Outcome` requires.\n\nAfter three consecutive empty waits, stop waiting blindly and enumerate with\n`ORCA orchestration worker-list --include-remote --json` (defaults to the bound\nRun; `--run <run_id>` overrides; the receipt's `scope` names which), acting on\neach row's `projection.attention` categories, `projection.attention.requiresAction`, and literal `projection.nextAction` argv.\nRows come newest first and page at 100: while `page.hasMore`, follow `page.nextCursor` with `--cursor <value>`.\nA `none` `nextAction` has no argv to run: read `liveness.reason` and keep waiting\nwith `check --wait`. Absence never earns an argv; settlement and pending work still do.\nLeave the wait only on positive proof the agent stopped: `exited` liveness, the\nworker's own observation of process exit, or a transcript whose final agent turn\nsent no `worker_done`. Then load `references/recovery-and-cleanup.md` and choose\n`worker-stop` or `worker-abandon` explicitly. `unverifiable` is absence,\nincluding when `worker-show` reports `agentWait` null. Absence never authorizes\nstop, abandon, retry, or release; keep waiting or inspect.\n\n`worker-start` is the normal path, composing placement, terminal readiness,\nprompt injection, and supervised resource ownership. `dispatch --inject` leaves\nan operator-created process unsupervised and is only for an expressiveness gap.\n\n## Task-spec contract\n\nEvery Task spec must be self-contained and name:\n\n- **Target:** the files, component, or environment in scope.\n- **Change:** the concrete result to produce.\n- **Constraints:** invariants, compatibility rules, and do-not-touch boundaries.\n- **Ownership:** what this worker may edit and any coordination boundary.\n- **Observable acceptance:** the test, output, or evidence that proves completion.\n\n## Completion accounting\n\nAfter an accepted success or failure report, immediately do exactly one:\n\n1. Reuse the same proven agent terminal for an immediate follow-up Dispatch.\n2. Record user-requested retention with `worker-retain`.\n3. Run `worker-release`.\n\nRelease is post-settlement cleanup, not cancellation. Only an accepted\nsettlement authorizes it; no other observation does. If release is uncertain,\nfollow its exact recovery receipt and never substitute `terminal close`.\n\nA valid `worker_done` settles the Task and Dispatch automatically; do not follow\nit with `task-update --status completed`. Enumerate the terminals still owing a\ndecision with `worker-list --run <run_id> --terminal-state reclaimable --json`,\nand do not end the coordinator turn until it returns none.\n\n## Conditional references\n\nThis compact guide is sufficient for the normal local loop. At an action gate\nbelow, run `ORCA skills get orchestration --reference references/<file>.md` and\nread only that document; `--references` lists the names. If the CLI rejects\n`--reference`, run `ORCA skills get orchestration --full` once instead: it\nreturns this exact kernel and every reference, so read only the named one. If an\nolder CLI rejects `--full`, keep this kernel's safety floor, use that command's\n`--help`, and never guess newer flags.\n\n| Action gate                                                                                                   | Bundled reference                         |\n| ------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |\n| Expanded DAG waves, launch model/effort, same-terminal reuse, or review ownership                             | `references/coordinator-loop.md`          |\n| You are a dispatched worker and the live preamble does not answer your question, or `check` returned an error | `references/worker-contract.md`           |\n| New worktree, exact workspace, SSH, WSL, or connected-server placement                                        | `references/placement-and-remote.md`      |\n| Inbox replay, follow-up messages, group addresses, or decision gates                                          | `references/messaging-and-gates.md`       |\n| Failed/stopped/unknown attempts, retry, stop, abandon, retain, or uncertain release                           | `references/recovery-and-cleanup.md`      |\n| Custom argv or terminal topology that `worker-start` cannot express                                           | `references/low-level-topology.md`        |\n| Any legacy label, adopted Run, compatibility receipt, or takeover                                             | `references/legacy-contract-migration.md` |\n\nRetired scheduler commands are not aliases for Run creation. Recovery commands\nmust provide their exact next action; follow it with the same selected executable.\n"
 
 // oxfmt-ignore
-const ORCHESTRATION_FULL_MARKDOWN = "---\nname: orchestration\ndescription: >-\n  Coordinate supervised Orca workers: threaded messages, blocking ask/reply,\n  task dispatch, worker_done/escalation waits, task DAGs, decision gates,\n  coordinator loops, and decomposing work across agents. Use `orca-cli` for full\n  ownership handoffs — \"hand off\", \"handoff\", \"handover\", \"give this to another\n  agent\", \"another worktree\" — unless asked to supervise, monitor, or coordinate\n  a DAG, and for terminal control, lightweight terminal prompts, shell commands,\n  Orca worktree management, and reading or waiting on terminals.\n---\n\n# Orca orchestration\n\nOrchestration is Orca's structured coordination layer. It records who owns work,\nwhich attempt is authoritative, and when supervised work has settled.\n\n## Outcome\n\n**Result:** every in-scope Task has one explicit outcome and every settled worker\nterminal has a next owner or cleanup decision. **Next consumer:** the user who\nrequested supervision. **Done:** all expected Dispatches have settled, every\ndelivered message was processed before acknowledgment, each settled worker was\nreused, explicitly retained, or released, and the turn ends only when the report\nto that user names, per Task, its outcome, the evidence behind it, and any\nunresolved blocker.\n\n**Safe failure:** preserve work and authority and report the state as unknown or\n`unverifiable`. Only positive proof of exit authorizes stop, abandon, or retry,\nand only an accepted settlement authorizes release. Every other observation,\nabsence included, is a checkpoint.\n\n## Classify the role\n\n| Current context                                                                                                                                | Role                    | Route                                                                          |\n| ---------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------------------------ |\n| The user explicitly asks to supervise, monitor, wait for results, track completion, coordinate a DAG, use a decision gate, or manage ask/reply | Coordinator             | Use the supervised loop below                                                  |\n| The current prompt contains a live injected preamble with Task and Dispatch IDs                                                                | Dispatched worker       | Follow the preamble and the worker obligations below                           |\n| The user asks to hand off ownership or start another agent/worktree without supervision                                                        | Handoff owner           | Use `orca-cli`; create no Run, Task, or Dispatch and do not monitor completion |\n| A message carries a legacy authority label                                                                                                     | Compatibility operator  | Load the legacy contract reference before any lifecycle mutation               |\n| No live preamble and no explicit supervision                                                                                                   | Ordinary terminal agent | Do not emit lifecycle messages; use `orca-cli` for terminal/worktree work      |\n\nModel or effort selection does not make a handoff supervised. Never substitute a\nnon-Orca subagent tool when Orca orchestration provenance was requested.\n\n## Authority and safety floor\n\n- A Run is a durable namespace and coordinator inbox; it does not schedule or\n  place workers. A Task is work. A Dispatch is one authoritative Task attempt.\n- Lifecycle authority comes from the active Dispatch, not a terminal title,\n  copied ID, old database row, provider transcript, or visible pane.\n- Workers use the exact executable, handle, Task ID, and Dispatch ID in the live\n  preamble, plus any other flag it carries. Never reconstruct, translate, or\n  broaden those arguments.\n- After remote start, address the worker by Dispatch ID. The execution host owns\n  process, filesystem, transcript, stop, and cleanup facts. Preserve the verdicts\n  `live` / `unverifiable` / `exited`; contact loss is not process death.\n- Liveness is layered: `worker-list`'s `projection.liveness` is the fleet verdict\n  for the agent; `worker-show`'s `observation.status` is PTY liveness only. A live\n  terminal can still hold a dead or stuck agent.\n- Folder workspaces are valid; never require Git or assume a worktree.\n- Clients and remote servers update independently. Treat unknown optional fields\n  as absent. A new stream operation requires advertised capability because old\n  decoders may silently drop unknown opcodes. Never fall back to local execution\n  when remote authority or capability is unproven.\n- Use the executable you used to run `skills get` for the entire run. In the\n  examples below, replace `ORCA` with it; do not create a shell variable or run\n  `ORCA` literally. If it fails, report that exact error instead of switching.\n- `ORCA status --json` shows your Orca session ID as `caller.orcaSessionId` when you have one.\n- A successful `orchestration send` proves durable enqueue; its wake or nudge is\n  best-effort attention only and does not prove the recipient read or accepted it.\n\n## Worker obligations\n\nThe injected preamble is authoritative. A dispatched worker must:\n\n1. Do only the current Task and use the preamble's `ask` command for a blocking\n   coordinator question. Never open a local question TUI the coordinator cannot\n   answer. Resume the same message ID after an ask timeout.\n2. Send heartbeats only at the cadence in the preamble. A heartbeat proves\n   liveness, not completion.\n3. Read coordinator follow-ups at each natural checkpoint — before starting a\n   new file, after a test run — and once more immediately before `worker_done`:\n   `ORCA orchestration check --terminal <your_handle> --json`.\n4. Send `worker_done` exactly once, from the dispatched terminal, with a\n   three-sentence executive summary, both lifecycle IDs, and explicit\n   `--outcome succeeded` or `--outcome failed`. Never encode failure only in prose.\n5. Append `--files-modified` and `--report-path` only with real values when\n   applicable. After `worker_done`, end the dispatched turn and idle; do not poll\n   or start new work.\n\nA direct user instruction after completion starts new user-owned work and takes\nprecedence over the idle rule. Do not reuse the settled lifecycle IDs.\n\n## Canonical supervised loop\n\nConfirm the runtime, bind one Run, and start the full independent wave before\nwaiting. `worker-start --spec` creates the Task and its attempt in one call:\n\n```text\nORCA status --json\nORCA orchestration run-create --objective \"<objective>\" --json\nORCA orchestration worker-start --spec \"<worker A task>\" --worktree current --agent codex --json\nORCA orchestration worker-start --spec \"<worker B task>\" --worktree current --agent claude --json\nORCA orchestration check --wait --types \"worker_done,escalation,question\" --timeout-ms 900000 --json\n```\n\nIf `worker-start` exits non-zero, do not relaunch. Read the receipt's\n`failedStage` and `residualResources`, then load\n`references/recovery-and-cleanup.md`.\n\nUse `task-create` plus `worker-start --task <task_id>` for planned fan-out with\ndependencies or a retry of a known Task. Use dependencies only for real ordering\nand prefer parallel waves over chains deeper than three or four steps; nested\nworkers obey the depth limit, and a new Run does not reset the caller's depth.\n\nA consuming `check` names its caller with `--terminal <handle>`, never `--from`;\nomit it inside the coordinator's own Orca terminal. It returns the bound Run's\noldest FIFO Delivery and replays that batch until acknowledged. Process every\nmessage: reply to questions, validate each `worker_done` against the expected\nactive Dispatch, and decide each settled terminal's next owner before the ack:\n\n```text\nORCA orchestration reply --id <message_id> --body \"<answer>\" --json\nORCA orchestration worker-release --dispatch <dispatch_id> --json\nORCA orchestration check --ack <delivery_id> --wait --types \"worker_done,escalation,question\" --timeout-ms 900000 --json\n```\n\nKeep waiting until every expected Dispatch settles. A timeout or empty result is\na checkpoint, not a failure. Do not stop, retry, release, or launch a duplicate\neditor without the positive proof `## Outcome` requires.\n\nAfter three consecutive empty waits, stop waiting blindly and enumerate with\n`ORCA orchestration worker-list --include-remote --json` (defaults to the bound\nRun; `--run <run_id>` overrides; the receipt's `scope` names which), acting on\neach row's `projection.attention` categories, `projection.attention.requiresAction`, and literal `projection.nextAction` argv.\nRows come newest first and page at 100: while `page.hasMore`, follow `page.nextCursor` with `--cursor <value>`.\nA `none` `nextAction` has no argv to run: read `liveness.reason` and keep waiting\nwith `check --wait`. Absence never earns an argv; settlement and pending work still do.\nLeave the wait only on positive proof the agent stopped: `exited` liveness, the\nworker's own observation of process exit, or a transcript whose final agent turn\nsent no `worker_done`. Then load `references/recovery-and-cleanup.md` and choose\n`worker-stop` or `worker-abandon` explicitly. `unverifiable` is absence,\nincluding when `worker-show` reports `agentWait` null. Absence never authorizes\nstop, abandon, retry, or release; keep waiting or inspect.\n\n`worker-start` is the normal path, composing placement, terminal readiness,\nprompt injection, and supervised resource ownership. `dispatch --inject` leaves\nan operator-created process unsupervised and is only for an expressiveness gap.\n\n## Task-spec contract\n\nEvery Task spec must be self-contained and name:\n\n- **Target:** the files, component, or environment in scope.\n- **Change:** the concrete result to produce.\n- **Constraints:** invariants, compatibility rules, and do-not-touch boundaries.\n- **Ownership:** what this worker may edit and any coordination boundary.\n- **Observable acceptance:** the test, output, or evidence that proves completion.\n\n## Completion accounting\n\nAfter an accepted success or failure report, immediately do exactly one:\n\n1. Reuse the same proven agent terminal for an immediate follow-up Dispatch.\n2. Record user-requested retention with `worker-retain`.\n3. Run `worker-release`.\n\nRelease is post-settlement cleanup, not cancellation. Only an accepted\nsettlement authorizes it; no other observation does. If release is uncertain,\nfollow its exact recovery receipt and never substitute `terminal close`.\n\nA valid `worker_done` settles the Task and Dispatch automatically; do not follow\nit with `task-update --status completed`. Enumerate the terminals still owing a\ndecision with `worker-list --run <run_id> --terminal-state reclaimable --json`,\nand do not end the coordinator turn until it returns none.\n\n## Conditional references\n\nThis compact guide is sufficient for the normal local loop. At an action gate\nbelow, run `ORCA skills get orchestration --reference references/<file>.md` and\nread only that document; `--references` lists the names. If the CLI rejects\n`--reference`, run `ORCA skills get orchestration --full` once instead: it\nreturns this exact kernel and every reference, so read only the named one. If an\nolder CLI rejects `--full`, keep this kernel's safety floor, use that command's\n`--help`, and never guess newer flags.\n\n| Action gate                                                                                                   | Bundled reference                         |\n| ------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |\n| Expanded DAG waves, launch model/effort, same-terminal reuse, or review ownership                             | `references/coordinator-loop.md`          |\n| You are a dispatched worker and the live preamble does not answer your question, or `check` returned an error | `references/worker-contract.md`           |\n| New worktree, exact workspace, SSH, WSL, or connected-server placement                                        | `references/placement-and-remote.md`      |\n| Inbox replay, follow-up messages, group addresses, or decision gates                                          | `references/messaging-and-gates.md`       |\n| Failed/stopped/unknown attempts, retry, stop, abandon, retain, or uncertain release                           | `references/recovery-and-cleanup.md`      |\n| Custom argv or terminal topology that `worker-start` cannot express                                           | `references/low-level-topology.md`        |\n| Any legacy label, adopted Run, compatibility receipt, or takeover                                             | `references/legacy-contract-migration.md` |\n\nRetired scheduler commands are not aliases for Run creation. Recovery commands\nmust provide their exact next action; follow it with the same selected executable.\n\n---\n\n# Bundled references\n\nThese references belong to the version-matched guide above. Read only the documents named by its action gates.\n\n<!-- bundled-reference: references/coordinator-loop.md -->\n\n# Coordinator loop\n\nLoad this reference for expanded DAG waves, per-invocation launch preferences,\nsame-terminal reuse, or review ownership. The compact guide remains the source\nof truth for the loop order and completion boundary.\n\n## Ready waves\n\nCreate independent Tasks before the first wait. Encode only real dependencies,\nthen use the ready view as external memory:\n\n```text\nORCA orchestration task-create --spec \"<dependent work>\" --deps <json_array> --json\nORCA orchestration task-list --ready --brief --json\n```\n\n`--brief` collapses whitespace and caps echoed specs at 160 characters;\n`spec_truncated` identifies shortened rows. Omit it when full specs are needed or\nwhen an older CLI rejects the flag. A nested worker must respect\n`nested_worker_depth_exceeded`; creating another Run does not reset depth.\n\n## Launch preferences\n\nFor a fresh Claude, Codex, Cursor, Antigravity, or Muse terminal, `--model`\naccepts an opaque provider model ID. Pass it only when the user named a model;\notherwise omit it so the worker inherits the user's configured agent default.\nAdd `--effort` only when that model supports it:\n\n```text\nORCA orchestration worker-start --task <task_id> --worktree current --agent claude --model opus --effort high --json\nORCA orchestration worker-start --task <task_id> --worktree current --agent muse --model muse-spark-1.3 --json\n```\n\nOther agents, including `opencode`, reject `--model`; they run the model set in\ntheir own config, so a coordinator wanting a same-model opencode worker relies\non that config.\n\n`--effort` requires `--model`; neither option combines with `--terminal`. A\nconnected worker server must advertise launch-preference support before Orca\nforwards either field. Compare `launch.requested` with `launch.effective`; never\nclaim a model or effort from requested arguments alone.\n\n## Reuse after settlement\n\nChoose the terminal's next owner before acknowledging the Delivery. When the\nsame exact agent has immediate follow-up work, recover the proven handle and\ntransfer cleanup ownership to the new Dispatch:\n\n```text\nORCA orchestration worker-show --dispatch <dispatch_id> --json\nORCA orchestration worker-start --task <next_task_id> --terminal <agent_terminal_handle> --json\n```\n\nOtherwise explicitly retain or release the settled worker. Do not leave it live\nonly to inspect output; archived output remains available through `worker-read`.\n\n## Review ownership\n\nA review-only `worker_done` authorizes synthesis of findings, not coordinator\nfile edits. Dispatch or hand off fixes unless the user explicitly assigned them\nto the coordinator. If the user's plan names a next owner, post-review fixes and\nPR preparation remain with that owner; the coordinator routes and synthesizes.\n\n<!-- bundled-reference: references/legacy-contract-migration.md -->\n\n# Legacy contract migration\n\nLoad this reference only for an authority label, adopted Run, compatibility or\nrecovery receipt, or explicit legacy takeover. A newly created attempt always\nuses the current grammar.\n\n## Authority labels\n\n- `[LEGACY COMPATIBILITY]` is live and attested. Run only the exact supported\n  command printed with the message, using the same selected executable and\n  arguments supplied by the original prompt.\n- `[LEGACY RECOVERY REPLAY — MAY HAVE BEEN SEEN]` is one bounded,\n  at-least-once cutover replay. Process it idempotently and acknowledge only\n  through the exact displayed guidance.\n- `[LEGACY READ-ONLY]` is inspection-only. It has no reply, acknowledgment, or\n  lifecycle mutation.\n- An unlabeled current message uses the current guide and grammar.\n\nAn explicitly selected current Run, attested current binding, current Dispatch,\nor federated attachment takes precedence over legacy fallback. A retained\nadoption record alone does not grant mutation authority. If liveness, principal\nownership, capability, or the exact legacy contract is unproven, degrade to\nread-only inspection and never fall back to local execution.\n\nAdoption preserves the live agent process, PTY/session, terminal handle,\ntab/pane, worktree or folder workspace, Task, and Dispatch. It never restarts or\nreplaces the worker and never revives the retired scheduler. Loss of lifecycle\nauthority does not invalidate the existing process, assignment, or filesystem\nwork. Exact recovery may restore the same PTY once in its original inactive\nbackground tab; it must not spawn, write, signal, stop, switch, focus, split, or\ninject a terminal.\n\n## Compatibility recovery\n\nWhen a compatibility response returns structured next-step arguments, execute\nthose exact arguments with the same selected CLI executable. Do not translate\nfrom memory, broaden the recipient, or retry as a current mutation unless the\nreceipt explicitly authorizes it.\n\nA pending ask, reply, final Dispatch settlement, and consuming check have\ndurable recovery identities. Heartbeat and escalation remain at-least-once\nacross a manual contract-boundary retry. If an ask may already have been\nanswered, run the exact non-consuming recovery check printed by Orca before\ncreating any new question. Never guess among identical question threads.\n\nOn packaged Windows, a legacy ask uses a two-step commit/resume protocol. The\ninitial command commits the question, prints its exact\n`ask --resume <message_id>` command, and exits with launcher status `75`. Run\nthat exact resume after the launcher or update boundary. For an attested WSL\nlaunch, preserve the printed `orca-ide` executable and distro route. Older WSL\nworkers without launch proof remain lifecycle read-only even while their\nterminal and filesystem work continue.\n\n## Read-only inspection and takeover\n\nRead-only inspection does not consume mail:\n\n```text\nORCA orchestration run-list --json\nORCA orchestration run-show --id run_legacy_local --json\nORCA orchestration run-show --id <adopted_run_id> --json\nORCA orchestration task-list --run <adopted_run_id> --json\nORCA orchestration inbox --full --json\nORCA orchestration check --terminal <legacy_handle> --peek --format --json\nORCA terminal read --terminal <legacy_handle> --json\nORCA terminal wait --terminal <legacy_handle> --for tui-idle --timeout-ms 60000 --json\n```\n\n`run_legacy_local` is an empty audit tombstone after adoption. Find the ordinary\nRun whose objective is `Recovered orchestration work from a contract update`.\n\nOnly when the original coordinator is unavailable or cannot prove retained\nauthority may a new live coordinator take over from its own terminal:\n\n```text\nORCA orchestration run-use --id <adopted_run_id> --takeover-legacy --json\nORCA orchestration check --run <adopted_run_id> --json\n```\n\nTakeover binds the authenticated invoking terminal; `--from` cannot nominate\nanother coordinator. It fences only the old coordinator and moves pending mail\ninto current Run delivery. It preserves live workers, Tasks, Dispatches, processes, and files.\nNever take over while the original coordinator is actively coordinating.\n\nDo not launch a replacement editor merely because Orca updated or authority is\nunclear. Keep the original worker as the only editor until a stable handoff\npoint, then use a fresh current Dispatch in a conflict-free placement.\n\n<!-- bundled-reference: references/low-level-topology.md -->\n\n# Low-level topology\n\nLoad this reference only when `worker-start` cannot express required custom argv\nor terminal topology. It is not the normal supervised loop and is never a full\nhandoff recipe.\n\n```text\nORCA terminal create --worktree active --title <task_name> --command \"<agent_command>\" --json\nORCA terminal wait --terminal <handle> --for tui-idle --timeout-ms 60000 --json\nORCA orchestration dispatch --task <task_id> --to <handle> --inject --json\n```\n\nWait for readiness only when startup could lose injected input. Prefer\nagent-first `worker-start` whenever its argv and topology are sufficient.\n\n`dispatch --inject` creates authoritative Task/Dispatch context but deliberately\nkeeps an operator-created process unsupervised: it creates no supervised worker\nresource row. `worker-show`, `worker-read`, and `worker-list` report the lane as\n`unsupervised`; `worker-stop` and `worker-abandon` do not close that process, and\nsettled retain/release take no process action.\n\nUse `worker-start --terminal <handle>` when lifecycle ownership of an existing\nagent terminal is required. Never imply that low-level dispatch retroactively\nowns a process, never use it to route around the nested-depth limit, and never\nuse it for an ownership handoff.\n\n<!-- bundled-reference: references/messaging-and-gates.md -->\n\n# Messaging and gates\n\nLoad this reference for inbox replay, attempt-specific guidance, group\naddresses, blocking questions, or coordinator-managed DAG decisions.\n\nA successful `send` proves durable enqueue. Wake and nudge are best-effort\nattention only: neither proves the recipient read the message, began a turn, or\naccepted steering.\n\n## Coordinator delivery loop\n\n`check` names its caller with `--terminal <handle>` and is the only verb that\nrejects `--from`. Omit `--terminal` inside an Orca terminal, where Orca resolves\nthe caller; pass it explicitly from anywhere else, including a dispatched\nworker reading coordinator follow-ups.\n\nA consuming coordinator `check` returns the bound Run's oldest FIFO Delivery,\nup to 50 messages, and replays that exact batch until acknowledged. Process\nevery row and required terminal ownership decision before `--ack`. Type filters\ndecide when a waiter wakes; they do not authorize skipping older actionable\nmail. A Delivery therefore always carries the whole FIFO batch whatever its\ntypes, and a `check` without `--wait` hands that batch over unfiltered.\n`--peek` and `--all` are read-only inspection, not progress through the\ncoordinator inbox.\n\nAn empty wait or timeout is a checkpoint. Continue rolling waits until every\nexpected Dispatch settles. Heartbeat or visible activity means alive, not done.\n\n## Addresses\n\nUse a stable Dispatch address for attempt-specific coordinator guidance:\n\n```text\nORCA orchestration send --to dispatch:<dispatch_id> --subject \"Follow-up\" --body \"<guidance>\" --json\n```\n\nDo not substitute a remote terminal handle. Omit `--from` for ordinary\ncoordinator calls; a dispatched worker instead copies the exact `--from` and\nother arguments in its preamble. `check` is the exception: it identifies\nits caller with `--terminal`, never `--from`.\n\nGroup addresses include `@all`, `@idle`, `@claude`, `@codex`, `@opencode`,\n`@gemini`, `@droid`, `@grok`, `@cursor`, and `@worktree:<id>`. Every group but\n`@worktree:<id>` means the live Dispatches of the sender's own Run. Mail goes\nto each `dispatch:<id>` mailbox, except a worker coordinating a child Run\nreceives it in that `run:<id>` mailbox. A sender bound to no Run is refused;\n`--run` must match the group audience and never grants membership.\nA Run group excludes its owning coordinator; a worker raising a blocker sends\nto `run:<id>`. A worker that created its own Run addresses that Run's workers,\nnot its siblings. `@worktree:<id>` reaches matching workspace terminals,\nincluding coordinators. Use groups only for intentional fan-out status or\nquestions. `worker_done`, heartbeat, and other\nDispatch lifecycle messages never target groups.\n\n## Questions and gates\n\nA worker uses `ask`; its timeout leaves one durable question pending, which the\nworker resumes by message ID. The coordinator answers that message with `reply`.\n\nUse a gate only for a coordinator-owned Task-DAG decision:\n\n```text\nORCA orchestration gate-create --task <task_id> --question \"<decision>\" --options <json_array> --json\nORCA orchestration gate-resolve --id <gate_id> --resolution \"<choice>\" --json\nORCA orchestration gate-list --task <task_id> --json\n```\n\nPass `json_array` using the quoting rules of the active shell; do not copy POSIX\nsingle-quote syntax into PowerShell or `cmd.exe`.\n\nDo not create a gate merely to answer a worker's `ask`.\n\n<!-- bundled-reference: references/placement-and-remote.md -->\n\n# Placement and remote execution\n\nLoad this reference before creating a new worktree or placing work through SSH,\nWSL, or another connected Orca server.\n\n## Placement choices\n\nA fresh worker means a fresh agent terminal, not a new Git worktree. Use the\ncurrent or an exact existing workspace by default. Create a worktree only when\nthe user requested one or a concrete checkout or filesystem conflict makes\nsharing unsafe.\n\n```text\n# Current workspace; setup is not rerun.\nORCA orchestration worker-start --task <task_id> --worktree current --agent codex --json\n\n# Stacked child worktree.\nORCA orchestration worker-start --task <task_id> --worktree new-child --name <name> --agent codex --setup run --json\n\n# Independent top-level worktree.\nORCA orchestration worker-start --task <task_id> --worktree new-top-level --name <name> --agent codex --setup run --json\n```\n\nCurrent and exact existing workspaces create a fresh terminal unless\n`--terminal` is explicit. Folder workspaces are first-class; do not invoke Git\nor require worktree lineage when the selected workspace is a folder.\n\nRegister a folder workspace through project setup. `repo add --path <dir>`\nrequires a valid Git repository and rejects a plain directory:\n\n```text\nORCA project setup-existing-folder --project <project_id> --host <host_id> --path <abs_path> --kind folder --json\n```\n\nThen place work on the returned workspace with an exact selector. A worktree\nselector needs the full `<repo-id>::<path>` value Orca returned, passed as\n`id:<newFullWorktreeId>`; a bare repo id is not a worktree id. `new-child` and\n`new-top-level` are worktree creation and do not apply to a folder.\n\nNew worktrees use agent-first creation and run setup by default. Preserve the\nrepository's startup policy: `start-immediately` can report setup as `running`,\nwhile `wait-for-setup` gates prompt delivery on success. Orca lineage, Git base,\nfilesystem isolation, coordination parentage, UI grouping, and execution host\nare separate decisions.\n\n## Connected servers\n\nThe Run and Tasks remain authoritative on the current server. `--on` selects\nonly the worker's execution server and appears only on `worker-start`:\n\n```text\nORCA orchestration worker-start --task <task_id> --on <environment> --worktree new-top-level --repo <exact_remote_repo_selector> --name <name> --agent codex --setup run --json\n```\n\nRemote `current` and `new-child` are invalid because they are ambiguous across\nservers. Use an exact discovered remote workspace, or `new-top-level` with an\nexact remote repository selector. After start, route every follow-up, read,\nstop, and cleanup by Dispatch ID; never repeat `--on` or substitute a remote\nterminal handle.\n\n```text\nORCA orchestration worker-show --dispatch <dispatch_id> --json\nORCA orchestration worker-read --dispatch <dispatch_id> --limit 50 --json\nORCA orchestration send --to dispatch:<dispatch_id> --subject \"Follow-up\" --body \"<guidance>\" --json\nORCA orchestration worker-list --run <run_id> --include-remote --json\n```\n\n`worker-list` reads local fleet state only; enumerate remote workers with\n`--include-remote` or every one of them reads `unverifiable`. Scope every list\nwith `--run <run_id>`: unscoped, it reports every Dispatch this runtime has\nrecorded, and the workers you are waiting on are lost in that history.\n\n## Execution-host and mixed-version floor\n\nThe execution host owns process, filesystem, transcript, stop, and cleanup\nfacts. Render only `live`, `unverifiable`, or `exited`. Connection loss, relay\nabsence, missing client inventory, or timeout yields `unverifiable`, never\nsynthetic exit and never a client-local substitute action.\n\nClients and servers update independently. Optional response fields may be\nabsent. Forward model/effort, transcript reads, cleanup, or another new remote\noperation only when the peer advertises the relevant capability; unknown stream\nopcodes can be silently dropped. A narrow unsupported response may degrade to a\ndocumented older path, but must not broaden the target or cross the execution\nboundary. Changing host-published content reaches old clients even without a\nwire-shape change, so preserve established semantics or negotiate the behavior.\n\nFor WSL, use the exact executable and arguments returned by Orca so the distro\nand packaged launcher remain bound. Do not translate a printed `orca-ide`\nrecovery command into a PATH-resolved local command.\n\n<!-- bundled-reference: references/recovery-and-cleanup.md -->\n\n# Recovery and cleanup\n\nLoad this reference only after a failed/stopped/unknown attempt, explicit retry\ndecision, stop/abandon request, retention request, or uncertain release.\n\n| Proven state            | Safe action                                                        |\n| ----------------------- | ------------------------------------------------------------------ |\n| `ready` or active       | Keep waiting; optionally read bounded output                       |\n| `failed` or `stopped`   | Start a replacement with `--retry-of`; repeat placement explicitly |\n| `outcome_unknown`       | Inspect, then choose `worker-stop` or explicit `worker-abandon`    |\n| Accepted `worker_done`  | Reuse, retain, or release                                          |\n| Remote contact lost     | Preserve `unverifiable`; do not stop or retry from absence alone   |\n| `unverifiable` liveness | Keep waiting or inspect; never stop, abandon, retry, or release    |\n| Proven `exited` agent   | Enumerate with `worker-list`; follow its `nextAction`              |\n\n## Inspect before acting\n\n```text\nORCA orchestration worker-list --run <run_id> --json\nORCA orchestration worker-list --run <run_id> --include-remote --json\nORCA orchestration worker-show --dispatch <dispatch_id> --json\nORCA orchestration worker-read --dispatch <dispatch_id> --limit 50 --json\n```\n\n`worker-list` is the enumerating command and the authority on agent liveness:\neach row carries `projection.liveness`, `projection.attention.categories`,\n`projection.attention.requiresAction`, and a literal `projection.nextAction`\nargv to run. Always scope it with `--run <run_id>`; an unscoped list reports\nevery Dispatch this runtime has ever recorded and buries the live ones.\n`worker-show`'s `observation.status` is PTY liveness only, so a `live` terminal\nwhose agent died at a trust prompt still reads `live` there.\n\nWhen the two disagree, the fleet verdict decides — unless the fleet row is\n`unverifiable` for a reason that names a gap on this client rather than a fact\nabout the worker. `missing_status`, `host_unavailable`, and\n`capability_unsupported` are such gaps: the first means this runtime holds no\nstatus row, the second that it could not ask the execution host at all, and the\nthird that a stale peer answered but lacks the fleet-snapshot capability.\nAgainst any of them, a `worker-show` verdict sourced from the execution host is\nthe better evidence and outranks the row. Only `host_unavailable` is contact\nloss; the other two mean the host was never asked or answered without the\ncapability.\n\nThis never promotes absence. `unverifiable` from either command still authorizes\nnothing — only a positive `live` or `exited` verdict does.\n\nA worker started with `--on <environment>` reads `unverifiable` until you\nenumerate with `--include-remote`, which asks its execution host for the\nverdict. Rows come newest first and past 100 the response pages, so follow\n`page.nextCursor` with `--cursor <value>` until `page.hasMore` is false.\n\n## Stall needs positive evidence\n\nLeave the wait only on positive proof the agent stopped: `exited` liveness, the\nworker's own observation of process exit, or a transcript whose final agent turn\nsent no `worker_done`. Only then choose `worker-stop` or `worker-abandon`.\n\n`unverifiable` is always absence — `missing_status`, `stale_status`,\n`restored_unconfirmed`, or a remote worker with no connection — and a null\n`agentWait` or an unchanged `worker-read` tail is that same absence seen again.\nAbsence never authorizes stop, abandon, retry, or release: keep waiting, or\ninspect until you hold one of the positive signals above. A `nextAction` that\nnames an inspecting command is asking for evidence, not for cleanup.\n\n`worker-read --source auto` uses a proven provider transcript when available and\notherwise returns bounded terminal output with a typed `fallbackReason`.\nContinue with its top-level cursor, which is pinned to that source. If Orca\nreports `source_changed`, restart without the old cursor. A bounded initial\ntranscript tail can return an EOF cursor that follows only newly appended records;\nread `contentComplete`, `clipping`, and `warnings` before assuming omitted older\nrecords are pageable. Never guess a provider session ID, transcript path, or\nremote terminal handle.\n\n## Was the mutation applied?\n\nWhen a mutation's response was lost and named no Dispatch, do not replay blind.\nEvery orchestration mutation accepts `--retry-request <id>`, which reuses one\noperation identity so Orca can replay, join, or recover it instead of starting a\nduplicate. Ask what happened first:\n\n```text\nORCA orchestration request-show --request <request_id> --json\n```\n\n`completed` means the mutation already took effect; read its recorded receipt\ninstead of rerunning. `pending` means the original mutation is still running or\nOrca restarted before recording its outcome; replay the original command with\n`--retry-request <request_id>`. `absent` means this runtime holds no receipt\nunder your caller identity — that is not proof nothing happened, so inspect the\naffected Task, Dispatch, and terminal before deciding whether to retry.\n\nWhen a worker's terminal accepted input but the submit is unconfirmed, use\n`terminal send --wait-submit <seconds>`: it observes the accepted prompt for that\nlong and, on timeout, returns the input-accepted receipt without resending.\n\n## Refused starts\n\n`dispatch` and `worker-start` refuse the following preflight cases with a stable\n`error.code`; read it before choosing a recovery, and treat `error.data.nextSteps`\nas the exact recovery text. Older hosts may omit `data`, so treat every field as\noptional.\n\n| Code                 | Meaning                                                                                                               | Recovery                                                                                                                       |\n| -------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |\n| `task_not_found`     | No Task with that id, or not in the bound Run (`data.taskId`, `data.runId`)                                           | Check `task-list --json`; create the Task with `task-create` if it does not exist                                              |\n| `task_not_startable` | Task cannot start now: not `ready`, or invalid `--retry-of` (`data.status`, `data.unmetDependencies`, `data.retryOf`) | Wait for running dependencies with `check --wait`; retry or unblock failed ones; inspect `dispatch-show` if already dispatched |\n| `inject_rejected`    | `--inject` refused because no recognized agent runs in the target (`data.terminal`, `data.reason`)                    | Start a recognized agent there or pick another terminal; or dispatch without `--inject` and use `terminal send`                |\n| `runtime_error`      | Any other failure, including a target terminal that already owns an active Dispatch                                   | Read the message, inspect state, and do not retry unchanged                                                                    |\n\n## Retry, stop, and abandon\n\nRetry only a positively proven failed or stopped attempt. Name the failed Task\nwith `--task`, since `--spec` creates a new one. Placement is never silently\ninherited:\n\n```text\nORCA orchestration worker-start --task <task_id> --retry-of <dispatch_id> --worktree <explicit_placement> --agent <agent> --json\n```\n\nAfter three consecutive failures for one Task, its dispatch context\ncircuit-breaks and the Task is failed. Do not route around that boundary with a\nnew Run or an unrelated Dispatch.\n\nFor `outcome_unknown`, inspect first, then make an explicit choice:\n\n```text\nORCA orchestration worker-stop --dispatch <dispatch_id> --json\nORCA orchestration worker-abandon --dispatch <dispatch_id> --json\n```\n\n`worker-stop` closes only the exact proven supervised agent terminal. It never\ndeletes the worktree, setup terminal, configured tabs, or unrelated processes.\n`worker-abandon` fences orchestration while accepting that resources may remain\nlive; it performs no remote, process, or filesystem action. When it settles a\nworker, it retains an owned terminal by the same rule as `worker-retain`, so Orca\nstops owing its release; a release already committed (`releasing`,\n`release_unknown`) is left as it is. An already-settled worker is left untouched.\n\nTo cancel a Task, settle its worker with `worker-stop` or `worker-abandon`, then\nrecord the reason. A cancelled Task is `failed`, so its dependents stay blocked\nuntil a `--retry-of` replacement completes it:\n\n```text\nORCA orchestration task-update --id <task_id> --status failed --result cancelled --json\n```\n\n## Retain and release\n\n```text\nORCA orchestration worker-retain --dispatch <dispatch_id> --json\nORCA orchestration worker-release --dispatch <dispatch_id> --json\n```\n\nRetain only when the user explicitly wants the settled terminal kept live.\nRelease works after succeeded and failed reports, archives readable output, and\ncloses only the exact terminal owned by that settled Dispatch. Replays may call\nrelease again safely. Reused, pre-existing, setup, coordinator, active,\nuser-taken-over, and unproven terminals are retained.\n\nA `worker-start` that failed before its agent was ready still owns the terminal\nit created. Its receipt names `worker-release`, and `worker-list` reports that\nrow as `reclaimable`; release it there rather than closing the terminal by hand.\n\nNever release because of timeout, TUI idle, heartbeat, status, question,\nescalation, or stale/rejected completion. If the receipt says `release_pending`\nor `release_unknown`, follow its exact recovery action. Never substitute\n`terminal close`.\n\n`orchestration reset` is destructive recovery. Do not run it during active\ncoordination unless the user explicitly abandons that state.\n\n<!-- bundled-reference: references/worker-contract.md -->\n\n# Worker contract\n\nThe injected preamble is authoritative. Copy its command rather than\nreconstructing flags. In particular, preserve the exact executable, worker\nhandle, Task ID, and Dispatch ID, and keep any other flag it carries (an older\nOrca host adds `--dispatch-capability`).\n\n## Heartbeat\n\nSend heartbeats only at the cadence required by the live preamble. Skip them\nwhile blocked inside `ask` or `check --wait`; those calls are liveness signals.\n\n```text\nORCA orchestration send --from <worker_handle> --type heartbeat --subject \"alive\" --task-id <task_id> --dispatch-id <dispatch_id> --phase \"<investigating|implementing|reviewing|waiting>\"\n```\n\nUse typed lifecycle flags, not a hand-written JSON payload. A heartbeat proves\nliveness, never completion.\n\n## Ask and resume\n\nUse Orca `ask` whenever the coordinator must answer. Never open a local question\nTUI the coordinator cannot answer.\n\n```text\nORCA orchestration ask --from <worker_handle> --question \"<question>\" --options \"<choice-a>,<choice-b>\" --timeout-ms 600000\n\nORCA orchestration ask --from <worker_handle> --resume <message_id> --timeout-ms 600000\n```\n\nA timeout or disconnect leaves the original question pending. Resume its\nmessage ID; do not create a duplicate question.\n\n## Reading coordinator follow-ups\n\nThe coordinator steers a running worker with `send --to dispatch:<id>`. That\nenqueue is durable but does not interrupt you, so nothing arrives unless you\nlook:\n\n```text\nORCA orchestration check --terminal <worker_handle> --json\n```\n\nRun it at each natural checkpoint — before starting a new file, after a test\nrun — and once more immediately before `worker_done`, so a redirect or a\ncancellation lands before the Task settles. `check` names its caller with\n`--terminal`, never `--from`. Stop checking after `worker_done`.\n\nIf `check` returns `consumer_fenced`, this process no longer owns its Dispatch:\nthe Attempt was re-attached to another worker or settled without you. Stop, do\nnot send `worker_done`, and do not retry the check. An empty `check` never means\nyou were replaced; `consumer_fenced` is the only way you learn that.\nIf `send` or `ask` returns `consumer_fenced`, the command ran from another\nparty's terminal (a coordinator or another worker); run it from your own terminal.\n\n## Escalation\n\nEscalate only before completion and only when the coordinator must intervene:\n\n```text\nORCA orchestration send --from <worker_handle> --type escalation --subject \"Blocked: <reason>\" --body \"<details>\" --task-id <task_id> --dispatch-id <dispatch_id>\n```\n\n## Completion\n\nSend exactly one terminal report. `--body` is three sentences: what changed,\nwhat was found, and what remains. Use `--outcome failed` when the requested work\nis not complete; never hide failure in prose or silently exit.\n\nAppend `--files-modified` or `--report-path` only when applicable, using actual\npaths. Do not send documentation placeholders as metadata.\n\n```text\nORCA orchestration send --from <worker_handle> --type worker_done --subject \"<short status>\" --body \"<three sentences: work, findings, remaining>\" --task-id <task_id> --dispatch-id <dispatch_id> --outcome succeeded\n```\n\nAfter `worker_done`, end the dispatched turn and idle. Do not poll, close your\nown terminal, or begin unrelated work. A later direct user instruction is new\nuser-owned work and must not reuse settled lifecycle IDs; a supervised follow-up\narrives with a fresh preamble and Task block.\n"
+const ORCHESTRATION_FULL_MARKDOWN = "---\nname: orchestration\ndescription: >-\n  Coordinate supervised Orca workers: threaded messages, blocking ask/reply,\n  task dispatch, worker_done/escalation waits, task DAGs, decision gates,\n  coordinator loops, and decomposing work across agents. Use `orca-cli` for full\n  ownership handoffs — \"hand off\", \"handoff\", \"handover\", \"give this to another\n  agent\", \"another worktree\" — unless asked to supervise, monitor, or coordinate\n  a DAG, and for terminal control, lightweight terminal prompts, shell commands,\n  Orca worktree management, and reading or waiting on terminals.\n---\n\n# Orca orchestration\n\nOrchestration is Orca's structured coordination layer. It records who owns work,\nwhich attempt is authoritative, and when supervised work has settled.\n\n## Outcome\n\n**Result:** every in-scope Task has one explicit outcome and every settled worker\nterminal has a next owner or cleanup decision. **Next consumer:** the user who\nrequested supervision. **Done:** all expected Dispatches have settled, every\ndelivered message was processed before acknowledgment, each settled worker was\nreused, explicitly retained, or released, and the turn ends only when the report\nto that user names, per Task, its outcome, the evidence behind it, and any\nunresolved blocker.\n\n**Safe failure:** preserve work and authority and report the state as unknown or\n`unverifiable`. Only positive proof of exit authorizes stop, abandon, or retry,\nand only an accepted settlement authorizes release. Every other observation,\nabsence included, is a checkpoint.\n\n## Classify the role\n\n| Current context                                                                                                                                | Role                    | Route                                                                          |\n| ---------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------------------------ |\n| The user explicitly asks to supervise, monitor, wait for results, track completion, coordinate a DAG, use a decision gate, or manage ask/reply | Coordinator             | Use the supervised loop below                                                  |\n| The current prompt contains a live injected preamble with Task and Dispatch IDs                                                                | Dispatched worker       | Follow the preamble and the worker obligations below                           |\n| The user asks to hand off ownership or start another agent/worktree without supervision                                                        | Handoff owner           | Use `orca-cli`; create no Run, Task, or Dispatch and do not monitor completion |\n| A message carries a legacy authority label                                                                                                     | Compatibility operator  | Load the legacy contract reference before any lifecycle mutation               |\n| No live preamble and no explicit supervision                                                                                                   | Ordinary terminal agent | Do not emit lifecycle messages; use `orca-cli` for terminal/worktree work      |\n\nModel or effort selection does not make a handoff supervised. Never substitute a\nnon-Orca subagent tool when Orca orchestration provenance was requested.\n\n## Authority and safety floor\n\n- A Run is a durable namespace and coordinator inbox; it does not schedule or\n  place workers. A Task is work. A Dispatch is one authoritative Task attempt.\n- Lifecycle authority comes from the active Dispatch, not a terminal title,\n  copied ID, old database row, provider transcript, or visible pane.\n- Workers use the exact executable, handle, Task ID, and Dispatch ID in the live\n  preamble, plus any other flag it carries. Never reconstruct, translate, or\n  broaden those arguments.\n- After remote start, address the worker by Dispatch ID. The execution host owns\n  process, filesystem, transcript, stop, and cleanup facts. Preserve the verdicts\n  `live` / `unverifiable` / `exited`; contact loss is not process death.\n- Liveness is layered: `worker-list`'s `projection.liveness` is the fleet verdict\n  for the agent; `worker-show`'s `observation.status` is PTY liveness only. A live\n  terminal can still hold a dead or stuck agent.\n- Folder workspaces are valid; never require Git or assume a worktree.\n- Clients and remote servers update independently. Treat unknown optional fields\n  as absent. A new stream operation requires advertised capability because old\n  decoders may silently drop unknown opcodes. Never fall back to local execution\n  when remote authority or capability is unproven.\n- Use the executable you used to run `skills get` for the entire run. In the\n  examples below, replace `ORCA` with it; do not create a shell variable or run\n  `ORCA` literally. If it fails, report that exact error instead of switching.\n- `ORCA status --json` shows your Orca session ID as `caller.orcaSessionId` when you have one.\n- A successful `orchestration send` proves durable enqueue; its wake or nudge is\n  best-effort attention only and does not prove the recipient read or accepted it.\n\n## Worker obligations\n\nThe injected preamble is authoritative. A dispatched worker must:\n\n1. Do only the current Task and use the preamble's `ask` command for a blocking\n   coordinator question. Never open a local question TUI the coordinator cannot\n   answer. Resume the same message ID after an ask timeout.\n2. Send heartbeats only at the cadence in the preamble. A heartbeat proves\n   liveness, not completion.\n3. Read coordinator follow-ups at each natural checkpoint — before starting a\n   new file, after a test run — and once more immediately before `worker_done`:\n   `ORCA orchestration check --terminal <your_handle> --json`.\n4. Send `worker_done` exactly once, from the dispatched terminal, with a\n   three-sentence executive summary, both lifecycle IDs, and explicit\n   `--outcome succeeded` or `--outcome failed`. Never encode failure only in prose.\n5. Append `--files-modified` and `--report-path` only with real values when\n   applicable. After `worker_done`, end the dispatched turn and idle; do not poll\n   or start new work.\n\nA direct user instruction after completion starts new user-owned work and takes\nprecedence over the idle rule. Do not reuse the settled lifecycle IDs.\n\n## Canonical supervised loop\n\nConfirm the runtime, bind one Run, and start the full independent wave before\nwaiting. `worker-start --spec` creates the Task and its attempt in one call:\n\n```text\nORCA status --json\nORCA orchestration run-create --objective \"<objective>\" --json\nORCA orchestration worker-start --spec \"<worker A task>\" --worktree current --agent codex --json\nORCA orchestration worker-start --spec \"<worker B task>\" --worktree current --agent claude --json\nORCA orchestration check --wait --types \"worker_done,escalation,question\" --timeout-ms 900000 --json\n```\n\nIf `worker-start` exits non-zero, do not relaunch. Read the receipt's\n`failedStage` and `residualResources`, then load\n`references/recovery-and-cleanup.md`.\n\nUse `task-create` plus `worker-start --task <task_id>` for planned fan-out with\ndependencies or a retry of a known Task. Use dependencies only for real ordering\nand prefer parallel waves over chains deeper than three or four steps; nested\nworkers obey the depth limit, and a new Run does not reset the caller's depth.\n\nA consuming `check` names its caller with `--terminal <handle>`, never `--from`;\nomit it inside the coordinator's own Orca terminal. It returns the bound Run's\noldest FIFO Delivery and replays that batch until acknowledged. Process every\nmessage: reply to questions, validate each `worker_done` against the expected\nactive Dispatch, and decide each settled terminal's next owner before the ack:\n\n```text\nORCA orchestration reply --id <message_id> --body \"<answer>\" --json\nORCA orchestration worker-release --dispatch <dispatch_id> --json\nORCA orchestration check --ack <delivery_id> --wait --types \"worker_done,escalation,question\" --timeout-ms 900000 --json\n```\n\nKeep waiting until every expected Dispatch settles. A timeout or empty result is\na checkpoint, not a failure. Do not stop, retry, release, or launch a duplicate\neditor without the positive proof `## Outcome` requires.\n\nAfter three consecutive empty waits, stop waiting blindly and enumerate with\n`ORCA orchestration worker-list --include-remote --json` (defaults to the bound\nRun; `--run <run_id>` overrides; the receipt's `scope` names which), acting on\neach row's `projection.attention` categories, `projection.attention.requiresAction`, and literal `projection.nextAction` argv.\nRows come newest first and page at 100: while `page.hasMore`, follow `page.nextCursor` with `--cursor <value>`.\nA `none` `nextAction` has no argv to run: read `liveness.reason` and keep waiting\nwith `check --wait`. Absence never earns an argv; settlement and pending work still do.\nLeave the wait only on positive proof the agent stopped: `exited` liveness, the\nworker's own observation of process exit, or a transcript whose final agent turn\nsent no `worker_done`. Then load `references/recovery-and-cleanup.md` and choose\n`worker-stop` or `worker-abandon` explicitly. `unverifiable` is absence,\nincluding when `worker-show` reports `agentWait` null. Absence never authorizes\nstop, abandon, retry, or release; keep waiting or inspect.\n\n`worker-start` is the normal path, composing placement, terminal readiness,\nprompt injection, and supervised resource ownership. `dispatch --inject` leaves\nan operator-created process unsupervised and is only for an expressiveness gap.\n\n## Task-spec contract\n\nEvery Task spec must be self-contained and name:\n\n- **Target:** the files, component, or environment in scope.\n- **Change:** the concrete result to produce.\n- **Constraints:** invariants, compatibility rules, and do-not-touch boundaries.\n- **Ownership:** what this worker may edit and any coordination boundary.\n- **Observable acceptance:** the test, output, or evidence that proves completion.\n\n## Completion accounting\n\nAfter an accepted success or failure report, immediately do exactly one:\n\n1. Reuse the same proven agent terminal for an immediate follow-up Dispatch.\n2. Record user-requested retention with `worker-retain`.\n3. Run `worker-release`.\n\nRelease is post-settlement cleanup, not cancellation. Only an accepted\nsettlement authorizes it; no other observation does. If release is uncertain,\nfollow its exact recovery receipt and never substitute `terminal close`.\n\nA valid `worker_done` settles the Task and Dispatch automatically; do not follow\nit with `task-update --status completed`. Enumerate the terminals still owing a\ndecision with `worker-list --run <run_id> --terminal-state reclaimable --json`,\nand do not end the coordinator turn until it returns none.\n\n## Conditional references\n\nThis compact guide is sufficient for the normal local loop. At an action gate\nbelow, run `ORCA skills get orchestration --reference references/<file>.md` and\nread only that document; `--references` lists the names. If the CLI rejects\n`--reference`, run `ORCA skills get orchestration --full` once instead: it\nreturns this exact kernel and every reference, so read only the named one. If an\nolder CLI rejects `--full`, keep this kernel's safety floor, use that command's\n`--help`, and never guess newer flags.\n\n| Action gate                                                                                                   | Bundled reference                         |\n| ------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |\n| Expanded DAG waves, launch model/effort, same-terminal reuse, or review ownership                             | `references/coordinator-loop.md`          |\n| You are a dispatched worker and the live preamble does not answer your question, or `check` returned an error | `references/worker-contract.md`           |\n| New worktree, exact workspace, SSH, WSL, or connected-server placement                                        | `references/placement-and-remote.md`      |\n| Inbox replay, follow-up messages, group addresses, or decision gates                                          | `references/messaging-and-gates.md`       |\n| Failed/stopped/unknown attempts, retry, stop, abandon, retain, or uncertain release                           | `references/recovery-and-cleanup.md`      |\n| Custom argv or terminal topology that `worker-start` cannot express                                           | `references/low-level-topology.md`        |\n| Any legacy label, adopted Run, compatibility receipt, or takeover                                             | `references/legacy-contract-migration.md` |\n\nRetired scheduler commands are not aliases for Run creation. Recovery commands\nmust provide their exact next action; follow it with the same selected executable.\n\n---\n\n# Bundled references\n\nThese references belong to the version-matched guide above. Read only the documents named by its action gates.\n\n<!-- bundled-reference: references/coordinator-loop.md -->\n\n# Coordinator loop\n\nLoad this reference for expanded DAG waves, per-invocation launch preferences,\nsame-terminal reuse, or review ownership. The compact guide remains the source\nof truth for the loop order and completion boundary.\n\n## Ready waves\n\nCreate independent Tasks before the first wait. Encode only real dependencies,\nthen use the ready view as external memory:\n\n```text\nORCA orchestration task-create --spec \"<dependent work>\" --deps <json_array> --json\nORCA orchestration task-list --ready --brief --json\n```\n\n`--brief` collapses whitespace and caps echoed specs at 160 characters;\n`spec_truncated` identifies shortened rows. Omit it when full specs are needed or\nwhen an older CLI rejects the flag. A nested worker must respect\n`nested_worker_depth_exceeded`; creating another Run does not reset depth.\n\n## Launch preferences\n\nFor a fresh Claude, Codex, Cursor, Antigravity, or Muse terminal, `--model`\naccepts an opaque provider model ID. Pass it only when the user named a model;\notherwise omit it so the worker inherits the user's configured agent default.\nAdd `--effort` only when that model supports it:\n\n```text\nORCA orchestration worker-start --task <task_id> --worktree current --agent claude --model opus --effort high --json\nORCA orchestration worker-start --task <task_id> --worktree current --agent muse --model muse-spark-1.3 --json\n```\n\nOpenCode also accepts `--model` in an existing worktree when the execution host\nverifies its CLI version and model availability. Creating a new worktree with an\nOpenCode model override is unsupported; use `--worktree current` or an existing\nworktree selector, or omit `--model`. OpenCode effort is unsupported. Omit the\nmodel to inherit its configuration; unsupported or unknown hosts refuse the\noverride explicitly.\n\n`--effort` requires `--model`; neither option combines with `--terminal`. A\nconnected worker server must advertise launch-preference support before Orca\nforwards either field. Compare `launch.requested` with `launch.effective`; never\nclaim a model or effort from requested arguments alone.\n\n## Reuse after settlement\n\nChoose the terminal's next owner before acknowledging the Delivery. When the\nsame exact agent has immediate follow-up work, recover the proven handle and\ntransfer cleanup ownership to the new Dispatch:\n\n```text\nORCA orchestration worker-show --dispatch <dispatch_id> --json\nORCA orchestration worker-start --task <next_task_id> --terminal <agent_terminal_handle> --json\n```\n\nOtherwise explicitly retain or release the settled worker. Do not leave it live\nonly to inspect output; archived output remains available through `worker-read`.\n\n## Review ownership\n\nA review-only `worker_done` authorizes synthesis of findings, not coordinator\nfile edits. Dispatch or hand off fixes unless the user explicitly assigned them\nto the coordinator. If the user's plan names a next owner, post-review fixes and\nPR preparation remain with that owner; the coordinator routes and synthesizes.\n\n<!-- bundled-reference: references/legacy-contract-migration.md -->\n\n# Legacy contract migration\n\nLoad this reference only for an authority label, adopted Run, compatibility or\nrecovery receipt, or explicit legacy takeover. A newly created attempt always\nuses the current grammar.\n\n## Authority labels\n\n- `[LEGACY COMPATIBILITY]` is live and attested. Run only the exact supported\n  command printed with the message, using the same selected executable and\n  arguments supplied by the original prompt.\n- `[LEGACY RECOVERY REPLAY — MAY HAVE BEEN SEEN]` is one bounded,\n  at-least-once cutover replay. Process it idempotently and acknowledge only\n  through the exact displayed guidance.\n- `[LEGACY READ-ONLY]` is inspection-only. It has no reply, acknowledgment, or\n  lifecycle mutation.\n- An unlabeled current message uses the current guide and grammar.\n\nAn explicitly selected current Run, attested current binding, current Dispatch,\nor federated attachment takes precedence over legacy fallback. A retained\nadoption record alone does not grant mutation authority. If liveness, principal\nownership, capability, or the exact legacy contract is unproven, degrade to\nread-only inspection and never fall back to local execution.\n\nAdoption preserves the live agent process, PTY/session, terminal handle,\ntab/pane, worktree or folder workspace, Task, and Dispatch. It never restarts or\nreplaces the worker and never revives the retired scheduler. Loss of lifecycle\nauthority does not invalidate the existing process, assignment, or filesystem\nwork. Exact recovery may restore the same PTY once in its original inactive\nbackground tab; it must not spawn, write, signal, stop, switch, focus, split, or\ninject a terminal.\n\n## Compatibility recovery\n\nWhen a compatibility response returns structured next-step arguments, execute\nthose exact arguments with the same selected CLI executable. Do not translate\nfrom memory, broaden the recipient, or retry as a current mutation unless the\nreceipt explicitly authorizes it.\n\nA pending ask, reply, final Dispatch settlement, and consuming check have\ndurable recovery identities. Heartbeat and escalation remain at-least-once\nacross a manual contract-boundary retry. If an ask may already have been\nanswered, run the exact non-consuming recovery check printed by Orca before\ncreating any new question. Never guess among identical question threads.\n\nOn packaged Windows, a legacy ask uses a two-step commit/resume protocol. The\ninitial command commits the question, prints its exact\n`ask --resume <message_id>` command, and exits with launcher status `75`. Run\nthat exact resume after the launcher or update boundary. For an attested WSL\nlaunch, preserve the printed `orca-ide` executable and distro route. Older WSL\nworkers without launch proof remain lifecycle read-only even while their\nterminal and filesystem work continue.\n\n## Read-only inspection and takeover\n\nRead-only inspection does not consume mail:\n\n```text\nORCA orchestration run-list --json\nORCA orchestration run-show --id run_legacy_local --json\nORCA orchestration run-show --id <adopted_run_id> --json\nORCA orchestration task-list --run <adopted_run_id> --json\nORCA orchestration inbox --full --json\nORCA orchestration check --terminal <legacy_handle> --peek --format --json\nORCA terminal read --terminal <legacy_handle> --json\nORCA terminal wait --terminal <legacy_handle> --for tui-idle --timeout-ms 60000 --json\n```\n\n`run_legacy_local` is an empty audit tombstone after adoption. Find the ordinary\nRun whose objective is `Recovered orchestration work from a contract update`.\n\nOnly when the original coordinator is unavailable or cannot prove retained\nauthority may a new live coordinator take over from its own terminal:\n\n```text\nORCA orchestration run-use --id <adopted_run_id> --takeover-legacy --json\nORCA orchestration check --run <adopted_run_id> --json\n```\n\nTakeover binds the authenticated invoking terminal; `--from` cannot nominate\nanother coordinator. It fences only the old coordinator and moves pending mail\ninto current Run delivery. It preserves live workers, Tasks, Dispatches, processes, and files.\nNever take over while the original coordinator is actively coordinating.\n\nDo not launch a replacement editor merely because Orca updated or authority is\nunclear. Keep the original worker as the only editor until a stable handoff\npoint, then use a fresh current Dispatch in a conflict-free placement.\n\n<!-- bundled-reference: references/low-level-topology.md -->\n\n# Low-level topology\n\nLoad this reference only when `worker-start` cannot express required custom argv\nor terminal topology. It is not the normal supervised loop and is never a full\nhandoff recipe.\n\n```text\nORCA terminal create --worktree active --title <task_name> --command \"<agent_command>\" --json\nORCA terminal wait --terminal <handle> --for tui-idle --timeout-ms 60000 --json\nORCA orchestration dispatch --task <task_id> --to <handle> --inject --json\n```\n\nWait for readiness only when startup could lose injected input. Prefer\nagent-first `worker-start` whenever its argv and topology are sufficient.\n\n`dispatch --inject` creates authoritative Task/Dispatch context but deliberately\nkeeps an operator-created process unsupervised: it creates no supervised worker\nresource row. `worker-show`, `worker-read`, and `worker-list` report the lane as\n`unsupervised`; `worker-stop` and `worker-abandon` do not close that process, and\nsettled retain/release take no process action.\n\nUse `worker-start --terminal <handle>` when lifecycle ownership of an existing\nagent terminal is required. Never imply that low-level dispatch retroactively\nowns a process, never use it to route around the nested-depth limit, and never\nuse it for an ownership handoff.\n\n<!-- bundled-reference: references/messaging-and-gates.md -->\n\n# Messaging and gates\n\nLoad this reference for inbox replay, attempt-specific guidance, group\naddresses, blocking questions, or coordinator-managed DAG decisions.\n\nA successful `send` proves durable enqueue. Wake and nudge are best-effort\nattention only: neither proves the recipient read the message, began a turn, or\naccepted steering.\n\n## Coordinator delivery loop\n\n`check` names its caller with `--terminal <handle>` and is the only verb that\nrejects `--from`. Omit `--terminal` inside an Orca terminal, where Orca resolves\nthe caller; pass it explicitly from anywhere else, including a dispatched\nworker reading coordinator follow-ups.\n\nA consuming coordinator `check` returns the bound Run's oldest FIFO Delivery,\nup to 50 messages, and replays that exact batch until acknowledged. Process\nevery row and required terminal ownership decision before `--ack`. Type filters\ndecide when a waiter wakes; they do not authorize skipping older actionable\nmail. A Delivery therefore always carries the whole FIFO batch whatever its\ntypes, and a `check` without `--wait` hands that batch over unfiltered.\n`--peek` and `--all` are read-only inspection, not progress through the\ncoordinator inbox.\n\nAn empty wait or timeout is a checkpoint. Continue rolling waits until every\nexpected Dispatch settles. Heartbeat or visible activity means alive, not done.\n\n## Addresses\n\nUse a stable Dispatch address for attempt-specific coordinator guidance:\n\n```text\nORCA orchestration send --to dispatch:<dispatch_id> --subject \"Follow-up\" --body \"<guidance>\" --json\n```\n\nDo not substitute a remote terminal handle. Omit `--from` for ordinary\ncoordinator calls; a dispatched worker instead copies the exact `--from` and\nother arguments in its preamble. `check` is the exception: it identifies\nits caller with `--terminal`, never `--from`.\n\nGroup addresses include `@all`, `@idle`, `@claude`, `@codex`, `@opencode`,\n`@gemini`, `@droid`, `@grok`, `@cursor`, and `@worktree:<id>`. Every group but\n`@worktree:<id>` means the live Dispatches of the sender's own Run. Mail goes\nto each `dispatch:<id>` mailbox, except a worker coordinating a child Run\nreceives it in that `run:<id>` mailbox. A sender bound to no Run is refused;\n`--run` must match the group audience and never grants membership.\nA Run group excludes its owning coordinator; a worker raising a blocker sends\nto `run:<id>`. A worker that created its own Run addresses that Run's workers,\nnot its siblings. `@worktree:<id>` reaches matching workspace terminals,\nincluding coordinators. Use groups only for intentional fan-out status or\nquestions. `worker_done`, heartbeat, and other\nDispatch lifecycle messages never target groups.\n\n## Questions and gates\n\nA worker uses `ask`; its timeout leaves one durable question pending, which the\nworker resumes by message ID. The coordinator answers that message with `reply`.\n\nUse a gate only for a coordinator-owned Task-DAG decision:\n\n```text\nORCA orchestration gate-create --task <task_id> --question \"<decision>\" --options <json_array> --json\nORCA orchestration gate-resolve --id <gate_id> --resolution \"<choice>\" --json\nORCA orchestration gate-list --task <task_id> --json\n```\n\nPass `json_array` using the quoting rules of the active shell; do not copy POSIX\nsingle-quote syntax into PowerShell or `cmd.exe`.\n\nDo not create a gate merely to answer a worker's `ask`.\n\n<!-- bundled-reference: references/placement-and-remote.md -->\n\n# Placement and remote execution\n\nLoad this reference before creating a new worktree or placing work through SSH,\nWSL, or another connected Orca server.\n\n## Placement choices\n\nA fresh worker means a fresh agent terminal, not a new Git worktree. Use the\ncurrent or an exact existing workspace by default. Create a worktree only when\nthe user requested one or a concrete checkout or filesystem conflict makes\nsharing unsafe.\n\n```text\n# Current workspace; setup is not rerun.\nORCA orchestration worker-start --task <task_id> --worktree current --agent codex --json\n\n# Stacked child worktree.\nORCA orchestration worker-start --task <task_id> --worktree new-child --name <name> --agent codex --setup run --json\n\n# Independent top-level worktree.\nORCA orchestration worker-start --task <task_id> --worktree new-top-level --name <name> --agent codex --setup run --json\n```\n\nCurrent and exact existing workspaces create a fresh terminal unless\n`--terminal` is explicit. Folder workspaces are first-class; do not invoke Git\nor require worktree lineage when the selected workspace is a folder.\n\nRegister a folder workspace through project setup. `repo add --path <dir>`\nrequires a valid Git repository and rejects a plain directory:\n\n```text\nORCA project setup-existing-folder --project <project_id> --host <host_id> --path <abs_path> --kind folder --json\n```\n\nThen place work on the returned workspace with an exact selector. A worktree\nselector needs the full `<repo-id>::<path>` value Orca returned, passed as\n`id:<newFullWorktreeId>`; a bare repo id is not a worktree id. `new-child` and\n`new-top-level` are worktree creation and do not apply to a folder.\n\nNew worktrees use agent-first creation and run setup by default. Preserve the\nrepository's startup policy: `start-immediately` can report setup as `running`,\nwhile `wait-for-setup` gates prompt delivery on success. Orca lineage, Git base,\nfilesystem isolation, coordination parentage, UI grouping, and execution host\nare separate decisions.\n\n## Connected servers\n\nThe Run and Tasks remain authoritative on the current server. `--on` selects\nonly the worker's execution server and appears only on `worker-start`:\n\n```text\nORCA orchestration worker-start --task <task_id> --on <environment> --worktree new-top-level --repo <exact_remote_repo_selector> --name <name> --agent codex --setup run --json\n```\n\nRemote `current` and `new-child` are invalid because they are ambiguous across\nservers. Use an exact discovered remote workspace, or `new-top-level` with an\nexact remote repository selector. After start, route every follow-up, read,\nstop, and cleanup by Dispatch ID; never repeat `--on` or substitute a remote\nterminal handle.\n\n```text\nORCA orchestration worker-show --dispatch <dispatch_id> --json\nORCA orchestration worker-read --dispatch <dispatch_id> --limit 50 --json\nORCA orchestration send --to dispatch:<dispatch_id> --subject \"Follow-up\" --body \"<guidance>\" --json\nORCA orchestration worker-list --run <run_id> --include-remote --json\n```\n\n`worker-list` reads local fleet state only; enumerate remote workers with\n`--include-remote` or every one of them reads `unverifiable`. Scope every list\nwith `--run <run_id>`: unscoped, it reports every Dispatch this runtime has\nrecorded, and the workers you are waiting on are lost in that history.\n\n## Execution-host and mixed-version floor\n\nThe execution host owns process, filesystem, transcript, stop, and cleanup\nfacts. Render only `live`, `unverifiable`, or `exited`. Connection loss, relay\nabsence, missing client inventory, or timeout yields `unverifiable`, never\nsynthetic exit and never a client-local substitute action.\n\nClients and servers update independently. Optional response fields may be\nabsent. Forward model/effort, transcript reads, cleanup, or another new remote\noperation only when the peer advertises the relevant capability; unknown stream\nopcodes can be silently dropped. A narrow unsupported response may degrade to a\ndocumented older path, but must not broaden the target or cross the execution\nboundary. Changing host-published content reaches old clients even without a\nwire-shape change, so preserve established semantics or negotiate the behavior.\n\nFor WSL, use the exact executable and arguments returned by Orca so the distro\nand packaged launcher remain bound. Do not translate a printed `orca-ide`\nrecovery command into a PATH-resolved local command.\n\n<!-- bundled-reference: references/recovery-and-cleanup.md -->\n\n# Recovery and cleanup\n\nLoad this reference only after a failed/stopped/unknown attempt, explicit retry\ndecision, stop/abandon request, retention request, or uncertain release.\n\n| Proven state            | Safe action                                                        |\n| ----------------------- | ------------------------------------------------------------------ |\n| `ready` or active       | Keep waiting; optionally read bounded output                       |\n| `failed` or `stopped`   | Start a replacement with `--retry-of`; repeat placement explicitly |\n| `outcome_unknown`       | Inspect, then choose `worker-stop` or explicit `worker-abandon`    |\n| Accepted `worker_done`  | Reuse, retain, or release                                          |\n| Remote contact lost     | Preserve `unverifiable`; do not stop or retry from absence alone   |\n| `unverifiable` liveness | Keep waiting or inspect; never stop, abandon, retry, or release    |\n| Proven `exited` agent   | Enumerate with `worker-list`; follow its `nextAction`              |\n\n## Inspect before acting\n\n```text\nORCA orchestration worker-list --run <run_id> --json\nORCA orchestration worker-list --run <run_id> --include-remote --json\nORCA orchestration worker-show --dispatch <dispatch_id> --json\nORCA orchestration worker-read --dispatch <dispatch_id> --limit 50 --json\n```\n\n`worker-list` is the enumerating command and the authority on agent liveness:\neach row carries `projection.liveness`, `projection.attention.categories`,\n`projection.attention.requiresAction`, and a literal `projection.nextAction`\nargv to run. Always scope it with `--run <run_id>`; an unscoped list reports\nevery Dispatch this runtime has ever recorded and buries the live ones.\n`worker-show`'s `observation.status` is PTY liveness only, so a `live` terminal\nwhose agent died at a trust prompt still reads `live` there.\n\nWhen the two disagree, the fleet verdict decides — unless the fleet row is\n`unverifiable` for a reason that names a gap on this client rather than a fact\nabout the worker. `missing_status`, `host_unavailable`, and\n`capability_unsupported` are such gaps: the first means this runtime holds no\nstatus row, the second that it could not ask the execution host at all, and the\nthird that a stale peer answered but lacks the fleet-snapshot capability.\nAgainst any of them, a `worker-show` verdict sourced from the execution host is\nthe better evidence and outranks the row. Only `host_unavailable` is contact\nloss; the other two mean the host was never asked or answered without the\ncapability.\n\nThis never promotes absence. `unverifiable` from either command still authorizes\nnothing — only a positive `live` or `exited` verdict does.\n\nA worker started with `--on <environment>` reads `unverifiable` until you\nenumerate with `--include-remote`, which asks its execution host for the\nverdict. Rows come newest first and past 100 the response pages, so follow\n`page.nextCursor` with `--cursor <value>` until `page.hasMore` is false.\n\n## Stall needs positive evidence\n\nLeave the wait only on positive proof the agent stopped: `exited` liveness, the\nworker's own observation of process exit, or a transcript whose final agent turn\nsent no `worker_done`. Only then choose `worker-stop` or `worker-abandon`.\n\n`unverifiable` is always absence — `missing_status`, `stale_status`,\n`restored_unconfirmed`, or a remote worker with no connection — and a null\n`agentWait` or an unchanged `worker-read` tail is that same absence seen again.\nAbsence never authorizes stop, abandon, retry, or release: keep waiting, or\ninspect until you hold one of the positive signals above. A `nextAction` that\nnames an inspecting command is asking for evidence, not for cleanup.\n\n`worker-read --source auto` uses a proven provider transcript when available and\notherwise returns bounded terminal output with a typed `fallbackReason`.\nContinue with its top-level cursor, which is pinned to that source. If Orca\nreports `source_changed`, restart without the old cursor. A bounded initial\ntranscript tail can return an EOF cursor that follows only newly appended records;\nread `contentComplete`, `clipping`, and `warnings` before assuming omitted older\nrecords are pageable. Never guess a provider session ID, transcript path, or\nremote terminal handle.\n\n## Was the mutation applied?\n\nWhen a mutation's response was lost and named no Dispatch, do not replay blind.\nEvery orchestration mutation accepts `--retry-request <id>`, which reuses one\noperation identity so Orca can replay, join, or recover it instead of starting a\nduplicate. Ask what happened first:\n\n```text\nORCA orchestration request-show --request <request_id> --json\n```\n\n`completed` means the mutation already took effect; read its recorded receipt\ninstead of rerunning. `pending` means the original mutation is still running or\nOrca restarted before recording its outcome; replay the original command with\n`--retry-request <request_id>`. `absent` means this runtime holds no receipt\nunder your caller identity — that is not proof nothing happened, so inspect the\naffected Task, Dispatch, and terminal before deciding whether to retry.\n\nWhen a worker's terminal accepted input but the submit is unconfirmed, use\n`terminal send --wait-submit <seconds>`: it observes the accepted prompt for that\nlong and, on timeout, returns the input-accepted receipt without resending.\n\n## Refused starts\n\n`dispatch` and `worker-start` refuse the following preflight cases with a stable\n`error.code`; read it before choosing a recovery, and treat `error.data.nextSteps`\nas the exact recovery text. Older hosts may omit `data`, so treat every field as\noptional.\n\n| Code                 | Meaning                                                                                                               | Recovery                                                                                                                       |\n| -------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |\n| `task_not_found`     | No Task with that id, or not in the bound Run (`data.taskId`, `data.runId`)                                           | Check `task-list --json`; create the Task with `task-create` if it does not exist                                              |\n| `task_not_startable` | Task cannot start now: not `ready`, or invalid `--retry-of` (`data.status`, `data.unmetDependencies`, `data.retryOf`) | Wait for running dependencies with `check --wait`; retry or unblock failed ones; inspect `dispatch-show` if already dispatched |\n| `inject_rejected`    | `--inject` refused because no recognized agent runs in the target (`data.terminal`, `data.reason`)                    | Start a recognized agent there or pick another terminal; or dispatch without `--inject` and use `terminal send`                |\n| `runtime_error`      | Any other failure, including a target terminal that already owns an active Dispatch                                   | Read the message, inspect state, and do not retry unchanged                                                                    |\n\n## Retry, stop, and abandon\n\nRetry only a positively proven failed or stopped attempt. Name the failed Task\nwith `--task`, since `--spec` creates a new one. Placement is never silently\ninherited:\n\n```text\nORCA orchestration worker-start --task <task_id> --retry-of <dispatch_id> --worktree <explicit_placement> --agent <agent> --json\n```\n\nAfter three consecutive failures for one Task, its dispatch context\ncircuit-breaks and the Task is failed. Do not route around that boundary with a\nnew Run or an unrelated Dispatch.\n\nFor `outcome_unknown`, inspect first, then make an explicit choice:\n\n```text\nORCA orchestration worker-stop --dispatch <dispatch_id> --json\nORCA orchestration worker-abandon --dispatch <dispatch_id> --json\n```\n\n`worker-stop` closes only the exact proven supervised agent terminal. It never\ndeletes the worktree, setup terminal, configured tabs, or unrelated processes.\n`worker-abandon` fences orchestration while accepting that resources may remain\nlive; it performs no remote, process, or filesystem action. When it settles a\nworker, it retains an owned terminal by the same rule as `worker-retain`, so Orca\nstops owing its release; a release already committed (`releasing`,\n`release_unknown`) is left as it is. An already-settled worker is left untouched.\n\nTo cancel a Task, settle its worker with `worker-stop` or `worker-abandon`, then\nrecord the reason. A cancelled Task is `failed`, so its dependents stay blocked\nuntil a `--retry-of` replacement completes it:\n\n```text\nORCA orchestration task-update --id <task_id> --status failed --result cancelled --json\n```\n\n## Retain and release\n\n```text\nORCA orchestration worker-retain --dispatch <dispatch_id> --json\nORCA orchestration worker-release --dispatch <dispatch_id> --json\n```\n\nRetain only when the user explicitly wants the settled terminal kept live.\nRelease works after succeeded and failed reports, archives readable output, and\ncloses only the exact terminal owned by that settled Dispatch. Replays may call\nrelease again safely. Reused, pre-existing, setup, coordinator, active,\nuser-taken-over, and unproven terminals are retained.\n\nA `worker-start` that failed before its agent was ready still owns the terminal\nit created. Its receipt names `worker-release`, and `worker-list` reports that\nrow as `reclaimable`; release it there rather than closing the terminal by hand.\n\nNever release because of timeout, TUI idle, heartbeat, status, question,\nescalation, or stale/rejected completion. If the receipt says `release_pending`\nor `release_unknown`, follow its exact recovery action. Never substitute\n`terminal close`.\n\n`orchestration reset` is destructive recovery. Do not run it during active\ncoordination unless the user explicitly abandons that state.\n\n<!-- bundled-reference: references/worker-contract.md -->\n\n# Worker contract\n\nThe injected preamble is authoritative. Copy its command rather than\nreconstructing flags. In particular, preserve the exact executable, worker\nhandle, Task ID, and Dispatch ID, and keep any other flag it carries (an older\nOrca host adds `--dispatch-capability`).\n\n## Heartbeat\n\nSend heartbeats only at the cadence required by the live preamble. Skip them\nwhile blocked inside `ask` or `check --wait`; those calls are liveness signals.\n\n```text\nORCA orchestration send --from <worker_handle> --type heartbeat --subject \"alive\" --task-id <task_id> --dispatch-id <dispatch_id> --phase \"<investigating|implementing|reviewing|waiting>\"\n```\n\nUse typed lifecycle flags, not a hand-written JSON payload. A heartbeat proves\nliveness, never completion.\n\n## Ask and resume\n\nUse Orca `ask` whenever the coordinator must answer. Never open a local question\nTUI the coordinator cannot answer.\n\n```text\nORCA orchestration ask --from <worker_handle> --question \"<question>\" --options \"<choice-a>,<choice-b>\" --timeout-ms 600000\n\nORCA orchestration ask --from <worker_handle> --resume <message_id> --timeout-ms 600000\n```\n\nA timeout or disconnect leaves the original question pending. Resume its\nmessage ID; do not create a duplicate question.\n\n## Reading coordinator follow-ups\n\nThe coordinator steers a running worker with `send --to dispatch:<id>`. That\nenqueue is durable but does not interrupt you, so nothing arrives unless you\nlook:\n\n```text\nORCA orchestration check --terminal <worker_handle> --json\n```\n\nRun it at each natural checkpoint — before starting a new file, after a test\nrun — and once more immediately before `worker_done`, so a redirect or a\ncancellation lands before the Task settles. `check` names its caller with\n`--terminal`, never `--from`. Stop checking after `worker_done`.\n\nIf `check` returns `consumer_fenced`, this process no longer owns its Dispatch:\nthe Attempt was re-attached to another worker or settled without you. Stop, do\nnot send `worker_done`, and do not retry the check. An empty `check` never means\nyou were replaced; `consumer_fenced` is the only way you learn that.\nIf `send` or `ask` returns `consumer_fenced`, the command ran from another\nparty's terminal (a coordinator or another worker); run it from your own terminal.\n\n## Escalation\n\nEscalate only before completion and only when the coordinator must intervene:\n\n```text\nORCA orchestration send --from <worker_handle> --type escalation --subject \"Blocked: <reason>\" --body \"<details>\" --task-id <task_id> --dispatch-id <dispatch_id>\n```\n\n## Completion\n\nSend exactly one terminal report. `--body` is three sentences: what changed,\nwhat was found, and what remains. Use `--outcome failed` when the requested work\nis not complete; never hide failure in prose or silently exit.\n\nAppend `--files-modified` or `--report-path` only when applicable, using actual\npaths. Do not send documentation placeholders as metadata.\n\n```text\nORCA orchestration send --from <worker_handle> --type worker_done --subject \"<short status>\" --body \"<three sentences: work, findings, remaining>\" --task-id <task_id> --dispatch-id <dispatch_id> --outcome succeeded\n```\n\nAfter `worker_done`, end the dispatched turn and idle. Do not poll, close your\nown terminal, or begin unrelated work. A later direct user instruction is new\nuser-owned work and must not reuse settled lifecycle IDs; a supervised follow-up\narrives with a fresh preamble and Task block.\n"
 
 // oxfmt-ignore
-const ORCHESTRATION_COORDINATOR_LOOP_REFERENCE_MARKDOWN = "# Coordinator loop\n\nLoad this reference for expanded DAG waves, per-invocation launch preferences,\nsame-terminal reuse, or review ownership. The compact guide remains the source\nof truth for the loop order and completion boundary.\n\n## Ready waves\n\nCreate independent Tasks before the first wait. Encode only real dependencies,\nthen use the ready view as external memory:\n\n```text\nORCA orchestration task-create --spec \"<dependent work>\" --deps <json_array> --json\nORCA orchestration task-list --ready --brief --json\n```\n\n`--brief` collapses whitespace and caps echoed specs at 160 characters;\n`spec_truncated` identifies shortened rows. Omit it when full specs are needed or\nwhen an older CLI rejects the flag. A nested worker must respect\n`nested_worker_depth_exceeded`; creating another Run does not reset depth.\n\n## Launch preferences\n\nFor a fresh Claude, Codex, Cursor, Antigravity, or Muse terminal, `--model`\naccepts an opaque provider model ID. Pass it only when the user named a model;\notherwise omit it so the worker inherits the user's configured agent default.\nAdd `--effort` only when that model supports it:\n\n```text\nORCA orchestration worker-start --task <task_id> --worktree current --agent claude --model opus --effort high --json\nORCA orchestration worker-start --task <task_id> --worktree current --agent muse --model muse-spark-1.3 --json\n```\n\nOther agents, including `opencode`, reject `--model`; they run the model set in\ntheir own config, so a coordinator wanting a same-model opencode worker relies\non that config.\n\n`--effort` requires `--model`; neither option combines with `--terminal`. A\nconnected worker server must advertise launch-preference support before Orca\nforwards either field. Compare `launch.requested` with `launch.effective`; never\nclaim a model or effort from requested arguments alone.\n\n## Reuse after settlement\n\nChoose the terminal's next owner before acknowledging the Delivery. When the\nsame exact agent has immediate follow-up work, recover the proven handle and\ntransfer cleanup ownership to the new Dispatch:\n\n```text\nORCA orchestration worker-show --dispatch <dispatch_id> --json\nORCA orchestration worker-start --task <next_task_id> --terminal <agent_terminal_handle> --json\n```\n\nOtherwise explicitly retain or release the settled worker. Do not leave it live\nonly to inspect output; archived output remains available through `worker-read`.\n\n## Review ownership\n\nA review-only `worker_done` authorizes synthesis of findings, not coordinator\nfile edits. Dispatch or hand off fixes unless the user explicitly assigned them\nto the coordinator. If the user's plan names a next owner, post-review fixes and\nPR preparation remain with that owner; the coordinator routes and synthesizes.\n"
+const ORCHESTRATION_COORDINATOR_LOOP_REFERENCE_MARKDOWN = "# Coordinator loop\n\nLoad this reference for expanded DAG waves, per-invocation launch preferences,\nsame-terminal reuse, or review ownership. The compact guide remains the source\nof truth for the loop order and completion boundary.\n\n## Ready waves\n\nCreate independent Tasks before the first wait. Encode only real dependencies,\nthen use the ready view as external memory:\n\n```text\nORCA orchestration task-create --spec \"<dependent work>\" --deps <json_array> --json\nORCA orchestration task-list --ready --brief --json\n```\n\n`--brief` collapses whitespace and caps echoed specs at 160 characters;\n`spec_truncated` identifies shortened rows. Omit it when full specs are needed or\nwhen an older CLI rejects the flag. A nested worker must respect\n`nested_worker_depth_exceeded`; creating another Run does not reset depth.\n\n## Launch preferences\n\nFor a fresh Claude, Codex, Cursor, Antigravity, or Muse terminal, `--model`\naccepts an opaque provider model ID. Pass it only when the user named a model;\notherwise omit it so the worker inherits the user's configured agent default.\nAdd `--effort` only when that model supports it:\n\n```text\nORCA orchestration worker-start --task <task_id> --worktree current --agent claude --model opus --effort high --json\nORCA orchestration worker-start --task <task_id> --worktree current --agent muse --model muse-spark-1.3 --json\n```\n\nOpenCode also accepts `--model` in an existing worktree when the execution host\nverifies its CLI version and model availability. Creating a new worktree with an\nOpenCode model override is unsupported; use `--worktree current` or an existing\nworktree selector, or omit `--model`. OpenCode effort is unsupported. Omit the\nmodel to inherit its configuration; unsupported or unknown hosts refuse the\noverride explicitly.\n\n`--effort` requires `--model`; neither option combines with `--terminal`. A\nconnected worker server must advertise launch-preference support before Orca\nforwards either field. Compare `launch.requested` with `launch.effective`; never\nclaim a model or effort from requested arguments alone.\n\n## Reuse after settlement\n\nChoose the terminal's next owner before acknowledging the Delivery. When the\nsame exact agent has immediate follow-up work, recover the proven handle and\ntransfer cleanup ownership to the new Dispatch:\n\n```text\nORCA orchestration worker-show --dispatch <dispatch_id> --json\nORCA orchestration worker-start --task <next_task_id> --terminal <agent_terminal_handle> --json\n```\n\nOtherwise explicitly retain or release the settled worker. Do not leave it live\nonly to inspect output; archived output remains available through `worker-read`.\n\n## Review ownership\n\nA review-only `worker_done` authorizes synthesis of findings, not coordinator\nfile edits. Dispatch or hand off fixes unless the user explicitly assigned them\nto the coordinator. If the user's plan names a next owner, post-review fixes and\nPR preparation remain with that owner; the coordinator routes and synthesizes.\n"
 
 // oxfmt-ignore
 const ORCHESTRATION_LEGACY_CONTRACT_MIGRATION_REFERENCE_MARKDOWN = "# Legacy contract migration\n\nLoad this reference only for an authority label, adopted Run, compatibility or\nrecovery receipt, or explicit legacy takeover. A newly created attempt always\nuses the current grammar.\n\n## Authority labels\n\n- `[LEGACY COMPATIBILITY]` is live and attested. Run only the exact supported\n  command printed with the message, using the same selected executable and\n  arguments supplied by the original prompt.\n- `[LEGACY RECOVERY REPLAY — MAY HAVE BEEN SEEN]` is one bounded,\n  at-least-once cutover replay. Process it idempotently and acknowledge only\n  through the exact displayed guidance.\n- `[LEGACY READ-ONLY]` is inspection-only. It has no reply, acknowledgment, or\n  lifecycle mutation.\n- An unlabeled current message uses the current guide and grammar.\n\nAn explicitly selected current Run, attested current binding, current Dispatch,\nor federated attachment takes precedence over legacy fallback. A retained\nadoption record alone does not grant mutation authority. If liveness, principal\nownership, capability, or the exact legacy contract is unproven, degrade to\nread-only inspection and never fall back to local execution.\n\nAdoption preserves the live agent process, PTY/session, terminal handle,\ntab/pane, worktree or folder workspace, Task, and Dispatch. It never restarts or\nreplaces the worker and never revives the retired scheduler. Loss of lifecycle\nauthority does not invalidate the existing process, assignment, or filesystem\nwork. Exact recovery may restore the same PTY once in its original inactive\nbackground tab; it must not spawn, write, signal, stop, switch, focus, split, or\ninject a terminal.\n\n## Compatibility recovery\n\nWhen a compatibility response returns structured next-step arguments, execute\nthose exact arguments with the same selected CLI executable. Do not translate\nfrom memory, broaden the recipient, or retry as a current mutation unless the\nreceipt explicitly authorizes it.\n\nA pending ask, reply, final Dispatch settlement, and consuming check have\ndurable recovery identities. Heartbeat and escalation remain at-least-once\nacross a manual contract-boundary retry. If an ask may already have been\nanswered, run the exact non-consuming recovery check printed by Orca before\ncreating any new question. Never guess among identical question threads.\n\nOn packaged Windows, a legacy ask uses a two-step commit/resume protocol. The\ninitial command commits the question, prints its exact\n`ask --resume <message_id>` command, and exits with launcher status `75`. Run\nthat exact resume after the launcher or update boundary. For an attested WSL\nlaunch, preserve the printed `orca-ide` executable and distro route. Older WSL\nworkers without launch proof remain lifecycle read-only even while their\nterminal and filesystem work continue.\n\n## Read-only inspection and takeover\n\nRead-only inspection does not consume mail:\n\n```text\nORCA orchestration run-list --json\nORCA orchestration run-show --id run_legacy_local --json\nORCA orchestration run-show --id <adopted_run_id> --json\nORCA orchestration task-list --run <adopted_run_id> --json\nORCA orchestration inbox --full --json\nORCA orchestration check --terminal <legacy_handle> --peek --format --json\nORCA terminal read --terminal <legacy_handle> --json\nORCA terminal wait --terminal <legacy_handle> --for tui-idle --timeout-ms 60000 --json\n```\n\n`run_legacy_local` is an empty audit tombstone after adoption. Find the ordinary\nRun whose objective is `Recovered orchestration work from a contract update`.\n\nOnly when the original coordinator is unavailable or cannot prove retained\nauthority may a new live coordinator take over from its own terminal:\n\n```text\nORCA orchestration run-use --id <adopted_run_id> --takeover-legacy --json\nORCA orchestration check --run <adopted_run_id> --json\n```\n\nTakeover binds the authenticated invoking terminal; `--from` cannot nominate\nanother coordinator. It fences only the old coordinator and moves pending mail\ninto current Run delivery. It preserves live workers, Tasks, Dispatches, processes, and files.\nNever take over while the original coordinator is actively coordinating.\n\nDo not launch a replacement editor merely because Orca updated or authority is\nunclear. Keep the original worker as the only editor until a stable handoff\npoint, then use a fresh current Dispatch in a conflict-free placement.\n"
diff --git a/src/cli/specs/orchestration-worker-specs.ts b/src/cli/specs/orchestration-worker-specs.ts
index a03bd6c8023..43674b9d757 100644
--- a/src/cli/specs/orchestration-worker-specs.ts
+++ b/src/cli/specs/orchestration-worker-specs.ts
@@ -36,7 +36,7 @@ export const ORCHESTRATION_WORKER_COMMAND_SPECS: CommandSpec[] = [
       'Current and existing worktrees never rerun setup; a fresh agent terminal is created unless --terminal is explicit.',
       'When reusing --terminal, pass --worktree for that terminal; current means the coordinator worktree.',
       '--agent takes an Orca agent id enabled on the worker server, such as claude, codex, cursor, antigravity, muse, zcode, opencode, or opencode2.',
-      '--model supports Claude, Codex, Cursor, Antigravity, and Muse opaque provider model ids; --effort requires --model. OMP accepts --model only; --effort is unsupported. Neither can combine with --terminal. Other agents, including opencode and zcode, launch with the model from their own config.',
+      '--model supports Claude, Codex, Cursor, Antigravity, and Muse opaque provider model ids; --effort requires --model. OMP accepts --model only; --effort is unsupported. Neither can combine with --terminal. OpenCode model selection requires an existing worktree, a verified execution-host CLI, and an available model; effort is unsupported. Other agents, including zcode, launch with the model from their own config.',
       'New worktrees use agent-first creation and default --setup to run. Repository start-immediately runs setup beside the agent; wait-for-setup gates agent readiness and task input.',
       'Creation flags (--name, --repo, --base-branch, --display-name, --comment, --setup) are rejected for current/existing worktrees. Use exact --repo on the selected server; project/host convenience routing remains on worktree create.',
       "How the worker runs follows the user's own setting for new agent tabs; there is no flag for it and no caller needs to ask. A dispatch the setting cannot apply to still starts, so the placement, agent, and launch options passed here are always the ones honoured.",
diff --git a/src/main/agent-launch/__fixtures__/host-agent-startup-call-sites.txt b/src/main/agent-launch/__fixtures__/host-agent-startup-call-sites.txt
index de078fd731e..193c69c2765 100644
--- a/src/main/agent-launch/__fixtures__/host-agent-startup-call-sites.txt
+++ b/src/main/agent-launch/__fixtures__/host-agent-startup-call-sites.txt
@@ -2,9 +2,8 @@
 #   attributes      a fresh agent the host builds; carries agentStartedTelemetry
 #   resume          continues an existing agent session; not a new start
 #   mobile-followup the phone's session-tab launch; attribution is a separate follow-up
-# The resolve-worktree-removal-target call also serves a bare typed command, which stays unattributed.
-src/main/runtime/orca-runtime-create-agent-session.ts 2 attributes
-src/main/runtime/orca-runtime-resolve-worktree-removal-target.ts 1 attributes
+# The shared execution-host builder also serves bare commands; only fresh-agent callers supply attribution.
+src/main/opencode/opencode-model-startup-plan.ts 2 attributes
 src/main/runtime/runtime-worktree-agent-startup.ts 3 attributes
 src/main/runtime/orca-runtime-get-agent-session-execution-namespace.ts 1 resume
 src/main/runtime/orca-runtime-resolve-mobile-session-terminal-command.ts 1 mobile-followup
diff --git a/src/main/agent-launch/agent-launch-executor.ts b/src/main/agent-launch/agent-launch-executor.ts
index 1d9bae4f45d..ac1511d1258 100644
--- a/src/main/agent-launch/agent-launch-executor.ts
+++ b/src/main/agent-launch/agent-launch-executor.ts
@@ -25,6 +25,7 @@
  * is injected as a factory instead of branched on here.
  */
 
+import { assertOpenCodeModelLaunchPreferencesAbsent } from '../opencode/opencode-model-startup-plan'
 import { parsePaneKey } from '../../shared/stable-pane-id'
 import type {
   AgentLaunchIntent,
@@ -76,6 +77,9 @@ export async function executeAgentLaunch(
   execution: AgentLaunchExecution
 ): Promise<AgentLaunchResult> {
   const { intent, runtime } = execution
+  if (intent.reuseTerminal || intent.target.kind === 'create-worktree') {
+    assertOpenCodeModelLaunchPreferencesAbsent(intent.agent, intent.sessionOptions)
+  }
   const vocabulary = execution.vocabulary ?? DEFAULT_LAUNCH_VOCABULARY
   const settings = readAgentLaunchModeSettings(runtime)
   const preflight = decideAgentLaunchMode({
diff --git a/src/main/agent-launch/agent-launch-opencode-model.test.ts b/src/main/agent-launch/agent-launch-opencode-model.test.ts
new file mode 100644
index 00000000000..39906f8c779
--- /dev/null
+++ b/src/main/agent-launch/agent-launch-opencode-model.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { AgentLaunchIntent } from '../../shared/agent-launch-intent'
+import { executeAgentLaunch } from './agent-launch-executor'
+
+function harness() {
+  const readSettings = vi.fn(() => {
+    throw new Error('settings_not_needed_for_refusal')
+  })
+  const createSupport = vi.fn(async () => {
+    throw new Error('support_not_needed_for_refusal')
+  })
+  const createTerminal = vi.fn(async () => ({ handle: 'term_new' }))
+  const deliverPrompt = vi.fn(async () => true)
+  const createWorktree = vi.fn(async () => ({
+    worktreeId: 'wt_new',
+    startupTerminalHandle: 'term_new'
+  }))
+  return {
+    readSettings,
+    createTerminal,
+    deliverPrompt,
+    createWorktree,
+    run: (intent: AgentLaunchIntent) =>
+      executeAgentLaunch({
+        intent,
+        runtime: {
+          getClientSettings: readSettings,
+          getStructuredAgentSessionCreateSupport: createSupport
+        },
+        surfaces: {
+          createTerminalAgent: createTerminal,
+          createStructuredSession: async () => {
+            throw new Error('structured_not_expected')
+          },
+          deliverTerminalPrompt: deliverPrompt
+        },
+        workspaces: { createWorktree }
+      })
+  }
+}
+
+const reused: AgentLaunchIntent = {
+  agent: 'opencode',
+  target: { kind: 'existing', worktree: 'folder:private' },
+  reuseTerminal: { handle: 'term_existing' },
+  prompt: { text: 'Read only', delivery: 'submit' },
+  sessionOptions: { model: 'private-proof/model-b' }
+}
+const creating: AgentLaunchIntent = {
+  ...reused,
+  reuseTerminal: undefined,
+  target: { kind: 'create-worktree', create: { repo: 'id:private', name: 'task' } }
+}
+
+describe('OpenCode model preferences on unsupported launch placements', () => {
+  it.each([reused, creating])(
+    'refuses before reading settings or creating or delivering',
+    async (intent) => {
+      const h = harness()
+      await expect(h.run(intent)).rejects.toMatchObject({ code: 'capability_unsupported' })
+      expect(h.readSettings).not.toHaveBeenCalled()
+      expect(h.createTerminal).not.toHaveBeenCalled()
+      expect(h.createWorktree).not.toHaveBeenCalled()
+      expect(h.deliverPrompt).not.toHaveBeenCalled()
+    }
+  )
+
+  it('preserves prompt delivery to a reused terminal without model preferences', async () => {
+    const h = harness()
+    expect((await h.run({ ...reused, sessionOptions: undefined })).outcome).toEqual({
+      kind: 'terminal',
+      handle: 'term_existing'
+    })
+    expect(h.deliverPrompt).toHaveBeenCalledOnce()
+    expect(h.createWorktree).not.toHaveBeenCalled()
+  })
+
+  it('preserves ordinary worktree creation without model preferences', async () => {
+    const h = harness()
+    expect((await h.run({ ...creating, sessionOptions: undefined })).worktreeId).toBe('wt_new')
+    expect(h.createWorktree).toHaveBeenCalledOnce()
+  })
+})
diff --git a/src/main/ai-vault-search/session-search-scope-entry-points.test.ts b/src/main/ai-vault-search/session-search-scope-entry-points.test.ts
index 0eefb2fd498..3b470e75138 100644
--- a/src/main/ai-vault-search/session-search-scope-entry-points.test.ts
+++ b/src/main/ai-vault-search/session-search-scope-entry-points.test.ts
@@ -1,3 +1,4 @@
+import '../runtime/rpc/unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it } from 'vitest'
 import { AiVaultHandler } from '../../relay/ai-vault-handler'
 import type { RelayDispatcher } from '../../relay/dispatcher'
diff --git a/src/main/ai-vault/local-log-tail-reader.ts b/src/main/ai-vault/local-log-tail-reader.ts
index 3045981e5c5..9044a64e833 100644
--- a/src/main/ai-vault/local-log-tail-reader.ts
+++ b/src/main/ai-vault/local-log-tail-reader.ts
@@ -1,4 +1,5 @@
 import { open } from 'node:fs/promises'
+import { LOCAL_READ_OPEN_FLAGS } from '../ipc/filesystem/local-regular-file-read'
 import {
   LOCAL_LOG_TAIL_CHUNK_BYTES,
   type LocalLogTailReadResult
@@ -23,7 +24,7 @@ export async function readLocalLogTailRange(
     throw new Error('Invalid local log tail byte offset')
   }
 
-  const handle = await open(filePath, 'r')
+  const handle = await open(filePath, LOCAL_READ_OPEN_FLAGS)
   try {
     const initialStats = await handle.stat()
     if (!initialStats.isFile()) {
diff --git a/src/main/ai-vault/session-document-stream-contract.test.ts b/src/main/ai-vault/session-document-stream-contract.test.ts
index 3ab4053b303..d0aee7cf305 100644
--- a/src/main/ai-vault/session-document-stream-contract.test.ts
+++ b/src/main/ai-vault/session-document-stream-contract.test.ts
@@ -110,13 +110,29 @@ describe('streamed session document contracts', () => {
     }
   )
 
-  it.each(['null', '[]', '123', '"text"'])(
+  it.each(['null', '[]', '[{}]', '123', '"text"', '"{}"'])(
     'does not publish a nonobject document %s',
     async (content) => {
       expect(await read(content)).toBeNull()
     }
   )
 
+  it('recognizes an object root after whitespace and empty byte chunks', async () => {
+    async function* padded() {
+      yield Buffer.alloc(0)
+      yield Buffer.from(' \t')
+      yield Buffer.from('\r\n')
+      yield Buffer.alloc(0)
+      yield* bytes('{"id":"日本語😀","messages":[1]}', 1)
+      yield Buffer.alloc(0)
+      yield Buffer.from(' \n')
+    }
+    expect(await read('', { bytes: padded() })).toEqual({
+      record: { id: '日本語😀' },
+      state: [1]
+    })
+  })
+
   it('validates discarded subtrees and closes their source on malformed input', async () => {
     let closed = false
     async function* malformed() {
diff --git a/src/main/ai-vault/session-document-stream.ts b/src/main/ai-vault/session-document-stream.ts
index 4fcf24f7a55..b8af9738617 100644
--- a/src/main/ai-vault/session-document-stream.ts
+++ b/src/main/ai-vault/session-document-stream.ts
@@ -115,15 +115,8 @@ export async function readStreamedSessionDocument<T>(args: {
     assembler.consume(token)
   })
   const decoder = new StringDecoder('utf8')
-  let objectRoot: boolean | undefined
   for await (const chunk of args.bytes) {
     throwIfAiVaultScanCancelled(args.signal)
-    if (objectRoot === undefined) {
-      const first = chunk.find((byte) => byte !== 32 && byte !== 9 && byte !== 10 && byte !== 13)
-      if (first !== undefined) {
-        objectRoot = first === 123
-      }
-    }
     parser.write(decoder.write(chunk))
     await yieldToEventLoop()
   }
@@ -136,5 +129,5 @@ export async function readStreamedSessionDocument<T>(args: {
   if (consumeFailure) {
     throw consumeFailure.error
   }
-  return objectRoot ? { record, state } : null
+  return assembler.current === record ? { record, state } : null
 }
diff --git a/src/main/ai-vault/session-scanner-opencode-cancellation.test.ts b/src/main/ai-vault/session-scanner-opencode-cancellation.test.ts
index 4f47af380cd..084a73cd661 100644
--- a/src/main/ai-vault/session-scanner-opencode-cancellation.test.ts
+++ b/src/main/ai-vault/session-scanner-opencode-cancellation.test.ts
@@ -1,4 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import type * as workerSpawn from './session-scanner-opencode-sqlite-worker-spawn'
 import type { SessionFileDiscovery } from './session-scanner-types'
 import type { TranscriptReadOutcome } from './session-transcript-consumers'
@@ -24,6 +27,7 @@ import {
   registerTranscriptConsumer,
   resetTranscriptConsumersForTests
 } from './session-transcript-consumers'
+import { runOpenCodeSqliteScanRequest } from './session-scanner-opencode-sqlite-scan-scope'
 
 const file = {
   path: '/fixture/opencode.db#session',
@@ -40,6 +44,7 @@ beforeEach(() => {
   resetSessionParseCacheForTests()
 })
 afterEach(() => {
+  vi.useRealTimers()
   resetTranscriptConsumersForTests()
   resetSessionParseCacheForTests()
 })
@@ -48,7 +53,11 @@ function configure(agent: 'opencode' | 'opencode2') {
   readers.discover.mockResolvedValue([{ agent, rootDir: '/fixture', files: [file] }])
   const accumulator = createAccumulator({ agent, file, sessionId: 'session' })
   accumulator.title = 'SQLite session'
-  return finalizeSession(accumulator, 'linux')
+  const session = finalizeSession(accumulator, 'linux')
+  if (!session) {
+    throw new Error('Configured SQLite session was empty')
+  }
+  return session
 }
 
 function untilAborted(signal: AbortSignal | undefined): Promise<never> {
@@ -61,6 +70,83 @@ function untilAborted(signal: AbortSignal | undefined): Promise<never> {
 }
 
 describe.each(['opencode', 'opencode2'] as const)('%s scan cancellation', (agent) => {
+  it('reports a deadline while retaining completed sessions and other agents, then retries', async () => {
+    vi.useFakeTimers()
+    const root = mkdtempSync(join(tmpdir(), 'orca-scan-deadline-'))
+    try {
+      const session = configure(agent)
+      const blocked = { ...file, path: '/fixture/opencode.db#blocked' }
+      const claudePath = join(root, 'claude.jsonl')
+      writeFileSync(
+        claudePath,
+        `${JSON.stringify({
+          type: 'user',
+          sessionId: 'retained-claude',
+          timestamp: '2026-05-01T10:00:00.000Z',
+          cwd: root,
+          message: { role: 'user', content: 'Retain this other-agent session' }
+        })}\n`
+      )
+      readers.discover.mockResolvedValue([
+        { agent, rootDir: '/fixture', files: [file, blocked] },
+        { agent: 'claude', rootDir: root, files: [{ ...file, path: claudePath }] }
+      ])
+      readers.parse.mockImplementation(({ sessionId, signal }) =>
+        sessionId === 'blocked'
+          ? runOpenCodeSqliteScanRequest(signal, untilAborted)
+          : Promise.resolve(session)
+      )
+      const pending = scanAiVaultSessions({ platform: 'linux' })
+      await vi.waitFor(() => expect(readers.parse).toHaveBeenCalledTimes(2))
+      await vi.advanceTimersByTimeAsync(45_000)
+      const result = await pending
+      expect(result.sessions.map((row) => row.sessionId)).toEqual(
+        expect.arrayContaining(['session', 'retained-claude'])
+      )
+      expect(result.sessions).toHaveLength(2)
+      expect(result.issues).toEqual([
+        expect.objectContaining({
+          agent,
+          path: blocked.path,
+          message: expect.stringContaining('45s work budget')
+        })
+      ])
+      readers.parse.mockResolvedValue({ ...session, sessionId: 'blocked', filePath: blocked.path })
+      const recovered = await scanAiVaultSessions({ platform: 'linux' })
+      expect(recovered.sessions).toHaveLength(3)
+      expect(
+        readers.parse.mock.calls.filter(([args]) => args.sessionId === 'blocked')
+      ).toHaveLength(2)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('marks a deadline capture incomplete instead of caching a failed history', async () => {
+    vi.useFakeTimers()
+    const session = configure(agent)
+    const outcomes: TranscriptReadOutcome[] = []
+    registerTranscriptConsumer({
+      beginRead: () => ({ message() {}, finish: (outcome) => outcomes.push(outcome) })
+    })
+    readers.capture.mockImplementationOnce(({ signal }) =>
+      runOpenCodeSqliteScanRequest(signal, untilAborted)
+    )
+    const pending = scanAiVaultSessions({ platform: 'linux' })
+    await vi.waitFor(() => expect(readers.capture).toHaveBeenCalledOnce())
+    await vi.advanceTimersByTimeAsync(45_000)
+    const result = await pending
+    expect(result.sessions).toEqual([])
+    expect(result.issues).toEqual([
+      expect.objectContaining({ message: expect.stringContaining('45s work budget') })
+    ])
+    expect(outcomes).toEqual([{ session: null, byteOffset: 0, incomplete: true }])
+    readers.capture.mockResolvedValue({ session, messages })
+    expect((await scanAiVaultSessions({ platform: 'linux' })).sessions).toHaveLength(1)
+    expect(readers.capture).toHaveBeenCalledTimes(2)
+    expect(outcomes.at(-1)?.incomplete).toBe(false)
+  })
+
   it.each(['parse', 'capture'] as const)(
     'cancels an active %s and retries the uncached read',
     async (mode) => {
diff --git a/src/main/ai-vault/session-scanner-opencode-sqlite-scan-scope.test.ts b/src/main/ai-vault/session-scanner-opencode-sqlite-scan-scope.test.ts
new file mode 100644
index 00000000000..bc97f1aa388
--- /dev/null
+++ b/src/main/ai-vault/session-scanner-opencode-sqlite-scan-scope.test.ts
@@ -0,0 +1,138 @@
+import { afterEach, expect, it, vi } from 'vitest'
+import {
+  OPENCODE_SQLITE_SCAN_BUDGET_MS,
+  runOpenCodeSqliteScanRequest,
+  withOpenCodeSqliteScanScope
+} from './session-scanner-opencode-sqlite-scan-scope'
+
+afterEach(() => vi.useRealTimers())
+
+function waitForAbort(signal: AbortSignal | undefined): Promise<never> {
+  if (!signal) {
+    throw new Error('Missing scoped request signal')
+  }
+  return new Promise((_resolve, reject) => {
+    signal.addEventListener('abort', () => reject(signal.reason), { once: true })
+  })
+}
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+it('spends the budget while admission is pending and refuses later work in that scan', async () => {
+  vi.useFakeTimers()
+  const admitted = vi.fn()
+  const outcome = withOpenCodeSqliteScanScope(async () => {
+    const error = await runOpenCodeSqliteScanRequest(undefined, waitForAbort).catch((err) => err)
+    expect(error).toMatchObject({ name: 'OpenCodeSqliteScanDeadlineError' })
+    await expect(runOpenCodeSqliteScanRequest(undefined, admitted)).rejects.toBe(error)
+  })
+  await vi.advanceTimersByTimeAsync(OPENCODE_SQLITE_SCAN_BUDGET_MS)
+  await outcome
+  expect(admitted).not.toHaveBeenCalled()
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+it('banks only outstanding work across legs and does not spend other-agent time', async () => {
+  vi.useFakeTimers()
+  const outcome = withOpenCodeSqliteScanScope(async () => {
+    await runOpenCodeSqliteScanRequest(undefined, () => wait(20_000))
+    await wait(70_000)
+    return runOpenCodeSqliteScanRequest(undefined, waitForAbort)
+  }).catch((error) => error)
+  await vi.advanceTimersByTimeAsync(90_000)
+  let completed = false
+  void outcome.then(() => {
+    completed = true
+  })
+  await vi.advanceTimersByTimeAsync(24_999)
+  expect(completed).toBe(false)
+  await vi.advanceTimersByTimeAsync(1)
+  expect(await outcome).toMatchObject({ name: 'OpenCodeSqliteScanDeadlineError' })
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+it('counts overlapping preparation and worker waits once', async () => {
+  vi.useFakeTimers()
+  const outcome = withOpenCodeSqliteScanScope(() =>
+    runOpenCodeSqliteScanRequest(undefined, () =>
+      Promise.all([
+        runOpenCodeSqliteScanRequest(undefined, waitForAbort),
+        runOpenCodeSqliteScanRequest(undefined, waitForAbort)
+      ])
+    )
+  ).catch((error) => error)
+  await vi.advanceTimersByTimeAsync(OPENCODE_SQLITE_SCAN_BUDGET_MS - 1)
+  expect(vi.getTimerCount()).toBe(1)
+  await vi.advanceTimersByTimeAsync(1)
+  expect(await outcome).toMatchObject({ name: 'OpenCodeSqliteScanDeadlineError' })
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+it('keeps concurrent scans independent and gives the next scan a fresh owner and budget', async () => {
+  vi.useFakeTimers()
+  const owners: unknown[] = []
+  const first = withOpenCodeSqliteScanScope(() =>
+    runOpenCodeSqliteScanRequest(undefined, (signal, owner) => {
+      owners.push(owner)
+      return waitForAbort(signal)
+    })
+  ).catch((error) => error)
+  await vi.advanceTimersByTimeAsync(30_000)
+  const second = withOpenCodeSqliteScanScope(() =>
+    runOpenCodeSqliteScanRequest(undefined, (signal, owner) => {
+      owners.push(owner)
+      return waitForAbort(signal)
+    })
+  ).catch((error) => error)
+  await vi.advanceTimersByTimeAsync(15_000)
+  expect(await first).toMatchObject({ name: 'OpenCodeSqliteScanDeadlineError' })
+  expect(vi.getTimerCount()).toBe(1)
+  await vi.advanceTimersByTimeAsync(30_000)
+  expect(await second).toMatchObject({ name: 'OpenCodeSqliteScanDeadlineError' })
+  await withOpenCodeSqliteScanScope(() =>
+    runOpenCodeSqliteScanRequest(undefined, async (_signal, owner) => {
+      owners.push(owner)
+    })
+  )
+  expect(new Set(owners).size).toBe(3)
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+it('preserves the caller cancellation reason and disposes its timer', async () => {
+  vi.useFakeTimers()
+  const controller = new AbortController()
+  const reason = new Error('caller cancelled')
+  const outcome = withOpenCodeSqliteScanScope(() =>
+    runOpenCodeSqliteScanRequest(controller.signal, waitForAbort)
+  ).catch((error) => error)
+  controller.abort(reason)
+  expect(await outcome).toBe(reason)
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+it('leaves unrelated native-chat and Zcode calls unscoped and retires the scan signal', async () => {
+  vi.useFakeTimers()
+  let scopedSignal: AbortSignal | undefined
+  const caller = new AbortController()
+  await withOpenCodeSqliteScanScope(async () => {
+    for (const agent of ['zcode', 'native-chat'] as const) {
+      await runOpenCodeSqliteScanRequest(
+        caller.signal,
+        async (signal, owner) => {
+          expect(signal).toBe(caller.signal)
+          expect(owner).toBeUndefined()
+          expect(vi.getTimerCount()).toBe(0)
+        },
+        agent
+      )
+    }
+    await runOpenCodeSqliteScanRequest(undefined, async (signal) => {
+      scopedSignal = signal
+    })
+  })
+  expect(scopedSignal?.aborted).toBe(true)
+  expect(caller.signal.aborted).toBe(false)
+  expect(vi.getTimerCount()).toBe(0)
+})
diff --git a/src/main/ai-vault/session-scanner-opencode-sqlite-scan-scope.ts b/src/main/ai-vault/session-scanner-opencode-sqlite-scan-scope.ts
new file mode 100644
index 00000000000..e3a53a535b2
--- /dev/null
+++ b/src/main/ai-vault/session-scanner-opencode-sqlite-scan-scope.ts
@@ -0,0 +1,75 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { throwIfSignalAborted } from '../../shared/abort-signal-reason'
+import type { WorkerThreadRequestOwner } from '../worker-thread-request-queue'
+
+export const OPENCODE_SQLITE_SCAN_BUDGET_MS = 45_000
+
+class OpenCodeSqliteScanScope implements WorkerThreadRequestOwner {
+  private readonly controller = new AbortController()
+  readonly signal = this.controller.signal
+  private remainingMs = OPENCODE_SQLITE_SCAN_BUDGET_MS
+  private outstanding = 0
+  private armedAt = 0
+  private timer: NodeJS.Timeout | undefined
+
+  async run<T>(
+    callerSignal: AbortSignal | undefined,
+    fn: (signal: AbortSignal, owner: WorkerThreadRequestOwner) => Promise<T>
+  ): Promise<T> {
+    throwIfSignalAborted(callerSignal)
+    throwIfSignalAborted(this.signal)
+    if (this.outstanding++ === 0) {
+      this.armedAt = Date.now()
+      this.timer = setTimeout(() => {
+        const error = new Error(
+          `OpenCode SQLite scan exceeded its ${OPENCODE_SQLITE_SCAN_BUDGET_MS / 1000}s work budget`
+        )
+        error.name = 'OpenCodeSqliteScanDeadlineError'
+        this.controller.abort(error)
+      }, this.remainingMs)
+      this.timer.unref?.()
+    }
+    const signal = callerSignal ? AbortSignal.any([callerSignal, this.signal]) : this.signal
+    try {
+      return await fn(signal, this)
+    } finally {
+      if (--this.outstanding === 0) {
+        this.pause()
+      }
+    }
+  }
+
+  dispose(): void {
+    this.pause()
+    this.controller.abort(new Error('OpenCode SQLite scan ended'))
+  }
+
+  private pause(): void {
+    if (this.timer) {
+      clearTimeout(this.timer)
+      this.timer = undefined
+      this.remainingMs = Math.max(0, this.remainingMs - (Date.now() - this.armedAt))
+    }
+  }
+}
+
+const scanScope = new AsyncLocalStorage<OpenCodeSqliteScanScope>()
+
+export async function withOpenCodeSqliteScanScope<T>(fn: () => Promise<T>): Promise<T> {
+  const scope = new OpenCodeSqliteScanScope()
+  try {
+    return await scanScope.run(scope, fn)
+  } finally {
+    scope.dispose()
+  }
+}
+
+// The clock covers outstanding SQLite work, including admission and WSL preparation.
+export function runOpenCodeSqliteScanRequest<T>(
+  signal: AbortSignal | undefined,
+  fn: (signal?: AbortSignal, owner?: WorkerThreadRequestOwner) => Promise<T>,
+  agent?: 'opencode2' | 'zcode' | 'native-chat'
+): Promise<T> {
+  const scope = agent === 'zcode' || agent === 'native-chat' ? undefined : scanScope.getStore()
+  return scope ? scope.run(signal, fn) : fn(signal)
+}
diff --git a/src/main/ai-vault/session-scanner-opencode-sqlite-worker-client.test.ts b/src/main/ai-vault/session-scanner-opencode-sqlite-worker-client.test.ts
index 93df4ed987c..68fb8d09d90 100644
--- a/src/main/ai-vault/session-scanner-opencode-sqlite-worker-client.test.ts
+++ b/src/main/ai-vault/session-scanner-opencode-sqlite-worker-client.test.ts
@@ -12,6 +12,7 @@ import type {
   OpenCodeSqliteWorkerResponse
 } from './session-scanner-opencode-sqlite-worker-protocol'
 import type { AiVaultScanIssue } from '../../shared/ai-vault-types'
+import { withOpenCodeSqliteScanScope } from './session-scanner-opencode-sqlite-scan-scope'
 
 // A worker_threads stand-in the tests drive directly: it records posted requests
 // and lets a test emit message/error/exit without a built worker bundle.
@@ -75,6 +76,63 @@ function makeFactory(workers: FakeWorker[]): () => Worker {
 }
 
 describe('OpenCodeSqliteWorkerClient', () => {
+  it('expires a scan in the FIFO without cancelling ordinary reads or a later scan', async () => {
+    vi.useFakeTimers()
+    const workers: FakeWorker[] = []
+    const client = new OpenCodeSqliteWorkerClient({ workerFactory: makeFactory(workers), log() {} })
+    const issues: AiVaultScanIssue[] = []
+    try {
+      const ordinary = [1, 2].map((id) =>
+        client.list({
+          dbPaths: [`/ordinary-${id}.db`],
+          limit: 1,
+          issues: []
+        })
+      )
+      const scan = withOpenCodeSqliteScanScope(() =>
+        client.list({
+          dbPaths: ['/scan.db'],
+          limit: 1,
+          issues
+        })
+      )
+      await vi.advanceTimersByTimeAsync(25_000)
+      workers[0].emit('message', {
+        id: workers[0].lastId(),
+        ok: true,
+        value: { candidates: [], issues: [] }
+      })
+      await vi.advanceTimersByTimeAsync(20_000)
+      await expect(scan).resolves.toEqual([])
+      expect(issues).toEqual([
+        expect.objectContaining({
+          kind: 'scope',
+          message: expect.stringContaining('45s work budget')
+        })
+      ])
+      expect(workers[0].postedRequests).toHaveLength(2)
+      expect(workers[0].terminated).toBe(false)
+      workers[0].emit('message', {
+        id: workers[0].lastId(),
+        ok: true,
+        value: { candidates: [], issues: [] }
+      })
+      await expect(Promise.all(ordinary)).resolves.toEqual([[], []])
+      const next = withOpenCodeSqliteScanScope(() =>
+        client.list({ dbPaths: ['/next.db'], limit: 1, issues: [] })
+      )
+      workers[0].emit('message', {
+        id: workers[0].lastId(),
+        ok: true,
+        value: { candidates: [], issues: [] }
+      })
+      await expect(next).resolves.toEqual([])
+    } finally {
+      client.dispose()
+      vi.useRealTimers()
+    }
+  })
+
   it('correlates responses by id and ignores stale ids', async () => {
     const workers: FakeWorker[] = []
     const client = new OpenCodeSqliteWorkerClient({ workerFactory: makeFactory(workers), log() {} })
@@ -188,7 +246,7 @@ describe('OpenCodeSqliteWorkerClient', () => {
       client.list({ dbPaths: ['/tmp/opencode.db'], limit: 10, issues: listIssues })
     ).resolves.toEqual([])
     expect(
-      listIssues.some((issue) => /background scanner could not start/.test(issue.message))
+      listIssues.some((issue) => issue.message.includes('background scanner could not start'))
     ).toBe(true)
     await expect(
       client.parse({ dbPath: '/tmp/opencode.db', sessionId: 'ses_skipped', platform: 'darwin' })
@@ -264,7 +322,7 @@ describe('OpenCodeSqliteWorkerClient', () => {
     const first = await client.list({ dbPaths: ['/db'], limit: 10, issues: firstIssues })
     expect(first).toEqual([])
     expect(
-      firstIssues.some((issue) => /background scanner could not start/.test(issue.message))
+      firstIssues.some((issue) => issue.message.includes('background scanner could not start'))
     ).toBe(true)
     await expect(
       client.parse({ dbPath: '/db', sessionId: 'ses_heal', platform: 'darwin' })
diff --git a/src/main/ai-vault/session-scanner-opencode-sqlite-worker-client.ts b/src/main/ai-vault/session-scanner-opencode-sqlite-worker-client.ts
index f303de52443..c6a85cb58b0 100644
--- a/src/main/ai-vault/session-scanner-opencode-sqlite-worker-client.ts
+++ b/src/main/ai-vault/session-scanner-opencode-sqlite-worker-client.ts
@@ -12,6 +12,7 @@ import type {
 import { parseOpenCodeSqliteCaptureValue } from './session-scanner-opencode-sqlite-worker-response'
 import type { SessionFileCandidate } from './session-scanner-types'
 import { errorMessage } from './session-scanner-values'
+import { runOpenCodeSqliteScanRequest } from './session-scanner-opencode-sqlite-scan-scope'
 
 // Why (#8864): a lazily-spawned, unref'd worker runs OpenCode SQLite reads off
 // the main-process event loop. This module owns only the OpenCode legs; the
@@ -117,7 +118,8 @@ export class OpenCodeSqliteWorkerClient {
           ...(args.agent ? { agent: args.agent } : {})
         }),
         LIST_TIMEOUT_MS,
-        args.signal
+        args.signal,
+        args.agent
       )) as OpenCodeSqliteListValue
       args.issues.push(...value.issues)
       return value.candidates
@@ -178,7 +180,8 @@ export class OpenCodeSqliteWorkerClient {
           ...(args.agent ? { agent: args.agent } : {})
         }),
         PARSE_TIMEOUT_MS,
-        args.signal
+        args.signal,
+        args.agent
       )
       // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the worker's parse leg returns exactly this, built by the repo's own reader on the other side of a structured clone.
       return value as AiVaultSession | null
@@ -217,7 +220,8 @@ export class OpenCodeSqliteWorkerClient {
           ...(args.agent ? { agent: args.agent } : {})
         }),
         CAPTURE_TIMEOUT_MS,
-        args.signal
+        args.signal,
+        args.agent
       )
       return parseOpenCodeSqliteCaptureValue(value)
     } catch (err) {
@@ -229,7 +233,12 @@ export class OpenCodeSqliteWorkerClient {
     args: Omit<OpenCodeNativeChatReadRequest, 'id'>,
     signal?: AbortSignal
   ): Promise<OpenCodeNativeChatReadValue> {
-    const value = await this.dispatch((id) => ({ ...args, id }), PARSE_TIMEOUT_MS, signal)
+    const value = await this.dispatch(
+      (id) => ({ ...args, id }),
+      PARSE_TIMEOUT_MS,
+      signal,
+      'native-chat'
+    )
     // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: Only this build's internal worker dispatch constructs page/signal results; they are not client-supplied paths or frames.
     return value as OpenCodeNativeChatReadValue
   }
@@ -241,13 +250,20 @@ export class OpenCodeSqliteWorkerClient {
   private async dispatch(
     buildRequest: (id: number) => OpenCodeSqliteWorkerRequest,
     timeoutMs: number,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    agent?: 'opencode2' | 'zcode' | 'native-chat'
   ): Promise<unknown> {
     const deadline = this.requestTimeoutMs ?? timeoutMs
-    const response = await this.requests.dispatch(
-      (id) => ({ ...buildRequest(id), timeoutMs: deadline }),
-      deadline,
-      signal
+    const response = await runOpenCodeSqliteScanRequest(
+      signal,
+      (requestSignal, owner) =>
+        this.requests.dispatch(
+          (id) => ({ ...buildRequest(id), timeoutMs: deadline }),
+          deadline,
+          requestSignal,
+          owner
+        ),
+      agent
     )
     if (!response.ok) {
       throw new Error(response.error)
diff --git a/src/main/ai-vault/session-scanner-opencode-sqlite-worker-spawn.ts b/src/main/ai-vault/session-scanner-opencode-sqlite-worker-spawn.ts
index 13b9cd3cd5e..e89a6361b1e 100644
--- a/src/main/ai-vault/session-scanner-opencode-sqlite-worker-spawn.ts
+++ b/src/main/ai-vault/session-scanner-opencode-sqlite-worker-spawn.ts
@@ -16,6 +16,7 @@ import {
   openCodeWslPath
 } from './session-scanner-opencode-wsl-client'
 import { findForeignSqliteReaderEntry } from '../foreign-sqlite-readers/foreign-sqlite-reader-entry-path'
+import { runOpenCodeSqliteScanRequest } from './session-scanner-opencode-sqlite-scan-scope'
 
 // Why: resolve the built worker entry + own the process-wide shared client so
 // the client class stays free of Electron (require'd lazily here) and the
@@ -179,8 +180,14 @@ async function listForHost(
       const first = paths.values().next().value!
       const issues: AiVaultScanIssue[] = []
       try {
-        const client = await openCodeWslClient(distro, first, args.signal)
-        const result = await client.list({ ...args, dbPaths: [...paths.keys()], issues })
+        const result = await runOpenCodeSqliteScanRequest(
+          args.signal,
+          async (signal) => {
+            const client = await openCodeWslClient(distro, first, signal)
+            return client.list({ ...args, signal, dbPaths: [...paths.keys()], issues })
+          },
+          args.agent
+        )
         return result.flatMap((candidate) => {
           const parsed = splitOpenCodeSqliteCandidate(candidate.file.path, args.agent)
           const original = parsed && paths.get(parsed.dbPath)
@@ -223,8 +230,14 @@ async function parseForHost(
   if (!wsl) {
     return getSharedClient().parse(args)
   }
-  const client = await openCodeWslClient(wsl.distro, args.dbPath, args.signal)
-  const session = await client.parse({ ...args, dbPath: wsl.linuxPath, platform: 'linux' })
+  const session = await runOpenCodeSqliteScanRequest(
+    args.signal,
+    async (signal) => {
+      const client = await openCodeWslClient(wsl.distro, args.dbPath, signal)
+      return client.parse({ ...args, signal, dbPath: wsl.linuxPath, platform: 'linux' })
+    },
+    args.agent
+  )
   return mapOpenCodeWslSession(session, args.dbPath)
 }
 
@@ -235,8 +248,14 @@ async function captureForHost(
   if (!wsl) {
     return getSharedClient().capture(args)
   }
-  const client = await openCodeWslClient(wsl.distro, args.dbPath, args.signal)
-  const capture = await client.capture({ ...args, dbPath: wsl.linuxPath, platform: 'linux' })
+  const capture = await runOpenCodeSqliteScanRequest(
+    args.signal,
+    async (signal) => {
+      const client = await openCodeWslClient(wsl.distro, args.dbPath, signal)
+      return client.capture({ ...args, signal, dbPath: wsl.linuxPath, platform: 'linux' })
+    },
+    args.agent
+  )
   return { ...capture, session: mapOpenCodeWslSession(capture.session, args.dbPath) }
 }
 
diff --git a/src/main/ai-vault/session-scanner-opencode-wsl-routing.test.ts b/src/main/ai-vault/session-scanner-opencode-wsl-routing.test.ts
index 754211c323c..9db4ba85e83 100644
--- a/src/main/ai-vault/session-scanner-opencode-wsl-routing.test.ts
+++ b/src/main/ai-vault/session-scanner-opencode-wsl-routing.test.ts
@@ -3,6 +3,7 @@ import type { AiVaultScanIssue } from '../../shared/ai-vault-types'
 import { createAccumulator, finalizeSession } from './session-scanner-accumulator'
 import type { SessionFileCandidate } from './session-scanner-types'
 import type * as wslClientModule from './session-scanner-opencode-wsl-client'
+import { withOpenCodeSqliteScanScope } from './session-scanner-opencode-sqlite-scan-scope'
 
 const mocks = vi.hoisted(() => ({
   native: {
@@ -59,9 +60,53 @@ beforeEach(() => {
   vi.clearAllMocks()
   vi.spyOn(process, 'platform', 'get').mockReturnValue('win32')
 })
-afterEach(() => vi.restoreAllMocks())
+afterEach(() => {
+  vi.useRealTimers()
+  vi.restoreAllMocks()
+})
 
 describe('OpenCode SQLite execution-host routes', () => {
+  it('budgets WSL preparation while retaining a native source that already answered', async () => {
+    vi.useFakeTimers()
+    mocks.native.list.mockResolvedValueOnce([row(native)])
+    mocks.guest.mockImplementationOnce((_distro, _path, signal: AbortSignal | undefined) => {
+      if (!signal) {
+        throw new Error('Missing scoped preparation signal')
+      }
+      return new Promise((_resolve, reject) =>
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true })
+      )
+    })
+    const issues: AiVaultScanIssue[] = []
+    const result = withOpenCodeSqliteScanScope(() =>
+      listOpenCodeSqliteSessionsViaWorker({
+        dbPaths: [native, ubuntu],
+        limit: 2,
+        issues
+      })
+    )
+    await vi.advanceTimersByTimeAsync(45_000)
+    expect((await result).map((entry) => entry.file.path)).toEqual([`${native}#same-session`])
+    expect(issues).toEqual([
+      expect.objectContaining({
+        path: ubuntu,
+        kind: 'scope',
+        message: expect.stringContaining('45s work budget')
+      })
+    ])
+    mocks.guest.mockResolvedValueOnce({ list: vi.fn(async () => [row(guest)]) })
+    const recoveredIssues: AiVaultScanIssue[] = []
+    const recovered = await withOpenCodeSqliteScanScope(() =>
+      listOpenCodeSqliteSessionsViaWorker({
+        dbPaths: [ubuntu],
+        limit: 2,
+        issues: recoveredIssues
+      })
+    )
+    expect(recovered).toHaveLength(1)
+    expect(recoveredIssues).toEqual([])
+  })
+
   it('separates native and distro databases and preserves equal IDs in different distros', async () => {
     const list = vi.fn(async (args) => [row(args.dbPaths[0])])
     mocks.guest.mockResolvedValue({ list })
diff --git a/src/main/ai-vault/session-scanner.ts b/src/main/ai-vault/session-scanner.ts
index 8716440a565..f0525c918c8 100644
--- a/src/main/ai-vault/session-scanner.ts
+++ b/src/main/ai-vault/session-scanner.ts
@@ -45,6 +45,7 @@ import { clampPositiveInteger, errorMessage } from './session-scanner-values'
 import { throwIfAiVaultScanCancelled } from './ai-vault-scan-cancellation'
 import { DEFAULT_AI_VAULT_SCAN_LIMIT } from '../../shared/ai-vault-session-depth'
 import { withDevinSessionsDbScan } from './session-scanner-devin-db'
+import { withOpenCodeSqliteScanScope } from './session-scanner-opencode-sqlite-scan-scope'
 
 const SESSION_PARSE_CONCURRENCY = 8
 const SESSION_PARSE_CANDIDATE_MULTIPLIER = 2
@@ -61,6 +62,10 @@ const SESSION_PARSE_CANDIDATE_MULTIPLIER = 2
 export async function scanAiVaultSessions(
   options: AiVaultScanOptions = {}
 ): Promise<AiVaultListResult> {
+  return withOpenCodeSqliteScanScope(() => scanAiVaultSessionStores(options))
+}
+
+async function scanAiVaultSessionStores(options: AiVaultScanOptions): Promise<AiVaultListResult> {
   // The span makes scan cost visible in the local trace file: STA-1278-style
   // "one core pegged" reports need to show whether transcript scanning is the
   // subsystem burning CPU, and how much of each scan the cache absorbed.
diff --git a/src/main/codex/codex-collab-call-delegation.test.ts b/src/main/codex/codex-collab-call-delegation.test.ts
index 96131248ddc..dbc116802e4 100644
--- a/src/main/codex/codex-collab-call-delegation.test.ts
+++ b/src/main/codex/codex-collab-call-delegation.test.ts
@@ -28,7 +28,9 @@ import { THREAD_ID } from './codex-structured-session-adapter-fixture'
 /** The delegation the parent's newest tool run reads as, the row a running chat's frontier judges. */
 async function newestRunDelegation(frames: Frame[]): Promise<NativeChatSubagentDelegation | null> {
   const { conversation } = projectNativeChatTranscript(
-    projectStructuredAgentSessionMessages(await publishedRows(frames), [], [])
+    projectStructuredAgentSessionMessages(await publishedRows(frames), [], [], {
+      rejectedInPlace: true
+    })
   )
   const runs = conversation.filter((message: NativeChatMessage) =>
     message.blocks.some((block) => block.type === 'tool-call')
diff --git a/src/main/codex/codex-collab-call-rows-on-positional-clients.test.ts b/src/main/codex/codex-collab-call-rows-on-positional-clients.test.ts
index 795716ed553..ae7770b5beb 100644
--- a/src/main/codex/codex-collab-call-rows-on-positional-clients.test.ts
+++ b/src/main/codex/codex-collab-call-rows-on-positional-clients.test.ts
@@ -47,7 +47,9 @@ function positionalRuns(rows: AgentJournalRenderItem[]): {
     })
   })
   const transcript = projectNativeChatTranscript(
-    projectStructuredAgentSessionMessages(rows, [], []).map(withoutCallIds)
+    projectStructuredAgentSessionMessages(rows, [], [], { rejectedInPlace: true }).map(
+      withoutCallIds
+    )
   )
   // The conversation's runs, then each helper's section's.
   const runs = [
diff --git a/src/main/codex/codex-legacy-session-resume.ts b/src/main/codex/codex-legacy-session-resume.ts
index 29112c38d03..a072383a660 100644
--- a/src/main/codex/codex-legacy-session-resume.ts
+++ b/src/main/codex/codex-legacy-session-resume.ts
@@ -86,6 +86,32 @@ export async function prepareLegacySharedCodexSessionResume(
   return { useRealCodexHome: true }
 }
 
+/** Explicit account restarts must move the verified rollout before changing credentials. */
+export async function prepareCodexAccountRestartResume(args: {
+  sourceHome: string
+  transcriptPath: string
+  targetHome: string
+  systemCodexHomePath: string
+}): Promise<string> {
+  if (sameRuntimePath(args.sourceHome, args.targetHome)) {
+    return args.targetHome
+  }
+  const relativePath = relative(
+    resolve(join(args.sourceHome, 'sessions')),
+    resolve(args.transcriptPath)
+  )
+  if (!isDatedRolloutRelativePath(relativePath)) {
+    throw new Error(RETRYABLE_RESUME_ERROR)
+  }
+  const paths = resolveCodexSessionBackfillPaths(args.systemCodexHomePath)
+  await materializeLegacyRollout(
+    args.transcriptPath,
+    join(args.targetHome, 'sessions', relativePath),
+    paths.auditLogPath
+  )
+  return args.targetHome
+}
+
 /**
  * Repins a per-account resume to the selected account's home, or null to keep
  * the session's own home.
diff --git a/src/main/codex/codex-structured-question-order.test.ts b/src/main/codex/codex-structured-question-order.test.ts
index 8ad4b75bd38..78c197644e2 100644
--- a/src/main/codex/codex-structured-question-order.test.ts
+++ b/src/main/codex/codex-structured-question-order.test.ts
@@ -206,6 +206,7 @@ function drawnPromptRows(): string[][] {
       client.items,
       [],
       client.submissions,
+      { rejectedInPlace: true },
       projectStructuredQuestionMessages
     )
   )
@@ -243,9 +244,9 @@ describe('a Codex ask with several questions', () => {
     ])
     // Mobile draws the shared projection in journal order, one row per question.
     expect(
-      projectStructuredAgentSessionMessages(client.items, [], client.submissions).map(
-        ({ blocks }) => (blocks[0]?.type === 'text' ? blocks[0].text.split('\n')[0] : null)
-      )
+      projectStructuredAgentSessionMessages(client.items, [], client.submissions, {
+        rejectedInPlace: false
+      }).map(({ blocks }) => (blocks[0]?.type === 'text' ? blocks[0].text.split('\n')[0] : null))
     ).toEqual(ASKED.map(({ question }) => question))
   })
 
diff --git a/src/main/daemon/terminal-cursor-line-context.test.ts b/src/main/daemon/terminal-cursor-line-context.test.ts
index 29afe00618b..3184d53ca17 100644
--- a/src/main/daemon/terminal-cursor-line-context.test.ts
+++ b/src/main/daemon/terminal-cursor-line-context.test.ts
@@ -157,4 +157,79 @@ describe('readTerminalCursorLineContext', () => {
     expect(detectTerminalComposerDraft(context)?.text).toBe(draft)
     emulator.dispose()
   })
+
+  it.each([true, false])('bounds blank-row cell reads with reusable cells %s', (reusable) => {
+    const terminal = new Terminal({ cols: 12, rows: 5, allowProposedApi: true })
+    try {
+      const rig = observeCellReads(terminal)
+      const active = rig.source.buffer.active
+      const source = {
+        ...rig.source,
+        buffer: { active: { ...active, getNullCell: reusable ? active.getNullCell : undefined } }
+      }
+      const context = readTerminalCursorLineContext(source, terminal.rows)
+      expect(context?.typedRows).toEqual([''])
+      expect(context?.typedRowsBelow).toEqual(['', '', '', ''])
+      expect(context?.promptGlyphBoldRows).toEqual([false])
+      expect(context?.rowsBelowCustomForeground).toEqual([false, false, false, false])
+      // A blank glyph search must share the full row scan; the cursor suffix is separate.
+      expect(rig.targets.length).toBeLessThanOrEqual(terminal.cols * (terminal.rows + 1))
+      expect(rig.allocated).toHaveLength(reusable ? 1 : 0)
+      expect(rig.targets.every((cell) => cell === rig.allocated[0])).toBe(true)
+    } finally {
+      terminal.dispose()
+    }
+  })
+
+  it('keeps dimmed first-glyph styles while excluding their text', () => {
+    const terminal = new Terminal({ cols: 32, rows: 5, allowProposedApi: true })
+    try {
+      writeSync(terminal, '\x1b[2;1m›\x1b[0m typed\x1b7\r\n\x1b[2;31mfooter\x1b[0m\x1b8')
+      const context = readTerminalCursorLineContext(terminal, terminal.rows)
+      expect(context?.typedRows).toEqual([' typed'])
+      expect(context?.promptGlyphBoldRows).toEqual([true])
+      expect(context?.typedRowsBelow[0]).toBe('')
+      expect(context?.rowsBelowCustomForeground?.[0]).toBe(true)
+    } finally {
+      terminal.dispose()
+    }
+  })
+
+  it('uses the first visible glyph even when later glyphs have styles', () => {
+    const terminal = new Terminal({ cols: 32, rows: 5, allowProposedApi: true })
+    try {
+      writeSync(
+        terminal,
+        '\x1b[1m \u00a0\x1b[22m›\x1b[1mX\x1b[0m\x1b7\r\n' +
+          '\x1b[31m  \x1b[39mplain \x1b[32mlater\x1b[0m\x1b8'
+      )
+      const context = readTerminalCursorLineContext(terminal, terminal.rows)
+      expect(context?.promptGlyphBoldRows).toEqual([false])
+      expect(context?.rowsBelowCustomForeground?.[0]).toBe(false)
+    } finally {
+      terminal.dispose()
+    }
+  })
+
+  it('finds styled first glyphs after unstyled blank cells', () => {
+    const terminal = new Terminal({ cols: 32, rows: 5, allowProposedApi: true })
+    try {
+      writeSync(terminal, '  \x1b[1m›\x1b[0m typed\x1b7\r\n  \x1b[31mfooter\x1b[0m\x1b8')
+      const context = readTerminalCursorLineContext(terminal, terminal.rows)
+      expect(context?.promptGlyphBoldRows).toEqual([true])
+      expect(context?.rowsBelowCustomForeground?.[0]).toBe(true)
+    } finally {
+      terminal.dispose()
+    }
+  })
+
+  it('keeps an unwritten cell between typed glyphs as a space', () => {
+    const terminal = new Terminal({ cols: 12, rows: 5, allowProposedApi: true })
+    try {
+      writeSync(terminal, 'a\x1b[3Gb')
+      expect(readTerminalCursorLineContext(terminal, terminal.rows)?.typedRows).toEqual(['a b'])
+    } finally {
+      terminal.dispose()
+    }
+  })
 })
diff --git a/src/main/daemon/terminal-snapshot-ansi-buffers.ts b/src/main/daemon/terminal-snapshot-ansi-buffers.ts
index e0b16d56d8f..65936f3c82b 100644
--- a/src/main/daemon/terminal-snapshot-ansi-buffers.ts
+++ b/src/main/daemon/terminal-snapshot-ansi-buffers.ts
@@ -1,21 +1,15 @@
 import type { TerminalModes } from './types'
+import { splitAtAlternateScreenEntry } from '../../shared/terminal-alternate-screen-split'
 
 export function splitTerminalSnapshotAnsi(
   snapshotAnsi: string,
   modes: TerminalModes
 ): { snapshotAnsi: string; scrollbackAnsi: string } {
-  if (!modes.alternateScreen) {
-    return { snapshotAnsi, scrollbackAnsi: '' }
-  }
-  const alternateScreenMarker = '\x1b[?1049h'
-  const start = snapshotAnsi.lastIndexOf(alternateScreenMarker)
-  if (start === -1) {
+  const split = modes.alternateScreen ? splitAtAlternateScreenEntry(snapshotAnsi) : null
+  if (!split) {
     return { snapshotAnsi, scrollbackAnsi: '' }
   }
   // Why: rehydrateSequences owns the alt-screen transition. Keeping the
   // normal buffer separate lets an already-alt renderer rebuild it safely.
-  return {
-    scrollbackAnsi: snapshotAnsi.slice(0, start),
-    snapshotAnsi: snapshotAnsi.slice(start + alternateScreenMarker.length)
-  }
+  return { scrollbackAnsi: split.normalAnsi, snapshotAnsi: split.alternateAnsi }
 }
diff --git a/src/main/destination-serialized-local-rename.test.ts b/src/main/destination-serialized-local-rename.test.ts
index 7bdab6a0914..6a969a6ee40 100644
--- a/src/main/destination-serialized-local-rename.test.ts
+++ b/src/main/destination-serialized-local-rename.test.ts
@@ -12,6 +12,7 @@ const { copyFileMock, handleMock, lstatMock, realpathMock, renameMock } = vi.hoi
 const handlers = new Map<string, (_event: unknown, args: unknown) => Promise<unknown>>()
 
 vi.mock('electron', () => ({
+  app: { getPath: () => '/orca-test-user-data' },
   ipcMain: { handle: handleMock }
 }))
 
diff --git a/src/main/global-fetch-call-site-audit.test.ts b/src/main/global-fetch-call-site-audit.test.ts
index 664bbaf1aa3..2be65fd1c73 100644
--- a/src/main/global-fetch-call-site-audit.test.ts
+++ b/src/main/global-fetch-call-site-audit.test.ts
@@ -22,6 +22,8 @@ const AUDITED_GLOBAL_FETCH_LINES = new Map<string, number>([
   ['main/gitea/client.ts', 1],
   // Generated OpenCode claim source consumes JSON or cancels its body in finally.
   ['main/opencode/opencode-startup-prompt-source.ts', 1],
+  // Authenticated loopback preflight consumes bounded JSON and cancels every body in finally.
+  ['main/opencode/opencode-launch-model-context.ts', 1],
   ['main/orca-profiles/profile-cloud-client.ts', 1],
   ['main/orca-profiles/profile-cloud-org-members-client.ts', 1],
   ['main/rate-limits/codex-fetcher.ts', 3],
diff --git a/src/main/ipc/app.test.ts b/src/main/ipc/app.test.ts
index aba55bee6e5..07b8b82f9a7 100644
--- a/src/main/ipc/app.test.ts
+++ b/src/main/ipc/app.test.ts
@@ -10,7 +10,7 @@ const {
   destroySystemTrayMock,
   relaunchAppMock,
   showOpenDialogMock,
-  grantFloatingWorkspaceDirectoryMock,
+  trustFloatingWorkspaceDirectoryMock,
   registerRendererShutdownCheckpointHandlerMock,
   registerMacKeyboardLayoutChangeNotificationsMock
 } = vi.hoisted(() => ({
@@ -22,7 +22,7 @@ const {
   destroySystemTrayMock: vi.fn(),
   relaunchAppMock: vi.fn(),
   showOpenDialogMock: vi.fn(),
-  grantFloatingWorkspaceDirectoryMock: vi.fn(),
+  trustFloatingWorkspaceDirectoryMock: vi.fn(),
   registerRendererShutdownCheckpointHandlerMock: vi.fn(),
   registerMacKeyboardLayoutChangeNotificationsMock: vi.fn()
 }))
@@ -103,7 +103,7 @@ vi.mock('../app-relaunch', () => ({
 
 vi.mock('./floating-workspace-directory', () => ({
   ensureDefaultFloatingWorkspacePath: vi.fn(),
-  grantFloatingWorkspaceDirectory: grantFloatingWorkspaceDirectoryMock,
+  trustFloatingWorkspaceDirectory: trustFloatingWorkspaceDirectoryMock,
   resolveFloatingTerminalCwd: vi.fn()
 }))
 
@@ -155,7 +155,7 @@ describe('registerAppHandlers', () => {
     relaunchAppMock.mockReset()
     relaunchAppMock.mockImplementation(() => appRelaunchMock())
     showOpenDialogMock.mockReset()
-    grantFloatingWorkspaceDirectoryMock.mockReset()
+    trustFloatingWorkspaceDirectoryMock.mockReset()
     registerRendererShutdownCheckpointHandlerMock.mockReset()
     registerMacKeyboardLayoutChangeNotificationsMock.mockReset()
     for (const probe of Object.values(windowsProbes)) {
@@ -416,7 +416,7 @@ describe('registerAppHandlers', () => {
     expect(showOpenDialogMock).toHaveBeenCalledWith({
       properties: ['openDirectory']
     })
-    expect(grantFloatingWorkspaceDirectoryMock).toHaveBeenCalledWith(store, '/Users/kaylee/notes')
+    expect(trustFloatingWorkspaceDirectoryMock).toHaveBeenCalledWith(store, '/Users/kaylee/notes')
   })
 
   // Why: the renderer reads these on every Windows capability refresh; the sync probes
diff --git a/src/main/ipc/app.ts b/src/main/ipc/app.ts
index ea74a240c38..d056727fdb7 100644
--- a/src/main/ipc/app.ts
+++ b/src/main/ipc/app.ts
@@ -15,10 +15,9 @@ import { isWslAvailableAsync, listWslDistrosAsync } from '../wsl'
 import { isGitBashAvailable } from '../git-bash'
 import { setUnreadDockBadgeCount } from '../dock/unread-badge'
 import { destroySystemTray } from '../tray/system-tray'
-import { authorizeExternalPath } from './filesystem-auth'
 import {
   ensureDefaultFloatingWorkspacePath,
-  grantFloatingWorkspaceDirectory,
+  trustFloatingWorkspaceDirectory,
   resolveFloatingTerminalCwd
 } from './floating-workspace-directory'
 import { isMarkdownDocumentName, markdownDocumentFromFilePath } from './markdown-documents'
@@ -60,7 +59,6 @@ async function pickFloatingMarkdownDocument(
   if (!isMarkdownDocumentName(filePath)) {
     throw new Error('Selected file is not a markdown document.')
   }
-  authorizeExternalPath(filePath)
   return markdownDocumentFromFilePath(cwd, filePath, { outsideRootRelativePath: 'basename' })
 }
 
@@ -70,7 +68,7 @@ async function pickFloatingWorkspaceDirectory(
 ): Promise<string | null> {
   const parentWindow = BrowserWindow.fromWebContents(event.sender)
   const options = {
-    // Why: this picker only grants access to an existing directory; creation belongs to explicit file actions.
+    // Why: this picker only chooses an existing directory; creation belongs to explicit file actions.
     properties: ['openDirectory']
   } satisfies Electron.OpenDialogOptions
   const result = parentWindow
@@ -80,8 +78,8 @@ async function pickFloatingWorkspaceDirectory(
     return null
   }
   const selectedDir = result.filePaths[0]
-  // Why: a user-approved picker selection is a trust grant for later markdown creation, unlike typed settings text.
-  await grantFloatingWorkspaceDirectory(store, selectedDir)
+  // Why: only a user-approved picker selection may become the floating terminal's cwd, unlike typed settings text.
+  await trustFloatingWorkspaceDirectory(store, selectedDir)
   return selectedDir
 }
 
diff --git a/src/main/ipc/automatic-load-path-text.ts b/src/main/ipc/automatic-load-path-text.ts
new file mode 100644
index 00000000000..2bc92ef3444
--- /dev/null
+++ b/src/main/ipc/automatic-load-path-text.ts
@@ -0,0 +1,47 @@
+import { basename, sep } from 'node:path'
+import { parseWslUncPath } from '../../shared/wsl-paths'
+
+// Why the path flavour, not the OS: these are Windows path rules, and tests exercise them with
+// path.win32 on any host.
+function usesWindowsPaths(): boolean {
+  return sep === '\\'
+}
+
+const WINDOWS_RESERVED_DEVICE_STEM =
+  /^(?:con|prn|aux|nul|conin\$|conout\$|clock\$|com[0-9¹²³]|lpt[0-9¹²³])$/i
+
+/**
+ * `NUL.png`, `com1 .jpg`, `Aux.`, `NUL:stream.png` name a Windows device, not a file, whatever the
+ * extension or alternate data stream (`:`).
+ */
+export function isWindowsReservedDeviceName(filePath: string): boolean {
+  if (!usesWindowsPaths()) {
+    return false
+  }
+  const stem =
+    basename(filePath)
+      .replace(/[. ]+$/, '')
+      .split(/[.:]/)[0] ?? ''
+  return WINDOWS_RESERVED_DEVICE_STEM.test(stem.replace(/ +$/, ''))
+}
+
+function toBackslashes(filePath: string): string {
+  return filePath.replace(/\//g, '\\')
+}
+
+/** A Windows device-namespace path (`\\?\`, `\\.\`), which can name devices and shares alike. */
+export function isDeviceNamespacePath(filePath: string): boolean {
+  return usesWindowsPaths() && /^\\\\[?.]\\/.test(toBackslashes(filePath))
+}
+
+/**
+ * A network share (`\\host\share`). WSL paths are UNC in form but stay on this machine, so they
+ * are not network paths.
+ */
+export function isNetworkSharePath(filePath: string): boolean {
+  if (!usesWindowsPaths() || isDeviceNamespacePath(filePath)) {
+    return false
+  }
+  const normalized = toBackslashes(filePath)
+  return normalized.startsWith('\\\\') && parseWslUncPath(normalized) === null
+}
diff --git a/src/main/ipc/filesystem-allowed-roots.test.ts b/src/main/ipc/filesystem-allowed-roots.test.ts
index ce4a30c62fa..7d965f218d7 100644
--- a/src/main/ipc/filesystem-allowed-roots.test.ts
+++ b/src/main/ipc/filesystem-allowed-roots.test.ts
@@ -15,7 +15,7 @@ import type { ProjectGroup } from '../../shared/project-group-types'
 import type { Project } from '../../shared/project-types'
 import type { Repo } from '../../shared/repo-types'
 import { getAllowedRoots } from './filesystem-allowed-roots'
-import { authorizeExternalPath, resolveAuthorizedPath } from './filesystem-auth'
+import { resolveAuthorizedPath } from './filesystem-auth'
 import { invalidateAuthorizedRootsCache } from './registered-worktree-roots-cache'
 import { computeWorkspaceRoot, getWorktreePathSettings } from './worktree-logic'
 
@@ -358,25 +358,6 @@ describe('resolveAuthorizedPath allowed-root reuse', () => {
     }
   )
 
-  it('builds no allowed-root list at all for a granted external path', async () => {
-    const external = join(outsideRoot, 'external.md')
-    await writeFile(external, 'notes\n')
-    authorizeExternalPath(external)
-    counts.getRepos = 0
-    counts.getProjects = 0
-    counts.getFolderWorkspaces = 0
-
-    for (let index = 0; index < 5; index += 1) {
-      await expect(resolveAuthorizedPath(external, store)).resolves.toBe(external)
-    }
-
-    // The grant answers on its own; hoisting the snapshot must not turn zero builds into one per read.
-    expect.soft(counts.getRepos).toBe(0)
-    expect.soft(counts.getProjects).toBe(0)
-    expect.soft(counts.getFolderWorkspaces).toBe(0)
-    expect.soft(vi.mocked(buildProjectGroupChildIndex)).not.toHaveBeenCalled()
-  })
-
   it.skipIf(process.platform === 'win32')(
     'still refuses a directory symlink that escapes every allowed root',
     async () => {
diff --git a/src/main/ipc/filesystem-auth.test.ts b/src/main/ipc/filesystem-auth.test.ts
index fa82b7a652c..12a9995eecf 100644
--- a/src/main/ipc/filesystem-auth.test.ts
+++ b/src/main/ipc/filesystem-auth.test.ts
@@ -10,12 +10,7 @@ import type { FolderWorkspace } from '../../shared/folder-workspace-types'
 import type { ProjectGroup } from '../../shared/project-group-types'
 import type { Repo } from '../../shared/repo-types'
 import type { GitWorktreeInfo } from '../../shared/worktree/types'
-import {
-  AUTHORIZED_EXTERNAL_PATHS_MAX,
-  authorizeExternalPath,
-  isPathAllowed,
-  resolveAuthorizedPath
-} from './filesystem-auth'
+import { resolveAuthorizedPath } from './filesystem-auth'
 import { isDescendantOrEqual, validateGitRelativeFilePath } from './filesystem-path-containment'
 import {
   __resetCreatedWorktreeRootsForTests,
@@ -419,42 +414,3 @@ describe('filesystem-auth path containment', () => {
     }
   })
 })
-
-describe('filesystem-auth authorized external path bound', () => {
-  // Empty allow-list store, so a path is allowed only if it (or an ancestor) is
-  // in the session-authorized external-path set.
-  const emptyStore = makeStore([])
-  const flood = (n: number): string =>
-    resolve(`/leak-audit-ext/flood-${String(n).padStart(6, '0')}`)
-
-  it('bounds the authorized external path set with LRU eviction', () => {
-    const keep = resolve('/leak-audit-ext/keep')
-    authorizeExternalPath(keep)
-
-    // Flood past the cap with distinct external paths, re-authorizing `keep`
-    // periodically so LRU keeps it hot.
-    const total = AUTHORIZED_EXTERNAL_PATHS_MAX + 200
-    for (let i = 0; i < total; i += 1) {
-      authorizeExternalPath(flood(i))
-      if (i % 250 === 0) {
-        authorizeExternalPath(keep)
-      }
-    }
-
-    // The oldest never-re-touched entries fell out of the bounded set...
-    expect(isPathAllowed(flood(0), emptyStore)).toBe(false)
-    // ...while the periodically re-authorized path and the most recent survive.
-    expect(isPathAllowed(keep, emptyStore)).toBe(true)
-    expect(isPathAllowed(flood(total - 1), emptyStore)).toBe(true)
-  })
-
-  it('re-authorizes an evicted path on next use (self-healing)', () => {
-    const path = resolve('/leak-audit-ext/evicted-then-reused')
-    for (let i = 0; i < AUTHORIZED_EXTERNAL_PATHS_MAX + 50; i += 1) {
-      authorizeExternalPath(flood(100_000 + i))
-    }
-    expect(isPathAllowed(path, emptyStore)).toBe(false)
-    authorizeExternalPath(path)
-    expect(isPathAllowed(path, emptyStore)).toBe(true)
-  })
-})
diff --git a/src/main/ipc/filesystem-auth.ts b/src/main/ipc/filesystem-auth.ts
index 620baa9b595..e031c6a91e1 100644
--- a/src/main/ipc/filesystem-auth.ts
+++ b/src/main/ipc/filesystem-auth.ts
@@ -1,7 +1,7 @@
 import { resolve, dirname, basename } from 'node:path'
-import { realpathSync } from 'node:fs'
 import { realpath } from 'node:fs/promises'
 import type { Store } from '../persistence'
+import { PATH_OUTSIDE_ALLOWED_DIRECTORIES } from '../../shared/local-file-access'
 import { getAllowedRoots } from './filesystem-allowed-roots'
 import { isDescendantOrEqual, isENOENT, normalizeExistingPath } from './filesystem-path-containment'
 import {
@@ -16,45 +16,16 @@ export { invalidateAuthorizedRootsCache } from './registered-worktree-roots-cach
 export { invalidateAuthorizedRootsCacheForRepo } from './registered-worktree-roots-scoped-invalidation'
 export { isENOENT } from './filesystem-path-containment'
 
-export const PATH_ACCESS_DENIED_MESSAGE =
-  'Access denied: path resolves outside allowed directories. If this blocks a legitimate workflow, please file a GitHub issue.'
-// Why: authorized external paths accumulate all session; LRU-bound the set. Safe to evict because every caller re-authorizes before operating.
-export const AUTHORIZED_EXTERNAL_PATHS_MAX = 4096
-const authorizedExternalPaths = new Set<string>()
-
-function rememberAuthorizedExternalPath(path: string): void {
-  // Delete-then-add makes re-authorized paths most-recent so LRU eviction sheds only the oldest untouched entries.
-  authorizedExternalPaths.delete(path)
-  authorizedExternalPaths.add(path)
-  while (authorizedExternalPaths.size > AUTHORIZED_EXTERNAL_PATHS_MAX) {
-    const oldest = authorizedExternalPaths.keys().next().value
-    if (oldest === undefined) {
-      break
-    }
-    authorizedExternalPaths.delete(oldest)
-  }
-}
-
-export function authorizeExternalPath(targetPath: string): void {
-  const resolvedTarget = resolve(targetPath)
-  rememberAuthorizedExternalPath(resolvedTarget)
-  try {
-    // Why: macOS canonicalizes /tmp to /private/tmp during read authorization.
-    rememberAuthorizedExternalPath(realpathSync(resolvedTarget))
-  } catch {}
-}
-
-/**
- * One allowed-root list shared by every check in a single authorization.
- *
- * Lazy so a path already covered by an external grant still builds nothing at all, the way it did
- * before the list was hoisted out of the individual checks.
- */
+export const PATH_ACCESS_DENIED_MESSAGE = `${PATH_OUTSIDE_ALLOWED_DIRECTORIES}. If this blocks a legitimate workflow, please file a GitHub issue.`
+/** One allowed-root list shared by every check in a single authorization, built on first use. */
 type AllowedRootsSnapshot = { get: () => readonly string[] }
 
-function createAllowedRootsSnapshot(store: Store): AllowedRootsSnapshot {
+function createAllowedRootsSnapshot(
+  store: Store,
+  extraRoots: readonly string[] = []
+): AllowedRootsSnapshot {
   let roots: readonly string[] | undefined
-  return { get: () => (roots ??= getAllowedRoots(store)) }
+  return { get: () => (roots ??= [...getAllowedRoots(store), ...extraRoots]) }
 }
 
 export function isPathAllowed(
@@ -63,14 +34,6 @@ export function isPathAllowed(
   allowedRoots?: AllowedRootsSnapshot
 ): boolean {
   const resolvedTarget = resolve(targetPath)
-  if (authorizedExternalPaths.has(resolvedTarget)) {
-    return true
-  }
-  for (const authorizedPath of authorizedExternalPaths) {
-    if (isDescendantOrEqual(resolvedTarget, authorizedPath)) {
-      return true
-    }
-  }
   return (allowedRoots?.get() ?? getAllowedRoots(store)).some((root) =>
     isDescendantOrEqual(resolvedTarget, root)
   )
@@ -81,6 +44,8 @@ export type ResolveAuthorizedPathOptions = {
    * Canonicalize the parent but preserve the leaf so delete/rename target the symlink itself, not its destination (which may live outside allowed roots).
    */
   preserveSymlink?: boolean
+  /** Roots only the desktop window may use (never runtime RPC), checked like any other root. */
+  extraRoots?: readonly string[]
 }
 
 export async function resolveAuthorizedPath(
@@ -91,7 +56,7 @@ export async function resolveAuthorizedPath(
   const resolvedTarget = resolve(targetPath)
   // Why: the roots depend only on store state, not on the candidate path, so one snapshot serves
   // every authorization below; each candidate is still checked against it in full.
-  const allowedRoots = createAllowedRootsSnapshot(store)
+  const allowedRoots = createAllowedRootsSnapshot(store, options.extraRoots)
   if (!(await isPathAllowedIncludingRegisteredWorktrees(resolvedTarget, store, { allowedRoots }))) {
     throw new Error(PATH_ACCESS_DENIED_MESSAGE)
   }
diff --git a/src/main/ipc/filesystem-document-folder-writes.test.ts b/src/main/ipc/filesystem-document-folder-writes.test.ts
new file mode 100644
index 00000000000..6e8e50ad205
--- /dev/null
+++ b/src/main/ipc/filesystem-document-folder-writes.test.ts
@@ -0,0 +1,324 @@
+import { mkdir, mkdtemp, readdir, realpath, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { Store } from '../persistence'
+import type * as RepoWorktrees from '../repo-worktrees'
+import {
+  registerSshFilesystemProvider,
+  unregisterSshFilesystemProvider
+} from '../providers/ssh-filesystem-dispatch'
+import { invalidateAuthorizedRootsCache } from './registered-worktree-roots-cache'
+
+type Handler = (event: unknown, args: unknown) => Promise<unknown>
+
+const { handlers, userData } = vi.hoisted(() => ({
+  handlers: new Map<string, Handler>(),
+  userData: { path: '' }
+}))
+
+vi.mock('electron', () => ({
+  app: { getPath: () => userData.path },
+  ipcMain: { handle: (channel: string, handler: Handler) => handlers.set(channel, handler) }
+}))
+vi.mock('../repo-worktrees', async () => {
+  const actual = await vi.importActual<typeof RepoWorktrees>('../repo-worktrees')
+  return { ...actual, listRepoWorktreeGraph: vi.fn(async () => []) }
+})
+
+import { registerFilesystemMutationHandlers } from './filesystem-mutations'
+
+let projectPaths: string[] = []
+
+// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: authorization reads only these Store members.
+const STORE = {
+  getRepos: () =>
+    projectPaths.map((path, index) => ({
+      id: `repo-${index}`,
+      path,
+      displayName: 'project',
+      badgeColor: '#000',
+      addedAt: 0
+    })),
+  getProjects: () => [],
+  getProjectGroups: () => [],
+  getFolderWorkspaces: () => [],
+  getSettings: () => ({ nestWorkspaces: false, workspaceDir: '' })
+} as unknown as Store
+
+const documentFolder = (documentPath: string) => ({ kind: 'document-folder', documentPath })
+
+async function settles(promise: Promise<unknown>): Promise<'ok' | 'denied'> {
+  return promise.then(
+    () => 'ok',
+    () => 'denied'
+  )
+}
+
+function call(channel: string, args: unknown): Promise<unknown> {
+  const handler = handlers.get(channel)
+  if (!handler) {
+    throw new Error(`no handler for ${channel}`)
+  }
+  return handler(null, args)
+}
+
+let base: string
+let docFolder: string
+let note: string
+
+beforeEach(async () => {
+  invalidateAuthorizedRootsCache()
+  handlers.clear()
+  base = await mkdtemp(join(await realpath(tmpdir()), 'orca-document-folder-'))
+  userData.path = join(base, 'user-data')
+  docFolder = join(base, 'notes')
+  note = join(docFolder, 'note.md')
+  await mkdir(join(userData.path, 'floating-workspace'), { recursive: true })
+  await mkdir(docFolder)
+  await writeFile(note, '# note\n')
+  await writeFile(join(base, 'shot.png'), 'png')
+  projectPaths = []
+  registerFilesystemMutationHandlers(STORE)
+})
+
+afterEach(async () => {
+  await rm(base, { recursive: true, force: true })
+})
+
+describe('renaming a document the user opened outside every project', () => {
+  it('renames it within its own folder', async () => {
+    const renamed = join(docFolder, 'renamed.md')
+
+    await call('fs:rename', { oldPath: note, newPath: renamed, access: documentFolder(note) })
+
+    expect(await readdir(docFolder)).toEqual(['renamed.md'])
+  })
+
+  it('refuses another file, a relative new name, and a request with no access', async () => {
+    await writeFile(join(docFolder, 'other.md'), 'other')
+
+    expect(
+      await settles(
+        call('fs:rename', {
+          oldPath: join(docFolder, 'other.md'),
+          newPath: join(docFolder, 'moved.md'),
+          access: documentFolder(note)
+        })
+      )
+    ).toBe('denied')
+    expect(
+      await settles(
+        call('fs:rename', { oldPath: note, newPath: 'moved.md', access: documentFolder(note) })
+      )
+    ).toBe('denied')
+    expect(
+      await settles(call('fs:rename', { oldPath: note, newPath: join(docFolder, 'plain.md') }))
+    ).toBe('denied')
+    expect((await readdir(docFolder)).sort()).toEqual(['note.md', 'other.md'])
+  })
+
+  it('undoes a rename with the renamed file declared as the document', async () => {
+    const renamed = join(docFolder, 'renamed.md')
+    await call('fs:rename', { oldPath: note, newPath: renamed, access: documentFolder(note) })
+
+    await call('fs:rename', { oldPath: renamed, newPath: note, access: documentFolder(renamed) })
+
+    expect(await readdir(docFolder)).toEqual(['note.md'])
+  })
+
+  // Why each destination is undone: the Undo declares the moved file, so it must come back from anywhere.
+  it('moves it into another outside folder, and Undo brings it back', async () => {
+    await mkdir(join(base, 'other'))
+    const moved = join(base, 'other', 'note.md')
+
+    await call('fs:rename', { oldPath: note, newPath: moved, access: documentFolder(note) })
+    expect(await readdir(join(base, 'other'))).toEqual(['note.md'])
+
+    await call('fs:rename', { oldPath: moved, newPath: note, access: documentFolder(moved) })
+    expect(await readdir(join(base, 'other'))).toEqual([])
+    expect(await readdir(docFolder)).toEqual(['note.md'])
+  })
+
+  it('moves it into a project, and Undo brings it back out', async () => {
+    const project = join(base, 'proj')
+    await mkdir(project)
+    projectPaths = [project]
+    invalidateAuthorizedRootsCache()
+    const moved = join(project, 'note.md')
+
+    await call('fs:rename', { oldPath: note, newPath: moved, access: documentFolder(note) })
+    expect(await readdir(project)).toEqual(['note.md'])
+
+    await call('fs:rename', { oldPath: moved, newPath: note, access: documentFolder(moved) })
+    expect(await readdir(project)).toEqual([])
+    expect(await readdir(docFolder)).toEqual(['note.md'])
+  })
+
+  it('moves it into a subfolder, and Undo brings it back', async () => {
+    await mkdir(join(docFolder, 'archive'))
+    const moved = join(docFolder, 'archive', 'note.md')
+
+    await call('fs:rename', { oldPath: note, newPath: moved, access: documentFolder(note) })
+    expect(await readdir(join(docFolder, 'archive'))).toEqual(['note.md'])
+
+    await call('fs:rename', { oldPath: moved, newPath: note, access: documentFolder(moved) })
+    expect(await readdir(join(docFolder, 'archive'))).toEqual([])
+    expect((await readdir(docFolder)).sort()).toEqual(['archive', 'note.md'])
+  })
+})
+
+describe('inserting an image into a document the user opened outside every project', () => {
+  it('copies the image into the document folder', async () => {
+    const outcome = await call('fs:importExternalPaths', {
+      sourcePaths: [join(base, 'shot.png')],
+      destDir: docFolder,
+      access: documentFolder(note)
+    })
+
+    expect(outcome).toMatchObject({ results: [{ status: 'imported' }] })
+    expect((await readdir(docFolder)).sort()).toEqual(['note.md', 'shot.png'])
+  })
+
+  it('copies the image into a subfolder of the document folder', async () => {
+    await mkdir(join(docFolder, 'images'))
+
+    await call('fs:importExternalPaths', {
+      sourcePaths: [join(base, 'shot.png')],
+      destDir: join(docFolder, 'images'),
+      access: documentFolder(note)
+    })
+
+    expect(await readdir(join(docFolder, 'images'))).toEqual(['shot.png'])
+  })
+
+  it.skipIf(process.platform === 'win32')(
+    'refuses an import through a linked subfolder that leads out',
+    async () => {
+      await mkdir(join(base, 'elsewhere'))
+      await symlink(join(base, 'elsewhere'), join(docFolder, 'linked'))
+
+      expect(
+        await settles(
+          call('fs:importExternalPaths', {
+            sourcePaths: [join(base, 'shot.png')],
+            destDir: join(docFolder, 'linked'),
+            access: documentFolder(note)
+          })
+        )
+      ).toBe('denied')
+      expect(await readdir(join(base, 'elsewhere'))).toEqual([])
+    }
+  )
+
+  it('refuses the parent folder, and any outside folder without access', async () => {
+    const importInto = (destDir: string, access?: unknown) =>
+      settles(
+        call('fs:importExternalPaths', {
+          sourcePaths: [join(base, 'shot.png')],
+          destDir,
+          access
+        })
+      )
+
+    expect(await importInto(base, documentFolder(note))).toBe('denied')
+    expect(await importInto(docFolder)).toBe('denied')
+    expect(await readdir(docFolder)).toEqual(['note.md'])
+  })
+})
+
+describe('a project file opened by its full path', () => {
+  it('renames into a subfolder of the project, which the project check allows', async () => {
+    const project = join(base, 'project')
+    await mkdir(join(project, 'docs', 'old'), { recursive: true })
+    await writeFile(join(project, 'docs', 'plan.md'), '# plan\n')
+    projectPaths = [project]
+    invalidateAuthorizedRootsCache()
+    const plan = join(project, 'docs', 'plan.md')
+
+    await call('fs:rename', {
+      oldPath: plan,
+      newPath: join(project, 'docs', 'old', 'plan.md'),
+      access: documentFolder(plan)
+    })
+
+    expect(await readdir(join(project, 'docs', 'old'))).toEqual(['plan.md'])
+  })
+
+  it('renames into another folder of the same project, as with no declared access', async () => {
+    const project = join(base, 'project')
+    await mkdir(join(project, 'docs'), { recursive: true })
+    await mkdir(join(project, 'archive'))
+    await writeFile(join(project, 'docs', 'plan.md'), '# plan\n')
+    projectPaths = [project]
+    invalidateAuthorizedRootsCache()
+    const plan = join(project, 'docs', 'plan.md')
+
+    await call('fs:rename', {
+      oldPath: plan,
+      newPath: join(project, 'archive', 'plan.md'),
+      access: documentFolder(plan)
+    })
+
+    expect(await readdir(join(project, 'archive'))).toEqual(['plan.md'])
+    expect(await readdir(join(project, 'docs'))).toEqual([])
+  })
+
+  it('moves out of the project, and Undo brings it back in', async () => {
+    const project = join(base, 'project')
+    await mkdir(join(project, 'docs'), { recursive: true })
+    await writeFile(join(project, 'docs', 'plan.md'), '# plan\n')
+    projectPaths = [project]
+    invalidateAuthorizedRootsCache()
+    const plan = join(project, 'docs', 'plan.md')
+    const moved = join(docFolder, 'plan.md')
+
+    await call('fs:rename', { oldPath: plan, newPath: moved, access: documentFolder(plan) })
+    expect((await readdir(docFolder)).sort()).toEqual(['note.md', 'plan.md'])
+
+    await call('fs:rename', { oldPath: moved, newPath: plan, access: documentFolder(moved) })
+    expect(await readdir(join(project, 'docs'))).toEqual(['plan.md'])
+    expect(await readdir(docFolder)).toEqual(['note.md'])
+  })
+
+  it('never moves another project file out by naming the opened document', async () => {
+    const project = join(base, 'project')
+    await mkdir(project)
+    await writeFile(join(project, 'secret.md'), 'secret')
+    projectPaths = [project]
+    invalidateAuthorizedRootsCache()
+
+    expect(
+      await settles(
+        call('fs:rename', {
+          oldPath: join(project, 'secret.md'),
+          newPath: join(docFolder, 'secret.md'),
+          access: documentFolder(note)
+        })
+      )
+    ).toBe('denied')
+    expect(await readdir(project)).toEqual(['secret.md'])
+  })
+})
+
+describe('an SSH rename', () => {
+  it('goes to the remote host as before, whatever access it declares', async () => {
+    const renameNoClobber = vi.fn().mockResolvedValue(undefined)
+    registerSshFilesystemProvider('ssh-1', { renameNoClobber } as never)
+    try {
+      await call('fs:rename', {
+        oldPath: note,
+        newPath: join(base, 'note.md'),
+        access: documentFolder(note),
+        connectionId: 'ssh-1',
+        expectedSshTargetId: 'ssh-1',
+        expectedSshConnectionGeneration: 0
+      })
+    } finally {
+      unregisterSshFilesystemProvider('ssh-1')
+    }
+
+    expect(renameNoClobber).toHaveBeenCalledWith(note, join(base, 'note.md'))
+    expect(await readdir(docFolder)).toEqual(['note.md'])
+  })
+})
diff --git a/src/main/ipc/filesystem-import-local-rollback.test.ts b/src/main/ipc/filesystem-import-local-rollback.test.ts
index 7e196d700dc..b76fe597b35 100644
--- a/src/main/ipc/filesystem-import-local-rollback.test.ts
+++ b/src/main/ipc/filesystem-import-local-rollback.test.ts
@@ -12,7 +12,6 @@ const { lstatMock, mkdirMock, openMock, readdirMock, rmMock, unlinkMock } = vi.h
   unlinkMock: vi.fn()
 }))
 
-vi.mock('./filesystem-auth', () => ({ authorizeExternalPath: vi.fn() }))
 vi.mock('node:fs/promises', () => ({
   lstat: lstatMock,
   mkdir: mkdirMock,
diff --git a/src/main/ipc/filesystem-import-local.ts b/src/main/ipc/filesystem-import-local.ts
index c77d841a53d..d7960a2beeb 100644
--- a/src/main/ipc/filesystem-import-local.ts
+++ b/src/main/ipc/filesystem-import-local.ts
@@ -1,6 +1,5 @@
 import { lstat } from 'node:fs/promises'
 import { basename, join, resolve } from 'node:path'
-import { authorizeExternalPath } from './filesystem-auth'
 import { isENOENT } from './filesystem-path-containment'
 import type { ImportItemResult } from '../../shared/filesystem-import-result-types'
 import {
@@ -10,8 +9,8 @@ import {
 } from './filesystem-import-local-tree-copy'
 
 /**
- * Import a single top-level source into destDir, handling authorization,
- * validation, pre-scan, deconfliction, and copy.
+ * Import a single top-level source into destDir, handling validation, pre-scan,
+ * deconfliction, and copy.
  */
 export async function importOneSource(
   sourcePath: string,
@@ -20,10 +19,6 @@ export async function importOneSource(
 ): Promise<ImportItemResult> {
   const resolvedSource = resolve(sourcePath)
 
-  // Why: authorize the external source path so downstream filesystem
-  // operations (lstat, readdir, copyFile) are permitted by Electron.
-  authorizeExternalPath(resolvedSource)
-
   // Why: validate source using lstat on the unresolved path *before*
   // canonicalization so top-level symlinks are rejected instead of being
   // silently dereferenced by realpath.
diff --git a/src/main/ipc/filesystem-import-ssh-path-safety.test.ts b/src/main/ipc/filesystem-import-ssh-path-safety.test.ts
index 297dcb22045..3a6b0f2f86c 100644
--- a/src/main/ipc/filesystem-import-ssh-path-safety.test.ts
+++ b/src/main/ipc/filesystem-import-ssh-path-safety.test.ts
@@ -15,9 +15,6 @@ vi.mock('node:fs/promises', () => ({
   readdir: readdirMock,
   realpath: realpathMock
 }))
-vi.mock('./filesystem-auth', () => ({
-  authorizeExternalPath: vi.fn()
-}))
 vi.mock('./filesystem-path-containment', () => ({
   isENOENT: (error: NodeJS.ErrnoException) => error.code === 'ENOENT'
 }))
diff --git a/src/main/ipc/filesystem-import-ssh.test.ts b/src/main/ipc/filesystem-import-ssh.test.ts
index 6a5d502b14c..3c18eea6981 100644
--- a/src/main/ipc/filesystem-import-ssh.test.ts
+++ b/src/main/ipc/filesystem-import-ssh.test.ts
@@ -27,7 +27,10 @@ const {
   getConnMgrMock: vi.fn()
 }))
 
-vi.mock('electron', () => ({ ipcMain: { handle: handleMock } }))
+vi.mock('electron', () => ({
+  app: { getPath: () => '/orca-test-user-data' },
+  ipcMain: { handle: handleMock }
+}))
 vi.mock('fs/promises', () => ({
   lstat: lstatMock,
   mkdir: mkdirMock,
diff --git a/src/main/ipc/filesystem-import-ssh.ts b/src/main/ipc/filesystem-import-ssh.ts
index 9268c6ece24..a0cb300ba21 100644
--- a/src/main/ipc/filesystem-import-ssh.ts
+++ b/src/main/ipc/filesystem-import-ssh.ts
@@ -1,6 +1,5 @@
 import { lstat } from 'node:fs/promises'
 import { basename, posix, resolve } from 'node:path'
-import { authorizeExternalPath } from './filesystem-auth'
 import { isENOENT } from './filesystem-path-containment'
 import { getSshConnectionManager } from './ssh'
 import { requireSshFilesystemProvider } from '../providers/ssh-filesystem-dispatch'
@@ -97,8 +96,6 @@ async function importOneSourceSsh(
 ): Promise<ImportItemResult> {
   const resolvedSource = resolve(sourcePath)
 
-  authorizeExternalPath(resolvedSource)
-
   const originalName = basename(resolvedSource)
   try {
     assertSafeRemotePathSegment(originalName, remotePathFlavor)
diff --git a/src/main/ipc/filesystem-import.test.ts b/src/main/ipc/filesystem-import.test.ts
index 8047c19f62d..c2df10fd70b 100644
--- a/src/main/ipc/filesystem-import.test.ts
+++ b/src/main/ipc/filesystem-import.test.ts
@@ -29,6 +29,7 @@ const {
 }))
 
 vi.mock('electron', () => ({
+  app: { getPath: () => '/orca-test-user-data' },
   ipcMain: { handle: handleMock }
 }))
 
diff --git a/src/main/ipc/filesystem-mutations.test.ts b/src/main/ipc/filesystem-mutations.test.ts
index 18d05ab5c96..36db8630dc5 100644
--- a/src/main/ipc/filesystem-mutations.test.ts
+++ b/src/main/ipc/filesystem-mutations.test.ts
@@ -14,6 +14,7 @@ const { handleMock, copyFileMock, lstatMock, mkdirMock, renameMock, writeFileMoc
   }))
 
 vi.mock('electron', () => ({
+  app: { getPath: () => '/orca-test-user-data' },
   ipcMain: { handle: handleMock }
 }))
 
diff --git a/src/main/ipc/filesystem-mutations.ts b/src/main/ipc/filesystem-mutations.ts
index ad1308f0c30..e96650a7442 100644
--- a/src/main/ipc/filesystem-mutations.ts
+++ b/src/main/ipc/filesystem-mutations.ts
@@ -3,7 +3,12 @@ import { constants } from 'node:fs'
 import { copyFile, mkdir, writeFile } from 'node:fs/promises'
 import { basename, dirname } from 'node:path'
 import type { Store } from '../persistence'
-import { resolveAuthorizedPath } from './filesystem-auth'
+import {
+  resolveDesktopAuthorizedPath,
+  resolveLocalRenamePaths,
+  resolveLocalRequestPath
+} from './local-file-access-resolution'
+import type { LocalFileAccess } from '../../shared/local-file-access'
 import { requireSshFilesystemProvider } from '../providers/ssh-filesystem-dispatch'
 import { resolveLocalDroppedPathsForAgent } from './dropped-path-resolution'
 import { importExternalPathsSsh } from './filesystem-import-ssh'
@@ -49,7 +54,7 @@ export function registerFilesystemMutationHandlers(store: Store): void {
         const provider = requireSshFilesystemProvider(args.connectionId)
         return provider.createFile(args.filePath)
       }
-      const filePath = await resolveAuthorizedPath(args.filePath, store)
+      const filePath = await resolveDesktopAuthorizedPath(args.filePath, store)
       await mkdir(dirname(filePath), { recursive: true })
       try {
         // Use the 'wx' flag for atomic create-if-not-exists, avoiding TOCTOU races
@@ -76,7 +81,7 @@ export function registerFilesystemMutationHandlers(store: Store): void {
         const provider = requireSshFilesystemProvider(args.connectionId)
         return provider.createDir(args.dirPath)
       }
-      const dirPath = await resolveAuthorizedPath(args.dirPath, store)
+      const dirPath = await resolveDesktopAuthorizedPath(args.dirPath, store)
       await assertNotExists(dirPath)
       await mkdir(dirPath, { recursive: true })
     }
@@ -89,7 +94,12 @@ export function registerFilesystemMutationHandlers(store: Store): void {
     'fs:rename',
     async (
       _event,
-      args: { oldPath: string; newPath: string; connectionId?: string } & SshMutationExpectation
+      args: {
+        oldPath: string
+        newPath: string
+        connectionId?: string
+        access?: LocalFileAccess
+      } & SshMutationExpectation
     ): Promise<void> => {
       assertSshMutationExpectation(
         args.connectionId,
@@ -107,9 +117,14 @@ export function registerFilesystemMutationHandlers(store: Store): void {
       // target file (potentially elsewhere in the worktree) and leave the
       // symlink dangling. newPath must also preserve its leaf so we don't
       // accidentally write into a symlinked destination name.
-      const oldPath = await resolveAuthorizedPath(args.oldPath, store, { preserveSymlink: true })
-      const newPath = await resolveAuthorizedPath(args.newPath, store, { preserveSymlink: true })
-      await renameLocalPathSerializedByDestination(oldPath, newPath)
+      // Outside every project, a document the user opened may still be renamed, to any path.
+      const { from, to } = await resolveLocalRenamePaths(
+        args.oldPath,
+        args.newPath,
+        args.access,
+        store
+      )
+      await renameLocalPathSerializedByDestination(from, to)
     }
   )
 
@@ -133,10 +148,10 @@ export function registerFilesystemMutationHandlers(store: Store): void {
         const provider = requireSshFilesystemProvider(args.connectionId)
         return provider.copy(args.sourcePath, args.destinationPath)
       }
-      const sourcePath = await resolveAuthorizedPath(args.sourcePath, store, {
+      const sourcePath = await resolveDesktopAuthorizedPath(args.sourcePath, store, {
         preserveSymlink: true
       })
-      const destinationPath = await resolveAuthorizedPath(args.destinationPath, store, {
+      const destinationPath = await resolveDesktopAuthorizedPath(args.destinationPath, store, {
         preserveSymlink: true
       })
       await mkdir(dirname(destinationPath), { recursive: true })
@@ -155,6 +170,7 @@ export function registerFilesystemMutationHandlers(store: Store): void {
         destDir: string
         connectionId?: string
         ensureDir?: boolean
+        access?: LocalFileAccess
       } & SshMutationExpectation
     ): Promise<{ results: ImportItemResult[] }> => {
       assertSshMutationExpectation(
@@ -180,7 +196,13 @@ export function registerFilesystemMutationHandlers(store: Store): void {
       // destination is outside allowed roots, the entire import fails.
       // This only applies to local imports — remote paths are authorized by
       // the SSH connection boundary (see importExternalPathsSsh).
-      const resolvedDest = await resolveAuthorizedPath(args.destDir, store)
+      // An image inserted into a document the user opened lands in that document's own folder.
+      const resolvedDest = await resolveLocalRequestPath(
+        args.destDir,
+        args.access,
+        store,
+        'import-into'
+      )
 
       const results: ImportItemResult[] = []
       const reservedNames = new Set<string>()
diff --git a/src/main/ipc/filesystem-runtime-upload-staging.test.ts b/src/main/ipc/filesystem-runtime-upload-staging.test.ts
index de32bd8ebb4..7f6b4d96b17 100644
--- a/src/main/ipc/filesystem-runtime-upload-staging.test.ts
+++ b/src/main/ipc/filesystem-runtime-upload-staging.test.ts
@@ -6,7 +6,6 @@ import type * as RuntimeImportLimits from './runtime-import-limits'
 
 type RuntimeImportLimitsModule = typeof RuntimeImportLimits
 
-vi.mock('./filesystem-auth', () => ({ authorizeExternalPath: () => {} }))
 // Why: real ceilings are gigabytes, and truncate() is not sparse on NTFS, so a
 // literal over-limit fixture would allocate that much on Windows CI.
 vi.mock('./runtime-import-limits', async (importOriginal) => ({
diff --git a/src/main/ipc/filesystem-runtime-upload-staging.ts b/src/main/ipc/filesystem-runtime-upload-staging.ts
index 6531f8a499a..9d5d8467e3e 100644
--- a/src/main/ipc/filesystem-runtime-upload-staging.ts
+++ b/src/main/ipc/filesystem-runtime-upload-staging.ts
@@ -6,7 +6,6 @@ import {
 import { constants } from 'node:fs'
 import { lstat, open, readdir, realpath } from 'node:fs/promises'
 import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path'
-import { authorizeExternalPath } from './filesystem-auth'
 import { isENOENT } from './filesystem-path-containment'
 import type {
   StagedExternalImportEntry,
@@ -36,10 +35,6 @@ export async function stageOneSourceForRuntimeUpload(
 ): Promise<StagedExternalImportSource> {
   const resolvedSource = resolve(sourcePath)
 
-  // Why: runtime uploads read client-local paths in the client main process;
-  // authorize before lstat just like local copy imports.
-  authorizeExternalPath(resolvedSource)
-
   let sourceStat: Awaited<ReturnType<typeof lstat>>
   try {
     sourceStat = await lstat(resolvedSource)
diff --git a/src/main/ipc/filesystem-search-rg-timeout.test.ts b/src/main/ipc/filesystem-search-rg-timeout.test.ts
index d4096500381..db6f3c9c57c 100644
--- a/src/main/ipc/filesystem-search-rg-timeout.test.ts
+++ b/src/main/ipc/filesystem-search-rg-timeout.test.ts
@@ -24,6 +24,7 @@ const {
 const handlers = new Map<string, (event: unknown, args: unknown) => unknown>()
 
 vi.mock('electron', () => ({
+  app: { getPath: () => '/orca-test-user-data' },
   ipcMain: {
     handle: handleMock
   },
@@ -43,7 +44,6 @@ vi.mock('../wsl', () => ({
 }))
 
 vi.mock('./filesystem-auth', () => ({
-  authorizeExternalPath: vi.fn(async (value: string) => value),
   resolveAuthorizedPath: resolveAuthorizedPathMock
 }))
 
diff --git a/src/main/ipc/filesystem-test-harness.ts b/src/main/ipc/filesystem-test-harness.ts
index a3a06b95e85..069f4c10d83 100644
--- a/src/main/ipc/filesystem-test-harness.ts
+++ b/src/main/ipc/filesystem-test-harness.ts
@@ -60,6 +60,7 @@ export const recordCrashBreadcrumbMock: IpcMock = vi.fn()
 export const promoteLocalDownloadedFolderMock: IpcMock = vi.fn()
 
 export const electronMock = {
+  app: { getPath: () => '/orca-test-user-data' },
   BrowserWindow: { fromWebContents: fromWebContentsMock },
   dialog: { showSaveDialog: showSaveDialogMock, showOpenDialog: showOpenDialogMock },
   ipcMain: { handle: handleMock },
@@ -237,6 +238,36 @@ const ALL_MOCKS = [
   pullRequestLinkedIssueMock
 ].flatMap(collectMocks)
 
+/** A FileHandle double over `content`: positional reads copy from it, and stat reports its size. */
+export function localFileHandleMock(
+  content: Buffer,
+  { isFile = true, size = content.byteLength }: { isFile?: boolean; size?: number } = {}
+): Record<string, unknown> {
+  return {
+    stat: vi.fn(async () => ({
+      size,
+      isFile: () => isFile,
+      isDirectory: () => false,
+      mtimeMs: 123,
+      dev: 1,
+      ino: 2,
+      birthtimeMs: 3
+    })),
+    read: vi.fn(async (buffer: Buffer, offset: number, length: number, position: number) => {
+      const bytesRead = content.copy(
+        buffer,
+        offset,
+        position,
+        Math.min(position + length, content.length)
+      )
+      return { bytesRead, buffer }
+    }),
+    write: vi.fn().mockResolvedValue(undefined),
+    writeFile: vi.fn().mockResolvedValue(undefined),
+    close: vi.fn()
+  }
+}
+
 /** Resets every filesystem IPC mock and reinstalls the defaults every suite starts from. */
 export function resetFilesystemIpcMocks(): void {
   handlers.clear()
@@ -272,14 +303,6 @@ export function resetFilesystemIpcMocks(): void {
   statMock.mockResolvedValue({ size: 10, isDirectory: () => false, mtimeMs: 123 })
   renameMock.mockResolvedValue(undefined)
   rmMock.mockResolvedValue(undefined)
-  openMock.mockResolvedValue({
-    read: vi.fn(async (buffer: Buffer) => {
-      buffer.fill(0x61)
-      return { bytesRead: buffer.length, buffer }
-    }),
-    write: vi.fn().mockResolvedValue(undefined),
-    writeFile: vi.fn().mockResolvedValue(undefined),
-    close: vi.fn()
-  })
+  openMock.mockResolvedValue(localFileHandleMock(Buffer.from('a'.repeat(10))))
   lstatMock.mockRejectedValue(Object.assign(new Error('missing'), { code: 'ENOENT' }))
 }
diff --git a/src/main/ipc/filesystem.test.ts b/src/main/ipc/filesystem.test.ts
index 68946d56cff..8582a3b00ac 100644
--- a/src/main/ipc/filesystem.test.ts
+++ b/src/main/ipc/filesystem.test.ts
@@ -18,7 +18,8 @@ import {
   getSshFilesystemProviderMock,
   tryDeleteWslUncPathMock,
   recordCrashBreadcrumbMock,
-  resetFilesystemIpcMocks
+  resetFilesystemIpcMocks,
+  localFileHandleMock
 } from './filesystem-test-harness'
 
 vi.mock('electron', async () => (await import('./filesystem-test-harness')).electronMock)
@@ -83,6 +84,13 @@ describe('registerFilesystemHandlers', () => {
     invalidateAuthorizedRootsCache()
   })
 
+  it('registers no channel that remembers a path grant', () => {
+    registerFilesystemHandlers(store as never)
+
+    expect(handlers.has('fs:readFile')).toBe(true)
+    expect(handlers.has('fs:authorizeExternalPath')).toBe(false)
+  })
+
   it('re-sorts SSH provider listings directories-first in natural order', async () => {
     // Why: the remote relay may be an older build that still sorts lexicographically.
     getSshFilesystemProviderMock.mockReturnValueOnce({
@@ -361,8 +369,7 @@ describe('registerFilesystemHandlers', () => {
     }
   ])('returns base64 content for supported $ext binaries', async ({ ext, mime, data }) => {
     const buf = Buffer.from(data)
-    statMock.mockResolvedValue({ size: buf.length, isDirectory: () => false, mtimeMs: 123 })
-    readFileMock.mockResolvedValue(buf)
+    openMock.mockResolvedValue(localFileHandleMock(buf))
     registerFilesystemHandlers(store as never)
     await expect(
       handlers.get('fs:readFile')!(null, { filePath: path.resolve(`/workspace/repo/file.${ext}`) })
@@ -376,8 +383,7 @@ describe('registerFilesystemHandlers', () => {
 
   it('opens text files larger than the old 5MB guard', async () => {
     const content = 'a'.repeat(6 * 1024 * 1024)
-    statMock.mockResolvedValue({ size: content.length, isDirectory: () => false, mtimeMs: 123 })
-    readFileMock.mockResolvedValue(Buffer.from(content))
+    openMock.mockResolvedValue(localFileHandleMock(Buffer.from(content)))
 
     registerFilesystemHandlers(store as never)
 
@@ -391,17 +397,8 @@ describe('registerFilesystemHandlers', () => {
 
   it('returns stable byte metadata only for opted-in local log snapshots', async () => {
     const content = Buffer.from('first\npartial')
-    const close = vi.fn()
-    openMock.mockResolvedValue({
-      stat: vi.fn().mockResolvedValue({
-        size: content.byteLength,
-        dev: 1,
-        ino: 2,
-        birthtimeMs: 3
-      }),
-      readFile: vi.fn().mockResolvedValue(content),
-      close
-    })
+    const handle = localFileHandleMock(content)
+    openMock.mockResolvedValue(handle)
     registerFilesystemHandlers(store as never)
 
     await expect(
@@ -414,12 +411,13 @@ describe('registerFilesystemHandlers', () => {
       isBinary: false,
       fileIdentity: '1:2:3'
     })
-    expect(close).toHaveBeenCalledTimes(1)
+    expect(handle.close).toHaveBeenCalledTimes(1)
     expect(readFileMock).not.toHaveBeenCalled()
   })
 
   it('rejects text files beyond the editor read budget', async () => {
-    statMock.mockResolvedValue({ size: 51 * 1024 * 1024, isDirectory: () => false, mtimeMs: 123 })
+    const handle = localFileHandleMock(Buffer.alloc(0), { size: 51 * 1024 * 1024 })
+    openMock.mockResolvedValue(handle)
 
     registerFilesystemHandlers(store as never)
 
@@ -427,18 +425,13 @@ describe('registerFilesystemHandlers', () => {
       handlers.get('fs:readFile')!(null, { filePath: path.resolve('/workspace/repo/huge.json') })
     ).rejects.toThrow('exceeds 50MB limit')
 
-    expect(readFileMock).not.toHaveBeenCalled()
+    expect(handle.read).not.toHaveBeenCalled()
+    expect(handle.close).toHaveBeenCalled()
   })
 
   it('probes large unknown binaries without reading the full file', async () => {
-    statMock.mockResolvedValue({ size: 6 * 1024 * 1024, isDirectory: () => false, mtimeMs: 123 })
-    openMock.mockResolvedValue({
-      read: vi.fn(async (buffer: Buffer) => {
-        buffer[0] = 0x00
-        return { bytesRead: 1, buffer }
-      }),
-      close: vi.fn()
-    })
+    const handle = localFileHandleMock(Buffer.alloc(6 * 1024 * 1024))
+    openMock.mockResolvedValue(handle)
 
     registerFilesystemHandlers(store as never)
 
@@ -449,7 +442,7 @@ describe('registerFilesystemHandlers', () => {
       isBinary: true
     })
 
-    expect(readFileMock).not.toHaveBeenCalled()
+    expect(handle.read).toHaveBeenCalledTimes(1)
   })
 
   it('moves files to trash', async () => {
@@ -519,8 +512,7 @@ describe('registerFilesystemHandlers', () => {
   })
 
   it('keeps non-image binaries hidden from the editor payload', async () => {
-    statMock.mockResolvedValue({ size: 4, isDirectory: () => false, mtimeMs: 123 })
-    readFileMock.mockResolvedValue(Buffer.from([0x00, 0x01, 0x02]))
+    openMock.mockResolvedValue(localFileHandleMock(Buffer.from([0x00, 0x01, 0x02])))
 
     registerFilesystemHandlers(store as never)
 
diff --git a/src/main/ipc/filesystem/filesystem-chunk-read-handler.ts b/src/main/ipc/filesystem/filesystem-chunk-read-handler.ts
new file mode 100644
index 00000000000..e04ccec5e78
--- /dev/null
+++ b/src/main/ipc/filesystem/filesystem-chunk-read-handler.ts
@@ -0,0 +1,42 @@
+import { ipcMain } from 'electron'
+import { readLocalFileRange } from './local-file-range-read'
+import { validateFileRangeRequest } from '../../../shared/file-range-read'
+import { requireSshFilesystemProvider } from '../../providers/ssh-filesystem-dispatch'
+import { readSshFileExplorerChunk } from '../../runtime/ssh-file-explorer-chunk-read'
+import { resolveLocalFileRequestPath } from '../local-file-access-resolution'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
+import type { FilesystemHandlerContext } from './filesystem-handler-context'
+
+export function registerFilesystemChunkReadHandler({ store }: FilesystemHandlerContext): void {
+  ipcMain.handle(
+    'fs:readFileChunk',
+    async (
+      _event,
+      args: {
+        filePath: string
+        connectionId?: string
+        access?: LocalFileAccess
+        offset: number
+        length: number
+      }
+    ) => {
+      validateFileRangeRequest(args.offset, args.length)
+      if (args.connectionId) {
+        const provider = requireSshFilesystemProvider(args.connectionId)
+        const stats = await provider.stat(args.filePath)
+        if (stats.type === 'directory') {
+          throw new Error('Cannot read a directory')
+        }
+        return readSshFileExplorerChunk(
+          provider,
+          args.filePath,
+          stats.size,
+          args.offset,
+          args.length
+        )
+      }
+      const filePath = await resolveLocalFileRequestPath(args.filePath, args.access, store)
+      return readLocalFileRange(filePath, args.offset, args.length)
+    }
+  )
+}
diff --git a/src/main/ipc/filesystem/filesystem-file-content-inspection.ts b/src/main/ipc/filesystem/filesystem-file-content-inspection.ts
index b140532c372..49473eb3f3f 100644
--- a/src/main/ipc/filesystem/filesystem-file-content-inspection.ts
+++ b/src/main/ipc/filesystem/filesystem-file-content-inspection.ts
@@ -1,6 +1,11 @@
-import { open } from 'node:fs/promises'
-import type { FileHandle } from 'node:fs/promises'
+import { extname } from 'node:path'
 import { localLogFileIdentity } from '../../ai-vault/local-log-tail-reader'
+import {
+  fileTooLargeError,
+  openLocalRegularFile,
+  readLocalFileBounded,
+  readLocalFilePrefix
+} from './local-regular-file-read'
 
 // Why: Monaco degrades features on large files like VS Code, so a 5MB block would needlessly lock out ordinary JSON/log files.
 export const MAX_TEXT_FILE_SIZE = 50 * 1024 * 1024 // 50MB
@@ -9,6 +14,7 @@ export const BINARY_PROBE_BYTES = 8192
 export const MAX_PREVIEWABLE_BINARY_SIZE = 50 * 1024 * 1024 // 50MB
 export const PREVIEWABLE_BINARY_MIME_TYPES: Record<string, string> = {
   '.png': 'image/png',
+  '.avif': 'image/avif',
   '.jpg': 'image/jpeg',
   '.jpeg': 'image/jpeg',
   '.gif': 'image/gif',
@@ -19,25 +25,57 @@ export const PREVIEWABLE_BINARY_MIME_TYPES: Record<string, string> = {
   '.pdf': 'application/pdf'
 }
 
-export async function readLocalLogSnapshot(filePath: string): Promise<{
+export type LocalFileContent = {
   content: string
   isBinary: boolean
+  isImage?: boolean
+  mimeType?: string
   fileIdentity?: string
-}> {
-  const handle = await open(filePath, 'r')
+}
+
+/** One open, one handle: the size check, binary probe and read all see the same regular file. */
+export async function readLocalFileContent(filePath: string): Promise<LocalFileContent> {
+  const { handle, stats } = await openLocalRegularFile(filePath)
+  try {
+    const mimeType = PREVIEWABLE_BINARY_MIME_TYPES[extname(filePath).toLowerCase()]
+    const sizeLimit = mimeType ? MAX_PREVIEWABLE_BINARY_SIZE : MAX_TEXT_FILE_SIZE
+    if (stats.size > sizeLimit) {
+      throw fileTooLargeError(stats.size, sizeLimit)
+    }
+    if (mimeType) {
+      const buffer = await readLocalFileBounded(handle, sizeLimit, stats.size)
+      return {
+        content: buffer.toString('base64'),
+        isBinary: true,
+        // Why: the renderer keys previewable-binary rendering off `isImage`, so set it for PDFs too to stay compatible.
+        isImage: true,
+        mimeType
+      }
+    }
+    // Why: probe large unknown files first so archives aren't fully buffered only to discover they aren't editable text.
+    if (
+      stats.size > BINARY_PROBE_BYTES &&
+      isBinaryBuffer(await readLocalFilePrefix(handle, BINARY_PROBE_BYTES))
+    ) {
+      return { content: '', isBinary: true }
+    }
+    const buffer = await readLocalFileBounded(handle, sizeLimit, stats.size)
+    if (isBinaryBuffer(buffer)) {
+      return { content: '', isBinary: true }
+    }
+    return { content: buffer.toString('utf-8'), isBinary: false }
+  } finally {
+    await handle.close()
+  }
+}
+
+export async function readLocalLogSnapshot(filePath: string): Promise<LocalFileContent> {
+  const { handle, stats } = await openLocalRegularFile(filePath)
   try {
-    const stats = await handle.stat()
     if (stats.size > MAX_TEXT_FILE_SIZE) {
-      throw new Error(
-        `File too large: ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds ${MAX_TEXT_FILE_SIZE / 1024 / 1024}MB limit`
-      )
-    }
-    const buffer = await handle.readFile()
-    if (buffer.byteLength > MAX_TEXT_FILE_SIZE) {
-      throw new Error(
-        `File too large: ${(buffer.byteLength / 1024 / 1024).toFixed(1)}MB exceeds ${MAX_TEXT_FILE_SIZE / 1024 / 1024}MB limit`
-      )
+      throw fileTooLargeError(stats.size, MAX_TEXT_FILE_SIZE)
     }
+    const buffer = await readLocalFileBounded(handle, MAX_TEXT_FILE_SIZE, stats.size)
     if (isBinaryBuffer(buffer)) {
       return { content: '', isBinary: true }
     }
@@ -62,17 +100,6 @@ export function isBinaryBuffer(buffer: Buffer): boolean {
   return false
 }
 
-export async function isBinaryFilePrefix(filePath: string): Promise<boolean> {
-  const handle: FileHandle = await open(filePath, 'r')
-  try {
-    const probe = Buffer.alloc(BINARY_PROBE_BYTES)
-    const { bytesRead } = await handle.read(probe, 0, probe.length, 0)
-    return isBinaryBuffer(probe.subarray(0, bytesRead))
-  } finally {
-    await handle.close()
-  }
-}
-
 export function isDirectoryEntry(entry: {
   isDirectory(): boolean
   isSymbolicLink(): boolean
diff --git a/src/main/ipc/filesystem/filesystem-read-handlers.ts b/src/main/ipc/filesystem/filesystem-read-handlers.ts
index 1d9fe681fee..f414f1d0c16 100644
--- a/src/main/ipc/filesystem/filesystem-read-handlers.ts
+++ b/src/main/ipc/filesystem/filesystem-read-handlers.ts
@@ -4,31 +4,32 @@ import {
   type PathExistenceResult
 } from '../../../shared/path-existence-batch'
 import { ipcMain } from 'electron'
-import { readdir, readFile, stat } from 'node:fs/promises'
-import { extname } from 'node:path'
+import { readdir, stat } from 'node:fs/promises'
 import type { DirEntry, MarkdownDocument } from '../../../shared/filesystem-entry-types'
 import { sortDirEntries } from '../../../shared/file-name-sort'
 import { requireSshFilesystemProvider } from '../../providers/ssh-filesystem-dispatch'
 import { resolveRegisteredWorktreePath } from '../registered-worktree-roots-cache'
-import { resolveAuthorizedPath } from '../filesystem-auth'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
+import {
+  resolveDesktopAuthorizedPath,
+  resolveLocalFileRequestPath
+} from '../local-file-access-resolution'
 import { isENOENT } from '../filesystem-path-containment'
 import { listMarkdownDocuments, markdownDocumentsFromRelativePaths } from '../markdown-documents'
 import { getLocalGitOptionsForRegisteredWorktree } from '../local-worktree-runtime-options'
 import { recordCrashBreadcrumb } from '../../crash-reporting/crash-breadcrumb-store'
 import { buildReadDirErrorBreadcrumb, type ReadDirThrowSite } from '../readdir-error-diagnostics'
 import type { FilesystemHandlerContext } from './filesystem-handler-context'
+import { registerFilesystemChunkReadHandler } from './filesystem-chunk-read-handler'
 import {
-  BINARY_PROBE_BYTES,
-  isBinaryBuffer,
-  isBinaryFilePrefix,
   isDirectoryEntry,
-  MAX_PREVIEWABLE_BINARY_SIZE,
-  MAX_TEXT_FILE_SIZE,
-  PREVIEWABLE_BINARY_MIME_TYPES,
-  readLocalLogSnapshot
+  readLocalFileContent,
+  readLocalLogSnapshot,
+  type LocalFileContent
 } from './filesystem-file-content-inspection'
 
 export function registerFilesystemReadHandlers(context: FilesystemHandlerContext): void {
+  registerFilesystemChunkReadHandler(context)
   const { store } = context
 
   ipcMain.handle(
@@ -43,7 +44,7 @@ export function registerFilesystemReadHandlers(context: FilesystemHandlerContext
           // Why: re-sort locally — the remote relay may be an older build with lexicographic ordering.
           return sortDirEntries(await provider.readDir(args.dirPath))
         }
-        const dirPath = await resolveAuthorizedPath(args.dirPath, store)
+        const dirPath = await resolveDesktopAuthorizedPath(args.dirPath, store)
         throwSite = 'readdir'
         const entries = await readdir(dirPath, { withFileTypes: true })
         const mapped = entries.map((entry) => ({
@@ -71,52 +72,21 @@ export function registerFilesystemReadHandlers(context: FilesystemHandlerContext
     'fs:readFile',
     async (
       _event,
-      args: { filePath: string; connectionId?: string; includeLocalLogMetadata?: boolean }
-    ): Promise<{
-      content: string
-      isBinary: boolean
-      isImage?: boolean
-      mimeType?: string
-      fileIdentity?: string
-    }> => {
+      args: {
+        filePath: string
+        connectionId?: string
+        includeLocalLogMetadata?: boolean
+        access?: LocalFileAccess
+      }
+    ): Promise<LocalFileContent> => {
       if (args.connectionId) {
         const provider = requireSshFilesystemProvider(args.connectionId)
         return provider.readFile(args.filePath)
       }
-      const filePath = await resolveAuthorizedPath(args.filePath, store)
-      if (args.includeLocalLogMetadata === true) {
-        return readLocalLogSnapshot(filePath)
-      }
-      const stats = await stat(filePath)
-      const mimeType = PREVIEWABLE_BINARY_MIME_TYPES[extname(filePath).toLowerCase()]
-      const sizeLimit = mimeType ? MAX_PREVIEWABLE_BINARY_SIZE : MAX_TEXT_FILE_SIZE
-      if (stats.size > sizeLimit) {
-        throw new Error(
-          `File too large: ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds ${sizeLimit / 1024 / 1024}MB limit`
-        )
-      }
-
-      if (mimeType) {
-        const buffer = await readFile(filePath)
-        return {
-          content: buffer.toString('base64'),
-          isBinary: true,
-          // Why: the renderer keys previewable-binary rendering off `isImage`, so set it for PDFs too to stay compatible.
-          isImage: true,
-          mimeType
-        }
-      }
-
-      // Why: probe large unknown files first so archives aren't fully buffered only to discover they aren't editable text.
-      if (stats.size > BINARY_PROBE_BYTES && (await isBinaryFilePrefix(filePath))) {
-        return { content: '', isBinary: true }
-      }
-
-      const buffer = await readFile(filePath)
-      if (isBinaryBuffer(buffer)) {
-        return { content: '', isBinary: true }
-      }
-      return { content: buffer.toString('utf-8'), isBinary: false }
+      const filePath = await resolveLocalFileRequestPath(args.filePath, args.access, store)
+      return args.includeLocalLogMetadata === true
+        ? readLocalLogSnapshot(filePath)
+        : readLocalFileContent(filePath)
     }
   )
 
@@ -143,14 +113,14 @@ export function registerFilesystemReadHandlers(context: FilesystemHandlerContext
     'fs:stat',
     async (
       _event,
-      args: { filePath: string; connectionId?: string }
+      args: { filePath: string; connectionId?: string; access?: LocalFileAccess }
     ): Promise<{ size: number; isDirectory: boolean; mtime: number }> => {
       if (args.connectionId) {
         const provider = requireSshFilesystemProvider(args.connectionId)
         const result = await provider.stat(args.filePath)
         return { size: result.size, isDirectory: result.type === 'directory', mtime: result.mtime }
       }
-      const filePath = await resolveAuthorizedPath(args.filePath, store)
+      const filePath = await resolveLocalFileRequestPath(args.filePath, args.access, store)
       const stats = await stat(filePath)
       return { size: stats.size, isDirectory: stats.isDirectory(), mtime: stats.mtimeMs }
     }
@@ -173,7 +143,7 @@ export function registerFilesystemReadHandlers(context: FilesystemHandlerContext
             try {
               await (provider
                 ? provider.stat(filePath)
-                : stat(await resolveAuthorizedPath(filePath, store)))
+                : stat(await resolveDesktopAuthorizedPath(filePath, store)))
               return true
             } catch (error) {
               if (isENOENT(error)) {
@@ -189,14 +159,17 @@ export function registerFilesystemReadHandlers(context: FilesystemHandlerContext
 
   ipcMain.handle(
     'fs:pathExists',
-    async (_event, args: { filePath: string; connectionId?: string }): Promise<boolean> => {
+    async (
+      _event,
+      args: { filePath: string; connectionId?: string; access?: LocalFileAccess }
+    ): Promise<boolean> => {
       try {
         if (args.connectionId) {
           const provider = requireSshFilesystemProvider(args.connectionId)
           await provider.stat(args.filePath)
           return true
         }
-        const filePath = await resolveAuthorizedPath(args.filePath, store)
+        const filePath = await resolveLocalFileRequestPath(args.filePath, args.access, store)
         await stat(filePath)
         return true
       } catch (error) {
diff --git a/src/main/ipc/filesystem/filesystem-search-handlers.ts b/src/main/ipc/filesystem/filesystem-search-handlers.ts
index 94cc07a2f1f..63ee18a1d4b 100644
--- a/src/main/ipc/filesystem/filesystem-search-handlers.ts
+++ b/src/main/ipc/filesystem/filesystem-search-handlers.ts
@@ -26,7 +26,7 @@ import {
   getSshFilesystemProvider,
   requireSshFilesystemProvider
 } from '../../providers/ssh-filesystem-dispatch'
-import { resolveAuthorizedPath } from '../filesystem-auth'
+import { resolveDesktopAuthorizedPath } from '../local-file-access-resolution'
 import { listQuickOpenFiles } from '../filesystem-list-files'
 import {
   isFileNameFilterQueryTooLarge,
@@ -52,7 +52,7 @@ export function registerFilesystemSearchHandlers(context: FilesystemHandlerConte
         const provider = requireSshFilesystemProvider(args.connectionId)
         return provider.search(args)
       }
-      const rootPath = await resolveAuthorizedPath(args.rootPath, store)
+      const rootPath = await resolveDesktopAuthorizedPath(args.rootPath, store)
       const localGitOptions = getLocalGitOptionsForRegisteredWorktree(
         store,
         args.rootPath,
diff --git a/src/main/ipc/filesystem/filesystem-write-handlers.ts b/src/main/ipc/filesystem/filesystem-write-handlers.ts
index 07d4de5b56a..ff614b8d35a 100644
--- a/src/main/ipc/filesystem/filesystem-write-handlers.ts
+++ b/src/main/ipc/filesystem/filesystem-write-handlers.ts
@@ -4,10 +4,15 @@ import type { SshMutationExpectation } from '../../../shared/ssh-types'
 import { assertSshMutationExpectation } from '../../ssh/ssh-connection-generation'
 import { requireSshFilesystemProvider } from '../../providers/ssh-filesystem-dispatch'
 import { tryDeleteWslUncPath } from '../../wsl-unc-delete'
-import { authorizeExternalPath, resolveAuthorizedPath } from '../filesystem-auth'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
+import {
+  resolveDesktopAuthorizedPath,
+  resolveLocalWriteRequestPath
+} from '../local-file-access-resolution'
 import { isENOENT } from '../filesystem-path-containment'
 import { registerFilesystemMutationHandlers } from '../filesystem-mutations'
 import type { FilesystemHandlerContext } from './filesystem-handler-context'
+import { assertLocalWriteTargetIsRegularFile } from './local-regular-file-read'
 
 export function registerFilesystemWriteHandlers(context: FilesystemHandlerContext): void {
   const { store } = context
@@ -16,7 +21,12 @@ export function registerFilesystemWriteHandlers(context: FilesystemHandlerContex
     'fs:writeFile',
     async (
       _event,
-      args: { filePath: string; content: string; connectionId?: string } & SshMutationExpectation
+      args: {
+        filePath: string
+        content: string
+        connectionId?: string
+        access?: LocalFileAccess
+      } & SshMutationExpectation
     ): Promise<void> => {
       assertSshMutationExpectation(
         args.connectionId,
@@ -28,7 +38,7 @@ export function registerFilesystemWriteHandlers(context: FilesystemHandlerContex
         const provider = requireSshFilesystemProvider(args.connectionId)
         return provider.writeFile(args.filePath, args.content)
       }
-      const filePath = await resolveAuthorizedPath(args.filePath, store)
+      const filePath = await resolveLocalWriteRequestPath(args.filePath, args.access, store)
       try {
         const fileStats = await lstat(filePath)
         if (fileStats.isDirectory()) {
@@ -39,6 +49,7 @@ export function registerFilesystemWriteHandlers(context: FilesystemHandlerContex
           throw error
         }
       }
+      await assertLocalWriteTargetIsRegularFile(filePath)
       await writeFile(filePath, args.content, 'utf-8')
     }
   )
@@ -64,7 +75,7 @@ export function registerFilesystemWriteHandlers(context: FilesystemHandlerContex
         return provider.deletePath(args.targetPath, args.recursive)
       }
       // Why: preserve the symlink so we delete the link, not its target (realpath would trash the real file, possibly outside all roots).
-      const targetPath = await resolveAuthorizedPath(args.targetPath, store, {
+      const targetPath = await resolveDesktopAuthorizedPath(args.targetPath, store, {
         preserveSymlink: true
       })
       // Why: WSL UNC targets have no Recycle Bin (shell.trashItem throws), so hard-delete via `rm` inside the distro (issue #6415).
@@ -84,8 +95,4 @@ export function registerFilesystemWriteHandlers(context: FilesystemHandlerContex
   )
 
   registerFilesystemMutationHandlers(store)
-
-  ipcMain.handle('fs:authorizeExternalPath', (_event, args: { targetPath: string }): void => {
-    authorizeExternalPath(args.targetPath)
-  })
 }
diff --git a/src/main/ipc/filesystem/local-file-range-read.test.ts b/src/main/ipc/filesystem/local-file-range-read.test.ts
new file mode 100644
index 00000000000..b73cd7788c2
--- /dev/null
+++ b/src/main/ipc/filesystem/local-file-range-read.test.ts
@@ -0,0 +1,50 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, expect, it } from 'vitest'
+import { readLocalFileRange } from './local-file-range-read'
+
+let folder: string
+beforeEach(async () => {
+  folder = await mkdtemp(join(tmpdir(), 'orca-file-range-'))
+})
+afterEach(async () => {
+  await rm(folder, { recursive: true, force: true })
+})
+
+it('reads only the requested bytes and reports partial and past-EOF ranges', async () => {
+  const file = join(folder, 'records.csv')
+  await writeFile(file, '0123456789')
+  await expect(readLocalFileRange(file, 3, 4)).resolves.toEqual({
+    contentBase64: Buffer.from('3456').toString('base64'),
+    bytesRead: 4,
+    eof: false
+  })
+  await expect(readLocalFileRange(file, 8, 4)).resolves.toEqual({
+    contentBase64: Buffer.from('89').toString('base64'),
+    bytesRead: 2,
+    eof: true
+  })
+  await expect(readLocalFileRange(file, 12, 4)).resolves.toEqual({
+    contentBase64: '',
+    bytesRead: 0,
+    eof: true
+  })
+})
+
+it('refuses directories through the shared regular-file guard', async () => {
+  await expect(readLocalFileRange(folder, 0, 4)).rejects.toThrow()
+})
+
+it('rejects invalid or excessive ranges before opening the path', async () => {
+  for (const [offset, length] of [
+    [-1, 1],
+    [0, 0],
+    [0, 512 * 1024 + 1],
+    [Number.MAX_SAFE_INTEGER, 2]
+  ]) {
+    await expect(readLocalFileRange(join(folder, 'missing.csv'), offset, length)).rejects.toThrow(
+      'Invalid file read range'
+    )
+  }
+})
diff --git a/src/main/ipc/filesystem/local-file-range-read.ts b/src/main/ipc/filesystem/local-file-range-read.ts
new file mode 100644
index 00000000000..d9baaf66ef3
--- /dev/null
+++ b/src/main/ipc/filesystem/local-file-range-read.ts
@@ -0,0 +1,31 @@
+import type { RuntimeFileReadChunkResult } from '../../../shared/runtime-types'
+import { openLocalRegularFile } from './local-regular-file-read'
+
+export async function readLocalFileRange(
+  filePath: string,
+  offset: number,
+  length: number
+): Promise<RuntimeFileReadChunkResult> {
+  if (
+    !Number.isSafeInteger(offset) ||
+    offset < 0 ||
+    !Number.isSafeInteger(length) ||
+    length < 1 ||
+    length > 512 * 1024 ||
+    offset > Number.MAX_SAFE_INTEGER - (length - 1)
+  ) {
+    throw new Error('Invalid file read range')
+  }
+  const { handle, stats } = await openLocalRegularFile(filePath)
+  try {
+    const buffer = Buffer.alloc(Math.min(length, Math.max(0, stats.size - offset)))
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset)
+    return {
+      contentBase64: buffer.subarray(0, bytesRead).toString('base64'),
+      bytesRead,
+      eof: offset + bytesRead >= stats.size
+    }
+  } finally {
+    await handle.close()
+  }
+}
diff --git a/src/main/ipc/filesystem/local-regular-file-read.test.ts b/src/main/ipc/filesystem/local-regular-file-read.test.ts
new file mode 100644
index 00000000000..995e40ed09e
--- /dev/null
+++ b/src/main/ipc/filesystem/local-regular-file-read.test.ts
@@ -0,0 +1,106 @@
+import { mkdtemp, realpath, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { readLocalFileContent } from './filesystem-file-content-inspection'
+import {
+  assertLocalWriteTargetIsRegularFile,
+  NOT_A_REGULAR_FILE_MESSAGE,
+  openLocalRegularFile,
+  readLocalFileBounded
+} from './local-regular-file-read'
+
+let base: string
+
+beforeEach(async () => {
+  base = await mkdtemp(join(await realpath(tmpdir()), 'orca-regular-file-read-'))
+})
+
+afterEach(async () => {
+  await rm(base, { recursive: true, force: true })
+})
+
+describe('local regular-file reads', () => {
+  it('reads a regular file', async () => {
+    const filePath = join(base, 'notes.txt')
+    await writeFile(filePath, 'hello\n')
+
+    await expect(readLocalFileContent(filePath)).resolves.toEqual({
+      content: 'hello\n',
+      isBinary: false
+    })
+  })
+
+  it('refuses a directory', async () => {
+    await expect(readLocalFileContent(base)).rejects.toThrow()
+  })
+
+  it('caps a read at the limit even when the file is bigger than its handle claimed', async () => {
+    const filePath = join(base, 'big.txt')
+    await writeFile(filePath, 'a'.repeat(2048))
+    const { handle } = await openLocalRegularFile(filePath)
+    try {
+      await expect(readLocalFileBounded(handle, 1024)).rejects.toThrow('File too large')
+    } finally {
+      await handle.close()
+    }
+  })
+
+  it('sizes the read from fstat, so a small file costs a small buffer', async () => {
+    const filePath = join(base, 'small.txt')
+    await writeFile(filePath, 'hello')
+    const { handle, stats } = await openLocalRegularFile(filePath)
+    const read = vi.spyOn(handle, 'read')
+    try {
+      await expect(readLocalFileBounded(handle, 1024 * 1024, stats.size)).resolves.toEqual(
+        Buffer.from('hello')
+      )
+      // One read sized past the reported length, then a 1-byte probe confirming EOF.
+      expect(read.mock.calls.map((call) => call.at(2))).toEqual([6, 1])
+    } finally {
+      await handle.close()
+    }
+  })
+
+  it('keeps reading a file that grew past its reported size, up to the cap', async () => {
+    const filePath = join(base, 'grew.txt')
+    await writeFile(filePath, 'a'.repeat(5000))
+    const { handle } = await openLocalRegularFile(filePath)
+    try {
+      await expect(readLocalFileBounded(handle, 1024 * 1024, 10)).resolves.toHaveLength(5000)
+      await expect(readLocalFileBounded(handle, 4096, 10)).rejects.toThrow('File too large')
+    } finally {
+      await handle.close()
+    }
+  })
+
+  // Why: device files are POSIX-only.
+  describe.skipIf(process.platform === 'win32')('non-regular files', () => {
+    it.each(['/dev/zero', '/dev/urandom'])(
+      'refuses %s before reading any of it',
+      async (device) => {
+        await expect(readLocalFileContent(device)).rejects.toThrow(NOT_A_REGULAR_FILE_MESSAGE)
+      }
+    )
+
+    it('refuses a symlink to a device', async () => {
+      const link = join(base, 'zero.png')
+      await symlink('/dev/zero', link)
+
+      await expect(readLocalFileContent(link)).rejects.toThrow(NOT_A_REGULAR_FILE_MESSAGE)
+    })
+
+    it('refuses writing over a device but allows a regular or missing file', async () => {
+      const filePath = join(base, 'notes.txt')
+      await writeFile(filePath, 'x')
+
+      await expect(assertLocalWriteTargetIsRegularFile('/dev/null')).rejects.toThrow(
+        NOT_A_REGULAR_FILE_MESSAGE
+      )
+      await expect(assertLocalWriteTargetIsRegularFile(filePath)).resolves.toBeUndefined()
+      await expect(
+        assertLocalWriteTargetIsRegularFile(join(base, 'missing.txt'))
+      ).resolves.toBeUndefined()
+    })
+  })
+})
diff --git a/src/main/ipc/filesystem/local-regular-file-read.ts b/src/main/ipc/filesystem/local-regular-file-read.ts
new file mode 100644
index 00000000000..acffa8cb109
--- /dev/null
+++ b/src/main/ipc/filesystem/local-regular-file-read.ts
@@ -0,0 +1,89 @@
+import { constants, type Stats } from 'node:fs'
+import { open, type FileHandle } from 'node:fs/promises'
+import { isENOENT } from '../filesystem-path-containment'
+
+export const NOT_A_REGULAR_FILE_MESSAGE = 'Not a regular file'
+
+// Why O_NONBLOCK: opening a FIFO would otherwise wait for a writer forever; regular files ignore
+// the flag and Windows has none.
+export const LOCAL_READ_OPEN_FLAGS = constants.O_RDONLY | (constants.O_NONBLOCK ?? 0)
+const LOCAL_WRITE_PROBE_FLAGS = constants.O_WRONLY | (constants.O_NONBLOCK ?? 0)
+const READ_CHUNK_BYTES = 1024 * 1024
+
+export function fileTooLargeError(size: number, limit: number): Error {
+  return new Error(
+    `File too large: ${(size / 1024 / 1024).toFixed(1)}MB exceeds ${limit / 1024 / 1024}MB limit`
+  )
+}
+
+/** Opens a path for reading, refusing anything but a regular file (FIFO, device, socket, directory). */
+export async function openLocalRegularFile(
+  filePath: string
+): Promise<{ handle: FileHandle; stats: Stats }> {
+  const handle = await open(filePath, LOCAL_READ_OPEN_FLAGS)
+  try {
+    const stats = await handle.stat()
+    if (!stats.isFile()) {
+      throw new Error(NOT_A_REGULAR_FILE_MESSAGE)
+    }
+    return { handle, stats }
+  } catch (error) {
+    await handle.close()
+    throw error
+  }
+}
+
+/**
+ * Reads from the start of the handle, sized from its fstat so a small file costs a small buffer.
+ * The size is only a hint: a file that grows past it is read on in bounded chunks, and the cap holds
+ * even when a file reports a false size.
+ */
+export async function readLocalFileBounded(
+  handle: FileHandle,
+  limit: number,
+  expectedSize = 0
+): Promise<Buffer> {
+  const chunks: Buffer[] = []
+  let total = 0
+  let nextChunkBytes = Math.max(0, Math.min(expectedSize, limit)) + 1
+  while (true) {
+    const chunk = Buffer.allocUnsafe(Math.min(nextChunkBytes, limit + 1 - total))
+    const { bytesRead } = await handle.read(chunk, 0, chunk.length, total)
+    if (bytesRead === 0) {
+      return chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, total)
+    }
+    chunks.push(chunk.subarray(0, bytesRead))
+    total += bytesRead
+    if (total > limit) {
+      throw fileTooLargeError(total, limit)
+    }
+    // Why a 1-byte probe after a short read: it confirms EOF without another full-size buffer.
+    nextChunkBytes = bytesRead < chunk.length ? 1 : READ_CHUNK_BYTES
+  }
+}
+
+export async function readLocalFilePrefix(handle: FileHandle, bytes: number): Promise<Buffer> {
+  const probe = Buffer.alloc(bytes)
+  const { bytesRead } = await handle.read(probe, 0, probe.length, 0)
+  return probe.subarray(0, bytesRead)
+}
+
+/** Refuses writing over an existing non-regular file, e.g. a device or FIFO. */
+export async function assertLocalWriteTargetIsRegularFile(filePath: string): Promise<void> {
+  let handle: FileHandle
+  try {
+    handle = await open(filePath, LOCAL_WRITE_PROBE_FLAGS)
+  } catch (error) {
+    if (isENOENT(error)) {
+      return
+    }
+    throw error
+  }
+  try {
+    if (!(await handle.stat()).isFile()) {
+      throw new Error(NOT_A_REGULAR_FILE_MESSAGE)
+    }
+  } finally {
+    await handle.close()
+  }
+}
diff --git a/src/main/ipc/floating-workspace-directory.test.ts b/src/main/ipc/floating-workspace-directory.test.ts
index 2b372586cf1..55438efe587 100644
--- a/src/main/ipc/floating-workspace-directory.test.ts
+++ b/src/main/ipc/floating-workspace-directory.test.ts
@@ -4,9 +4,8 @@ import path from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { GlobalSettings } from '../../shared/global-settings-types'
 
-const { appGetPathMock, authorizeExternalPathMock } = vi.hoisted(() => ({
-  appGetPathMock: vi.fn(),
-  authorizeExternalPathMock: vi.fn()
+const { appGetPathMock } = vi.hoisted(() => ({
+  appGetPathMock: vi.fn()
 }))
 
 vi.mock('electron', () => ({
@@ -15,13 +14,9 @@ vi.mock('electron', () => ({
   }
 }))
 
-vi.mock('./filesystem-auth', () => ({
-  authorizeExternalPath: authorizeExternalPathMock
-}))
-
 import {
   ensureDefaultFloatingWorkspacePath,
-  grantFloatingWorkspaceDirectory,
+  trustFloatingWorkspaceDirectory,
   resolveFloatingTerminalCwd,
   sanitizeFloatingWorkspaceDirectorySetting
 } from './floating-workspace-directory'
@@ -48,7 +43,7 @@ function createStore(settings: Partial<GlobalSettings> = {}): TestStore {
   return store
 }
 
-describe('floating workspace directory authorization', () => {
+describe('floating workspace directory', () => {
   let tempRoot: string
   let homeDir: string
   let userDataDir: string
@@ -67,7 +62,6 @@ describe('floating workspace directory authorization', () => {
       }
       throw new Error(`unexpected app path: ${name}`)
     })
-    authorizeExternalPathMock.mockClear()
   })
 
   afterEach(async () => {
@@ -78,46 +72,37 @@ describe('floating workspace directory authorization', () => {
     await symlink(target, linkPath, process.platform === 'win32' ? 'junction' : 'dir')
   }
 
-  it('defaults terminal cwd to home without authorizing home for markdown writes', async () => {
+  it('defaults terminal cwd to home', async () => {
     const store = createStore()
 
     await expect(resolveFloatingTerminalCwd(store as never)).resolves.toBe(homeDir)
-
-    expect(authorizeExternalPathMock).not.toHaveBeenCalledWith(homeDir)
   })
 
   it('keeps the app-owned directory for floating markdown notes', async () => {
     await expect(ensureDefaultFloatingWorkspacePath()).resolves.toBe(
       path.join(userDataDir, 'floating-workspace')
     )
-
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith(
-      path.join(userDataDir, 'floating-workspace')
-    )
   })
 
-  it('persists picker-approved directories and reauthorizes them on resolution', async () => {
+  it('persists picker-approved directories and resolves them as the cwd', async () => {
     const store = createStore()
     const selectedDir = path.join(tempRoot, 'notes')
     await mkdir(selectedDir)
     const canonicalSelectedDir = await realpath(selectedDir)
 
-    await grantFloatingWorkspaceDirectory(store as never, selectedDir)
+    await trustFloatingWorkspaceDirectory(store, selectedDir)
 
     expect(store.settings.floatingTerminalTrustedCwds).toEqual([canonicalSelectedDir])
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith(canonicalSelectedDir)
 
-    authorizeExternalPathMock.mockClear()
     await expect(
       resolveFloatingTerminalCwd(store as never, {
         path: selectedDir,
         requireTrusted: true
       })
     ).resolves.toBe(canonicalSelectedDir)
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith(canonicalSelectedDir)
   })
 
-  it('stores symlink grants as canonical targets and rejects the link after retargeting', async () => {
+  it('stores a symlinked choice as its canonical target and rejects the link after retargeting', async () => {
     const store = createStore()
     const originalTarget = path.join(tempRoot, 'original-target')
     const retargetedTarget = path.join(tempRoot, 'retargeted-target')
@@ -127,16 +112,12 @@ describe('floating workspace directory authorization', () => {
     await symlinkDirectory(originalTarget, selectedLink)
     const canonicalOriginalTarget = await realpath(originalTarget)
 
-    await grantFloatingWorkspaceDirectory(store as never, selectedLink)
+    await trustFloatingWorkspaceDirectory(store, selectedLink)
 
     expect(store.settings.floatingTerminalTrustedCwds).toEqual([canonicalOriginalTarget])
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith(canonicalOriginalTarget)
 
     await unlink(selectedLink)
     await symlinkDirectory(retargetedTarget, selectedLink)
-    const canonicalRetargetedTarget = await realpath(retargetedTarget)
-
-    authorizeExternalPathMock.mockClear()
     await expect(
       resolveFloatingTerminalCwd(store as never, {
         path: selectedLink,
@@ -146,10 +127,9 @@ describe('floating workspace directory authorization', () => {
     await expect(
       sanitizeFloatingWorkspaceDirectorySetting(store as never, selectedLink)
     ).resolves.toBe('')
-    expect(authorizeExternalPathMock).not.toHaveBeenCalledWith(canonicalRetargetedTarget)
   })
 
-  it('keeps temporarily inaccessible trusted directories when adding a new grant', async () => {
+  it('keeps temporarily inaccessible trusted directories when adding a new one', async () => {
     const missingTrustedDir = path.join(tempRoot, 'offline-drive', 'notes')
     const selectedDir = path.join(tempRoot, 'new-notes')
     await mkdir(selectedDir)
@@ -158,7 +138,7 @@ describe('floating workspace directory authorization', () => {
       floatingTerminalTrustedCwds: [missingTrustedDir]
     })
 
-    await grantFloatingWorkspaceDirectory(store as never, selectedDir)
+    await trustFloatingWorkspaceDirectory(store, selectedDir)
 
     expect(store.settings.floatingTerminalTrustedCwds).toEqual([
       missingTrustedDir,
@@ -200,6 +180,5 @@ describe('floating workspace directory authorization', () => {
     await expect(resolveFloatingTerminalCwd(store as never, { path: arbitraryDir })).resolves.toBe(
       arbitraryDir
     )
-    expect(authorizeExternalPathMock).not.toHaveBeenCalledWith(arbitraryDir)
   })
 })
diff --git a/src/main/ipc/floating-workspace-directory.ts b/src/main/ipc/floating-workspace-directory.ts
index 9e5f7d34cb7..7c7a70cdd34 100644
--- a/src/main/ipc/floating-workspace-directory.ts
+++ b/src/main/ipc/floating-workspace-directory.ts
@@ -5,7 +5,6 @@ import { app } from 'electron'
 import type { GlobalSettings } from '../../shared/global-settings-types'
 import type { FloatingTerminalCwdRequest } from '../../shared/ui-chrome-types'
 import type { Store } from '../persistence'
-import { authorizeExternalPath } from './filesystem-auth'
 
 const FLOATING_WORKSPACE_DIRNAME = 'floating-workspace'
 
@@ -68,12 +67,14 @@ function isTrustedFloatingWorkspaceDirectory(
   return getTrustedFloatingWorkspaceDirectories(settings).has(path.resolve(canonicalDirPath))
 }
 
+/** The app-owned folder floating markdown documents are created in; a desktop-only root. */
+export function getDefaultFloatingWorkspacePath(): string {
+  return path.join(app.getPath('userData'), FLOATING_WORKSPACE_DIRNAME)
+}
+
 export async function ensureDefaultFloatingWorkspacePath(): Promise<string> {
-  const cwd = path.join(app.getPath('userData'), FLOATING_WORKSPACE_DIRNAME)
+  const cwd = getDefaultFloatingWorkspacePath()
   await mkdir(cwd, { recursive: true })
-  // Why: the default floating workspace lives outside repo roots by design;
-  // authorize only this app-owned directory instead of widening access to ~.
-  authorizeExternalPath(cwd)
   return cwd
 }
 
@@ -94,18 +95,16 @@ export async function resolveFloatingTerminalCwd(
     return ensureDefaultFloatingWorkspacePath()
   }
 
+  // Why: only picker-approved directories may become the cwd, so arbitrary settings text can't.
   if (isTrustedFloatingWorkspaceDirectory(canonicalCwd, store.getSettings())) {
-    // Why: picker-approved directories are persisted as explicit grants, so a
-    // restart can restore file creation access without trusting arbitrary text.
-    authorizeExternalPath(canonicalCwd)
     return canonicalCwd
   }
 
   return args?.requireTrusted === true ? ensureDefaultFloatingWorkspacePath() : cwd
 }
 
-export async function grantFloatingWorkspaceDirectory(
-  store: Store,
+export async function trustFloatingWorkspaceDirectory(
+  store: Pick<Store, 'getSettings' | 'updateSettings'>,
   dirPath: string
 ): Promise<void> {
   const resolvedDir = resolveFloatingWorkspaceInput(dirPath)
@@ -113,7 +112,6 @@ export async function grantFloatingWorkspaceDirectory(
   if (!canonicalDir) {
     return
   }
-  authorizeExternalPath(canonicalDir)
   const trustedDirectories = await getPreservedTrustedFloatingWorkspaceDirectories(
     store.getSettings()
   )
diff --git a/src/main/ipc/jira-user-search.ts b/src/main/ipc/jira-user-search.ts
new file mode 100644
index 00000000000..2a5861aaff8
--- /dev/null
+++ b/src/main/ipc/jira-user-search.ts
@@ -0,0 +1,44 @@
+import { ipcMain } from 'electron'
+import { listAssignableUsers, listAssignableUsersForProject, searchUsers } from '../jira/issues'
+
+function normalizeSiteId(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}
+
+/** Registers the `jira:*` user-search IPC handlers (assignable and site-wide). */
+export function registerJiraUserSearchHandlers(): void {
+  ipcMain.handle(
+    'jira:listAssignableUsers',
+    async (_event, args: { key: string; query?: string; siteId?: string }) => {
+      if (typeof args?.key !== 'string' || !args.key.trim()) {
+        return []
+      }
+      return listAssignableUsers(
+        args.key.trim(),
+        typeof args.query === 'string' ? args.query : undefined,
+        normalizeSiteId(args.siteId)
+      )
+    }
+  )
+
+  ipcMain.handle(
+    'jira:listAssignableUsersForProject',
+    async (_event, args: { projectIdOrKey: string; query?: string; siteId?: string }) => {
+      if (typeof args?.projectIdOrKey !== 'string' || !args.projectIdOrKey.trim()) {
+        return []
+      }
+      return listAssignableUsersForProject(
+        args.projectIdOrKey.trim(),
+        typeof args.query === 'string' ? args.query : undefined,
+        normalizeSiteId(args.siteId)
+      )
+    }
+  )
+
+  ipcMain.handle('jira:searchUsers', async (_event, args?: { query?: string; siteId?: string }) => {
+    return searchUsers(
+      typeof args?.query === 'string' ? args.query : undefined,
+      normalizeSiteId(args?.siteId)
+    )
+  })
+}
diff --git a/src/main/ipc/jira.ts b/src/main/ipc/jira.ts
index 0d78eec5f44..6d0db96c1a2 100644
--- a/src/main/ipc/jira.ts
+++ b/src/main/ipc/jira.ts
@@ -2,6 +2,7 @@ import { ipcMain } from 'electron'
 import { connect, disconnect, getStatus, selectSite, testConnection } from '../jira/client'
 import { _resetPreflightCache } from './preflight'
 import { JiraCancellableRequests } from './jira-cancellable-requests'
+import { registerJiraUserSearchHandlers } from './jira-user-search'
 import {
   addIssueComment,
   createIssue,
@@ -9,7 +10,6 @@ import {
   getIssueSummary,
   getIssueComments,
   getProjectStatusOrder,
-  listAssignableUsers,
   listCreateFields,
   listIssueTypes,
   listIssues,
@@ -17,7 +17,6 @@ import {
   listProjects,
   listTransitions,
   searchIssues,
-  searchUsers,
   updateIssue
 } from '../jira/issues'
 import type {
@@ -285,26 +284,7 @@ export function registerJiraHandlers(): void {
     return listPriorities(normalizeSiteId(args?.siteId))
   })
 
-  ipcMain.handle(
-    'jira:listAssignableUsers',
-    async (_event, args: { key: string; query?: string; siteId?: string }) => {
-      if (typeof args?.key !== 'string' || !args.key.trim()) {
-        return []
-      }
-      return listAssignableUsers(
-        args.key.trim(),
-        typeof args.query === 'string' ? args.query : undefined,
-        normalizeSiteId(args.siteId)
-      )
-    }
-  )
-
-  ipcMain.handle('jira:searchUsers', async (_event, args?: { query?: string; siteId?: string }) => {
-    return searchUsers(
-      typeof args?.query === 'string' ? args.query : undefined,
-      normalizeSiteId(args?.siteId)
-    )
-  })
+  registerJiraUserSearchHandlers()
 
   ipcMain.handle('jira:listTransitions', async (_event, args: { key: string; siteId?: string }) => {
     if (typeof args?.key !== 'string' || !args.key.trim()) {
diff --git a/src/main/ipc/keybindings.test.ts b/src/main/ipc/keybindings.test.ts
index ec8016287d5..7199d39a0a4 100644
--- a/src/main/ipc/keybindings.test.ts
+++ b/src/main/ipc/keybindings.test.ts
@@ -1,21 +1,14 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { KeybindingFileSnapshot } from '../../shared/keybindings'
 
-const {
-  authorizeExternalPathMock,
-  getAllWindowsMock,
-  handleMock,
-  openPathMock,
-  rebuildAppMenuMock,
-  showItemInFolderMock
-} = vi.hoisted(() => ({
-  authorizeExternalPathMock: vi.fn(),
-  getAllWindowsMock: vi.fn(() => []),
-  handleMock: vi.fn(),
-  openPathMock: vi.fn(),
-  rebuildAppMenuMock: vi.fn(),
-  showItemInFolderMock: vi.fn()
-}))
+const { getAllWindowsMock, handleMock, openPathMock, rebuildAppMenuMock, showItemInFolderMock } =
+  vi.hoisted(() => ({
+    getAllWindowsMock: vi.fn(() => []),
+    handleMock: vi.fn(),
+    openPathMock: vi.fn(),
+    rebuildAppMenuMock: vi.fn(),
+    showItemInFolderMock: vi.fn()
+  }))
 
 vi.mock('electron', () => ({
   BrowserWindow: {
@@ -30,10 +23,6 @@ vi.mock('electron', () => ({
   }
 }))
 
-vi.mock('./filesystem-auth', () => ({
-  authorizeExternalPath: authorizeExternalPathMock
-}))
-
 vi.mock('../menu/register-app-menu', () => ({
   rebuildAppMenu: rebuildAppMenuMock
 }))
@@ -60,7 +49,6 @@ function getHandler(channel: string): (...args: unknown[]) => unknown {
 
 describe('registerKeybindingHandlers', () => {
   beforeEach(() => {
-    authorizeExternalPathMock.mockReset()
     getAllWindowsMock.mockReturnValue([])
     handleMock.mockReset()
     openPathMock.mockReset()
@@ -68,11 +56,10 @@ describe('registerKeybindingHandlers', () => {
     showItemInFolderMock.mockReset()
   })
 
-  it('authorizes the keybindings file for in-app editing when ensuring it exists', () => {
+  it('returns the keybindings file when ensuring it exists', () => {
     registerKeybindingHandlers({ ensureFile: vi.fn(() => snapshot) } as never)
 
     expect(getHandler('keybindings:ensureFile')()).toBe(snapshot)
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith(snapshot.path)
   })
 
   it('reconciles plugin command conflicts after a shortcut edit', () => {
@@ -92,12 +79,11 @@ describe('registerKeybindingHandlers', () => {
     expect(onChanged).toHaveBeenCalledOnce()
   })
 
-  it('authorizes the keybindings file before opening it outside Orca', async () => {
+  it('opens the keybindings file outside Orca', async () => {
     openPathMock.mockResolvedValue('')
     registerKeybindingHandlers({ ensureFile: vi.fn(() => snapshot) } as never)
 
     await expect(getHandler('keybindings:openFile')()).resolves.toBe(snapshot)
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith(snapshot.path)
     expect(openPathMock).toHaveBeenCalledWith(snapshot.path)
   })
 })
diff --git a/src/main/ipc/keybindings.ts b/src/main/ipc/keybindings.ts
index 7a71f3116c0..6e137bf6ca6 100644
--- a/src/main/ipc/keybindings.ts
+++ b/src/main/ipc/keybindings.ts
@@ -2,7 +2,6 @@ import { BrowserWindow, ipcMain, shell } from 'electron'
 import type { KeybindingActionId, KeybindingFileSnapshot } from '../../shared/keybindings'
 import type { KeybindingService } from '../keybindings/keybinding-service'
 import { rebuildAppMenu } from '../menu/register-app-menu'
-import { authorizeExternalPath } from './filesystem-auth'
 
 function broadcastKeybindingsChanged(snapshot: KeybindingFileSnapshot): void {
   for (const window of BrowserWindow.getAllWindows()) {
@@ -21,9 +20,6 @@ export function registerKeybindingHandlers(
 
   ipcMain.handle('keybindings:ensureFile', () => {
     const snapshot = service.ensureFile()
-    // Why: keybindings.json lives in Orca's app config directory, not inside a
-    // workspace. Opening it in the editor still needs normal fs IPC access.
-    authorizeExternalPath(snapshot.path)
     broadcastKeybindingsChanged(snapshot)
     onChanged?.()
     return snapshot
@@ -48,7 +44,6 @@ export function registerKeybindingHandlers(
 
   ipcMain.handle('keybindings:openFile', async () => {
     const snapshot = service.ensureFile()
-    authorizeExternalPath(snapshot.path)
     const error = await shell.openPath(snapshot.path)
     if (error) {
       throw new Error(error)
@@ -58,7 +53,6 @@ export function registerKeybindingHandlers(
 
   ipcMain.handle('keybindings:revealFile', () => {
     const snapshot = service.ensureFile()
-    authorizeExternalPath(snapshot.path)
     shell.showItemInFolder(snapshot.path)
     return snapshot
   })
diff --git a/src/main/ipc/local-file-access-resolution-network-path.test.ts b/src/main/ipc/local-file-access-resolution-network-path.test.ts
new file mode 100644
index 00000000000..b2340146526
--- /dev/null
+++ b/src/main/ipc/local-file-access-resolution-network-path.test.ts
@@ -0,0 +1,382 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as NodeFs from 'node:fs'
+import type * as NodePath from 'node:path'
+import type { Store } from '../persistence'
+
+// Why win32 paths on every host: a UNC image in a document is a Windows credential leak, and the
+// guarantee is that its path text is refused before any filesystem call can reach the network.
+vi.mock('node:path', async () => {
+  const actual = await vi.importActual<typeof NodePath>('node:path')
+  return { ...actual.win32, default: actual.win32 }
+})
+
+const { fsCalls } = vi.hoisted(() => {
+  const calls: string[] = []
+  return { fsCalls: calls }
+})
+
+vi.mock('node:fs/promises', () => {
+  const record = (name: string) =>
+    vi.fn(async (target: unknown) => {
+      fsCalls.push(`${name} ${String(target)}`)
+      if (name !== 'realpath') {
+        return { isFile: () => true, isDirectory: () => false }
+      }
+      // A project image that is really a link to a device name.
+      if (String(target).endsWith('share-link.png')) {
+        // A local image that is really a link onto a network share.
+        return '\\\\nas\\pics\\shot.png'
+      }
+      return String(target).endsWith('dev-link.png') ? 'C:\\repo\\CON.png' : target
+    })
+  return { realpath: record('realpath'), stat: record('stat'), open: record('open') }
+})
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFs>()
+  return {
+    ...actual,
+    statSync: vi.fn((target: unknown) => {
+      fsCalls.push(`statSync ${String(target)}`)
+      throw new Error('statSync is not expected')
+    })
+  }
+})
+vi.mock('electron', () => ({ app: { getPath: () => 'C:\\Users\\me\\AppData\\Roaming\\Orca' } }))
+vi.mock('../repo-worktrees', () => ({ listRepoWorktreeGraph: vi.fn(async () => []) }))
+
+import {
+  resolveLocalFileRequestPath,
+  resolveLocalRenamePaths,
+  resolveLocalRequestPath
+} from './local-file-access-resolution'
+
+// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: authorization reads only these Store members.
+const store = {
+  getRepos: () => [
+    { id: 'repo', path: 'C:\\repo', displayName: 'repo', badgeColor: '#000', addedAt: 0 }
+  ],
+  getProjects: () => [],
+  getProjectGroups: () => [],
+  getFolderWorkspaces: () => [],
+  getSettings: () => ({ nestWorkspaces: false, workspaceDir: '' })
+} as unknown as Store
+
+const besideTodo = { kind: 'document-folder', documentPath: 'C:\\Users\\me\\notes\\todo.md' }
+
+const networkTargets = [
+  '\\\\attacker.example\\share\\x.png',
+  '//attacker.example/share/x.png',
+  '\\\\?\\UNC\\attacker.example\\share\\x.png'
+]
+
+describe('document images on a network share', () => {
+  beforeEach(() => {
+    fsCalls.length = 0
+  })
+
+  it.each(networkTargets)(
+    'refuses %s from a project document without touching it',
+    async (target) => {
+      await expect(
+        resolveLocalFileRequestPath(
+          target,
+          { kind: 'document-resource', documentPath: 'C:\\repo\\README.md' },
+          store
+        )
+      ).rejects.toThrow('Access denied')
+      expect(fsCalls.filter((call) => call.includes('attacker'))).toEqual([])
+    }
+  )
+
+  it.each(networkTargets)(
+    'refuses %s from a document outside every project without touching it',
+    async (target) => {
+      await expect(
+        resolveLocalFileRequestPath(
+          target,
+          { kind: 'document-resource', documentPath: 'C:\\Users\\me\\notes\\todo.md' },
+          store
+        )
+      ).rejects.toThrow('Access denied')
+      expect(fsCalls.filter((call) => call.includes('attacker'))).toEqual([])
+    }
+  )
+
+  it('refuses it with no declared access too', async () => {
+    await expect(resolveLocalFileRequestPath(networkTargets[0], undefined, store)).rejects.toThrow(
+      'Access denied'
+    )
+    expect(fsCalls.filter((call) => call.includes('attacker'))).toEqual([])
+  })
+})
+
+const CHAT_IMAGE = { kind: 'chat-image' } as const
+
+describe('chat transcript images on Windows', () => {
+  beforeEach(() => {
+    fsCalls.length = 0
+  })
+
+  it.each([...networkTargets, '\\\\.\\C:\\x.png', '//?/C:/x.png'])(
+    'refuses %s without touching it',
+    async (target) => {
+      await expect(resolveLocalFileRequestPath(target, CHAT_IMAGE, store)).rejects.toThrow(
+        'Access denied'
+      )
+      expect(fsCalls).toEqual([])
+    }
+  )
+
+  it.each([
+    'C:\\Users\\me\\Pictures\\shot.png',
+    '\\\\wsl.localhost\\Ubuntu\\home\\me\\shot.png',
+    '\\\\wsl$\\Ubuntu\\tmp\\agent.webp'
+  ])('reads the local image %s in place', async (target) => {
+    await expect(resolveLocalFileRequestPath(target, CHAT_IMAGE, store)).resolves.toBe(target)
+  })
+})
+
+describe('Windows reserved device names in automatic image loads', () => {
+  beforeEach(() => {
+    fsCalls.length = 0
+  })
+
+  const deviceTargets = [
+    'C:\\Users\\me\\notes\\NUL.png',
+    'C:\\Users\\me\\notes\\com1.jpg',
+    'C:\\Users\\me\\notes\\Lpt9 .gif',
+    'C:\\Users\\me\\notes\\aux..png',
+    'C:\\Users\\me\\notes\\CON.tar.png',
+    'C:\\Users\\me\\notes\\NUL:.png',
+    'C:\\Users\\me\\notes\\COM1:.png',
+    'C:\\Users\\me\\notes\\NUL:stream.png',
+    'C:\\Users\\me\\notes\\CONIN$.png',
+    'C:\\Users\\me\\notes\\CONOUT$',
+    'C:\\Users\\me\\notes\\clock$.jpg',
+    'C:\\Users\\me\\notes\\COM0.png',
+    'C:\\Users\\me\\notes\\LPT0.png',
+    'C:\\Users\\me\\notes\\com¹.png'
+  ]
+
+  it.each(deviceTargets)('refuses %s as a chat image without touching it', async (target) => {
+    await expect(resolveLocalFileRequestPath(target, CHAT_IMAGE, store)).rejects.toThrow(
+      'Access denied'
+    )
+    expect(fsCalls).toEqual([])
+  })
+
+  it.each(deviceTargets)(
+    'refuses %s from a document beside it without touching it',
+    async (target) => {
+      await expect(
+        resolveLocalFileRequestPath(
+          target,
+          { kind: 'document-resource', documentPath: 'C:\\Users\\me\\notes\\todo.md' },
+          store
+        )
+      ).rejects.toThrow('Access denied')
+      expect(fsCalls).toEqual([])
+    }
+  )
+
+  it.each(deviceTargets)(
+    'refuses %s as a new file beside an opened document without touching it',
+    async (target) => {
+      await expect(
+        resolveLocalRequestPath(target, besideTodo, store, 'import-into')
+      ).rejects.toThrow('Access denied')
+      expect(fsCalls).toEqual([])
+    }
+  )
+
+  it.each([...networkTargets, 'C:\\Users\\me\\other\\shot.png'])(
+    'refuses %s outside an opened document folder without touching it',
+    async (target) => {
+      await expect(
+        resolveLocalRequestPath(target, besideTodo, store, 'import-into')
+      ).rejects.toThrow('Access denied')
+      expect(fsCalls).toEqual([])
+    }
+  )
+
+  it('still reads an ordinary image whose name only starts like a device', async () => {
+    await expect(
+      resolveLocalFileRequestPath('C:\\Users\\me\\notes\\console.png', CHAT_IMAGE, store)
+    ).resolves.toBe('C:\\Users\\me\\notes\\console.png')
+  })
+})
+
+// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: authorization reads only these Store members.
+const shareProjectStore = {
+  getRepos: () => [
+    {
+      id: 'repo',
+      path: '\\\\server\\share\\repo',
+      displayName: 'repo',
+      badgeColor: '#000',
+      addedAt: 0
+    }
+  ],
+  getProjects: () => [],
+  getProjectGroups: () => [],
+  getFolderWorkspaces: () => [],
+  getSettings: () => ({ nestWorkspaces: false, workspaceDir: '' })
+} as unknown as Store
+
+describe('automatic image loads and dot segments that resolve to a device name', () => {
+  beforeEach(() => {
+    fsCalls.length = 0
+  })
+
+  it.each(['C:\\d\\NUL.png\\.', 'C:\\d\\COM1.png\\x\\..', 'C:/d/COM1.jpg/.'])(
+    'refuses %s for both access kinds without touching it',
+    async (target) => {
+      await expect(resolveLocalFileRequestPath(target, CHAT_IMAGE, store)).rejects.toThrow(
+        'Access denied'
+      )
+      await expect(
+        resolveLocalFileRequestPath(
+          target,
+          { kind: 'document-resource', documentPath: 'C:\\d\\README.md' },
+          store
+        )
+      ).rejects.toThrow('Access denied')
+      expect(fsCalls).toEqual([])
+    }
+  )
+
+  it('refuses a device name inside a project for automatic loads without touching it', async () => {
+    await expect(
+      resolveLocalFileRequestPath('C:\\repo\\NUL.png', CHAT_IMAGE, store)
+    ).rejects.toThrow('Access denied')
+    expect(fsCalls).toEqual([])
+  })
+
+  it('refuses a project image whose real target is a device name', async () => {
+    await expect(
+      resolveLocalFileRequestPath(
+        'C:\\repo\\dev-link.png',
+        { kind: 'document-resource', documentPath: 'C:\\repo\\README.md' },
+        store
+      )
+    ).rejects.toThrow('Access denied')
+  })
+})
+
+describe('the default check runs first for every declared kind', () => {
+  beforeEach(() => {
+    fsCalls.length = 0
+  })
+
+  it.each([
+    ['user-file', 'read', { kind: 'user-file' }],
+    [
+      'document-resource',
+      'read',
+      { kind: 'document-resource', documentPath: 'C:\\repo\\README.md' }
+    ],
+    ['chat-image', 'read', CHAT_IMAGE],
+    ['document-folder', 'import-into', besideTodo]
+  ] as const)(
+    'never touches a share outside every project while resolving %s %s',
+    async (_kind, operation, access) => {
+      for (const target of networkTargets) {
+        await resolveLocalRequestPath(target, access, store, operation).catch(() => undefined)
+      }
+      expect(fsCalls.filter((call) => call.includes('attacker'))).toEqual([])
+    }
+  )
+
+  it('never touches a share while resolving a rename of an opened document', async () => {
+    for (const target of networkTargets) {
+      await resolveLocalRenamePaths(besideTodo.documentPath, target, besideTodo, store)
+    }
+    expect(fsCalls.filter((call) => call.includes('attacker'))).toEqual([])
+  })
+})
+
+const besideShareDocument = {
+  kind: 'document-resource',
+  documentPath: '\\\\nas\\notes\\todo.md'
+}
+
+const besideAccentedShareDocument = {
+  kind: 'document-resource',
+  documentPath: '\\\\n\u00e1s\\notes\\todo.md'
+}
+
+describe('automatic image loads on a network share', () => {
+  beforeEach(() => {
+    fsCalls.length = 0
+  })
+
+  it('reads a chat or document image inside a project the user added from the share', async () => {
+    const image = '\\\\server\\share\\repo\\out.png'
+
+    await expect(resolveLocalFileRequestPath(image, CHAT_IMAGE, shareProjectStore)).resolves.toBe(
+      image
+    )
+    await expect(
+      resolveLocalFileRequestPath(
+        image,
+        { kind: 'document-resource', documentPath: '\\\\server\\share\\repo\\README.md' },
+        shareProjectStore
+      )
+    ).resolves.toBe(image)
+  })
+
+  it('refuses a local link that leads onto a share outside every project', async () => {
+    await expect(
+      resolveLocalFileRequestPath('C:\\Users\\me\\share-link.png', CHAT_IMAGE, store)
+    ).rejects.toThrow('Access denied')
+  })
+
+  it('refuses a chat share image outside every project without touching the share', async () => {
+    await expect(
+      resolveLocalFileRequestPath('\\\\server\\share\\other\\x.png', CHAT_IMAGE, shareProjectStore)
+    ).rejects.toThrow('Access denied')
+    expect(fsCalls.filter((call) => call.includes('other'))).toEqual([])
+  })
+
+  // Why beside a share document too: a host spelled with a look-alike (U+212A KELVIN SIGN, an NFD
+  // accent) can pass a case-folded folder comparison, so no share is loaded outside a project.
+  it.each([
+    '\\\\nas\\notes\\x.png',
+    '\\\\NAS\\Notes\\img\\y.png',
+    '//nas/notes/z.png',
+    '\\\\nas\\other\\x.png',
+    '\\\\evil\\notes\\x.png',
+    '\\\\nas\\notes-evil\\x.png',
+    '\\\\attacker.example\\share\\x.png'
+  ])('refuses %s beside a share document without touching any share', async (target) => {
+    await expect(
+      resolveLocalFileRequestPath(target, besideShareDocument, shareProjectStore)
+    ).rejects.toThrow('Access denied')
+    expect(fsCalls).toEqual([])
+  })
+
+  it.each(['\\\\bac\u212Aup\\notes\\x.png', '//bac\u212Aup/notes/x.png'])(
+    'refuses the KELVIN SIGN host spelling %s beside a document on \\\\backup without touching it',
+    async (target) => {
+      await expect(
+        resolveLocalFileRequestPath(
+          target,
+          { kind: 'document-resource', documentPath: '\\\\backup\\notes\\todo.md' },
+          shareProjectStore
+        )
+      ).rejects.toThrow('Access denied')
+      expect(fsCalls).toEqual([])
+    }
+  )
+
+  it('refuses an NFD spelling of an accented share host beside a document on it, without touching it', async () => {
+    await expect(
+      resolveLocalFileRequestPath(
+        '\\\\na\u0301s\\notes\\x.png',
+        besideAccentedShareDocument,
+        shareProjectStore
+      )
+    ).rejects.toThrow('Access denied')
+    expect(fsCalls).toEqual([])
+  })
+})
diff --git a/src/main/ipc/local-file-access-resolution.test.ts b/src/main/ipc/local-file-access-resolution.test.ts
new file mode 100644
index 00000000000..e659a516c96
--- /dev/null
+++ b/src/main/ipc/local-file-access-resolution.test.ts
@@ -0,0 +1,469 @@
+import { mkdir, mkdtemp, realpath, rm, stat, symlink, writeFile } from 'node:fs/promises'
+import { homedir, tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { Store } from '../persistence'
+import type * as RepoWorktrees from '../repo-worktrees'
+import { resolveAuthorizedPath } from './filesystem-auth'
+import {
+  resolveDesktopAuthorizedPath,
+  resolveLocalFileRequestPath,
+  resolveLocalRenamePaths,
+  resolveLocalRequestPath,
+  resolveLocalWriteRequestPath,
+  type LocalRequestOperation
+} from './local-file-access-resolution'
+import { readLocalFileContent } from './filesystem/filesystem-file-content-inspection'
+import {
+  assertLocalWriteTargetIsRegularFile,
+  NOT_A_REGULAR_FILE_MESSAGE
+} from './filesystem/local-regular-file-read'
+import { invalidateAuthorizedRootsCache } from './registered-worktree-roots-cache'
+
+const { userData } = vi.hoisted(() => ({ userData: { path: '' } }))
+
+vi.mock('electron', () => ({ app: { getPath: () => userData.path } }))
+vi.mock('../repo-worktrees', async () => {
+  const actual = await vi.importActual<typeof RepoWorktrees>('../repo-worktrees')
+  return { ...actual, listRepoWorktreeGraph: vi.fn(async () => []) }
+})
+
+type Registration = { repoPaths?: string[]; folderPath?: string }
+
+function makeStore({ repoPaths = [], folderPath }: Registration): Store {
+  const repos = repoPaths.map((path, index) => ({
+    id: `repo-${index}`,
+    path,
+    displayName: 'project',
+    badgeColor: '#000',
+    addedAt: 0
+  }))
+  const folders = folderPath ? [{ id: 'folder', folderPath, projectGroupId: 'none' }] : []
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: authorization reads only these Store members.
+  return {
+    getRepos: () => repos.map((repo) => ({ ...repo })),
+    getProjects: () => [],
+    getProjectGroups: () => [],
+    getFolderWorkspaces: () => folders.map((folder) => ({ ...folder })),
+    getSettings: () => ({ nestWorkspaces: false, workspaceDir: '' })
+  } as unknown as Store
+}
+
+const USER_FILE = { kind: 'user-file' } as const
+const documentResource = (documentPath: string) =>
+  ({ kind: 'document-resource', documentPath }) as const
+const documentFolder = (documentPath: string) =>
+  ({ kind: 'document-folder', documentPath }) as const
+
+async function settles(promise: Promise<unknown>): Promise<'ok' | 'denied'> {
+  return promise.then(
+    () => 'ok',
+    () => 'denied'
+  )
+}
+
+let base: string
+let project: string
+let outside: string
+
+beforeEach(async () => {
+  invalidateAuthorizedRootsCache()
+  base = await mkdtemp(join(await realpath(tmpdir()), 'orca-file-access-'))
+  project = join(base, 'project')
+  outside = join(base, 'outside')
+  userData.path = join(base, 'user-data')
+  await mkdir(project)
+  await mkdir(outside)
+  await mkdir(join(userData.path, 'floating-workspace'), { recursive: true })
+  await writeFile(join(outside, 'notes.txt'), 'outside notes\n')
+})
+
+afterEach(async () => {
+  await rm(base, { recursive: true, force: true })
+})
+
+describe('user-file requests', () => {
+  it('read a regular file outside every project in place', async () => {
+    const store = makeStore({})
+    const filePath = await resolveLocalFileRequestPath(join(outside, 'notes.txt'), USER_FILE, store)
+
+    await expect(readLocalFileContent(filePath)).resolves.toEqual({
+      content: 'outside notes\n',
+      isBinary: false
+    })
+  })
+
+  it.each(['notes.txt', 'C:notes.txt'])('refuse the non-absolute path %s', async (relative) => {
+    await expect(resolveLocalFileRequestPath(relative, USER_FILE, makeStore({}))).rejects.toThrow(
+      'absolute path'
+    )
+  })
+
+  it('stat a directory but never read one', async () => {
+    const dirPath = await resolveLocalFileRequestPath(outside, USER_FILE, makeStore({}))
+
+    expect((await stat(dirPath)).isDirectory()).toBe(true)
+    await expect(readLocalFileContent(dirPath)).rejects.toThrow()
+  })
+
+  it('save an outside file, but never onto a device', async () => {
+    const store = makeStore({})
+    const filePath = join(outside, 'notes.txt')
+
+    await expect(resolveLocalWriteRequestPath(filePath, USER_FILE, store)).resolves.toBe(filePath)
+    await expect(resolveLocalWriteRequestPath(filePath, undefined, store)).rejects.toThrow(
+      'Access denied'
+    )
+    if (process.platform !== 'win32') {
+      await expect(assertLocalWriteTargetIsRegularFile('/dev/null')).rejects.toThrow(
+        NOT_A_REGULAR_FILE_MESSAGE
+      )
+    }
+  })
+
+  it.skipIf(process.platform === 'win32')('refuse /dev/zero promptly', async () => {
+    const filePath = await resolveLocalFileRequestPath('/dev/zero', USER_FILE, makeStore({}))
+
+    await expect(readLocalFileContent(filePath)).rejects.toThrow(NOT_A_REGULAR_FILE_MESSAGE)
+  })
+})
+
+describe('a declared kind never refuses what the default project check allows', () => {
+  const outsideDocument = () => join(outside, 'doc-folder', 'note.md')
+  const declaredKinds = (): [string, unknown, LocalRequestOperation][] => [
+    ['user-file read', USER_FILE, 'read'],
+    ['user-file write', USER_FILE, 'write'],
+    ['document-resource read', documentResource(outsideDocument()), 'read'],
+    ['chat-image read', { kind: 'chat-image' }, 'read'],
+    [
+      'document-folder import-into',
+      { kind: 'document-folder', documentPath: outsideDocument() },
+      'import-into'
+    ]
+  ]
+
+  beforeEach(async () => {
+    await mkdir(join(project, 'src'), { recursive: true })
+    await mkdir(join(outside, 'doc-folder'), { recursive: true })
+    await writeFile(join(project, 'src', 'notes.txt'), 'text')
+  })
+
+  it('accepts every in-project path the default accepts, for every kind and operation', async () => {
+    const store = makeStore({ repoPaths: [project] })
+    const targets = [
+      join(project, 'src', 'notes.txt'),
+      join(project, 'src'),
+      join(project, 'src', 'new-name.txt'),
+      join(userData.path, 'floating-workspace', 'scratch.md')
+    ]
+    for (const [label, access, operation] of declaredKinds()) {
+      for (const target of targets) {
+        const byDefault = await resolveLocalRequestPath(target, undefined, store, operation)
+        await expect(
+          resolveLocalRequestPath(target, access, store, operation),
+          `${label} ${target}`
+        ).resolves.toBe(byDefault)
+      }
+    }
+  })
+
+  it.skipIf(process.platform === 'win32')(
+    'accepts an in-project link for every kind exactly as the default does',
+    async () => {
+      await symlink(join(project, 'src', 'notes.txt'), join(project, 'notes-link'))
+      const store = makeStore({ repoPaths: [project] })
+      for (const [label, access, operation] of declaredKinds()) {
+        const byDefault = await resolveLocalRequestPath(
+          join(project, 'notes-link'),
+          undefined,
+          store,
+          operation
+        )
+        await expect(
+          resolveLocalRequestPath(join(project, 'notes-link'), access, store, operation),
+          label
+        ).resolves.toBe(byDefault)
+      }
+    }
+  )
+
+  it('renames an in-project document exactly as the default does', async () => {
+    const store = makeStore({ repoPaths: [project] })
+    const source = join(project, 'src', 'notes.txt')
+    for (const target of [
+      join(project, 'src', 'new-name.txt'),
+      join(project, 'new-name.txt'),
+      join(userData.path, 'floating-workspace', 'scratch.md')
+    ]) {
+      const byDefault = await resolveLocalRenamePaths(source, target, undefined, store)
+      await expect(
+        resolveLocalRenamePaths(source, target, documentFolder(source), store),
+        target
+      ).resolves.toEqual(byDefault)
+    }
+  })
+})
+
+describe('requests with no declared access (roots only)', () => {
+  it('refuse a file outside every project, even one a user-file request may read', async () => {
+    const store = makeStore({ repoPaths: [project] })
+
+    await expect(
+      resolveLocalFileRequestPath(join(outside, 'notes.txt'), undefined, store)
+    ).rejects.toThrow('Access denied')
+    await expect(
+      resolveLocalFileRequestPath(join(outside, 'notes.txt'), { kind: 'grant-everything' }, store)
+    ).rejects.toThrow('Access denied')
+  })
+
+  it('allow the app-owned floating-workspace folder on the desktop only', async () => {
+    const store = makeStore({ repoPaths: [project] })
+    const untitled = join(userData.path, 'floating-workspace', 'untitled.md')
+
+    await expect(resolveDesktopAuthorizedPath(untitled, store)).resolves.toBe(untitled)
+    await expect(resolveAuthorizedPath(untitled, store)).rejects.toThrow('Access denied')
+  })
+
+  it('refuse the home folder, which the floating workspace starts in', async () => {
+    await expect(
+      resolveDesktopAuthorizedPath(homedir(), makeStore({ repoPaths: [project] }))
+    ).rejects.toThrow('Access denied')
+  })
+})
+
+// Why: creating a symlink on Windows needs elevation or Developer Mode.
+describe.skipIf(process.platform === 'win32')('project symlinks under every spelling', () => {
+  let real: string
+  let alias: string
+  let alias2: string
+  let privateBase: string
+  let varAlias: string
+  let secret: string
+
+  beforeEach(async () => {
+    // Mirrors macOS /var -> /private/var: an alias of an ancestor above the project root.
+    privateBase = join(base, 'private')
+    varAlias = join(base, 'var')
+    real = join(privateBase, 'real', 'project')
+    alias = join(base, 'alias-project')
+    alias2 = join(base, 'alias2-project')
+    await mkdir(join(real, 'sub'), { recursive: true })
+    await symlink(privateBase, varAlias)
+    await symlink(real, alias)
+    await symlink(real, alias2)
+    secret = join(outside, 'secret.txt')
+    await writeFile(secret, 'secret\n')
+    await writeFile(join(real, 'notes.md'), 'notes\n')
+    await symlink(secret, join(real, 'escape.txt'))
+    await symlink(outside, join(real, 'dir-link'))
+    await symlink(outside, join(real, 'sub', 'deep-link'))
+  })
+
+  const viaDirLink = (root: string): string => join(root, 'dir-link', 'secret.txt')
+
+  it.each<[string, () => Registration, () => string]>([
+    ['a leaf symlink', () => ({ repoPaths: [real] }), () => join(real, 'escape.txt')],
+    ['a directory symlink', () => ({ repoPaths: [real] }), () => viaDirLink(real)],
+    ['a directory symlink via an alias', () => ({ repoPaths: [real] }), () => viaDirLink(alias)],
+    [
+      'a directory symlink, registered and named via two aliases',
+      () => ({ repoPaths: [alias] }),
+      () => viaDirLink(alias2)
+    ],
+    [
+      'a directory symlink, registered via alias and named canonically',
+      () => ({ folderPath: alias }),
+      () => viaDirLink(real)
+    ],
+    [
+      'a deep directory symlink in a folder workspace',
+      () => ({ folderPath: real }),
+      () => join(alias, 'sub', 'deep-link', 'secret.txt')
+    ],
+    [
+      'a directory symlink named with `..`',
+      () => ({ repoPaths: [real] }),
+      () => join(alias, 'sub', '..', 'dir-link', 'secret.txt')
+    ],
+    [
+      'a directory symlink via an ancestor alias',
+      () => ({ repoPaths: [real] }),
+      () => viaDirLink(real.replace(privateBase, varAlias))
+    ],
+    [
+      'a leaf symlink via an ancestor alias',
+      () => ({ repoPaths: [real] }),
+      () => join(real.replace(privateBase, varAlias), 'escape.txt')
+    ]
+  ])('never read or write through %s out of the project', async (_label, register, named) => {
+    const store = makeStore(register())
+
+    expect(await settles(resolveLocalFileRequestPath(named(), undefined, store))).toBe('denied')
+    expect(await settles(resolveLocalWriteRequestPath(named(), undefined, store))).toBe('denied')
+    expect(await settles(resolveLocalFileRequestPath(secret, undefined, store))).toBe('denied')
+  })
+
+  it('reads a project link the user opened by name in place, while project requests stay refused', async () => {
+    const store = makeStore({ repoPaths: [real] })
+    const link = join(real, 'escape.txt')
+
+    expect(await settles(resolveLocalFileRequestPath(link, undefined, store))).toBe('denied')
+    const named = await resolveLocalFileRequestPath(link, USER_FILE, store)
+    await expect(readLocalFileContent(named)).resolves.toEqual({
+      content: 'secret\n',
+      isBinary: false
+    })
+  })
+})
+
+describe('document-resource requests', () => {
+  let otherProject: string
+
+  beforeEach(async () => {
+    otherProject = join(base, 'other-project')
+    await mkdir(join(project, 'docs'), { recursive: true })
+    await mkdir(otherProject)
+    await writeFile(join(project, 'docs', 'README.md'), '# doc\n')
+    await writeFile(join(project, 'logo.png'), 'png')
+    await writeFile(join(otherProject, 'shared.png'), 'png')
+    await writeFile(join(project, 'notes.txt'), 'text')
+    await writeFile(join(outside, 'outside.png'), 'png')
+    await mkdir(join(outside, 'doc-folder', 'img'), { recursive: true })
+    await writeFile(join(outside, 'doc-folder', 'note.md'), '# note\n')
+    await writeFile(join(outside, 'doc-folder', 'img', 'nested.png'), 'png')
+    await writeFile(join(outside, 'doc-folder', 'sibling.png'), 'png')
+  })
+
+  it('limit a project document to every project root, whatever the file type', async () => {
+    const store = makeStore({ repoPaths: [project, otherProject] })
+    const access = documentResource(join(project, 'docs', 'README.md'))
+    const outcome = (path: string) => settles(resolveLocalFileRequestPath(path, access, store))
+
+    expect(await outcome(join(project, 'logo.png'))).toBe('ok')
+    expect(await outcome(join(otherProject, 'shared.png'))).toBe('ok')
+    expect(await outcome(join(project, 'notes.txt'))).toBe('ok')
+    expect(await outcome(join(outside, 'outside.png'))).toBe('denied')
+  })
+
+  it('limit a document outside every project to its own folder', async () => {
+    const store = makeStore({ repoPaths: [project] })
+    const access = documentResource(join(outside, 'doc-folder', 'note.md'))
+    const outcome = (path: string) => settles(resolveLocalFileRequestPath(path, access, store))
+
+    expect(await outcome(join(outside, 'doc-folder', 'sibling.png'))).toBe('ok')
+    expect(await outcome(join(outside, 'doc-folder', 'img', 'nested.png'))).toBe('ok')
+    expect(await outcome(join(outside, 'outside.png'))).toBe('denied')
+    expect(await outcome('/dev/zero')).toBe('denied')
+  })
+
+  it.skipIf(process.platform === 'win32')(
+    'refuse a symlink in the document folder that leads out of it',
+    async () => {
+      const store = makeStore({})
+      await symlink(join(outside, 'outside.png'), join(outside, 'doc-folder', 'escape.png'))
+      const access = documentResource(join(outside, 'doc-folder', 'note.md'))
+
+      expect(
+        await settles(
+          resolveLocalFileRequestPath(join(outside, 'doc-folder', 'escape.png'), access, store)
+        )
+      ).toBe('denied')
+    }
+  )
+
+  it.skipIf(process.platform === 'win32')(
+    'read a link of any name in a project or beside the document when its target stays there',
+    async () => {
+      await writeFile(join(outside, 'doc-folder', 'diagram'), 'png')
+      await symlink(join(outside, 'doc-folder', 'diagram'), join(outside, 'doc-folder', 'a.png'))
+      await symlink(join(project, 'notes.txt'), join(project, 'notes-link'))
+      const store = makeStore({ repoPaths: [project] })
+
+      const inProject = documentResource(join(project, 'docs', 'README.md'))
+      const besideDoc = documentResource(join(outside, 'doc-folder', 'note.md'))
+      expect(
+        await settles(resolveLocalFileRequestPath(join(project, 'notes-link'), inProject, store))
+      ).toBe('ok')
+      expect(
+        await settles(
+          resolveLocalFileRequestPath(join(outside, 'doc-folder', 'a.png'), besideDoc, store)
+        )
+      ).toBe('ok')
+    }
+  )
+})
+
+describe('chat-image requests', () => {
+  const CHAT_IMAGE = { kind: 'chat-image' } as const
+
+  it('read any local image file in place, whatever turn named it', async () => {
+    const shot = join(outside, 'shot.png')
+    await writeFile(shot, 'png')
+
+    const filePath = await resolveLocalFileRequestPath(shot, CHAT_IMAGE, makeStore({}))
+
+    await expect(readLocalFileContent(filePath)).resolves.toMatchObject({
+      isBinary: true,
+      mimeType: 'image/png'
+    })
+  })
+
+  it.each(['shot.avif', 'shot.bmp', 'shot.ico', 'shot.svg', 'shot.webp'])(
+    'read %s',
+    async (name) => {
+      await writeFile(join(outside, name), 'image')
+      expect(
+        await settles(resolveLocalFileRequestPath(join(outside, name), CHAT_IMAGE, makeStore({})))
+      ).toBe('ok')
+    }
+  )
+
+  it.skipIf(process.platform === 'win32')(
+    'judge a link by its target: an extensionless link to an image loads',
+    async () => {
+      await writeFile(join(outside, 'shot.png'), 'png')
+      await symlink(join(outside, 'shot.png'), join(outside, 'latest-screenshot'))
+
+      expect(
+        await settles(
+          resolveLocalFileRequestPath(join(outside, 'latest-screenshot'), CHAT_IMAGE, makeStore({}))
+        )
+      ).toBe('ok')
+    }
+  )
+
+  it.each(['notes.txt', 'missing.png'])('refuse %s', async (name) => {
+    expect(
+      await settles(resolveLocalFileRequestPath(join(outside, name), CHAT_IMAGE, makeStore({})))
+    ).toBe('denied')
+  })
+
+  it('refuse a relative path, a device and a PDF', async () => {
+    const store = makeStore({})
+    await writeFile(join(outside, 'doc.pdf'), '%PDF')
+
+    expect(await settles(resolveLocalFileRequestPath('shot.png', CHAT_IMAGE, store))).toBe('denied')
+    expect(await settles(resolveLocalFileRequestPath('/dev/zero', CHAT_IMAGE, store))).toBe(
+      'denied'
+    )
+    expect(
+      await settles(resolveLocalFileRequestPath(join(outside, 'doc.pdf'), CHAT_IMAGE, store))
+    ).toBe('denied')
+  })
+
+  it.skipIf(process.platform === 'win32')(
+    'refuse an image-named link to a text file or a device',
+    async () => {
+      await symlink(join(outside, 'notes.txt'), join(outside, 'secret.png'))
+      await symlink('/dev/zero', join(outside, 'zero.png'))
+      const store = makeStore({})
+
+      expect(
+        await settles(resolveLocalFileRequestPath(join(outside, 'secret.png'), CHAT_IMAGE, store))
+      ).toBe('denied')
+      expect(
+        await settles(resolveLocalFileRequestPath(join(outside, 'zero.png'), CHAT_IMAGE, store))
+      ).toBe('denied')
+    }
+  )
+})
diff --git a/src/main/ipc/local-file-access-resolution.ts b/src/main/ipc/local-file-access-resolution.ts
new file mode 100644
index 00000000000..94054a0ddf2
--- /dev/null
+++ b/src/main/ipc/local-file-access-resolution.ts
@@ -0,0 +1,317 @@
+import { dirname, extname, isAbsolute, resolve } from 'node:path'
+import { realpath, stat } from 'node:fs/promises'
+import type { Store } from '../persistence'
+import type { LocalFileAccess } from '../../shared/local-file-access'
+import {
+  PATH_ACCESS_DENIED_MESSAGE,
+  resolveAuthorizedPath,
+  type ResolveAuthorizedPathOptions
+} from './filesystem-auth'
+import { isDescendantOrEqual } from './filesystem-path-containment'
+import { PREVIEWABLE_BINARY_MIME_TYPES } from './filesystem/filesystem-file-content-inspection'
+import { getDefaultFloatingWorkspacePath } from './floating-workspace-directory'
+import {
+  isDeviceNamespacePath,
+  isNetworkSharePath,
+  isWindowsReservedDeviceName
+} from './automatic-load-path-text'
+import { NOT_A_REGULAR_FILE_MESSAGE } from './filesystem/local-regular-file-read'
+
+const USER_FILE_NEEDS_ABSOLUTE_PATH_MESSAGE =
+  'Access denied: a file opened by name needs an absolute path.'
+const USER_FILE_ACCESS: LocalFileAccess = { kind: 'user-file' }
+
+const CHAT_IMAGE_TYPE_MESSAGE = 'Access denied: a chat can only show local image files.'
+
+/** Desktop IPC's root check: the project roots plus the app-owned floating-workspace folder. */
+export async function resolveDesktopAuthorizedPath(
+  targetPath: string,
+  store: Store,
+  options: ResolveAuthorizedPathOptions = {}
+): Promise<string> {
+  return resolveAuthorizedPath(targetPath, store, {
+    ...options,
+    extraRoots: [getDefaultFloatingWorkspacePath()]
+  })
+}
+
+/** A file the user named is used where it is; no root applies, and nothing is remembered. */
+function resolveUserNamedLocalPath(targetPath: string): string {
+  // Why isAbsolute on the raw input: resolve() would anchor `notes.txt` or `C:notes` to main's cwd.
+  if (typeof targetPath !== 'string' || !isAbsolute(targetPath)) {
+    throw new Error(USER_FILE_NEEDS_ABSOLUTE_PATH_MESSAGE)
+  }
+  return resolve(targetPath)
+}
+
+/**
+ * A user-named path that must be an existing regular file, e.g. a notebook or a log being tailed.
+ * Inside a project it resolves as the default check does, to the real file.
+ */
+export async function resolveUserNamedRegularFile(
+  targetPath: string,
+  store: Store
+): Promise<string> {
+  const filePath = await resolveLocalRequestPath(targetPath, USER_FILE_ACCESS, store, 'read')
+  if (!(await stat(filePath)).isFile()) {
+    throw new Error(NOT_A_REGULAR_FILE_MESSAGE)
+  }
+  return filePath
+}
+
+// Why every previewable type but PDF: chat shows these in an <img>, which renders no PDF.
+function isChatImage(filePath: string): boolean {
+  const extension = extname(filePath).toLowerCase()
+  return Boolean(PREVIEWABLE_BINARY_MIME_TYPES[extension]) && extension !== '.pdf'
+}
+
+// Why the resolved path: `NUL.png\.` and `COM1.png\x\..` resolve to a device name.
+function isRefusedAutomaticLoadPath(filePath: string): boolean {
+  return isDeviceNamespacePath(filePath) || isWindowsReservedDeviceName(filePath)
+}
+
+/**
+ * A file a document references (an image, typically) beyond what the default check allows: one in
+ * the document's own folder, like the common markdown-preview rule. A target outside the folder,
+ * or a network share, is refused by its path text before any filesystem call; a symlink inside the
+ * folder is still resolved by the folder check.
+ */
+async function resolveDocumentResourcePath(
+  targetPath: string,
+  documentPath: string
+): Promise<string> {
+  if (
+    typeof targetPath !== 'string' ||
+    !isAbsolute(targetPath) ||
+    typeof documentPath !== 'string' ||
+    !isAbsolute(documentPath)
+  ) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  const resolvedTarget = resolve(targetPath)
+  if (isRefusedAutomaticLoadPath(resolvedTarget)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  const documentFolder = dirname(resolve(documentPath))
+  if (isNetworkSharePath(resolvedTarget) || !isDescendantOrEqual(resolvedTarget, documentFolder)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  const realTarget = resolve(await realpath(resolvedTarget))
+  if (!isDescendantOrEqual(realTarget, resolve(await realpath(documentFolder)))) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  if (isRefusedAutomaticLoadPath(realTarget)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  return realTarget
+}
+
+/**
+ * An image shown in a chat transcript, whoever's turn named it: any absolute local image file,
+ * typed by its real target. Transcripts load as they scroll into view, so a network share is read
+ * only inside a project the user added from it (the default check); anywhere else its path text,
+ * like a device path, is refused before any filesystem call.
+ */
+async function resolveChatImagePath(targetPath: string, store: Store): Promise<string> {
+  if (typeof targetPath !== 'string' || !isAbsolute(targetPath)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  const resolvedTarget = resolve(targetPath)
+  if (isRefusedAutomaticLoadPath(resolvedTarget)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  if (isNetworkSharePath(resolvedTarget)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  const realTarget = resolve(await realpath(resolvedTarget))
+  if (isRefusedAutomaticLoadPath(realTarget)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  if (isNetworkSharePath(realTarget) && !isNetworkSharePath(resolvedTarget)) {
+    // Why: a local link may still lead onto a share; that is readable only inside a project.
+    await resolveDesktopAuthorizedPath(realTarget, store)
+  }
+  // Why the real target's type: `shot.png -> ~/.ssh/id_rsa` must not be read as an image.
+  if (!isChatImage(realTarget)) {
+    throw new Error(CHAT_IMAGE_TYPE_MESSAGE)
+  }
+  return realTarget
+}
+
+/**
+ * Adding a file beside a document the user opened: the target must stay inside the document's own
+ * folder, symlinks included.
+ */
+async function resolveDocumentFolderPath(
+  targetPath: string,
+  documentPath: string
+): Promise<string> {
+  if (
+    typeof targetPath !== 'string' ||
+    !isAbsolute(targetPath) ||
+    typeof documentPath !== 'string' ||
+    !isAbsolute(documentPath)
+  ) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  const resolvedTarget = resolve(targetPath)
+  const documentFolder = dirname(resolve(documentPath))
+  if (
+    isRefusedAutomaticLoadPath(resolvedTarget) ||
+    !isDescendantOrEqual(resolvedTarget, documentFolder)
+  ) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  const realTarget = resolve(await realpath(resolvedTarget))
+  const realFolder = resolve(await realpath(documentFolder))
+  if (isRefusedAutomaticLoadPath(realTarget) || !isDescendantOrEqual(realTarget, realFolder)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  return realTarget
+}
+
+function isOpenedDocument(targetPath: unknown, documentPath: string): boolean {
+  return (
+    typeof targetPath === 'string' &&
+    isAbsolute(targetPath) &&
+    isAbsolute(documentPath) &&
+    resolve(targetPath) === resolve(documentPath)
+  )
+}
+
+// Why parse: IPC input is untyped, and an unrecognised access kind must fall back to roots only.
+function parseLocalFileAccess(access: unknown): LocalFileAccess | undefined {
+  if (typeof access !== 'object' || access === null || !('kind' in access)) {
+    return undefined
+  }
+  if (access.kind === 'user-file') {
+    return { kind: 'user-file' }
+  }
+  if (access.kind === 'chat-image') {
+    return { kind: 'chat-image' }
+  }
+  if (
+    access.kind === 'document-folder' &&
+    'documentPath' in access &&
+    typeof access.documentPath === 'string'
+  ) {
+    return { kind: 'document-folder', documentPath: access.documentPath }
+  }
+  if (
+    access.kind === 'document-resource' &&
+    'documentPath' in access &&
+    typeof access.documentPath === 'string'
+  ) {
+    return { kind: 'document-resource', documentPath: access.documentPath }
+  }
+  return undefined
+}
+
+/** What a desktop request does with its path; each declared kind adds access to only some. */
+export type LocalRequestOperation = 'read' | 'write' | 'rename-from' | 'rename-to' | 'import-into'
+
+type KindRule = (targetPath: string) => Promise<string>
+
+function declaredKindRule(
+  fileAccess: LocalFileAccess,
+  operation: LocalRequestOperation,
+  store: Store
+): KindRule | undefined {
+  switch (fileAccess.kind) {
+    case 'user-file':
+      // Why renames: resolveLocalRenamePaths declares this only for the opened document itself.
+      return operation !== 'import-into'
+        ? async (targetPath) => resolveUserNamedLocalPath(targetPath)
+        : undefined
+    case 'document-resource':
+      return operation === 'read'
+        ? (targetPath) => resolveDocumentResourcePath(targetPath, fileAccess.documentPath)
+        : undefined
+    case 'chat-image':
+      return operation === 'read'
+        ? (targetPath) => resolveChatImagePath(targetPath, store)
+        : undefined
+    case 'document-folder':
+      return operation === 'import-into'
+        ? (targetPath) => resolveDocumentFolderPath(targetPath, fileAccess.documentPath)
+        : undefined
+  }
+}
+
+/**
+ * The one resolver for desktop local file requests. A declared kind never refuses what the default
+ * project check allows; its own rule only adds paths outside every project.
+ */
+export async function resolveLocalRequestPath(
+  targetPath: string,
+  access: unknown,
+  store: Store,
+  operation: LocalRequestOperation
+): Promise<string> {
+  // Why the leaf is kept: a rename acts on a link itself, never on what it points to.
+  const options = { preserveSymlink: operation === 'rename-from' || operation === 'rename-to' }
+  const fileAccess = parseLocalFileAccess(access)
+  const kindRule = fileAccess && declaredKindRule(fileAccess, operation, store)
+  if (!fileAccess || !kindRule) {
+    return resolveDesktopAuthorizedPath(targetPath, store, options)
+  }
+  if (typeof targetPath !== 'string') {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  // Why device text first: a device is never a file to load, even inside a project.
+  const automaticLoad = fileAccess.kind === 'document-resource' || fileAccess.kind === 'chat-image'
+  if (automaticLoad && isRefusedAutomaticLoadPath(resolve(targetPath))) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  // Why the default check refuses an outside path by its text first: no share is contacted here.
+  const insideRoots = await resolveDesktopAuthorizedPath(targetPath, store, options).catch(
+    () => undefined
+  )
+  if (insideRoots === undefined) {
+    return kindRule(targetPath)
+  }
+  if (automaticLoad && isRefusedAutomaticLoadPath(insideRoots)) {
+    throw new Error(PATH_ACCESS_DENIED_MESSAGE)
+  }
+  return insideRoots
+}
+
+/**
+ * Both paths of a desktop rename. Renaming the opened document (its document-folder access) follows
+ * the user-file rule: the user typed the new path, so it may go anywhere, and its Undo, declared
+ * from the moved file, may come back from there. Any other rename gets the default check only.
+ */
+export async function resolveLocalRenamePaths(
+  oldPath: string,
+  newPath: string,
+  access: unknown,
+  store: Store
+): Promise<{ from: string; to: string }> {
+  const fileAccess = parseLocalFileAccess(access)
+  const renameAccess =
+    fileAccess?.kind === 'document-folder' && isOpenedDocument(oldPath, fileAccess.documentPath)
+      ? USER_FILE_ACCESS
+      : undefined
+  return {
+    from: await resolveLocalRequestPath(oldPath, renameAccess, store, 'rename-from'),
+    to: await resolveLocalRequestPath(newPath, renameAccess, store, 'rename-to')
+  }
+}
+
+/** A desktop read/stat request; no declared access means roots only. */
+export function resolveLocalFileRequestPath(
+  targetPath: string,
+  access: unknown,
+  store: Store
+): Promise<string> {
+  return resolveLocalRequestPath(targetPath, access, store, 'read')
+}
+
+/** A desktop save; user-file access adds the open file the user named. */
+export function resolveLocalWriteRequestPath(
+  targetPath: string,
+  access: unknown,
+  store: Store
+): Promise<string> {
+  return resolveLocalRequestPath(targetPath, access, store, 'write')
+}
diff --git a/src/main/ipc/local-log-tail-lifetime.test.ts b/src/main/ipc/local-log-tail-lifetime.test.ts
index 4abf283b9ec..95d320164a8 100644
--- a/src/main/ipc/local-log-tail-lifetime.test.ts
+++ b/src/main/ipc/local-log-tail-lifetime.test.ts
@@ -13,12 +13,16 @@ vi.mock('electron', () => ({
     handle: (name: string, handler: (...args: unknown[]) => unknown) => handlers.set(name, handler)
   }
 }))
-vi.mock('./filesystem-auth', () => ({ resolveAuthorizedPath: authorize }))
+vi.mock('./local-file-access-resolution', () => ({ resolveUserNamedRegularFile: authorize }))
 import {
   closeAllLocalLogTailWatchers,
   getActiveLocalLogTailWatcherCount,
   registerLocalLogTailHandlers
 } from './local-log-tail'
+import type { Store } from '../persistence'
+
+// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: path resolution is mocked, so the store is never read.
+const NO_STORE = {} as Store
 
 class Sender extends EventEmitter {
   dead = false
@@ -41,8 +45,7 @@ beforeEach(async () => {
   filePath = join(directory, 'fixture.log')
   await writeFile(filePath, 'test\n')
   authorize.mockReset().mockResolvedValue(filePath)
-  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: authorization is mocked; the handler never reads Store in this isolated fixture.
-  registerLocalLogTailHandlers({} as never)
+  registerLocalLogTailHandlers(NO_STORE)
 })
 afterEach(async () => {
   closeAllLocalLogTailWatchers()
diff --git a/src/main/ipc/local-log-tail.test.ts b/src/main/ipc/local-log-tail.test.ts
index 5f7f46ab0f5..ce88830304e 100644
--- a/src/main/ipc/local-log-tail.test.ts
+++ b/src/main/ipc/local-log-tail.test.ts
@@ -18,7 +18,9 @@ vi.mock('electron', () => ({
 
 vi.mock('node:fs', () => ({ watch: watchMock }))
 
-vi.mock('./filesystem-auth', () => ({ resolveAuthorizedPath: resolveAuthorizedPathMock }))
+vi.mock('./local-file-access-resolution', () => ({
+  resolveUserNamedRegularFile: resolveAuthorizedPathMock
+}))
 
 vi.mock('../ai-vault/local-log-tail-reader', () => ({
   readLocalLogTailRange: readRangeMock
@@ -29,6 +31,10 @@ import {
   getActiveLocalLogTailWatcherCount,
   registerLocalLogTailHandlers
 } from './local-log-tail'
+import type { Store } from '../persistence'
+
+// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: path resolution is mocked, so the store is never read.
+const NO_STORE = {} as Store
 
 type FakeWatcher = {
   close: ReturnType<typeof vi.fn>
@@ -64,7 +70,7 @@ beforeEach(() => {
   watchMock.mockReset()
   resolveAuthorizedPathMock.mockReset().mockImplementation(async (path: string) => path)
   readRangeMock.mockReset()
-  registerLocalLogTailHandlers({} as never)
+  registerLocalLogTailHandlers(NO_STORE)
 })
 
 afterEach(() => {
@@ -87,7 +93,7 @@ describe('local log tail IPC', () => {
     )
     emitChange?.('change')
 
-    expect(resolveAuthorizedPathMock).toHaveBeenCalledWith('/logs/session.jsonl', expect.anything())
+    expect(resolveAuthorizedPathMock).toHaveBeenCalledWith('/logs/session.jsonl', NO_STORE)
     expect(watchMock).toHaveBeenCalledWith('/logs/session.jsonl', expect.any(Function))
     expect(sender.send).toHaveBeenCalledWith('fs:localLogTailChanged', {
       subscriptionId: 'tail-1',
diff --git a/src/main/ipc/local-log-tail.ts b/src/main/ipc/local-log-tail.ts
index 0892665ad50..85d402910de 100644
--- a/src/main/ipc/local-log-tail.ts
+++ b/src/main/ipc/local-log-tail.ts
@@ -1,6 +1,5 @@
 import { ipcMain, type WebContents } from 'electron'
 import { watch, type FSWatcher } from 'node:fs'
-import type { Store } from '../persistence'
 import type {
   LocalLogTailChangedPayload,
   LocalLogTailReadArgs,
@@ -8,7 +7,8 @@ import type {
   LocalLogTailWatchArgs
 } from '../../shared/local-log-tail-types'
 import { readLocalLogTailRange } from '../ai-vault/local-log-tail-reader'
-import { resolveAuthorizedPath } from './filesystem-auth'
+import type { Store } from '../persistence'
+import { resolveUserNamedRegularFile } from './local-file-access-resolution'
 import { abortWhenRendererGone } from './renderer-lifetime-abort'
 
 type TailSenderOwner = {
@@ -109,7 +109,7 @@ async function startWatch(
   const pending = Symbol(subscriptionId)
   owner.pending.set(key, pending)
   try {
-    const filePath = await resolveAuthorizedPath(args.filePath, store)
+    const filePath = await resolveUserNamedRegularFile(args.filePath, store)
     if (
       sender.isDestroyed() ||
       owner.signal.aborted ||
@@ -147,7 +147,7 @@ export function registerLocalLogTailHandlers(store: Store): void {
   ipcMain.handle(
     'fs:readLocalLogTail',
     async (_event, args: LocalLogTailReadArgs): Promise<LocalLogTailReadResult> => {
-      const filePath = await resolveAuthorizedPath(args.filePath, store)
+      const filePath = await resolveUserNamedRegularFile(args.filePath, store)
       return readLocalLogTailRange(filePath, args.fromByteOffset, args.expectedIdentity)
     }
   )
diff --git a/src/main/ipc/notebook-project-link.test.ts b/src/main/ipc/notebook-project-link.test.ts
new file mode 100644
index 00000000000..d0036d1d38f
--- /dev/null
+++ b/src/main/ipc/notebook-project-link.test.ts
@@ -0,0 +1,102 @@
+import { EventEmitter } from 'node:events'
+import { mkdir, mkdtemp, realpath, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import type { Store } from '../persistence'
+import type * as RepoWorktrees from '../repo-worktrees'
+import { invalidateAuthorizedRootsCache } from './registered-worktree-roots-cache'
+
+type Handler = (event: unknown, args: unknown) => unknown
+
+const { handlers, startNotebookKernelMock, userData } = vi.hoisted(() => ({
+  handlers: new Map<string, Handler>(),
+  startNotebookKernelMock: vi.fn(),
+  userData: { path: '' }
+}))
+
+vi.mock('electron', () => ({
+  app: { getPath: () => userData.path },
+  ipcMain: { handle: (channel: string, handler: Handler) => handlers.set(channel, handler) }
+}))
+vi.mock('../repo-worktrees', async () => {
+  const actual = await vi.importActual<typeof RepoWorktrees>('../repo-worktrees')
+  return { ...actual, listRepoWorktreeGraph: vi.fn(async () => []) }
+})
+vi.mock('../notebook/notebook-kernel', () => ({ startNotebookKernel: startNotebookKernelMock }))
+
+import { registerNotebookHandlers } from './notebook'
+
+let base: string
+let project: string
+
+function storeWithProject(projectPath: string): Store {
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: authorization reads only these Store members.
+  return {
+    getRepos: () => [
+      { id: 'repo', path: projectPath, displayName: 'project', badgeColor: '#000', addedAt: 0 }
+    ],
+    getProjects: () => [],
+    getProjectGroups: () => [],
+    getFolderWorkspaces: () => [],
+    getSettings: () => ({ nestWorkspaces: false, workspaceDir: '' })
+  } as unknown as Store
+}
+
+beforeEach(async () => {
+  invalidateAuthorizedRootsCache()
+  handlers.clear()
+  startNotebookKernelMock.mockReset().mockReturnValue({
+    kernel: { execute: vi.fn(), interrupt: vi.fn(), shutdown: vi.fn() },
+    ready: Promise.resolve({ status: 'ready' }),
+    exited: new Promise(() => {})
+  })
+  base = await mkdtemp(join(await realpath(tmpdir()), 'orca-notebook-link-'))
+  project = join(base, 'project')
+  userData.path = join(base, 'user-data')
+  await mkdir(join(project, 'analysis'), { recursive: true })
+  await mkdir(join(userData.path, 'floating-workspace'), { recursive: true })
+  await writeFile(join(project, 'analysis', 'real.ipynb'), '{}')
+  registerNotebookHandlers(storeWithProject(project))
+})
+
+afterEach(async () => {
+  await rm(base, { recursive: true, force: true })
+})
+
+it.skipIf(process.platform === 'win32')(
+  'runs a notebook opened through a project link in its real folder, as the project check resolves it',
+  async () => {
+    await symlink(join(project, 'analysis', 'real.ipynb'), join(project, 'nb.ipynb'))
+    const owner = Object.assign(new EventEmitter(), { send: vi.fn(), isDestroyed: () => false })
+
+    await handlers.get('notebook:startKernel')!(
+      { sender: owner },
+      { filePath: join(project, 'nb.ipynb'), python: '/py' }
+    )
+
+    expect(startNotebookKernelMock).toHaveBeenCalledWith(
+      expect.objectContaining({ cwd: join(project, 'analysis') })
+    )
+  }
+)
+
+it.skipIf(process.platform === 'win32')(
+  'runs a linked notebook outside every project in its real folder, as before',
+  async () => {
+    const notes = join(base, 'notes')
+    await mkdir(join(notes, 'analysis'), { recursive: true })
+    await writeFile(join(notes, 'analysis', 'real.ipynb'), '{}')
+    await symlink(join(notes, 'analysis', 'real.ipynb'), join(notes, 'nb.ipynb'))
+    const owner = Object.assign(new EventEmitter(), { send: vi.fn(), isDestroyed: () => false })
+
+    await handlers.get('notebook:startKernel')!(
+      { sender: owner },
+      { filePath: join(notes, 'nb.ipynb'), python: '/py' }
+    )
+
+    expect(startNotebookKernelMock).toHaveBeenCalledWith(
+      expect.objectContaining({ cwd: join(notes, 'analysis') })
+    )
+  }
+)
diff --git a/src/main/ipc/notebook.test.ts b/src/main/ipc/notebook.test.ts
index 961c652f316..f8bd1ddc567 100644
--- a/src/main/ipc/notebook.test.ts
+++ b/src/main/ipc/notebook.test.ts
@@ -1,5 +1,9 @@
 import { EventEmitter } from 'node:events'
+import { mkdtemp, realpath, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as NodeFsPromises from 'node:fs/promises'
 import type { KernelFrame } from '../../shared/notebook-kernel-types'
 
 const handlers = new Map<string, (event: unknown, args: unknown) => unknown>()
@@ -14,11 +18,23 @@ vi.mock('electron', () => ({
       handlers.set(channel, handler)
   }
 }))
-vi.mock('./filesystem-auth', () => ({ resolveAuthorizedPath: resolveAuthorizedPathMock }))
+vi.mock('./local-file-access-resolution', () => ({
+  resolveUserNamedRegularFile: resolveAuthorizedPathMock,
+  resolveDesktopAuthorizedPath: resolveAuthorizedPathMock
+}))
 vi.mock('../notebook/notebook-kernel', () => ({ startNotebookKernel: startNotebookKernelMock }))
+// Why: the mocked resolver returns made-up `/real/...` paths, which stand for real files already.
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFsPromises>()
+  return {
+    ...actual,
+    realpath: async (path: string) => (path.startsWith('/real/') ? path : actual.realpath(path))
+  }
+})
 
 import { registerNotebookHandlers } from './notebook'
 import type { Store } from '../persistence'
+import type * as FileAccessResolution from './local-file-access-resolution'
 
 function fakeKernel() {
   let onFrame: (frame: KernelFrame) => void = () => {}
@@ -122,6 +138,30 @@ describe('notebook IPC', () => {
     expect(first.kernel.execute).not.toHaveBeenCalled()
   })
 
+  it('starts a kernel for a notebook outside every project, and refuses a relative path', async () => {
+    const actual = await vi.importActual<typeof FileAccessResolution>(
+      './local-file-access-resolution'
+    )
+    resolveAuthorizedPathMock.mockImplementation(actual.resolveUserNamedRegularFile)
+    const folder = await mkdtemp(join(await realpath(tmpdir()), 'orca-notebook-'))
+    try {
+      const notebook = join(folder, 'analysis.ipynb')
+      await writeFile(notebook, '{}')
+      fakeKernel()
+      const start = handlers.get('notebook:startKernel')!
+
+      await expect(
+        start({ sender: fakeOwner() }, { filePath: notebook, python: '/py' })
+      ).resolves.toEqual({ status: 'ready' })
+      expect(startNotebookKernelMock).toHaveBeenCalledWith(expect.objectContaining({ cwd: folder }))
+      await expect(
+        start({ sender: fakeOwner() }, { filePath: 'analysis.ipynb', python: '/py' })
+      ).rejects.toThrow('absolute path')
+    } finally {
+      await rm(folder, { recursive: true, force: true })
+    }
+  })
+
   it.each(['shutdown', 'destroyed', 'did-navigate', 'render-process-gone'])(
     'does not start a kernel after %s while path authorization is pending',
     async (boundary) => {
@@ -229,9 +269,9 @@ describe('notebook IPC', () => {
     const old = start({ sender: owner }, alias)
     const fresh = start({ sender: owner }, canonical)
     handlers.get('notebook:shutdownKernel')!({ sender: owner }, alias)
-    aliasAuthorization.resolve(canonical.filePath)
+    aliasAuthorization.resolve(`/real${canonical.filePath}`)
     await expect(old).resolves.toMatchObject({ status: 'failed' })
-    canonicalAuthorization.resolve(canonical.filePath)
+    canonicalAuthorization.resolve(`/real${canonical.filePath}`)
 
     await expect(fresh).resolves.toEqual({ status: 'ready' })
     handlers.get('notebook:execute')!({ sender: owner }, { ...canonical, code: 'canonical' })
diff --git a/src/main/ipc/notebook.ts b/src/main/ipc/notebook.ts
index f599734a03c..f5ec3109beb 100644
--- a/src/main/ipc/notebook.ts
+++ b/src/main/ipc/notebook.ts
@@ -1,8 +1,12 @@
 import { randomUUID } from 'node:crypto'
+import { realpath } from 'node:fs/promises'
 import { dirname } from 'node:path'
 import { ipcMain, type WebContents } from 'electron'
 import type { Store } from '../persistence'
-import { resolveAuthorizedPath } from './filesystem-auth'
+import {
+  resolveDesktopAuthorizedPath,
+  resolveUserNamedRegularFile
+} from './local-file-access-resolution'
 import { createSenderScopedRequestCancellations } from './sender-scoped-request-cancellation'
 import { startNotebookKernel, type NotebookKernel } from '../notebook/notebook-kernel'
 import {
@@ -57,6 +61,8 @@ function kernelsOf(owner: WebContents): Map<string, NotebookKernel> {
   return kernels
 }
 
+// Why the notebook path is user-named: it is an open tab, and it only picks the kernel's cwd and
+// the venv folder. Inside a project it resolves to the real file, so the cwd is its real folder.
 export function registerNotebookHandlers(store: Store): void {
   ipcMain.handle(
     'notebook:listPythonEnvironments',
@@ -64,7 +70,7 @@ export function registerNotebookHandlers(store: Store): void {
       _event,
       args: { filePath: string; rootPath: string | null; runWorkspaceInterpreters: boolean }
     ): Promise<PythonEnvironments> => {
-      await resolveAuthorizedPath(args.filePath, store)
+      await resolveUserNamedRegularFile(args.filePath, store)
       // Why the unresolved path: rootPath is in the same (possibly symlinked) form, e.g. /tmp.
       return listPythonEnvironments(args.filePath, args.rootPath, {
         runWorkspaceInterpreters: args.runWorkspaceInterpreters === true
@@ -96,8 +102,9 @@ export function registerNotebookHandlers(store: Store): void {
       starts.set(args.filePath, pending)
       pending.add(controller)
       try {
-        // Why: run from the notebook's folder so relative imports and data paths resolve as on disk.
-        const cwd = dirname(await resolveAuthorizedPath(args.filePath, store))
+        // Why the real file's folder: relative imports and data paths resolve as on disk, even when
+        // the notebook was opened through a link.
+        const cwd = dirname(await realpath(await resolveUserNamedRegularFile(args.filePath, store)))
         if (controller.signal.aborted || owner.isDestroyed()) {
           return { status: 'failed', detail: 'The notebook closed before its kernel started.' }
         }
@@ -144,9 +151,9 @@ export function registerNotebookHandlers(store: Store): void {
       _event,
       args: { filePath: string; rootPath: string | null; python: string }
     ): Promise<CreateVenvResult> => {
-      await resolveAuthorizedPath(args.filePath, store)
+      await resolveUserNamedRegularFile(args.filePath, store)
       if (args.rootPath) {
-        await resolveAuthorizedPath(args.rootPath, store)
+        await resolveDesktopAuthorizedPath(args.rootPath, store)
       }
       return createNotebookVenv(args.python, notebookVenvParent(args.filePath, args.rootPath))
     }
diff --git a/src/main/ipc/preflight-remote-ssh.test.ts b/src/main/ipc/preflight-remote-ssh.test.ts
index 4ad02ec5d04..6fad3ec344f 100644
--- a/src/main/ipc/preflight-remote-ssh.test.ts
+++ b/src/main/ipc/preflight-remote-ssh.test.ts
@@ -92,9 +92,33 @@ vi.mock('../gitea/client', () => ({
 }))
 
 import { registerPreflightHandlers } from './preflight'
+import { detectAgentCommandsOnHost } from '../preflight/agent-detection'
 import { resetPreflightMocks, type HandlerMap } from './preflight-test-harness'
 
 describe('preflight', () => {
+  it('resolves exact Qoder command labels on the SSH host using the existing request', async () => {
+    const request = vi.fn().mockResolvedValue({ agents: ['qoder', 'unrelated'] })
+    getActiveMultiplexerMock.mockReturnValue({ isDisposed: () => false, request })
+    await expect(
+      detectAgentCommandsOnHost(['qodercli', 'qoder'], { connectionId: 'ssh-qoder' })
+    ).resolves.toEqual(new Set(['qoder']))
+    expect(request).toHaveBeenCalledWith('preflight.detectAgents', {
+      commands: [
+        { id: 'qodercli', cmd: 'qodercli' },
+        { id: 'qoder', cmd: 'qoder' }
+      ]
+    })
+    expect(isCommandOnLocalPathMock).not.toHaveBeenCalled()
+  })
+
+  it('refuses command selection after SSH contact loss without probing the local host', async () => {
+    getActiveMultiplexerMock.mockReturnValue(null)
+    await expect(
+      detectAgentCommandsOnHost(['qodercli', 'qoder'], { connectionId: 'ssh-qoder' })
+    ).rejects.toThrow('execution host connection')
+    expect(isCommandOnLocalPathMock).not.toHaveBeenCalled()
+  })
+
   const originalPlatform = process.platform
   const handlers: HandlerMap = {}
 
diff --git a/src/main/ipc/pty-daemon-spawn-codex-auth.test.ts b/src/main/ipc/pty-daemon-spawn-codex-auth.test.ts
index cb60984c50c..0ecb8da064e 100644
--- a/src/main/ipc/pty-daemon-spawn-codex-auth.test.ts
+++ b/src/main/ipc/pty-daemon-spawn-codex-auth.test.ts
@@ -7,7 +7,8 @@ import {
 import {
   expectedOmpStatusExtension,
   TEST_CODEX_HOME,
-  TEST_CODEX_AUTH_JSON
+  TEST_CODEX_AUTH_JSON,
+  TEST_MANAGED_ROOT
 } from './pty-ipc-test-constants'
 import { setupPtyIpcSuite } from './pty-ipc-test-harness'
 import { createDaemonActiveProviderFixtures } from './pty-ipc-daemon-provider-fixtures'
@@ -15,6 +16,8 @@ import { join } from 'node:path'
 import { SETUP_AGENT_SEQUENCE_STARTUP_COMMAND_ENV } from '../../shared/setup-agent-sequencing'
 import { registerPtyHandlers, resolveCodexHomeAfterManagedAuthReadiness } from './pty'
 
+const consumerConfigHome = join(TEST_MANAGED_ROOT, 'opencode-consumer-config')
+
 vi.mock('electron', () => import('./pty-ipc-mock-registry').then((m) => m.electronModuleMock()))
 vi.mock('fs', () => import('./pty-ipc-mock-registry').then((m) => m.fsModuleMock()))
 vi.mock('node-pty', () => import('./pty-ipc-mock-registry').then((m) => m.nodePtyModuleMock()))
@@ -435,11 +438,15 @@ describe('registerPtyHandlers', () => {
         expect(env.ORCA_OPENCODE_HOOK_PORT).toBe('4567')
       })
       it('mirrors a user-provided OPENCODE_CONFIG_DIR into a source-scoped overlay on the daemon path', async () => {
-        const env = await daemonSpawnAndGetEnv({ OPENCODE_CONFIG_DIR: '/user/custom/opencode' })
+        const env = await daemonSpawnAndGetEnv({
+          OPENCODE_CONFIG_DIR: '/user/custom/opencode',
+          XDG_CONFIG_HOME: consumerConfigHome
+        })
         // Why: OpenCode loads config from a single dir, so the user's path is mirrored into a source-scoped overlay, not passed through.
         expect(openCodeBuildPtyEnvMock).toHaveBeenCalledWith(
           expect.any(String),
-          '/user/custom/opencode'
+          '/user/custom/opencode',
+          join(consumerConfigHome, 'opencode')
         )
         expect(env.OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-overlay')
         expect(env.ORCA_OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-overlay')
@@ -448,11 +455,13 @@ describe('registerPtyHandlers', () => {
       it('uses source OpenCode config env instead of remirroring a parent overlay', async () => {
         const env = await daemonSpawnAndGetEnv({
           OPENCODE_CONFIG_DIR: '/tmp/parent-orca-opencode-overlay',
-          ORCA_OPENCODE_SOURCE_CONFIG_DIR: '/user/custom/opencode'
+          ORCA_OPENCODE_SOURCE_CONFIG_DIR: '/user/custom/opencode',
+          XDG_CONFIG_HOME: consumerConfigHome
         })
         expect(openCodeBuildPtyEnvMock).toHaveBeenCalledWith(
           expect.any(String),
-          '/user/custom/opencode'
+          '/user/custom/opencode',
+          join(consumerConfigHome, 'opencode')
         )
         expect(env.OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-overlay')
         expect(env.ORCA_OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-overlay')
diff --git a/src/main/ipc/pty-ipc-suite-environment.ts b/src/main/ipc/pty-ipc-suite-environment.ts
index c7256a57f3e..fbab71bead1 100644
--- a/src/main/ipc/pty-ipc-suite-environment.ts
+++ b/src/main/ipc/pty-ipc-suite-environment.ts
@@ -58,6 +58,7 @@ import { _resetWslCachesForTests } from '../wsl'
 
 /** The mocked webContents each suite asserts sends against. */
 export type PtyIpcTestWebContents = {
+  id: number
   on: Mock
   send: Mock
   removeListener: Mock
@@ -92,6 +93,7 @@ export function createPtyIpcSuiteEnvironment(): PtyIpcSuiteEnvironment {
     isVisible: () => true,
     isMinimized: () => false,
     webContents: {
+      id: 1,
       on: vi.fn(),
       send: vi.fn(),
       removeListener: vi.fn(),
@@ -101,6 +103,7 @@ export function createPtyIpcSuiteEnvironment(): PtyIpcSuiteEnvironment {
   const mainWindowIpcEvent = { sender: mainWindow.webContents }
   const foreignWindowIpcEvent = {
     sender: {
+      id: 2,
       on: vi.fn(),
       send: vi.fn(),
       removeListener: vi.fn(),
diff --git a/src/main/ipc/pty-pane-restart-replace.test.ts b/src/main/ipc/pty-pane-restart-replace.test.ts
index 50558a0f870..5fc47deac66 100644
--- a/src/main/ipc/pty-pane-restart-replace.test.ts
+++ b/src/main/ipc/pty-pane-restart-replace.test.ts
@@ -1,6 +1,9 @@
-import { describe, expect, it, vi } from 'vitest'
+import { PtyBindingPersistenceOperations } from '../persistence/loading-store/pty-binding-persistence'
+import { describe, expect, it, onTestFinished, vi } from 'vitest'
 import { setupPtyIpcSuite, type PtyIpcSuiteFixtures } from './pty-ipc-test-harness'
-import { SessionNotFoundError } from '../daemon/daemon-errors'
+import { registerSshPtyProvider, unregisterSshPtyProvider } from './pty/provider/registry'
+import { toAppSshPtyId } from '../providers/ssh-pty-id'
+import { TerminalKilledError } from '../daemon/daemon-pty-lifecycle-errors'
 import { makePaneKey } from '../../shared/stable-pane-id'
 import { registerPtyHandlers, setLocalPtyProvider } from './pty'
 import { TerminalIntentionalStops } from '../runtime/terminal-intentional-stops'
@@ -56,6 +59,34 @@ const leafId = '12121212-1212-4212-8212-121212121212'
 const paneKey = makePaneKey(tabId, leafId)
 
 type RestartHarness = ReturnType<typeof installRestartHarness>
+type FakeSession = {
+  tabsByWorktree: Record<string, { id: string; worktreeId: string; ptyId: string | null }[]>
+  terminalLayoutsByTabId: Record<
+    string,
+    {
+      root: { type: 'leaf'; leafId: string }
+      activeLeafId: string
+      expandedLeafId: null
+      ptyIdsByLeafId: Record<string, string>
+    }
+  >
+  terminalPtyIncarnationsByPaneKey: Record<string, string>
+}
+
+function seedSession(ptyId: string): FakeSession {
+  return {
+    tabsByWorktree: { [worktreeId]: [{ id: tabId, worktreeId, ptyId }] },
+    terminalLayoutsByTabId: {
+      [tabId]: {
+        root: { type: 'leaf', leafId },
+        activeLeafId: leafId,
+        expandedLeafId: null,
+        ptyIdsByLeafId: { [leafId]: ptyId }
+      }
+    },
+    terminalPtyIncarnationsByPaneKey: { [paneKey]: 'inc-old' }
+  }
+}
 
 function registerWithFakes(
   mainWindow: PtyIpcSuiteFixtures['mainWindow'],
@@ -78,13 +109,15 @@ function installRestartHarness(
   options: { shutdownFails?: boolean; shutdownGate?: Promise<void> } = {}
 ) {
   let oldSessionAlive = true
-  const control = { shutdownFails: options.shutdownFails ?? false }
+  const control = { shutdownFails: options.shutdownFails ?? false, failNextWrite: false }
+  const boundAtFreshLaunch: (string | undefined)[] = []
   const providerSpawn = vi.fn(async (spawnOptions: { attachOnly?: boolean }) => {
     if (!spawnOptions.attachOnly) {
+      boundAtFreshLaunch.push(leafBinding())
       return { id: 'pty-new', incarnationId: 'inc-new' }
     }
     if (!oldSessionAlive) {
-      throw new SessionNotFoundError('pty-old')
+      throw new TerminalKilledError('pty-old')
     }
     return { id: 'pty-old', incarnationId: 'inc-old', isReattach: true }
   })
@@ -120,31 +153,75 @@ function installRestartHarness(
   }
   // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the restart path calls only the provider members this fake defines.
   setLocalPtyProvider(provider as unknown as Parameters<typeof setLocalPtyProvider>[0])
-  let session = {
-    tabsByWorktree: { [worktreeId]: [{ id: tabId, worktreeId, ptyId: 'pty-old' }] },
-    terminalLayoutsByTabId: {
-      [tabId]: {
-        root: { type: 'leaf' as const, leafId },
-        activeLeafId: leafId,
-        expandedLeafId: null,
-        ptyIdsByLeafId: { [leafId]: 'pty-old' }
-      }
-    },
-    terminalPtyIncarnationsByPaneKey: { [paneKey]: 'inc-old' }
-  }
+  let session = seedSession('pty-old')
   const store = {
-    getWorkspaceSession: vi.fn(() => session),
+    getWorkspaceSession: vi.fn((_hostId?: string): FakeSession => session),
     setWorkspaceSession: vi.fn((next) => {
       session = next
     }),
     flushOrThrow: vi.fn(),
-    runDurableMutation: vi.fn(async <T>(mutate: () => { value: T }) => mutate().value),
-    persistPtyBinding: vi.fn(),
+    runDurableMutation: vi.fn(
+      async <T>(
+        mutate: () => { value: T; persist?: boolean | 'if-dirty'; rollback?: () => void }
+      ) => {
+        const mutation = mutate()
+        if (mutation.persist !== false) {
+          if (control.failNextWrite) {
+            control.failNextWrite = false
+            mutation.rollback?.()
+            throw new Error('save failed')
+          }
+          durableBindings.push(leafBinding())
+        }
+        return mutation.value
+      }
+    ),
+    getWorkspaceSessionHostIds: vi.fn(() => [
+      'local',
+      ...Object.keys(state.workspaceSessionsByHostId)
+    ]),
     getFolderWorkspace: vi.fn(() => undefined),
     getFolderWorkspaces: vi.fn(() => []),
     getProjectGroups: vi.fn(() => []),
     getRepos: vi.fn(() => [])
   }
+  const state: {
+    workspaceSession: FakeSession
+    workspaceSessionsByHostId: Record<string, FakeSession>
+  } = { workspaceSession: session, workspaceSessionsByHostId: {} }
+  const durableBindings: (string | undefined)[] = []
+  function leafBinding(hostId?: string): string | undefined {
+    return store.getWorkspaceSession(hostId).terminalLayoutsByTabId[tabId]?.ptyIdsByLeafId?.[leafId]
+  }
+  // Like the store, a missing host partition reads as an empty session, never the local one.
+  store.getWorkspaceSession.mockImplementation((hostId?: string) =>
+    hostId && hostId !== 'local'
+      ? (state.workspaceSessionsByHostId[hostId] ?? {
+          tabsByWorktree: {},
+          terminalLayoutsByTabId: {},
+          terminalPtyIncarnationsByPaneKey: {}
+        })
+      : state.workspaceSession
+  )
+  const bindingRuntime = {
+    state,
+    dirtyProfileStateDomains: new Set(),
+    runDurableMutation: store.runDurableMutation,
+    writeTimer: null,
+    pendingWrite: null,
+    quitFlushStarted: false,
+    writeGeneration: 0,
+    lastDurableWriteGeneration: 0
+  }
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: binding writes read only state, write bookkeeping, durable mutation and the session partitions from these fakes.
+  const bindingArgs = [bindingRuntime, store] as unknown as ConstructorParameters<
+    typeof PtyBindingPersistenceOperations
+  >
+  const bindingOperations = new PtyBindingPersistenceOperations(...bindingArgs)
+  const storeWithRetirement = Object.assign(store, {
+    persistPtyBinding: vi.fn(bindingOperations.persistPtyBinding.bind(bindingOperations)),
+    retirePtyBinding: bindingOperations.retirePtyBinding.bind(bindingOperations)
+  })
   const runtime = {
     setPtyController: vi.fn(),
     resolveTerminalPane: vi.fn(() => {
@@ -165,7 +242,18 @@ function installRestartHarness(
     onPtyData: vi.fn(),
     intentionalPtyStops: new TerminalIntentionalStops()
   }
-  return { providerSpawn, shutdown, store, runtime, control }
+  return {
+    providerSpawn,
+    shutdown,
+    store: storeWithRetirement,
+    runtime,
+    control,
+    provider,
+    leafBinding,
+    durableBindings,
+    boundAtFreshLaunch,
+    partitions: state.workspaceSessionsByHostId
+  }
 }
 
 function restartSpawnArgs(extra: { replacesPtyId?: string } = {}) {
@@ -283,4 +371,270 @@ describe('pty:spawn replacing a pane owner', () => {
     expect(exitPayloads('pty-old')).toHaveLength(1)
     expect(exitPayloads('pty-old')[0]).not.toHaveProperty('replacedByRestart')
   })
+  it('swaps the stopped binding for the replacement in one write, never unbinding the pane', async () => {
+    const { providerSpawn, store, runtime, durableBindings, boundAtFreshLaunch } =
+      installRestartHarness()
+    const session = store.getWorkspaceSession()
+    const layout = structuredClone(session.terminalLayoutsByTabId[tabId])
+    registerWithFakes(mainWindow, runtime, store)
+    await handlers.get('pty:spawn')!(null, restartSpawnArgs({ replacesPtyId: 'pty-old' }))
+    const swapped = store.getWorkspaceSession()
+    expect(boundAtFreshLaunch).toEqual(['pty-old'])
+    expect(durableBindings).toEqual(['pty-new'])
+    expect(swapped.tabsByWorktree[worktreeId]).toEqual([
+      { ...session.tabsByWorktree[worktreeId][0], ptyId: 'pty-new' }
+    ])
+    expect(swapped.terminalLayoutsByTabId[tabId]).toEqual({
+      ...layout,
+      ptyIdsByLeafId: { [leafId]: 'pty-new' }
+    })
+    expect(swapped.terminalPtyIncarnationsByPaneKey).toEqual({ [paneKey]: 'inc-new' })
+    expect(providerSpawn.mock.calls.every(([options]) => !options.attachOnly)).toBe(true)
+  })
+
+  it('launches fresh when a stale snapshot re-publishes the stopped binding mid-spawn', async () => {
+    const { providerSpawn, store, runtime, leafBinding } = installRestartHarness()
+    runtime.createPreAllocatedTerminalHandle.mockImplementationOnce(() => {
+      // A debounced renderer layout patch still carrying the old id lands after the stop.
+      const current = store.getWorkspaceSession()
+      current.terminalLayoutsByTabId[tabId] = {
+        ...current.terminalLayoutsByTabId[tabId],
+        ptyIdsByLeafId: { [leafId]: 'pty-old' }
+      }
+      return 'term-restart'
+    })
+    registerWithFakes(mainWindow, runtime, store)
+    await expect(
+      handlers.get('pty:spawn')!(null, restartSpawnArgs({ replacesPtyId: 'pty-old' }))
+    ).resolves.toMatchObject({ id: 'pty-new' })
+    expect(runtime.createPreAllocatedTerminalHandle).toHaveBeenCalled()
+    expect(providerSpawn.mock.calls.every(([options]) => !options.attachOnly)).toBe(true)
+    expect(leafBinding()).toBe('pty-new')
+  })
+
+  it('swaps a binding the renderer withdrew before connecting the replacement', async () => {
+    const { providerSpawn, store, runtime, leafBinding } = installRestartHarness()
+    runtime.createPreAllocatedTerminalHandle.mockImplementationOnce(() => {
+      // A split tab's partial layout map, or an SSH terminated lease, lets the renderer clear land.
+      delete store.getWorkspaceSession().terminalLayoutsByTabId[tabId].ptyIdsByLeafId[leafId]
+      return 'term-restart'
+    })
+    registerWithFakes(mainWindow, runtime, store)
+    await expect(
+      handlers.get('pty:spawn')!(null, restartSpawnArgs({ replacesPtyId: 'pty-old' }))
+    ).resolves.toMatchObject({ id: 'pty-new' })
+    expect(providerSpawn.mock.calls.every(([options]) => !options.attachOnly)).toBe(true)
+    expect(leafBinding()).toBe('pty-new')
+  })
+
+  it('clears the stopped binding when the replacement fails, so the remount starts fresh', async () => {
+    const { providerSpawn, store, runtime, leafBinding } = installRestartHarness()
+    providerSpawn.mockRejectedValueOnce(new Error('spawn failed'))
+    registerWithFakes(mainWindow, runtime, store)
+    await expect(
+      handlers.get('pty:spawn')!(null, restartSpawnArgs({ replacesPtyId: 'pty-old' }))
+    ).rejects.toThrow('spawn failed')
+    const boundAfterFailure = leafBinding()
+    // The renderer's recovery remount sends no replacesPtyId.
+    await expect(handlers.get('pty:spawn')!(null, restartSpawnArgs())).resolves.toMatchObject({
+      id: 'pty-new'
+    })
+    expect(boundAfterFailure).toBeUndefined()
+    expect(providerSpawn.mock.calls.every(([options]) => !options.attachOnly)).toBe(true)
+  })
+
+  it('reaps the replacement when its binding save fails, and the remount starts fresh', async () => {
+    const { provider, providerSpawn, store, runtime, control, leafBinding } =
+      installRestartHarness()
+    control.failNextWrite = true
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+    registerWithFakes(mainWindow, runtime, store)
+    await expect(
+      handlers.get('pty:spawn')!(null, restartSpawnArgs({ replacesPtyId: 'pty-old' }))
+    ).rejects.toThrow('ORCA_TERMINAL_SESSION_STATE_SAVE_FAILED')
+    expect(provider.shutdown).toHaveBeenCalledWith(
+      'pty-new',
+      expect.objectContaining({ immediate: true })
+    )
+    const boundAfterFailure = leafBinding()
+    await expect(handlers.get('pty:spawn')!(null, restartSpawnArgs())).resolves.toMatchObject({
+      id: 'pty-new'
+    })
+    expect(boundAfterFailure).toBeUndefined()
+    expect(providerSpawn.mock.calls.every(([options]) => !options.attachOnly)).toBe(true)
+  })
+
+  it('refuses an old restart after another owner has already claimed the pane', async () => {
+    const { shutdown, providerSpawn, store, runtime } = installRestartHarness()
+    store.getWorkspaceSession().terminalLayoutsByTabId[tabId].ptyIdsByLeafId[leafId] = 'successor'
+    registerWithFakes(mainWindow, runtime, store)
+    await expect(
+      handlers.get('pty:spawn')!(null, restartSpawnArgs({ replacesPtyId: 'pty-old' }))
+    ).rejects.toThrow('terminal_pane_owner_changed')
+    expect(shutdown).not.toHaveBeenCalled()
+    expect(providerSpawn).not.toHaveBeenCalled()
+    expect(store.setWorkspaceSession).not.toHaveBeenCalled()
+  })
+
+  it('reaps the replacement when a successor binds the pane during its spawn', async () => {
+    const { provider, providerSpawn, store, runtime, leafBinding } = installRestartHarness()
+    providerSpawn.mockImplementationOnce(async () => {
+      store.getWorkspaceSession().terminalLayoutsByTabId[tabId].ptyIdsByLeafId[leafId] = 'successor'
+      return { id: 'pty-new', incarnationId: 'inc-new' }
+    })
+    registerWithFakes(mainWindow, runtime, store)
+    await expect(
+      handlers.get('pty:spawn')!(null, restartSpawnArgs({ replacesPtyId: 'pty-old' }))
+    ).rejects.toThrow('terminal_pane_owner_changed')
+    expect(provider.shutdown).toHaveBeenCalledWith(
+      'pty-new',
+      expect.objectContaining({ immediate: true })
+    )
+    expect(leafBinding()).toBe('successor')
+  })
+
+  /** The SSH pane lives only in its host partition; the local leaf keeps an unrelated id. */
+  async function withSshRestart(
+    run: (
+      host: RestartHarness & { oldId: string; newId: string; hostId: string },
+      restart: (extra?: { replacesPtyId?: string }) => Promise<unknown>
+    ) => Promise<void>
+  ): Promise<void> {
+    const harness = installRestartHarness()
+    const connectionId = 'restart-ssh'
+    const hostId = 'ssh:restart-ssh'
+    const oldId = toAppSshPtyId(connectionId, 'pty-old')
+    const newId = toAppSshPtyId(connectionId, 'pty-new')
+    harness.partitions[hostId] = seedSession(oldId)
+    Object.assign(harness.store, {
+      markSshRemotePtyLease: vi.fn(),
+      upsertSshRemotePtyLease: vi.fn(),
+      removeSshRemotePtyLease: vi.fn(),
+      supersedeSshRemotePtyLeasesForBoundPane: vi.fn()
+    })
+    let oldAlive = true
+    harness.shutdown.mockImplementation(async () => {
+      oldAlive = false
+    })
+    harness.providerSpawn.mockImplementation(async (options) => {
+      if (!options.attachOnly) {
+        return { id: newId, incarnationId: 'inc-new' }
+      }
+      if (!oldAlive) {
+        throw new TerminalKilledError(oldId)
+      }
+      return { id: oldId, incarnationId: 'inc-old', isReattach: true }
+    })
+    registerSshPtyProvider(
+      connectionId,
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: same fake provider surface used by the local restart fixture.
+      harness.provider as unknown as Parameters<typeof registerSshPtyProvider>[1]
+    )
+    const localSpawn = vi.fn(() => {
+      throw new Error('wrong execution host')
+    })
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the test must never reach the local provider.
+    setLocalPtyProvider({
+      ...harness.provider,
+      spawn: localSpawn,
+      shutdown: localSpawn
+    } as unknown as Parameters<typeof setLocalPtyProvider>[0])
+    registerWithFakes(mainWindow, harness.runtime, harness.store)
+    try {
+      await run({ ...harness, oldId, newId, hostId }, async (extra = {}) =>
+        handlers.get('pty:spawn')!(null, { ...restartSpawnArgs(extra), connectionId })
+      )
+      expect(localSpawn).not.toHaveBeenCalled()
+      expect(harness.leafBinding()).toBe('pty-old')
+    } finally {
+      unregisterSshPtyProvider(connectionId)
+    }
+  }
+
+  it('swaps the direct-SSH host binding without touching the local provider', async () => {
+    await withSshRestart(async (host, restart) => {
+      await expect(restart({ replacesPtyId: host.oldId })).resolves.toMatchObject({
+        id: host.newId
+      })
+      expect(host.shutdown).toHaveBeenCalledWith(
+        host.oldId,
+        expect.objectContaining({ immediate: true })
+      )
+      expect(host.store.persistPtyBinding).toHaveBeenCalledWith(expect.any(Function), host.hostId)
+      expect(host.leafBinding(host.hostId)).toBe(host.newId)
+      expect(host.providerSpawn.mock.calls.every(([options]) => !options.attachOnly)).toBe(true)
+    })
+  })
+
+  it('reaps a direct-SSH replacement when a successor binds the host pane during its spawn', async () => {
+    await withSshRestart(async (host, restart) => {
+      host.providerSpawn.mockImplementationOnce(async () => {
+        host.partitions[host.hostId].terminalLayoutsByTabId[tabId].ptyIdsByLeafId[leafId] =
+          'successor'
+        return { id: host.newId, incarnationId: 'inc-new' }
+      })
+      await expect(restart({ replacesPtyId: host.oldId })).rejects.toThrow(
+        'terminal_pane_owner_changed'
+      )
+      expect(host.shutdown).toHaveBeenCalledWith(
+        host.newId,
+        expect.objectContaining({ immediate: true })
+      )
+      expect(host.leafBinding(host.hostId)).toBe('successor')
+    })
+  })
+
+  it('clears the direct-SSH stopped binding when the replacement fails, so the remount starts fresh', async () => {
+    await withSshRestart(async (host, restart) => {
+      host.providerSpawn.mockRejectedValueOnce(new Error('spawn failed'))
+      await expect(restart({ replacesPtyId: host.oldId })).rejects.toThrow('spawn failed')
+      const boundAfterFailure = host.leafBinding(host.hostId)
+      await expect(restart()).resolves.toMatchObject({ id: host.newId })
+      expect(boundAfterFailure).toBeUndefined()
+      expect(host.providerSpawn.mock.calls.every(([options]) => !options.attachOnly)).toBe(true)
+    })
+  })
+
+  it.each(['darwin', 'linux', 'win32'])(
+    'restarts a folder workspace on %s without deleting its pane',
+    async (platform) => {
+      const originalPlatform = process.platform
+      Object.defineProperty(process, 'platform', { configurable: true, value: platform })
+      onTestFinished(() => {
+        Object.defineProperty(process, 'platform', { configurable: true, value: originalPlatform })
+      })
+      const { store, runtime, leafBinding } = installRestartHarness()
+      const folderId = 'folder:restart-folder'
+      const session = store.getWorkspaceSession()
+      session.tabsByWorktree[folderId] = session.tabsByWorktree[worktreeId].map((tab) => ({
+        ...tab,
+        worktreeId: folderId
+      }))
+      session.tabsByWorktree[worktreeId] = []
+      const folder = {
+        id: 'restart-folder',
+        folderPath: process.cwd(),
+        name: 'Restart',
+        projectGroupId: null
+      }
+      Object.assign(store, {
+        getFolderWorkspaces: vi.fn(() => [folder]),
+        getFolderWorkspace: vi.fn(() => folder)
+      })
+      registerWithFakes(mainWindow, runtime, store)
+      await expect(
+        handlers.get('pty:spawn')!(null, {
+          ...restartSpawnArgs({ replacesPtyId: 'pty-old' }),
+          worktreeId: folderId,
+          cwd: process.cwd()
+        })
+      ).resolves.toMatchObject({ id: 'pty-new' })
+      expect(store.getWorkspaceSession().tabsByWorktree[folderId]).toHaveLength(1)
+      expect(leafBinding()).toBe('pty-new')
+      expect(store.getWorkspaceSession().terminalLayoutsByTabId[tabId].root).toEqual({
+        type: 'leaf',
+        leafId
+      })
+    }
+  )
 })
diff --git a/src/main/ipc/pty-spawn-env-agent-overlays.test.ts b/src/main/ipc/pty-spawn-env-agent-overlays.test.ts
index 4c7204f1980..c194cf04179 100644
--- a/src/main/ipc/pty-spawn-env-agent-overlays.test.ts
+++ b/src/main/ipc/pty-spawn-env-agent-overlays.test.ts
@@ -1,3 +1,4 @@
+import { join } from 'node:path'
 import { withFreshOmpLaunch } from '../../shared/omp-fresh-launch'
 import { describe, expect, it, vi } from 'vitest'
 import {
@@ -7,10 +8,12 @@ import {
   mimoCodeBuildPtyEnvMock,
   piBuildPtyEnvMock
 } from './pty-ipc-mock-registry'
-import { posixOnlyIt } from './pty-ipc-test-constants'
+import { posixOnlyIt, TEST_MANAGED_ROOT } from './pty-ipc-test-constants'
 import { setupPtyIpcSuite } from './pty-ipc-test-harness'
 import { SETUP_AGENT_SEQUENCE_STARTUP_COMMAND_ENV } from '../../shared/setup-agent-sequencing'
 
+const consumerConfigHome = join(TEST_MANAGED_ROOT, 'opencode-consumer-config')
+
 vi.mock('electron', () => import('./pty-ipc-mock-registry').then((m) => m.electronModuleMock()))
 vi.mock('fs', () => import('./pty-ipc-mock-registry').then((m) => m.fsModuleMock()))
 vi.mock('node-pty', () => import('./pty-ipc-mock-registry').then((m) => m.nodePtyModuleMock()))
@@ -99,11 +102,13 @@ describe('registerPtyHandlers', () => {
     it('mirrors the original OpenCode source dir when launched from an Orca overlay shell', async () => {
       const env = await spawnAndGetEnv({
         OPENCODE_CONFIG_DIR: '/tmp/parent-orca-opencode-overlay',
-        ORCA_OPENCODE_SOURCE_CONFIG_DIR: '/tmp/user-opencode-config'
+        ORCA_OPENCODE_SOURCE_CONFIG_DIR: '/tmp/user-opencode-config',
+        XDG_CONFIG_HOME: consumerConfigHome
       })
       expect(openCodeBuildPtyEnvMock).toHaveBeenCalledWith(
         expect.any(String),
-        '/tmp/user-opencode-config'
+        '/tmp/user-opencode-config',
+        join(consumerConfigHome, 'opencode')
       )
       expect(env.OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-overlay')
       expect(env.ORCA_OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-overlay')
@@ -112,10 +117,15 @@ describe('registerPtyHandlers', () => {
     it('does not treat inherited Orca OpenCode config as user config without a source dir', async () => {
       const env = await spawnAndGetEnv({
         OPENCODE_CONFIG_DIR: '/tmp/parent-orca-opencode-overlay',
-        ORCA_OPENCODE_CONFIG_DIR: '/tmp/parent-orca-opencode-overlay'
+        ORCA_OPENCODE_CONFIG_DIR: '/tmp/parent-orca-opencode-overlay',
+        XDG_CONFIG_HOME: consumerConfigHome
       })
 
-      expect(openCodeBuildPtyEnvMock).toHaveBeenCalledWith(expect.any(String), undefined)
+      expect(openCodeBuildPtyEnvMock).toHaveBeenCalledWith(
+        expect.any(String),
+        undefined,
+        join(consumerConfigHome, 'opencode')
+      )
       expect(env.OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-config')
       expect(env.ORCA_OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-config')
       expect(env.ORCA_OPENCODE_SOURCE_CONFIG_DIR).toBeUndefined()
@@ -222,16 +232,20 @@ describe('registerPtyHandlers', () => {
           return ''
         })
 
-        const env = await spawnAndGetEnv(undefined, {
-          HOME: '/home/pim',
-          SHELL: '/bin/zsh',
-          OPENCODE_CONFIG_DIR: undefined,
-          ORCA_OPENCODE_SOURCE_CONFIG_DIR: undefined
-        })
+        const env = await spawnAndGetEnv(
+          { XDG_CONFIG_HOME: consumerConfigHome },
+          {
+            HOME: '/home/pim',
+            SHELL: '/bin/zsh',
+            OPENCODE_CONFIG_DIR: undefined,
+            ORCA_OPENCODE_SOURCE_CONFIG_DIR: undefined
+          }
+        )
 
         expect(openCodeBuildPtyEnvMock).toHaveBeenCalledWith(
           expect.any(String),
-          '/home/pim/company/opencode-config'
+          '/home/pim/company/opencode-config',
+          join(consumerConfigHome, 'opencode')
         )
         expect(env.OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-overlay')
         expect(env.ORCA_OPENCODE_CONFIG_DIR).toBe('/tmp/orca-opencode-overlay')
diff --git a/src/main/ipc/pty/host-env/codex-resume.ts b/src/main/ipc/pty/host-env/codex-resume.ts
index a7118cb08b8..463660e00d7 100644
--- a/src/main/ipc/pty/host-env/codex-resume.ts
+++ b/src/main/ipc/pty/host-env/codex-resume.ts
@@ -30,6 +30,7 @@ export type PrepareCodexResumeHomeArgs = {
   providerSession?: AgentProviderSessionMetadata
   target: CodexAccountSelectionTarget
   launchEnv?: NodeJS.ProcessEnv
+  useSelectedAccount?: boolean
 }
 
 export function prepareCodexResumeHome(
@@ -48,7 +49,8 @@ export function prepareCodexResumeHome(
     preparation: prepareCodexSessionResume({
       providerSession,
       target: args.target,
-      launchEnv: args.launchEnv
+      launchEnv: args.launchEnv,
+      ...(args.useSelectedAccount ? { useSelectedAccount: true } : {})
     })
   }
 }
diff --git a/src/main/ipc/pty/host-env/opencode-config.ts b/src/main/ipc/pty/host-env/opencode-config.ts
index 88dafabc88e..74aa1e46625 100644
--- a/src/main/ipc/pty/host-env/opencode-config.ts
+++ b/src/main/ipc/pty/host-env/opencode-config.ts
@@ -6,6 +6,8 @@ import { openCode2HookService, openCodeHookService } from '../../../opencode/hoo
 import { resolveOpenCodeSourceConfigDir, restoreOrStripOverlayEnv } from './pi-agent'
 import { selectOpenCodeHookAgent } from '../../../../shared/opencode-launch-command'
 import { isTuiAgentEnabled } from '../../../../shared/tui-agent-selection'
+import { resolveOpenCodeConfigDirectory } from '../../../../shared/opencode-config-directory'
+import { readSessionShellStartupEnvVar } from '../../../pty/shell-startup-env'
 import type { BuildPtyHostEnvOptions } from './types'
 
 type OpenCodeSourceConfig = {
@@ -41,7 +43,7 @@ export function applyOpenCodeStatusPluginEnv(
   config: OpenCodeSourceConfig,
   options: Pick<
     BuildPtyHostEnvOptions,
-    'launchAgent' | 'agentStatusHooksEnabled' | 'disabledTuiAgents' | 'isWsl'
+    'launchAgent' | 'agentStatusHooksEnabled' | 'disabledTuiAgents' | 'isWsl' | 'shellPath'
   >,
   command: string | undefined
 ): 'opencode' | 'opencode2' | null {
@@ -69,7 +71,13 @@ export function applyOpenCodeStatusPluginEnv(
   env.ORCA_OPENCODE_AGENT = agent
   // WSL owns its config writes; only the guest overlay may enter a WSL pane.
   if (!options.isWsl) {
-    Object.assign(env, service.buildPtyEnv(id, config.directory))
+    const executionEnv = { ...process.env, ...env }
+    const shellConfigHome = readSessionShellStartupEnvVar('XDG_CONFIG_HOME', env, options.shellPath)
+    const defaultConfigDir = resolveOpenCodeConfigDirectory({
+      ...executionEnv,
+      XDG_CONFIG_HOME: shellConfigHome ?? executionEnv.XDG_CONFIG_HOME
+    })
+    Object.assign(env, service.buildPtyEnv(id, config.directory, defaultConfigDir))
   }
   if (env.OPENCODE_CONFIG_DIR) {
     // Shell startup can re-export the default; preserve this pane's overlay and original source.
diff --git a/src/main/ipc/pty/host-env/opencode-hook-installation.test.ts b/src/main/ipc/pty/host-env/opencode-hook-installation.test.ts
index ddae2771aba..fe42ca5735c 100644
--- a/src/main/ipc/pty/host-env/opencode-hook-installation.test.ts
+++ b/src/main/ipc/pty/host-env/opencode-hook-installation.test.ts
@@ -77,6 +77,85 @@ afterEach(() => {
 })
 
 describe('OpenCode installation uses the current enabled agents', () => {
+  it.each(
+    process.platform === 'win32' ? (['home', 'xdg'] as const) : (['home', 'xdg', 'shell'] as const)
+  )(
+    'consumer config root follows the %s execution environment without redirecting JSON',
+    (kind) => {
+      const home = join(root, 'consumer-home')
+      const xdg = join(root, 'consumer-xdg')
+      const consumer = kind === 'home' ? join(home, '.config', 'opencode') : join(xdg, 'opencode')
+      mkdirSync(home, { recursive: true })
+      mkdirSync(consumer, { recursive: true })
+      const settings = '{"model":"consumer-model","description":"external-settings"}'
+      writeFileSync(join(consumer, 'opencode.json'), settings)
+      if (kind === 'shell') {
+        writeFileSync(join(home, '.zshrc'), `export XDG_CONFIG_HOME='${xdg}'\n`)
+      }
+      const input = {
+        HOME: home,
+        USERPROFILE: home,
+        XDG_CONFIG_HOME: kind === 'xdg' ? xdg : '',
+        SHELL: kind === 'shell' ? '/bin/zsh' : '/bin/sh'
+      }
+      const env = buildPtyHostEnv(
+        'folder-pane',
+        { ...input },
+        { ...options, launchAgent: 'opencode' }
+      )
+      expect(existsSync(plugin(consumer, 'opencode'))).toBe(true)
+      expect(existsSync(plugin(config, 'opencode'))).toBe(false)
+      expect(readFileSync(join(consumer, 'opencode.json'), 'utf8')).toBe(settings)
+      expect(env.OPENCODE_CONFIG_DIR).toBeUndefined()
+      for (const key of ['HOME', 'USERPROFILE', 'XDG_CONFIG_HOME', 'SHELL'] as const) {
+        expect(env[key]).toBe(input[key])
+      }
+    }
+  )
+
+  it.skipIf(process.platform === 'win32').each([
+    { selected: '/bin/bash', inherited: '/bin/zsh', file: '.bash_profile' },
+    { selected: '/bin/zsh', inherited: '/bin/bash', file: '.zshrc' }
+  ])('consumer config follows selected $selected over inherited $inherited', (selection) => {
+    const home = join(root, 'selected-shell-home')
+    const selectedXdg = join(root, 'selected-shell-xdg')
+    const inheritedXdg = join(root, 'inherited-shell-xdg')
+    mkdirSync(home)
+    writeFileSync(
+      join(home, '.bash_profile'),
+      `export XDG_CONFIG_HOME='${selection.file === '.bash_profile' ? selectedXdg : inheritedXdg}'\n`
+    )
+    writeFileSync(
+      join(home, '.zshrc'),
+      `export XDG_CONFIG_HOME='${selection.file === '.zshrc' ? selectedXdg : inheritedXdg}'\n`
+    )
+    const input = { HOME: home, USERPROFILE: home, XDG_CONFIG_HOME: '', SHELL: selection.inherited }
+    const launchOptions = {
+      ...options,
+      launchAgent: 'opencode' as const,
+      shellPath: selection.selected
+    }
+    const env = buildPtyHostEnv('selected-shell-pane', input, launchOptions)
+    expect(existsSync(plugin(join(selectedXdg, 'opencode'), 'opencode'))).toBe(true)
+    expect(existsSync(plugin(join(inheritedXdg, 'opencode'), 'opencode'))).toBe(false)
+    expect(env.SHELL).toBe(selection.inherited)
+    expect(env.OPENCODE_CONFIG_DIR).toBeUndefined()
+  })
+
+  it.each([false, true])('consumer config root is untouched with hooks disabled %s', (disabled) => {
+    const consumer = join(root, 'disabled-consumer')
+    buildPtyHostEnv(
+      'pane',
+      { XDG_CONFIG_HOME: consumer },
+      {
+        ...options,
+        agentStatusHooksEnabled: disabled,
+        disabledTuiAgents: disabled ? ['opencode', 'opencode2'] : []
+      }
+    )
+    expect(existsSync(join(consumer, 'opencode'))).toBe(false)
+  })
+
   it('refuses spawn if a prepared startup intent loses its owned installer', () => {
     mkdirSync(fixture.userData, { recursive: true })
     writeFileSync(
diff --git a/src/main/ipc/pty/host-env/types.ts b/src/main/ipc/pty/host-env/types.ts
index 20981d0cce4..c3dfe1ae6e9 100644
--- a/src/main/ipc/pty/host-env/types.ts
+++ b/src/main/ipc/pty/host-env/types.ts
@@ -23,6 +23,8 @@ export type BuildPtyHostEnvOptions = {
   launchCommand?: string
   /** Trusted agent identity for wrapped commands that cannot be recognized from text. */
   launchAgent?: TuiAgent
+  /** Selected execution shell, which may differ from inherited SHELL. */
+  shellPath?: string
   isWsl?: boolean
   /** Distro for WSL spawns (null = Windows default distro); drives the WSL hook relay + endpoint repoint. Only read when isWsl. */
   wslDistro?: string | null
@@ -53,6 +55,7 @@ export type PrepareCodexSessionResume = (args: {
   providerSession: AgentProviderSessionMetadata
   target: CodexAccountSelectionTarget
   launchEnv?: NodeJS.ProcessEnv
+  useSelectedAccount?: boolean
 }) => Promise<CodexSessionResumePreparation | null>
 
 export type CodexHomePtySpawnedLifecycleArgs = {
diff --git a/src/main/ipc/pty/ipc/spawn-begin.ts b/src/main/ipc/pty/ipc/spawn-begin.ts
index bc0e86ccd2d..a7ae10bc036 100644
--- a/src/main/ipc/pty/ipc/spawn-begin.ts
+++ b/src/main/ipc/pty/ipc/spawn-begin.ts
@@ -13,11 +13,12 @@ import {
   pendingRuntimePaneCreatesByOwnerKey
 } from '../pane/spawn-reservation'
 import { resolveStablePaneOwner } from '../pane/stable-owner'
+import { excludeReplacedPaneOwner } from '../pane/pane-owner-replacement'
 import type { PtyIpcSpawnState } from './spawn-state'
 import type { PtySpawnIpcArgs } from './spawn-types'
 
 /** The pane key a spawn names before preflight; null when it names no stable pane. */
-function resolveEarlyPaneKey(args: PtySpawnIpcArgs): string | null {
+export function resolveEarlyPaneKey(args: PtySpawnIpcArgs): string | null {
   const leafId =
     typeof args.leafId === 'string' && isTerminalLeafId(args.leafId) ? args.leafId : null
   return typeof args.worktreeId === 'string' &&
@@ -45,12 +46,15 @@ export async function beginPtyIpcSpawn(
   const initialStablePanePtyId = (() => {
     try {
       return !args.connectionId && initialPaneKey
-        ? resolveStablePaneOwner(
-            ctx.deps.runtime,
-            ctx.deps.store,
-            initialPaneKey,
-            args.worktreeId,
-            args.connectionId
+        ? excludeReplacedPaneOwner(
+            resolveStablePaneOwner(
+              ctx.deps.runtime,
+              ctx.deps.store,
+              initialPaneKey,
+              args.worktreeId,
+              args.connectionId
+            ),
+            ctx.replacedPaneOwner
           )?.ptyId
         : undefined
     } catch {
@@ -87,12 +91,15 @@ export async function beginPtyIpcSpawn(
   }
   ctx.earlyStablePaneOwner =
     initialPaneKey && args.worktreeId
-      ? resolveStablePaneOwner(
-          ctx.deps.runtime,
-          ctx.deps.store,
-          initialPaneKey,
-          args.worktreeId,
-          args.connectionId
+      ? excludeReplacedPaneOwner(
+          resolveStablePaneOwner(
+            ctx.deps.runtime,
+            ctx.deps.store,
+            initialPaneKey,
+            args.worktreeId,
+            args.connectionId
+          ),
+          ctx.replacedPaneOwner
         )
       : null
   ctx.earlyWorktreeId = args.worktreeId
diff --git a/src/main/ipc/pty/ipc/spawn-commit-persist.ts b/src/main/ipc/pty/ipc/spawn-commit-persist.ts
index 46fd8e714bb..41752886ab9 100644
--- a/src/main/ipc/pty/ipc/spawn-commit-persist.ts
+++ b/src/main/ipc/pty/ipc/spawn-commit-persist.ts
@@ -3,6 +3,7 @@ import { closeStartupQueryAuthorityForPty, getRelayPtyId } from '../provider/reg
 import { createTerminalSessionStateSaveFailureMessage } from '../../../../shared/terminal-session-state-save-failure'
 import { recordCodexPaneAccountForSpawn } from '../host-env/codex-home'
 import { persistAdmittedStablePaneBinding } from '../pane/stable-owner'
+import { swapReplacedPaneBinding } from '../pane/pane-owner-replacement'
 import { claimSshPaneLease } from '../pane/ssh-pane-lease-claim'
 import {
   pendingByPaneKey,
@@ -60,9 +61,13 @@ export async function persistPtyIpcSpawnCommit(ctx: PtyIpcSpawnState): Promise<P
         ...(ctx.cwd ? { startupCwd: ctx.cwd } : {}),
         origin: spawnCommitBindingOrigin(ctx.result)
       }
-      const persisted = args.connectionId
-        ? await ctx.deps.store.persistPtyBinding(binding, toSshExecutionHostId(args.connectionId))
-        : await ctx.deps.store.persistPtyBinding(binding)
+      const hostId = args.connectionId ? toSshExecutionHostId(args.connectionId) : undefined
+      const input = ctx.replacedPaneOwner
+        ? swapReplacedPaneBinding(ctx.deps.store, binding, ctx.replacedPaneOwner, hostId)
+        : binding
+      const persisted = hostId
+        ? await ctx.deps.store.persistPtyBinding(input, hostId)
+        : await ctx.deps.store.persistPtyBinding(input)
       if (persisted === false) {
         throw new Error('terminal_pane_owner_changed')
       }
diff --git a/src/main/ipc/pty/ipc/spawn-env-codex.ts b/src/main/ipc/pty/ipc/spawn-env-codex.ts
index b69bc65fed2..2db804bdf54 100644
--- a/src/main/ipc/pty/ipc/spawn-env-codex.ts
+++ b/src/main/ipc/pty/ipc/spawn-env-codex.ts
@@ -39,7 +39,8 @@ export async function assemblePtyIpcSpawnCodexEnv(ctx: PtyIpcSpawnState): Promis
         launchAgent: args.launchAgent,
         providerSession: args.resumeProviderSession,
         target: ctx.codexSelectionTarget,
-        launchEnv: ctx.baseEnv
+        launchEnv: ctx.baseEnv,
+        ...(args.replacesPtyId ? { useSelectedAccount: true } : {})
       })
   ctx.codexResumeLaunch = codexResumePreparation
     ? await ctx.deps.resolveCodexResumeLaunch(args.command, codexResumePreparation)
@@ -138,6 +139,7 @@ export async function assemblePtyIpcSpawnCodexEnv(ctx: PtyIpcSpawnState): Promis
         stripInheritedOrcaCodexHome: ctx.stripInheritedOrcaCodexHome,
         launchCommand: ctx.launchCommand,
         launchAgent: isTuiAgent(args.launchAgent) ? args.launchAgent : undefined,
+        shellPath: ctx.effectiveShellOverride,
         isWsl: shouldSkipCodexHomeEnvForWindowsShell(ctx.effectiveShellOverride, ctx.cwd),
         wslDistro: ctx.codexSelectionTarget.runtime === 'wsl' ? ctx.expectedWslDistro : null,
         agentStatusHooksEnabled: isAgentStatusHooksEnabled(ptySettings),
diff --git a/src/main/ipc/pty/ipc/spawn-execute.ts b/src/main/ipc/pty/ipc/spawn-execute.ts
index 2d9de676c39..54507a722d0 100644
--- a/src/main/ipc/pty/ipc/spawn-execute.ts
+++ b/src/main/ipc/pty/ipc/spawn-execute.ts
@@ -10,6 +10,7 @@ import { getCohortAtEmit } from '../../../telemetry/cohort-classifier'
 import { agentKindSchema } from '../../../../shared/telemetry-events'
 import { normalizeNodePtySpawnError } from '../provider/liveness'
 import { resolveStablePaneOwner, spawnForStablePane } from '../pane/stable-owner'
+import { excludeReplacedPaneOwner } from '../pane/pane-owner-replacement'
 import { assertSpawnReplyWasLive } from '../pane/agent-session-owners'
 import { deletePtyOwnership } from '../provider/ownership-state'
 import { ptySizes } from '../delivery/visibility-state'
@@ -23,13 +24,19 @@ export async function executePtyIpcSpawn(ctx: PtyIpcSpawnState): Promise<void> {
       ctx.deps.trustedTerminalHandleEnv.add(ctx.preAllocatedHandle)
     }
     ctx.spawnTiming.mark('options')
-    const stablePaneOwnerCandidate = resolveStablePaneOwner(
-      ctx.deps.runtime,
-      ctx.deps.store,
-      ctx.reservationPaneKey,
-      args.worktreeId,
-      args.connectionId
-    )
+    // Why exclude: the restart's own stop leaves its binding for the bind to swap, not to reattach.
+    const resolveOwner = () =>
+      excludeReplacedPaneOwner(
+        resolveStablePaneOwner(
+          ctx.deps.runtime,
+          ctx.deps.store,
+          ctx.reservationPaneKey,
+          args.worktreeId,
+          args.connectionId
+        ),
+        ctx.replacedPaneOwner
+      )
+    const stablePaneOwnerCandidate = resolveOwner()
     const expectedPtyId =
       stablePaneOwnerCandidate?.ptyId ?? ctx.effectiveSessionAppId ?? ctx.effectiveSessionId
     if (expectedPtyId) {
@@ -56,14 +63,7 @@ export async function executePtyIpcSpawn(ctx: PtyIpcSpawnState): Promise<void> {
           owner: stablePaneOwnerCandidate,
           worktreeId: args.worktreeId,
           connectionId: args.connectionId,
-          resolveOwner: () =>
-            resolveStablePaneOwner(
-              ctx.deps.runtime,
-              ctx.deps.store,
-              ctx.reservationPaneKey,
-              args.worktreeId,
-              args.connectionId
-            )
+          resolveOwner
         })
     ctx.result = stablePaneSpawn.result
     ctx.stablePaneOwner = stablePaneSpawn.owner
diff --git a/src/main/ipc/pty/ipc/spawn-qoder-command.ts b/src/main/ipc/pty/ipc/spawn-qoder-command.ts
new file mode 100644
index 00000000000..27106c6bf63
--- /dev/null
+++ b/src/main/ipc/pty/ipc/spawn-qoder-command.ts
@@ -0,0 +1,34 @@
+import { resolveQoderTerminalCommand } from '../../../runtime/qoder-terminal-command-resolution'
+import { resolveStartupShell } from '../../../../shared/tui-agent-startup-shell'
+import { resolveLocalWindowsAgentStartupShell } from '../../../../shared/windows-terminal-shell'
+import type { PtyIpcSpawnState } from './spawn-state'
+
+export async function preparePtyIpcQoderCommand(ctx: PtyIpcSpawnState): Promise<void> {
+  if (ctx.preAdoptedStablePane || ctx.args.launchAgent !== 'qoder') {
+    return
+  }
+  const connectionId = ctx.args.connectionId
+  const isWsl = ctx.codexSelectionTarget.runtime === 'wsl'
+  const platform = connectionId || isWsl ? 'linux' : process.platform
+  const launch = await resolveQoderTerminalCommand(
+    {
+      launchAgent: ctx.args.launchAgent,
+      command: ctx.launchCommand,
+      launchConfig: ctx.effectiveLaunchConfig
+    },
+    {
+      connectionId,
+      context: connectionId ? undefined : { wslDistro: ctx.expectedWslDistro, wslDefault: isWsl },
+      shell: resolveStartupShell(
+        platform,
+        resolveLocalWindowsAgentStartupShell({
+          platform,
+          isRemote: Boolean(connectionId),
+          terminalWindowsShell: ctx.effectiveShellOverride
+        })
+      )
+    }
+  )
+  ctx.launchCommand = launch.command
+  ctx.effectiveLaunchConfig = launch.launchConfig
+}
diff --git a/src/main/ipc/pty/ipc/spawn-run.ts b/src/main/ipc/pty/ipc/spawn-run.ts
index 7efeb23538d..83e8a77841c 100644
--- a/src/main/ipc/pty/ipc/spawn-run.ts
+++ b/src/main/ipc/pty/ipc/spawn-run.ts
@@ -1,8 +1,14 @@
 import { rejectPaneSpawnReservation, reserveIdlePaneSpawn } from '../pane/spawn-reservation'
 import { ptySizes } from '../delivery/visibility-state'
-import { beginPtyIpcSpawn, resolveEarlyPaneSpawnReservationKey } from './spawn-begin'
+import {
+  beginPtyIpcSpawn,
+  resolveEarlyPaneKey,
+  resolveEarlyPaneSpawnReservationKey
+} from './spawn-begin'
+import { releaseStoppedPaneBinding, stopReplacedPaneOwner } from '../pane/pane-owner-replacement'
 import { preparePtyIpcSpawnPreflight } from './spawn-preflight'
 import { assemblePtyIpcSpawnEnv } from './spawn-env'
+import { preparePtyIpcQoderCommand } from './spawn-qoder-command'
 import { buildPtyIpcSpawnOptions } from './spawn-options'
 import { executePtyIpcSpawn } from './spawn-execute'
 import { commitPtyIpcSpawn } from './spawn-commit'
@@ -42,9 +48,12 @@ export async function runPtyIpcSpawn(deps: PtySpawnIpcDeps, args: PtySpawnIpcArg
   }
   try {
     if (args.replacesPtyId !== undefined) {
-      // Why: stop before resolving the pane owner, so the spawn below finds a dead owner and
-      // launches fresh instead of reattaching the process this restart exists to replace.
-      await deps.stopReplacedPty(args.replacesPtyId)
+      ctx.replacedPaneOwner = await stopReplacedPaneOwner(deps, {
+        replacesPtyId: args.replacesPtyId,
+        paneKey: resolveEarlyPaneKey(args),
+        worktreeId: args.worktreeId,
+        connectionId: args.connectionId
+      })
     }
     triggerPtySpawnPushTargetMaterialization(deps, args)
     const early = await beginPtyIpcSpawn(ctx)
@@ -53,6 +62,7 @@ export async function runPtyIpcSpawn(deps: PtySpawnIpcDeps, args: PtySpawnIpcArg
     }
     await preparePtyIpcSpawnPreflight(ctx)
     await assemblePtyIpcSpawnEnv(ctx)
+    await preparePtyIpcQoderCommand(ctx)
     const earlyReserved = await buildPtyIpcSpawnOptions(ctx).catch((error: unknown) => {
       restoreProvisionalPtySize(ctx)
       throw error
@@ -79,6 +89,9 @@ export async function runPtyIpcSpawn(deps: PtySpawnIpcDeps, args: PtySpawnIpcArg
       )
       ctx.pendingRegistrationPtyId = null
     }
+    if (ctx.replacedPaneOwner) {
+      await releaseStoppedPaneBinding(deps.store, ctx.replacedPaneOwner)
+    }
     // Why: once the reservation is created, any later throw —
     // spawn failure, persist failure, or a post-spawn helper such as
     // seedHeadlessTerminal/registerPty/track — must settle it. Otherwise
diff --git a/src/main/ipc/pty/ipc/spawn-state.ts b/src/main/ipc/pty/ipc/spawn-state.ts
index b1240c4ec6e..d753ac4a6fd 100644
--- a/src/main/ipc/pty/ipc/spawn-state.ts
+++ b/src/main/ipc/pty/ipc/spawn-state.ts
@@ -8,6 +8,7 @@ import { createPtySpawnTiming } from '../../pty-spawn-timing'
 import { noCodexResumeLaunch, type CodexResumeLaunch } from '../host-env/codex-resume'
 import type { StablePaneOwner } from '../pane/stable-owner'
 import type { PaneSpawnReservation } from '../pane/spawn-reservation'
+import type { ReplacedPaneOwner } from '../pane/pane-owner-replacement'
 import { localProvider } from '../provider/registry'
 import type { AdoptStablePaneResult, PtySpawnIpcArgs, PtySpawnIpcDeps } from './spawn-types'
 
@@ -25,6 +26,7 @@ export type PtyIpcSpawnState = {
   earlyWorktreeId: string | undefined
   paneSpawnReservationKey: string | null
   paneSpawnReservation: PaneSpawnReservation | null
+  replacedPaneOwner: ReplacedPaneOwner | null
   finishTerminalInstall: () => void
   result: PtySpawnResult
   stablePaneOwner: StablePaneOwner | null
@@ -103,6 +105,7 @@ export function createPtyIpcSpawnState(
     earlyWorktreeId: undefined,
     paneSpawnReservationKey: null,
     paneSpawnReservation: null,
+    replacedPaneOwner: null,
     finishTerminalInstall: () => {},
     result: { id: '' },
     stablePaneOwner: null,
diff --git a/src/main/ipc/pty/ipc/spawn-types.ts b/src/main/ipc/pty/ipc/spawn-types.ts
index d1f340be17d..8e91799c429 100644
--- a/src/main/ipc/pty/ipc/spawn-types.ts
+++ b/src/main/ipc/pty/ipc/spawn-types.ts
@@ -104,6 +104,7 @@ export type PtySpawnIpcDeps = {
     providerSession?: AgentProviderSessionMetadata
     target: CodexAccountSelectionTarget
     launchEnv?: NodeJS.ProcessEnv
+    useSelectedAccount?: boolean
   }) => PreparedCodexResumeHome | null
   noCodexResumeLaunch: (command: string | undefined) => CodexResumeLaunch
   resolveCodexResumeLaunch: (
diff --git a/src/main/ipc/pty/pane/pane-owner-replacement.test.ts b/src/main/ipc/pty/pane/pane-owner-replacement.test.ts
new file mode 100644
index 00000000000..681a48ba616
--- /dev/null
+++ b/src/main/ipc/pty/pane/pane-owner-replacement.test.ts
@@ -0,0 +1,108 @@
+import { expect, it, vi } from 'vitest'
+import { fixture } from '../../../persistence/loading-store/profile-state-delayed-authority-fixture'
+import { TEST_LEAF_1, TEST_LEAF_2 } from '../../../persistence-session-fixtures'
+import { swapReplacedPaneBinding, type ReplacedPaneOwner } from './pane-owner-replacement'
+
+vi.mock('../../../telemetry/client', () => ({ track: vi.fn() }))
+vi.mock('../../../telemetry/cohort-classifier', () => ({
+  getCohortAtEmit: () => ({ nth_repo_added: 2 })
+}))
+vi.mock('../../../ssh/ssh-config-parser', () => ({
+  loadUserSshConfig: () => ({ hosts: [] }),
+  sshConfigHostsToTargets: () => []
+}))
+
+const worktreeId = 'repo-local::/fixture/local'
+const tabId = 'restart-tab'
+
+function replaced(ptyId: string, hostId?: string): ReplacedPaneOwner {
+  return { ptyId, pane: { worktreeId, tabId, leafId: TEST_LEAF_1, hostId } }
+}
+
+type FixtureStore = Awaited<ReturnType<typeof fixture>>['store']
+
+/** The binding swap must survive the renderer's own pre-connect clear, which strict fences refuse. */
+async function expectSwapAfterRendererClear(
+  store: FixtureStore,
+  oldId: string,
+  newId: string,
+  hostId?: string
+): Promise<void> {
+  expect(
+    store.getWorkspaceSession(hostId).terminalLayoutsByTabId[tabId].ptyIdsByLeafId?.[TEST_LEAF_1]
+  ).toBeUndefined()
+  const binding = { worktreeId, tabId, leafId: TEST_LEAF_1, ptyId: newId, incarnationId: 'inc-new' }
+  expect(
+    await store.persistPtyBinding(
+      { ...binding, expectedBinding: { ptyId: oldId, incarnationId: 'inc-old' } },
+      hostId
+    )
+  ).toBe(false)
+  expect(
+    await store.persistPtyBinding(
+      swapReplacedPaneBinding(store, binding, replaced(oldId, hostId), hostId),
+      hostId
+    )
+  ).toBe(true)
+  expect(
+    store.getWorkspaceSession(hostId).terminalLayoutsByTabId[tabId].ptyIdsByLeafId?.[TEST_LEAF_1]
+  ).toBe(newId)
+}
+
+it('swaps a local split pane whose renderer layout patch already dropped the stopped binding', async () => {
+  const { store } = await fixture()
+  const pane = { worktreeId, tabId }
+  await store.persistPtyBinding({
+    ...pane,
+    leafId: TEST_LEAF_1,
+    ptyId: 'old',
+    incarnationId: 'inc-old'
+  })
+  await store.persistPtyBinding({ ...pane, leafId: TEST_LEAF_2, ptyId: 'sibling' })
+  const layouts = structuredClone(store.getWorkspaceSession().terminalLayoutsByTabId)
+  // The mounted restart clears only its own leaf before connecting; a partial map is honored.
+  delete layouts[tabId].ptyIdsByLeafId![TEST_LEAF_1]
+  store.patchWorkspaceSession({ terminalLayoutsByTabId: layouts })
+  await expectSwapAfterRendererClear(store, 'old', 'new')
+  expect(
+    store.getWorkspaceSession().terminalLayoutsByTabId[tabId].ptyIdsByLeafId?.[TEST_LEAF_2]
+  ).toBe('sibling')
+})
+
+it('swaps an SSH pane whose terminated lease let the renderer clear withdraw the binding', async () => {
+  const { store } = await fixture()
+  const hostId = 'ssh:restart'
+  const oldId = 'ssh:restart@@remote-old'
+  await store.persistPtyBinding(
+    { worktreeId, tabId, leafId: TEST_LEAF_1, ptyId: oldId, incarnationId: 'inc-old' },
+    hostId
+  )
+  store.upsertSshRemotePtyLease({
+    targetId: 'restart',
+    ptyId: 'remote-old',
+    worktreeId,
+    tabId,
+    leafId: TEST_LEAF_1,
+    state: 'attached'
+  })
+  // What the replacement stop records (finishPtyShutdown).
+  store.markSshRemotePtyLease('restart', 'remote-old', 'terminated')
+  const layouts = structuredClone(store.getWorkspaceSession(hostId).terminalLayoutsByTabId)
+  layouts[tabId].ptyIdsByLeafId = {}
+  store.patchWorkspaceSession({ terminalLayoutsByTabId: layouts }, hostId)
+  await expectSwapAfterRendererClear(store, oldId, 'ssh:restart@@remote-new', hostId)
+})
+
+it('refuses the swap when another owner holds the leaf', async () => {
+  const { store } = await fixture()
+  await store.persistPtyBinding({ worktreeId, tabId, leafId: TEST_LEAF_1, ptyId: 'successor' })
+  const binding = { worktreeId, tabId, leafId: TEST_LEAF_1, ptyId: 'new' }
+  expect(
+    await store.persistPtyBinding(
+      swapReplacedPaneBinding(store, binding, replaced('old'), undefined)
+    )
+  ).toBe(false)
+  expect(
+    store.getWorkspaceSession().terminalLayoutsByTabId[tabId].ptyIdsByLeafId?.[TEST_LEAF_1]
+  ).toBe('successor')
+})
diff --git a/src/main/ipc/pty/pane/pane-owner-replacement.ts b/src/main/ipc/pty/pane/pane-owner-replacement.ts
new file mode 100644
index 00000000000..0130ae8b702
--- /dev/null
+++ b/src/main/ipc/pty/pane/pane-owner-replacement.ts
@@ -0,0 +1,96 @@
+import { toSshExecutionHostId } from '../../../../shared/execution-host'
+import { parsePaneKey } from '../../../../shared/stable-pane-id'
+import type { Store } from '../../../persistence'
+import type { PersistPtyBindingArgs } from '../../../persistence/loading-store/pty-binding-persistence'
+import type { OrcaRuntimeService } from '../../../runtime/orca-runtime'
+import { resolveStablePaneOwner, type StablePaneOwner } from './stable-owner'
+
+/** The owner a replacing spawn stopped. Its binding stays until the replacement's bind swaps it. */
+export type ReplacedPaneOwner = {
+  ptyId: string
+  pane: { worktreeId: string; tabId: string; leafId: string; hostId: string | undefined } | null
+}
+
+/** Caller holds the pane's spawn reservation, so no other spawn can claim the pane meanwhile. */
+export async function stopReplacedPaneOwner(
+  deps: {
+    runtime?: OrcaRuntimeService
+    store?: Store
+    stopReplacedPty: (id: string) => Promise<void>
+  },
+  args: {
+    replacesPtyId: string
+    paneKey: string | null
+    worktreeId: string | undefined
+    connectionId: string | null | undefined
+  }
+): Promise<ReplacedPaneOwner> {
+  const owner = resolveStablePaneOwner(
+    deps.runtime,
+    deps.store,
+    args.paneKey,
+    args.worktreeId,
+    args.connectionId
+  )
+  if (owner && owner.ptyId !== args.replacesPtyId) {
+    throw new Error('terminal_pane_owner_changed')
+  }
+  await deps.stopReplacedPty(args.replacesPtyId)
+  const pane = args.paneKey ? parsePaneKey(args.paneKey) : null
+  return {
+    ptyId: args.replacesPtyId,
+    pane:
+      pane && args.worktreeId
+        ? {
+            worktreeId: args.worktreeId,
+            tabId: pane.tabId,
+            leafId: pane.leafId,
+            hostId: args.connectionId ? toSshExecutionHostId(args.connectionId) : undefined
+          }
+        : null
+  }
+}
+
+/** The stopped id is dead whatever its incarnation, so a binding naming it must not be reattached. */
+export function excludeReplacedPaneOwner(
+  owner: StablePaneOwner | null,
+  replaced: ReplacedPaneOwner | null
+): StablePaneOwner | null {
+  return owner && owner.ptyId === replaced?.ptyId ? null : owner
+}
+
+/**
+ * The replacement's bind is the swap: decided inside the bind's durable mutation, it takes a leaf
+ * still naming the stopped id, or one the renderer already cleared; any other owner wins.
+ */
+export function swapReplacedPaneBinding(
+  store: Store,
+  binding: PersistPtyBindingArgs,
+  replaced: ReplacedPaneOwner,
+  hostId: string | undefined
+): () => PersistPtyBindingArgs | null {
+  return () => {
+    const bound =
+      store.getWorkspaceSession(hostId).terminalLayoutsByTabId?.[binding.tabId]?.ptyIdsByLeafId?.[
+        binding.leafId
+      ]
+    // Unbound is ok: the renderer's pre-connect clear can withdraw it (split tab, SSH lease ended).
+    return bound === undefined || bound === replaced.ptyId ? binding : null
+  }
+}
+
+/** Best effort: a failed replacement must not leave the stopped id bound for the remount to reattach. */
+export async function releaseStoppedPaneBinding(
+  store: Store | undefined,
+  replaced: ReplacedPaneOwner
+): Promise<void> {
+  if (!store || !replaced.pane) {
+    return
+  }
+  const { hostId, ...pane } = replaced.pane
+  try {
+    await store.retirePtyBinding({ ...pane, ptyId: replaced.ptyId }, hostId)
+  } catch (error) {
+    console.warn('[pty] could not clear the stopped pane binding after a failed restart:', error)
+  }
+}
diff --git a/src/main/ipc/pty/provider/local-configure.ts b/src/main/ipc/pty/provider/local-configure.ts
index f4dd8f32007..7a494522ec0 100644
--- a/src/main/ipc/pty/provider/local-configure.ts
+++ b/src/main/ipc/pty/provider/local-configure.ts
@@ -89,6 +89,7 @@ export function configureLocalPtyProvider(args: {
         }),
         launchCommand: ctx?.command,
         launchAgent: ctx?.launchAgent,
+        shellPath: ctx?.shellPath,
         isWsl: ctx?.isWsl,
         wslDistro: ctx?.wslDistro ?? null,
         agentStatusHooksEnabled: isAgentStatusHooksEnabled(ptySettings),
diff --git a/src/main/ipc/pty/runtime/spawn-preflight.ts b/src/main/ipc/pty/runtime/spawn-preflight.ts
index 484f9166e4b..5effb7e682e 100644
--- a/src/main/ipc/pty/runtime/spawn-preflight.ts
+++ b/src/main/ipc/pty/runtime/spawn-preflight.ts
@@ -272,6 +272,7 @@ export async function prepareRuntimePtySpawn(
         stripInheritedOrcaCodexHome: ctx.stripInheritedOrcaCodexHome,
         launchCommand: ctx.launchCommand,
         launchAgent: isTuiAgent(args.launchAgent) ? args.launchAgent : undefined,
+        shellPath: ctx.daemonShellOverride,
         isWsl: shouldSkipCodexHomeEnvForWindowsShell(ctx.daemonShellOverride, ctx.cwd),
         wslDistro: ctx.codexSelectionTarget.runtime === 'wsl' ? ctx.expectedWslDistro : null,
         agentStatusHooksEnabled: isAgentStatusHooksEnabled(ptySettings),
diff --git a/src/main/ipc/qoder-desktop-execution-host.test.ts b/src/main/ipc/qoder-desktop-execution-host.test.ts
new file mode 100644
index 00000000000..9d5955d9835
--- /dev/null
+++ b/src/main/ipc/qoder-desktop-execution-host.test.ts
@@ -0,0 +1,299 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { setupPtyIpcSuite } from './pty-ipc-test-harness'
+import { createDaemonActiveProviderFixtures } from './pty-ipc-daemon-provider-fixtures'
+import {
+  registerPtyHandlers,
+  registerSshPtyProvider,
+  unregisterSshPtyProvider,
+  getLocalPtyProvider
+} from './pty'
+import { isCommandOnPath } from './preflight-command-exec'
+import { detectWslCommandsOnPath } from './preflight-wsl-agent-detection'
+import type * as FsPromises from 'node:fs/promises'
+import type { Store } from '../persistence'
+import type { FolderWorkspace } from '../../shared/folder-workspace-types'
+import { buildAgentResumeStartupPlan } from '../../shared/tui-agent-startup'
+import type { PtySpawnIpcArgs } from './pty/ipc/spawn-types'
+
+vi.mock('./preflight-command-exec', () => ({ isCommandOnPath: vi.fn() }))
+vi.mock('./local-agent-install-dir-detection', () => ({
+  detectCommandsInInstallDirs: () => new Set()
+}))
+vi.mock('./preflight-wsl-agent-detection', () => ({ detectWslCommandsOnPath: vi.fn() }))
+const { mux } = vi.hoisted(() => ({ mux: vi.fn() }))
+vi.mock('../ssh/ssh-target-registry', () => ({ getActiveMultiplexer: mux }))
+vi.mock('node:fs/promises', async (importOriginal) => ({
+  ...(await importOriginal<typeof FsPromises>()),
+  stat: vi.fn(async () => ({ isDirectory: () => true }))
+}))
+vi.mock('electron', () => import('./pty-ipc-mock-registry').then((m) => m.electronModuleMock()))
+vi.mock('fs', () => import('./pty-ipc-mock-registry').then((m) => m.fsModuleMock()))
+vi.mock('node-pty', () => import('./pty-ipc-mock-registry').then((m) => m.nodePtyModuleMock()))
+vi.mock('node:child_process', async (importOriginal) =>
+  (await import('./pty-ipc-mock-registry')).childProcessModuleMock(await importOriginal())
+)
+vi.mock('../opencode/hook-service', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.openCodeHookServiceModuleMock())
+)
+vi.mock('../mimo/hook-service', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.mimoHookServiceModuleMock())
+)
+vi.mock('../agent-hooks/server', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.agentHookServerModuleMock())
+)
+vi.mock('../pi/titlebar-extension-service', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.piTitlebarExtensionModuleMock())
+)
+vi.mock('../pwsh', () => import('./pty-ipc-mock-registry').then((m) => m.pwshModuleMock()))
+vi.mock('../wsl', async (importOriginal) =>
+  (await import('./pty-ipc-mock-registry')).wslModuleMock(await importOriginal())
+)
+vi.mock('../telemetry/client', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.telemetryClientModuleMock())
+)
+vi.mock('../telemetry/classify-error', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.classifyErrorModuleMock())
+)
+vi.mock('../cli/linux-terminal-orca-cli-shim', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.linuxCliShimModuleMock())
+)
+vi.mock('../memory/pty-registry', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.ptyRegistryModuleMock())
+)
+vi.mock('../agent-hooks/migration-unsupported-pty-state', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.migrationUnsupportedPtyModuleMock())
+)
+vi.mock('../codex/codex-pane-account-registry', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.codexPaneAccountRegistryModuleMock())
+)
+vi.mock('../codex/codex-state-db-backfill-recovery', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.codexBackfillRecoveryModuleMock())
+)
+
+describe('desktop Qoder execution-host selection', () => {
+  const { handlers, mainWindow } = setupPtyIpcSuite()
+  const { setupDaemonAdapter, withWin32Platform } = createDaemonActiveProviderFixtures({
+    handlers,
+    mainWindow
+  })
+  const nativeProbe = vi.mocked(isCommandOnPath)
+  const wslProbe = vi.mocked(detectWslCommandsOnPath)
+  beforeEach(() => {
+    nativeProbe.mockReset().mockImplementation(async (cmd) => cmd === 'qodercli')
+    wslProbe.mockReset().mockResolvedValue(new Set(['qoder']))
+    mux.mockReset()
+  })
+  async function spawn(args: Partial<PtySpawnIpcArgs> = {}, store?: Store) {
+    const providerSpawn = setupDaemonAdapter()
+    registerPtyHandlers(mainWindow, undefined, undefined, undefined, undefined, store)
+    const result = await handlers.get('pty:spawn')!(null, {
+      cols: 80,
+      rows: 24,
+      cwd: process.cwd(),
+      worktreeId: `repo-review::${process.cwd()}`,
+      launchAgent: 'qoder',
+      command: 'qodercli --resume original-id',
+      ...args
+    })
+    return { providerSpawn, result }
+  }
+  function folderStore(folderPath: string): Store {
+    const folder: FolderWorkspace = {
+      id: 'review-folder',
+      projectGroupId: 'review-group',
+      name: 'review',
+      folderPath,
+      linkedTask: null,
+      comment: '',
+      isArchived: false,
+      isUnread: false,
+      isPinned: false,
+      sortOrder: 0,
+      lastActivityAt: 0,
+      createdAt: 0,
+      updatedAt: 0
+    }
+    const store: Pick<
+      Store,
+      'getFolderWorkspace' | 'getFolderWorkspaces' | 'getProjectGroups' | 'getRepos'
+    > = {
+      getFolderWorkspace: () => folder,
+      getFolderWorkspaces: () => [folder],
+      getProjectGroups: () => [],
+      getRepos: () => []
+    }
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: These launches omit pane metadata; only folder path/status methods are reached, trust is disabled by the suite.
+    return store as Store
+  }
+  it.each([
+    ['legacy-only', ['qodercli']],
+    ['both', ['qoder', 'qodercli']]
+  ] as const)('keeps legacy preference on %s native hosts', async (_, commands) => {
+    nativeProbe.mockImplementation(async (cmd) => commands.some((found) => found === cmd))
+    const { providerSpawn } = await spawn()
+    expect(providerSpawn).toHaveBeenCalledWith(
+      expect.objectContaining({ command: 'qodercli --resume original-id' })
+    )
+    expect(nativeProbe).toHaveBeenCalledWith('qodercli')
+    expect(nativeProbe).toHaveBeenCalledWith('qoder')
+    expect(wslProbe).not.toHaveBeenCalled()
+  })
+  it('preserves exact resume tokens and captured configuration on a native folder', async () => {
+    nativeProbe.mockImplementation(async (cmd) => cmd === 'qoder')
+    const plan = buildAgentResumeStartupPlan({
+      agent: 'qoder',
+      providerSession: { key: 'session_id', id: 'session with spaces' },
+      platform: 'darwin',
+      cmdOverrides: {}
+    })
+    if (!plan) {
+      throw new Error('Missing Qoder resume plan')
+    }
+    const { providerSpawn, result } = await spawn(
+      {
+        worktreeId: 'folder:review-folder',
+        command: plan.launchCommand,
+        launchConfig: plan.launchConfig
+      },
+      folderStore(process.cwd())
+    )
+    expect(providerSpawn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        command: "qoder '--resume' 'session with spaces'",
+        cwd: process.cwd(),
+        worktreeId: 'folder:review-folder'
+      })
+    )
+    expect(result).toMatchObject({ launchConfig: { ...plan.launchConfig, agentCommand: 'qoder' } })
+  })
+  it.each([
+    { command: "echo 'qodercli --resume text'", launchAgent: 'qoder' },
+    { command: 'qodercli --resume original-id', launchAgent: undefined },
+    { command: '/caller/qodercli --resume original-id', launchAgent: 'qoder' },
+    { command: 'qoder --resume original-id', launchAgent: 'qoder' }
+  ] as const)('leaves caller and shell commands unchanged: $command', async (args) => {
+    const { providerSpawn } = await spawn(args)
+    expect(providerSpawn).toHaveBeenCalledWith(expect.objectContaining({ command: args.command }))
+    expect(nativeProbe).not.toHaveBeenCalled()
+    expect(wslProbe).not.toHaveBeenCalled()
+    expect(mux).not.toHaveBeenCalled()
+  })
+  it('uses the selected project WSL distro rather than installed native legacy', async () => {
+    await withWin32Platform(async () => {
+      const { providerSpawn } = await spawn({
+        cwd: '/work/project',
+        worktreeId: 'repo-review::/work/project',
+        projectRuntime: {
+          status: 'resolved',
+          runtime: {
+            kind: 'wsl',
+            hostPlatform: 'wsl',
+            projectId: 'project-review',
+            distro: 'Debian',
+            reason: 'project-override',
+            cacheKey: 'review'
+          }
+        }
+      })
+      expect(providerSpawn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          command: 'qoder --resume original-id',
+          shellOverride: 'wsl.exe',
+          terminalWindowsWslDistro: 'Debian'
+        })
+      )
+      expect(wslProbe).toHaveBeenCalledWith({ distro: 'Debian' }, ['qodercli', 'qoder'])
+      expect(nativeProbe).not.toHaveBeenCalled()
+    })
+  })
+  it('retains a repo-less UNC folder execution distro', async () => {
+    await withWin32Platform(async () => {
+      const { providerSpawn } = await spawn(
+        {
+          cwd: String.raw`\\wsl.localhost\Ubuntu\home\review\folder`,
+          worktreeId: 'folder:review-folder',
+          shellOverride: 'wsl.exe'
+        },
+        folderStore(String.raw`\\wsl.localhost\Ubuntu\home\review\folder`)
+      )
+      expect(providerSpawn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          command: 'qoder --resume original-id',
+          terminalWindowsWslDistro: 'Ubuntu',
+          cwd: '//wsl.localhost/Ubuntu/home/review/folder'
+        })
+      )
+      expect(wslProbe).toHaveBeenCalledWith({ distro: 'Ubuntu' }, ['qodercli', 'qoder'])
+      expect(nativeProbe).not.toHaveBeenCalled()
+    })
+  })
+  it('keeps native Windows launches on the host shell', async () => {
+    await withWin32Platform(async () => {
+      nativeProbe.mockImplementation(async (cmd) => cmd === 'qoder')
+      const { providerSpawn } = await spawn({
+        cwd: 'C:\\review',
+        worktreeId: 'repo-review::C:\\review',
+        shellOverride: 'cmd.exe'
+      })
+      expect(providerSpawn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          command: 'qoder --resume original-id',
+          shellOverride: 'cmd.exe',
+          terminalWindowsWslDistro: null
+        })
+      )
+      expect(wslProbe).not.toHaveBeenCalled()
+    })
+  })
+  it.each(['modern-only', 'legacy-only', 'missing', 'disposed'] as const)(
+    'lets SSH own detection and refuse absent contact: %s',
+    async (host) => {
+      const remoteSpawn = setupDaemonAdapter()
+      registerSshPtyProvider('ssh-qoder-review', getLocalPtyProvider())
+      const localSpawn = setupDaemonAdapter()
+      const request = vi
+        .fn()
+        .mockResolvedValue({ agents: [host === 'modern-only' ? 'qoder' : 'qodercli'] })
+      mux.mockReturnValue(
+        host === 'missing' ? null : { isDisposed: () => host === 'disposed', request }
+      )
+      registerPtyHandlers(mainWindow)
+      try {
+        const pending = handlers.get('pty:spawn')!(null, {
+          cols: 80,
+          rows: 24,
+          cwd: '/remote/folder',
+          worktreeId: 'repo-ssh::/remote/folder',
+          connectionId: 'ssh-qoder-review',
+          launchAgent: 'qoder',
+          command: "qodercli '--resume' 'same remote id'"
+        })
+        if (host === 'missing' || host === 'disposed') {
+          await expect(pending).rejects.toThrow('execution host connection')
+          expect(remoteSpawn).not.toHaveBeenCalled()
+          expect(request).not.toHaveBeenCalled()
+        } else {
+          await pending
+          expect(remoteSpawn).toHaveBeenCalledWith(
+            expect.objectContaining({
+              cwd: '/remote/folder',
+              command: `${host === 'modern-only' ? 'qoder' : 'qodercli'} '--resume' 'same remote id'`
+            })
+          )
+          expect(request).toHaveBeenCalledWith('preflight.detectAgents', {
+            commands: [
+              { id: 'qodercli', cmd: 'qodercli' },
+              { id: 'qoder', cmd: 'qoder' }
+            ]
+          })
+        }
+        expect(localSpawn).not.toHaveBeenCalled()
+        expect(nativeProbe).not.toHaveBeenCalled()
+        expect(wslProbe).not.toHaveBeenCalled()
+        expect(mux).toHaveBeenCalledWith('ssh-qoder-review')
+      } finally {
+        unregisterSshPtyProvider('ssh-qoder-review')
+      }
+    }
+  )
+})
diff --git a/src/main/ipc/qoder-independent-renderer-spawn-review.test.ts b/src/main/ipc/qoder-independent-renderer-spawn-review.test.ts
new file mode 100644
index 00000000000..a9c20cc9ad3
--- /dev/null
+++ b/src/main/ipc/qoder-independent-renderer-spawn-review.test.ts
@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from 'vitest'
+import { setupPtyIpcSuite } from './pty-ipc-test-harness'
+import { createDaemonActiveProviderFixtures } from './pty-ipc-daemon-provider-fixtures'
+import { registerPtyHandlers } from './pty'
+import { detectAgentCommandsOnHost } from '../preflight/agent-detection'
+import { buildAgentStartupPlan, buildAgentResumeStartupPlan } from '../../shared/tui-agent-startup'
+import { agentStartedTelemetry } from '../agent-launch/agent-started-telemetry'
+import { trackMock } from './pty-ipc-mock-registry'
+
+vi.mock('../preflight/agent-detection', () => ({
+  detectAgentCommandsOnHost: vi.fn(async () => new Set(['qoder']))
+}))
+vi.mock('electron', () => import('./pty-ipc-mock-registry').then((m) => m.electronModuleMock()))
+vi.mock('fs', () => import('./pty-ipc-mock-registry').then((m) => m.fsModuleMock()))
+vi.mock('node-pty', () => import('./pty-ipc-mock-registry').then((m) => m.nodePtyModuleMock()))
+vi.mock('node:child_process', async (importOriginal) =>
+  (await import('./pty-ipc-mock-registry')).childProcessModuleMock(await importOriginal())
+)
+vi.mock('../opencode/hook-service', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.openCodeHookServiceModuleMock())
+)
+vi.mock('../mimo/hook-service', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.mimoHookServiceModuleMock())
+)
+vi.mock('../agent-hooks/server', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.agentHookServerModuleMock())
+)
+vi.mock('../pi/titlebar-extension-service', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.piTitlebarExtensionModuleMock())
+)
+vi.mock('../pwsh', () => import('./pty-ipc-mock-registry').then((m) => m.pwshModuleMock()))
+vi.mock('../wsl', async (importOriginal) =>
+  (await import('./pty-ipc-mock-registry')).wslModuleMock(await importOriginal())
+)
+vi.mock('../telemetry/client', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.telemetryClientModuleMock())
+)
+vi.mock('../telemetry/classify-error', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.classifyErrorModuleMock())
+)
+vi.mock('../cli/linux-terminal-orca-cli-shim', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.linuxCliShimModuleMock())
+)
+vi.mock('../memory/pty-registry', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.ptyRegistryModuleMock())
+)
+vi.mock('../agent-hooks/migration-unsupported-pty-state', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.migrationUnsupportedPtyModuleMock())
+)
+vi.mock('../codex/codex-pane-account-registry', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.codexPaneAccountRegistryModuleMock())
+)
+vi.mock('../codex/codex-state-db-backfill-recovery', () =>
+  import('./pty-ipc-mock-registry').then((m) => m.codexBackfillRecoveryModuleMock())
+)
+
+describe('independent renderer Qoder provider spawn boundary', () => {
+  const { handlers, mainWindow } = setupPtyIpcSuite()
+  const { setupDaemonAdapter } = createDaemonActiveProviderFixtures({ handlers, mainWindow })
+  it.each(['start', 'resume'] as const)(
+    'selects modern-only executable for desktop %s',
+    async (mode) => {
+      const plan =
+        mode === 'start'
+          ? buildAgentStartupPlan({
+              agent: 'qoder',
+              prompt: 'review prompt',
+              agentArgs: null,
+              cmdOverrides: {},
+              platform: 'darwin'
+            })
+          : buildAgentResumeStartupPlan({
+              agent: 'qoder',
+              providerSession: { key: 'session_id', id: 'original-review-session' },
+              cmdOverrides: {},
+              platform: 'darwin'
+            })
+      if (!plan) {
+        throw new Error('Missing existing Qoder startup plan')
+      }
+      const physicalSpawn = setupDaemonAdapter()
+      registerPtyHandlers(mainWindow)
+      await handlers.get('pty:spawn')!(null, {
+        cols: 80,
+        rows: 24,
+        cwd: process.cwd(),
+        command: plan.launchCommand,
+        launchAgent: 'qoder',
+        launchConfig: plan.launchConfig,
+        ...(mode === 'start' ? { telemetry: agentStartedTelemetry('qoder', 'orchestration') } : {})
+      })
+      expect(physicalSpawn.mock.calls.at(-1)?.[0].command).toBe(
+        plan.launchCommand.replace(/^qodercli/, 'qoder')
+      )
+      expect(detectAgentCommandsOnHost).toHaveBeenCalled()
+      const events = trackMock.mock.calls.filter(([event]) => event === 'agent_started')
+      if (mode === 'start') {
+        expect(events).toEqual([
+          [
+            'agent_started',
+            { agent_kind: 'qoder', launch_source: 'orchestration', request_kind: 'new' }
+          ]
+        ])
+      } else {
+        expect(events).toEqual([])
+      }
+    }
+  )
+  it.each([
+    'qoder --resume original-review-session',
+    '/caller/qodercli --resume original-review-session'
+  ])('preserves an explicitly chosen command: %s', async (command) => {
+    const physicalSpawn = setupDaemonAdapter()
+    registerPtyHandlers(mainWindow)
+    await handlers.get('pty:spawn')!(null, {
+      cols: 80,
+      rows: 24,
+      cwd: process.cwd(),
+      command,
+      launchAgent: 'qoder'
+    })
+    expect(physicalSpawn.mock.calls.at(-1)?.[0].command).toBe(command)
+    expect(trackMock).not.toHaveBeenCalledWith('agent_started', expect.anything())
+  })
+})
diff --git a/src/main/ipc/runtime-upload-file-stream.test.ts b/src/main/ipc/runtime-upload-file-stream.test.ts
index 4d11bc18652..87d2c66c61a 100644
--- a/src/main/ipc/runtime-upload-file-stream.test.ts
+++ b/src/main/ipc/runtime-upload-file-stream.test.ts
@@ -35,7 +35,6 @@ vi.mock('./runtime-environment-transport-routing', () => ({
   callRuntimeEnvironment: (...args: Parameters<typeof callRuntimeEnvironment>) =>
     callRuntimeEnvironment(...args)
 }))
-vi.mock('./filesystem-auth', () => ({ authorizeExternalPath: () => {} }))
 // Why: see filesystem-runtime-upload-staging.test.ts — a real over-limit fixture
 // would allocate gigabytes on Windows.
 vi.mock('./runtime-import-limits', async (importOriginal) => ({
diff --git a/src/main/ipc/runtime-upload-file-stream.ts b/src/main/ipc/runtime-upload-file-stream.ts
index 28271774ce0..079549e4711 100644
--- a/src/main/ipc/runtime-upload-file-stream.ts
+++ b/src/main/ipc/runtime-upload-file-stream.ts
@@ -5,7 +5,6 @@ import type {
   RuntimeUploadFileStreamRequest,
   StagedRuntimeUploadFileIdentity
 } from '../../shared/runtime-upload-staging-contract'
-import { authorizeExternalPath } from './filesystem-auth'
 import { formatByteCeiling, REMOTE_IMPORT_MAX_FILE_BYTES } from './runtime-import-limits'
 import {
   isRuntimeEnvironmentManuallyDisconnected,
@@ -39,9 +38,6 @@ export async function streamExternalFileToRuntime(
 ): Promise<{ byteLength: number }> {
   const sourcePath = resolveEntrySourcePath(args.sourceRootPath, args.entryRelativePath)
 
-  // Why: parity with staging — an OS drop authorizes the paths it hands over.
-  authorizeExternalPath(sourcePath)
-
   // Why: relativePath is the hidden .orca-upload-<nonce> temp destination, so a
   // dropped file names its source instead of a path the user never chose.
   const displayPath = args.entryRelativePath || basename(args.sourceRootPath)
@@ -189,7 +185,7 @@ async function sendChunk(
 }
 
 function resolveEntrySourcePath(sourceRootPath: string, entryRelativePath: string): string {
-  // Why: staging resolves before authorizing, so the streamer has to agree on
+  // Why: staging resolves the source first, so the streamer has to agree on
   // the same absolute path or the two checks can disagree.
   const root = resolve(sourceRootPath)
   return entryRelativePath ? join(root, entryRelativePath) : root
diff --git a/src/main/ipc/runtime-upload-slice-boundaries.test.ts b/src/main/ipc/runtime-upload-slice-boundaries.test.ts
index 0c2bd457b1f..6a7b580e086 100644
--- a/src/main/ipc/runtime-upload-slice-boundaries.test.ts
+++ b/src/main/ipc/runtime-upload-slice-boundaries.test.ts
@@ -16,7 +16,6 @@ import type { StagedRuntimeUploadFileIdentity } from '../../shared/runtime-uploa
 
 // Why: real limits, real host write flags ('wx' then 'a') and the real chunk
 // schema — the slice loop is exercised exactly at the boundaries it must respect.
-vi.mock('./filesystem-auth', () => ({ authorizeExternalPath: () => {} }))
 
 type ChunkParams = { relativePath: string; contentBase64: string; append: boolean }
 type CallOptions = { expectedEnvironmentRuntimeId?: string; signal?: AbortSignal }
diff --git a/src/main/ipc/tui-agent-detection-commands.test.ts b/src/main/ipc/tui-agent-detection-commands.test.ts
index b6d536f732b..4d1ca779012 100644
--- a/src/main/ipc/tui-agent-detection-commands.test.ts
+++ b/src/main/ipc/tui-agent-detection-commands.test.ts
@@ -6,6 +6,24 @@ import {
 } from './tui-agent-detection-commands'
 
 describe('tui agent detection commands', () => {
+  it.each(['darwin', 'linux', 'win32', 'wsl'] as const)(
+    'detects modern and legacy Qoder once on %s',
+    (runtime) => {
+      const commands = KNOWN_TUI_AGENT_DETECTION_COMMANDS.filter(
+        (command) => command.id === 'qoder'
+      )
+      for (const found of [
+        new Set(['qoder']),
+        new Set(['qodercli']),
+        new Set(['qoder', 'qodercli'])
+      ]) {
+        expect(resolveDetectedTuiAgentIds(commands, found, runtime)).toEqual(['qoder'])
+      }
+      expect(resolveDetectedTuiAgentIds(commands, new Set(['qoder-unrelated']), runtime)).toEqual(
+        []
+      )
+    }
+  )
   it('requires Claude before reporting Claude Agent Teams', () => {
     const commands = KNOWN_TUI_AGENT_DETECTION_COMMANDS.filter(
       (command) => command.id === 'claude-agent-teams'
diff --git a/src/main/jira/issues.test.ts b/src/main/jira/issues.test.ts
index 526741afa35..e7fecbe60da 100644
--- a/src/main/jira/issues.test.ts
+++ b/src/main/jira/issues.test.ts
@@ -119,6 +119,29 @@ describe('Jira issue operations', () => {
     )
   })
 
+  it('scopes create-time assignable search by project, with the Server username param', async () => {
+    jiraRequestMock.mockResolvedValueOnce([{ accountId: 'acc-1', displayName: 'Ada' }])
+    const { listAssignableUsersForProject } = await import('./issues')
+
+    const cloudUsers = await listAssignableUsersForProject('ALP', 'ada', 'site-1')
+
+    expect(jiraRequestMock).toHaveBeenCalledWith(
+      expect.anything(),
+      '/rest/api/3/user/assignable/search?project=ALP&maxResults=50&query=ada'
+    )
+    expect(cloudUsers).toEqual([expect.objectContaining({ accountId: 'acc-1' })])
+
+    getClientsMock.mockReturnValue([makeServerEntry()])
+    jiraRequestMock.mockResolvedValueOnce([])
+
+    await listAssignableUsersForProject('ALP', 'ada', 'server-1')
+
+    expect(jiraRequestMock).toHaveBeenLastCalledWith(
+      expect.anything(),
+      '/rest/api/2/user/assignable/search?project=ALP&maxResults=50&username=ada'
+    )
+  })
+
   it('loads Jira summaries without descriptions, rendered fields, or attachment media', async () => {
     jiraRequestMock.mockResolvedValueOnce({
       id: 'issue-1',
diff --git a/src/main/jira/issues.ts b/src/main/jira/issues.ts
index 450b6e19d72..74d185468f3 100644
--- a/src/main/jira/issues.ts
+++ b/src/main/jira/issues.ts
@@ -6,6 +6,7 @@ export { getIssueComments } from './jira-issue-comments'
 export { listProjects } from './jira-project-queries'
 export {
   listAssignableUsers,
+  listAssignableUsersForProject,
   listCreateFields,
   listIssueTypes,
   listPriorities,
diff --git a/src/main/jira/jira-issue-create-metadata.ts b/src/main/jira/jira-issue-create-metadata.ts
index 90325930afa..070107f9b3f 100644
--- a/src/main/jira/jira-issue-create-metadata.ts
+++ b/src/main/jira/jira-issue-create-metadata.ts
@@ -162,17 +162,18 @@ export async function searchUsers(query?: string, siteId?: string | null): Promi
   }
 }
 
-export async function listAssignableUsers(
-  key: string,
-  query?: string,
-  siteId?: string | null
+async function searchAssignableUsers(
+  scope: { issueKey: string } | { project: string },
+  query: string | undefined,
+  siteId: string | null | undefined,
+  label: string
 ): Promise<JiraUser[]> {
   const entry = getClients(siteId)[0]
   if (!entry) {
     return []
   }
   const isServer = entry.site.authType === 'server'
-  const params = new URLSearchParams({ issueKey: key, maxResults: '50' })
+  const params = new URLSearchParams({ ...scope, maxResults: '50' })
   if (query?.trim()) {
     // Server/DC filters assignable users by `username`; `query` is Cloud-only.
     params.set(isServer ? 'username' : 'query', query.trim())
@@ -189,9 +190,31 @@ export async function listAssignableUsers(
       clearToken(entry.site.id)
       throw error
     }
-    console.warn('[jira] listAssignableUsers failed:', error)
+    console.warn(`[jira] ${label} failed:`, error)
     return []
   } finally {
     release()
   }
 }
+
+export async function listAssignableUsers(
+  key: string,
+  query?: string,
+  siteId?: string | null
+): Promise<JiraUser[]> {
+  return searchAssignableUsers({ issueKey: key }, query, siteId, 'listAssignableUsers')
+}
+
+// Creation has no issue key yet, so assignability is scoped by project.
+export async function listAssignableUsersForProject(
+  projectIdOrKey: string,
+  query?: string,
+  siteId?: string | null
+): Promise<JiraUser[]> {
+  return searchAssignableUsers(
+    { project: projectIdOrKey },
+    query,
+    siteId,
+    'listAssignableUsersForProject'
+  )
+}
diff --git a/src/main/native-chat/agent-model-catalog/agent-model-catalog-service.test.ts b/src/main/native-chat/agent-model-catalog/agent-model-catalog-service.test.ts
index d51a98b3d8b..02025485151 100644
--- a/src/main/native-chat/agent-model-catalog/agent-model-catalog-service.test.ts
+++ b/src/main/native-chat/agent-model-catalog/agent-model-catalog-service.test.ts
@@ -5,7 +5,11 @@ import {
   agentModelCatalogFingerprintForRecord
 } from './agent-model-catalog-fingerprint'
 import { createAgentModelCatalogService } from './agent-model-catalog-service'
-import { AgentModelCatalogStore, type AgentModelCatalogSuccess } from './agent-model-catalog-store'
+import {
+  AGENT_MODEL_CATALOG_FRESH_MS,
+  AgentModelCatalogStore,
+  type AgentModelCatalogSuccess
+} from './agent-model-catalog-store'
 
 function record(accountHomePath: string): AgentSessionRecord {
   // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the service reads only provider, accountHome and location; the rest of the record is irrelevant here.
@@ -55,7 +59,8 @@ describe('agent model catalog service', () => {
       probes: { codex: probe }
     })
     expect(await service.read({ agent: 'codex', sessionId: 'session-1' })).toEqual({
-      origin: 'unknown'
+      origin: 'unknown',
+      listingInProgress: true
     })
     // A second read while the probe is in flight must not start another, and a
     // record-scoped read probes the RECORD's pinned home, not the selection.
@@ -81,7 +86,10 @@ describe('agent model catalog service', () => {
       probes: { codex: probe }
     })
     // The record-less read follows the CURRENT selection: unknown, never gpt-old.
-    expect(await service.read({ agent: 'codex' })).toEqual({ origin: 'unknown' })
+    expect(await service.read({ agent: 'codex' })).toEqual({
+      origin: 'unknown',
+      listingInProgress: true
+    })
     expect(probe).toHaveBeenCalledWith('/homes/new')
     await vi.waitFor(async () => {
       const result = await service.read({ agent: 'codex' })
@@ -139,7 +147,8 @@ describe('agent model catalog service', () => {
       probes: { codex: probe }
     })
     expect(await service.read({ agent: 'codex', sessionId: 'session-1' })).toEqual({
-      origin: 'unknown'
+      origin: 'unknown',
+      listingInProgress: true
     })
     await vi.waitFor(() => expect(probe).toHaveBeenCalledTimes(1))
     // Still a clean unknown — and the failure TTL suppresses a probe storm.
@@ -164,6 +173,94 @@ describe('agent model catalog service', () => {
     expect(probe).not.toHaveBeenCalled()
   })
 
+  describe('a read that waits for the first listing', () => {
+    function deferredListing() {
+      let resolve!: (success: AgentModelCatalogSuccess) => void
+      let reject!: (error: Error) => void
+      const promise = new Promise<AgentModelCatalogSuccess>((res, rej) => {
+        resolve = res
+        reject = rej
+      })
+      return { promise, resolve, reject }
+    }
+
+    function coldService(probe: (home: string) => Promise<AgentModelCatalogSuccess>) {
+      const store = new AgentModelCatalogStore()
+      const service = createAgentModelCatalogService({
+        store,
+        getRecord: () => undefined,
+        resolveAccountHome: async () => CODEX_HOME('/homes/selected'),
+        probes: { codex: probe }
+      })
+      return { store, service }
+    }
+
+    it('joins the listing the first read started and answers with it', async () => {
+      const pending = deferredListing()
+      const probe = vi.fn(() => pending.promise)
+      const { service } = coldService(probe)
+      expect(await service.read({ agent: 'codex' })).toEqual({
+        origin: 'unknown',
+        listingInProgress: true
+      })
+      const waited = service.read({ agent: 'codex', waitForListing: true })
+      pending.resolve(listing('gpt-listed'))
+      const result = await waited
+      expect(result.origin === 'unknown' ? null : result.models[0]!.id).toBe('gpt-listed')
+      expect(probe).toHaveBeenCalledTimes(1)
+    })
+
+    it('answers a plain unknown when the listing fails', async () => {
+      const pending = deferredListing()
+      const { service } = coldService(() => pending.promise)
+      const waited = service.read({ agent: 'codex', waitForListing: true })
+      pending.reject(new Error('spawn failed'))
+      expect(await waited).toEqual({ origin: 'unknown' })
+    })
+
+    it('does not wait or report a listing while a failure is inside its TTL', async () => {
+      const probe = vi.fn(async (): Promise<AgentModelCatalogSuccess> => {
+        throw new Error('spawn failed')
+      })
+      const { store, service } = coldService(probe)
+      store.recordFailure(selectedHomeFingerprint('/homes/selected'), 'spawn failed')
+      expect(await service.read({ agent: 'codex', waitForListing: true })).toEqual({
+        origin: 'unknown'
+      })
+      expect(await service.read({ agent: 'codex' })).toEqual({ origin: 'unknown' })
+      expect(probe).not.toHaveBeenCalled()
+    })
+
+    it('reports no listing where the host has no lister for the account', async () => {
+      const store = new AgentModelCatalogStore()
+      const service = createAgentModelCatalogService({
+        store,
+        getRecord: () => undefined,
+        resolveAccountHome: async () => CODEX_HOME('/homes/selected')
+      })
+      expect(await service.read({ agent: 'codex', waitForListing: true })).toEqual({
+        origin: 'unknown'
+      })
+    })
+
+    it('serves an aged entry at once and refreshes it behind the answer', async () => {
+      let now = 0
+      const store = new AgentModelCatalogStore({ now: () => now })
+      store.recordSuccess(selectedHomeFingerprint('/homes/selected'), 'codex', listing('gpt-old'))
+      now = AGENT_MODEL_CATALOG_FRESH_MS
+      const probe = vi.fn(() => new Promise<AgentModelCatalogSuccess>(() => {}))
+      const service = createAgentModelCatalogService({
+        store,
+        getRecord: () => undefined,
+        resolveAccountHome: async () => CODEX_HOME('/homes/selected'),
+        probes: { codex: probe }
+      })
+      const result = await service.read({ agent: 'codex', waitForListing: true })
+      expect(result.origin === 'unknown' ? null : result.models[0]!.id).toBe('gpt-old')
+      expect(probe).toHaveBeenCalledTimes(1)
+    })
+  })
+
   describe('a read for the workspace a new chat runs in', () => {
     function serviceWith(mayOverride: boolean) {
       const store = new AgentModelCatalogStore()
diff --git a/src/main/native-chat/agent-model-catalog/agent-model-catalog-service.ts b/src/main/native-chat/agent-model-catalog/agent-model-catalog-service.ts
index 8c794331a2c..638b0f54272 100644
--- a/src/main/native-chat/agent-model-catalog/agent-model-catalog-service.ts
+++ b/src/main/native-chat/agent-model-catalog/agent-model-catalog-service.ts
@@ -35,6 +35,8 @@ export type AgentModelCatalogService = {
     sessionId?: string
     /** Where a new chat would run; null when one was named but is not a local directory. */
     workspacePath?: string | null
+    /** With no entry yet, answer from the listing this read starts or joins instead of `unknown`. */
+    waitForListing?: boolean
   }) => Promise<AgentSessionModelCatalogResult>
 }
 
@@ -79,8 +81,9 @@ async function workspaceKeepsListedDefault(
  * launch); without one, the key is the account a launch would pin right now —
  * never "whichever account listed last". `unknown` tells the client to keep
  * its static seed, and a missing or aged entry kicks one joined background
- * probe so the next read is warm. Failures are the store's 30s TTL, never an
- * answer — a picker is a user surface and must not block.
+ * probe so the next read is warm. With no entry, the answer says that listing
+ * is running, and only a read that asks waits for it. Failures are the store's
+ * 30s TTL, never an answer: inside it a read answers `unknown` at once.
  */
 export function createAgentModelCatalogService(
   deps: AgentModelCatalogServiceDeps
@@ -110,14 +113,27 @@ export function createAgentModelCatalogService(
         })
         accountHomePath = resolved.path
       }
-      const entry = deps.store.get(fingerprint)
+      let entry = deps.store.get(fingerprint)
       const probe = deps.probes?.[params.agent]
-      if (probe && accountHomePath && deps.store.shouldRefresh(fingerprint)) {
-        const home = accountHomePath
-        void deps.store.refresh(fingerprint, params.agent, () => probe(home))
-      }
+      const home = accountHomePath
+      // Without an entry, join a running listing too: that is the one a waiting read answers from.
+      const listing =
+        probe &&
+        home &&
+        (entry ? deps.store.shouldRefresh(fingerprint) : !deps.store.hasActiveFailure(fingerprint))
+          ? deps.store.refresh(fingerprint, params.agent, () => probe(home))
+          : null
       if (!entry) {
-        return { origin: 'unknown' }
+        if (!listing) {
+          return { origin: 'unknown' }
+        }
+        if (!params.waitForListing) {
+          return { origin: 'unknown', listingInProgress: true }
+        }
+        entry = await listing
+        if (!entry) {
+          return { origin: 'unknown' }
+        }
       }
       return resultFromEntry(
         entry,
diff --git a/src/main/native-chat/agent-session-journal/journal-dispatch-reducer.ts b/src/main/native-chat/agent-session-journal/journal-dispatch-reducer.ts
index a52ff73288c..5e4574b60eb 100644
--- a/src/main/native-chat/agent-session-journal/journal-dispatch-reducer.ts
+++ b/src/main/native-chat/agent-session-journal/journal-dispatch-reducer.ts
@@ -8,7 +8,11 @@ import {
 import { agentJournalSubmissionKey } from '../../../shared/agent-session-journal-item-key'
 import { journalDispatchRowApplies } from './journal-dispatch-settlement'
 import type { JournalReducerState } from './journal-reducer'
-import { notePersonTurnAccepted, placeHandedOverMessage } from './journal-submission-fold'
+import {
+  notePersonTurnAccepted,
+  placeHandedOverMessage,
+  placeRejectedMessage
+} from './journal-submission-fold'
 import type { JournalRow } from './journal-row-schema'
 
 export function applyJournalDispatchRow(
@@ -39,6 +43,8 @@ export function applyJournalDispatchRow(
   if (row.state === 'pending') {
     submission.handedOverAt = row.ts
     placeHandedOverMessage(state, submission, row)
+  } else if (row.state === 'rejected') {
+    placeRejectedMessage(state, submission, row)
   }
   if (row.recovered) {
     submission.recovered = row.recovered
diff --git a/src/main/native-chat/agent-session-journal/journal-lifecycle-batch-appender.ts b/src/main/native-chat/agent-session-journal/journal-lifecycle-batch-appender.ts
index c05d22a8745..68ba188e402 100644
--- a/src/main/native-chat/agent-session-journal/journal-lifecycle-batch-appender.ts
+++ b/src/main/native-chat/agent-session-journal/journal-lifecycle-batch-appender.ts
@@ -3,6 +3,7 @@ import type { JournalReducerState } from './journal-reducer'
 import { journalLifecycleBatchRowBuilder } from './journal-row-builders'
 import type { JournalLifecycleBatchInput } from './journal-store-contracts'
 import type { JournalRow } from './journal-row-schema'
+import { journalQueuedRejectionRowBuilders } from './journal-pending-submission-recovery'
 
 const SETTLEMENT_ALREADY_APPLIED = new Error('journal_settlement_already_applied')
 
@@ -12,10 +13,38 @@ export class JournalLifecycleBatchAppender {
       state: () => JournalReducerState
       cursor: () => AgentJournalCursor
       enqueue: (build: (seq: number, ts: number) => JournalRow) => Promise<JournalRow>
+      enqueueRows: (
+        plan: () => readonly ((seq: number, ts: number) => JournalRow)[]
+      ) => Promise<JournalRow[]>
     }
   ) {}
 
   append(input: JournalLifecycleBatchInput): Promise<AgentJournalCursor> {
+    const { rejectsQueued } = input
+    if (rejectsQueued) {
+      // Planned on the lane: the sends queued then, and this batch unless it already landed. With
+      // none left (a Stop withdrew them first) it failed no one, so nothing is written.
+      return this.deps
+        .enqueueRows(() => {
+          const rejections = journalQueuedRejectionRowBuilders(
+            this.deps.state,
+            input.fence,
+            rejectsQueued
+          )
+          return rejections.length === 0 || this.wasApplied(input.settlementId)
+            ? rejections
+            : [
+                ...rejections,
+                journalLifecycleBatchRowBuilder(
+                  this.deps.state,
+                  input.settlementId,
+                  input.mutations,
+                  input
+                )
+              ]
+        })
+        .then(() => this.deps.cursor())
+    }
     if (this.wasApplied(input.settlementId)) {
       return Promise.resolve(this.deps.cursor())
     }
diff --git a/src/main/native-chat/agent-session-journal/journal-pending-submission-recovery.ts b/src/main/native-chat/agent-session-journal/journal-pending-submission-recovery.ts
index 964ea42f931..b52e3648b72 100644
--- a/src/main/native-chat/agent-session-journal/journal-pending-submission-recovery.ts
+++ b/src/main/native-chat/agent-session-journal/journal-pending-submission-recovery.ts
@@ -2,6 +2,9 @@ import type { AgentJournalDispatchRejection } from '../../../shared/agent-sessio
 import type { AgentJournalSubmission } from '../../../shared/agent-session-journal-types'
 import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session-queued-submission'
 import { DISPATCH_DOUBT_HOST_RESTARTED } from './journal-dispatch-doubt-reasons'
+import type { JournalReducerState } from './journal-reducer'
+import { journalDispatchRowBuilder } from './journal-row-builders'
+import type { JournalRow } from './journal-row-schema'
 import type { AgentSessionJournal } from './journal-store'
 
 /** Settles every submission a process fact left unanswerable. Doubt is never
@@ -88,3 +91,21 @@ export async function rejectJournalQueuedSubmissions(
   )
   return queued.map((entry) => entry.clientMessageId)
 }
+
+/** Rows rejecting every submission still queued, read from `state` when called: for an append
+ *  that must carry them with what follows, in one transaction. */
+export function journalQueuedRejectionRowBuilders(
+  state: () => JournalReducerState,
+  fence: number,
+  rejection: AgentJournalDispatchRejection
+): ((seq: number, ts: number) => JournalRow)[] {
+  return [...state().submissions.values()].filter(isQueuedAgentJournalSubmission).map((entry) =>
+    journalDispatchRowBuilder(state, {
+      clientMessageId: entry.clientMessageId,
+      state: 'rejected',
+      ...rejection,
+      fence,
+      recovered: true
+    })
+  )
+}
diff --git a/src/main/native-chat/agent-session-journal/journal-queued-rejection-batch.test.ts b/src/main/native-chat/agent-session-journal/journal-queued-rejection-batch.test.ts
new file mode 100644
index 00000000000..d218a356fae
--- /dev/null
+++ b/src/main/native-chat/agent-session-journal/journal-queued-rejection-batch.test.ts
@@ -0,0 +1,129 @@
+// A failed start's row and the queued messages it failed land in ONE append, the messages first:
+// no reader meets one without the other, and the messages sit above the row that says why.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, expect, it } from 'vitest'
+import { agentSessionFailureFact } from '../../../shared/agent-session-failure'
+import { agentSessionFailureWords } from '../../../shared/agent-session-failure-words'
+import { agentJournalSubmissionKey } from '../../../shared/agent-session-journal-item-key'
+import {
+  AGENT_JOURNAL_THREAD_SCOPE,
+  type AgentSessionJournalIdentity
+} from '../../../shared/agent-session-journal-types'
+import type { AgentSessionJournal } from './journal-store'
+import {
+  closeTestJournalHostDatabases,
+  createTrackedJournalOpener
+} from './journal-host-database-test-support'
+
+const IDENTITY: AgentSessionJournalIdentity = {
+  sessionId: 'session-start',
+  workspaceId: 'ws-1',
+  hostId: 'host-1',
+  agent: 'claude',
+  providerHandle: { kind: 'claude', sessionId: 'native-1', leafUuid: null }
+}
+
+const START_FAILED = agentSessionFailureWords(agentSessionFailureFact('providerStartFailed'), {
+  surface: 'rejection'
+})
+const ERROR_ROW = { provider: 'orca', clientMessageId: 'start-failure:gen-1' } as const
+
+let root: string
+let clock = 1_000
+const journals = createTrackedJournalOpener()
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'orca-queued-rejection-batch-'))
+})
+
+afterEach(async () => {
+  await closeTestJournalHostDatabases()
+  await rm(root, { recursive: true, force: true })
+})
+
+async function openWithQueued(...ids: string[]): Promise<AgentSessionJournal> {
+  const journal = await journals.open({
+    identity: IDENTITY,
+    stateDirectory: root,
+    now: () => (clock += 1),
+    mintEpoch: () => 'epoch-1'
+  })
+  for (const id of ids) {
+    await journal.appendSubmission({
+      clientMessageId: id,
+      payloadFingerprint: `fp-${id}`,
+      body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: id }] },
+      fence: 0,
+      handoverRecorded: true
+    })
+  }
+  return journal
+}
+
+function startFailureBatch(mutations = 1) {
+  return {
+    settlementId: 'start-failure:gen-1',
+    fence: 0,
+    recovered: true as const,
+    mutations: Array.from({ length: mutations }, () => ({
+      kind: 'item' as const,
+      identity: ERROR_ROW,
+      body: { kind: 'status' as const, tone: 'error' as const, text: 'Claude did not start.' },
+      turnScope: AGENT_JOURNAL_THREAD_SCOPE
+    })),
+    rejectsQueued: START_FAILED
+  }
+}
+
+it('writes the rejections first and the row after them, and draws the messages above it', async () => {
+  const journal = await openWithQueued('first', 'second')
+  const before = journal.cursor().sequence
+
+  await journal.appendLifecycleBatch(startFailureBatch())
+
+  expect(journal.cursor().sequence).toBe(before + 3)
+  expect(journal.submissions().map((entry) => entry.dispatchState)).toEqual([
+    'rejected',
+    'rejected'
+  ])
+  const order = journal.snapshot().items.map((item) => item.itemId)
+  expect(order).toEqual([
+    agentJournalSubmissionKey('first'),
+    agentJournalSubmissionKey('second'),
+    'orca:start-failure%3Agen-1'
+  ])
+})
+
+it('writes neither when the row cannot be written', async () => {
+  const journal = await openWithQueued('first')
+  const before = journal.cursor().sequence
+
+  // An empty batch breaks the row's bound, so the transaction rolls back as a whole.
+  await expect(journal.appendLifecycleBatch(startFailureBatch(0))).rejects.toThrow(
+    'journal_lifecycle_batch_mutation_bound_exceeded'
+  )
+
+  expect(journal.cursor().sequence).toBe(before)
+  expect(journal.submissions().map((entry) => entry.dispatchState)).toEqual(['pending'])
+})
+
+// A Stop that reaches the lane first takes the message back; the failed start then failed no one.
+it('writes nothing when a Stop withdrew every queued message first', async () => {
+  const journal = await openWithQueued('first')
+  const withdrawal = agentSessionFailureWords(agentSessionFailureFact('cancelled'), {
+    surface: 'rejection'
+  })
+
+  await Promise.all([
+    journal.rejectQueuedSubmissions(0, withdrawal),
+    journal.appendLifecycleBatch(startFailureBatch())
+  ])
+
+  expect(journal.submissions()[0]?.rejection).toEqual({ kind: 'cancelled' })
+  expect(journal.snapshot().items.map((item) => item.itemId)).toEqual([
+    agentJournalSubmissionKey('first')
+  ])
+})
diff --git a/src/main/native-chat/agent-session-journal/journal-reducer.test.ts b/src/main/native-chat/agent-session-journal/journal-reducer.test.ts
index 45681f32871..60d068ebfd8 100644
--- a/src/main/native-chat/agent-session-journal/journal-reducer.test.ts
+++ b/src/main/native-chat/agent-session-journal/journal-reducer.test.ts
@@ -551,7 +551,7 @@ describe('submission and dispatch state machine', () => {
     expect(state.receipts.get('cm_1')).toBeTruthy()
   })
 
-  it('keeps a refused write rejected and leaves its bubble where it was', () => {
+  it('keeps a refused write rejected, at its rejection, whatever comes after', () => {
     const state = fold([
       submission,
       {
@@ -579,7 +579,8 @@ describe('submission and dispatch state machine', () => {
       submittedAt: submission.ts,
       reason: 'provider_write_failed: closed before enqueue'
     })
-    expect(renderJournalState(state).items[0]?.sequence).toBe(submission.seq)
+    // It sits where it was rejected; the late `pending` moves nothing.
+    expect(renderJournalState(state).items[0]?.sequence).toBe(2)
   })
 
   it('ignores a dispatch for a submission this epoch never saw', () => {
diff --git a/src/main/native-chat/agent-session-journal/journal-reducer.ts b/src/main/native-chat/agent-session-journal/journal-reducer.ts
index a7d6f150e70..e2d1b1ef3ca 100644
--- a/src/main/native-chat/agent-session-journal/journal-reducer.ts
+++ b/src/main/native-chat/agent-session-journal/journal-reducer.ts
@@ -6,9 +6,9 @@
 // dropped rather than resurrecting stale content, and ordering is by the
 // position (sequence, then place in the row) of the write that CREATED an item
 // (a later revision updates the body, it does not move the bubble) — except a
-// queued message, which sits where its handover put it. Producer linkage is
-// likewise the creating write's: a revision naming no producer keeps it, one
-// naming any replaces it.
+// queued message, which sits where its handover put it, and a rejected one, which
+// sits where it was rejected. Producer linkage is likewise the creating write's: a
+// revision naming no producer keeps it, one naming any replaces it.
 
 import type {
   AgentJournalAcceptanceReceipt,
diff --git a/src/main/native-chat/agent-session-journal/journal-rejected-message-placement.test.ts b/src/main/native-chat/agent-session-journal/journal-rejected-message-placement.test.ts
new file mode 100644
index 00000000000..ce5b407d3e8
--- /dev/null
+++ b/src/main/native-chat/agent-session-journal/journal-rejected-message-placement.test.ts
@@ -0,0 +1,158 @@
+// A rejected message sits where it was rejected, in no turn: queued, handed over or sent directly.
+// One in doubt stays where it was: it may have reached the agent.
+
+import { describe, expect, it } from 'vitest'
+import { agentJournalSubmissionKey } from '../../../shared/agent-session-journal-item-key'
+import {
+  AGENT_JOURNAL_THREAD_SCOPE,
+  type AgentJournalTurnScope
+} from '../../../shared/agent-session-journal-types'
+import { DISPATCH_REJECTED_HOST_RESTARTED } from '../../../shared/structured-agent-session-dispatch-rejection'
+import { projectStructuredAgentSessionMessages } from '../../../shared/structured-agent-session-message-projection'
+import { projectJournalBatch } from '../agent-session-wire/agent-session-journal-batch'
+import { DISPATCH_DOUBT_HOST_RESTARTED } from './journal-dispatch-doubt-reasons'
+import { applyJournalRow, createJournalReducerState, renderJournalState } from './journal-reducer'
+import { buildJournalSubmissionRow, journalRowBase } from './journal-row-builders'
+import type { JournalRow } from './journal-row-schema'
+
+function journal() {
+  const state = createJournalReducerState('session-1', 'epoch-1')
+  let seq = 0
+  const push = (next: JournalRow): JournalRow => {
+    applyJournalRow(state, next)
+    return next
+  }
+  return {
+    state,
+    submission(clientMessageId: string, handoverRecorded = true) {
+      seq += 1
+      return push(
+        buildJournalSubmissionRow({
+          state,
+          clientMessageId,
+          payloadFingerprint: `fp-${clientMessageId}`,
+          providerHandle: { kind: 'codex', threadId: 'thread-1' },
+          body: {
+            kind: 'message',
+            role: 'user',
+            blocks: [{ type: 'text', text: clientMessageId }]
+          },
+          seq,
+          fence: 1,
+          ts: 1_000 + seq,
+          ...(handoverRecorded ? { handoverRecorded: true } : {})
+        })
+      )
+    },
+    dispatch(
+      clientMessageId: string,
+      state_: 'pending' | 'rejected' | 'unknown',
+      turnScope: AgentJournalTurnScope = AGENT_JOURNAL_THREAD_SCOPE
+    ) {
+      seq += 1
+      return push({
+        kind: 'dispatch',
+        clientMessageId,
+        state: state_,
+        providerItemId: null,
+        reason:
+          state_ === 'rejected'
+            ? DISPATCH_REJECTED_HOST_RESTARTED
+            : state_ === 'unknown'
+              ? DISPATCH_DOUBT_HOST_RESTARTED
+              : null,
+        ...(state_ === 'rejected' ? { rejection: { kind: 'hostRestarted' } } : {}),
+        ...journalRowBase(state.epoch, seq, 1, 1_000 + seq),
+        turnScope
+      })
+    },
+    /** Other work between the send and its settlement, as a turn running ahead of it would write. */
+    advance(rows: number) {
+      seq += rows
+      state.lastSequence = seq
+    }
+  }
+}
+
+function placed(state: ReturnType<typeof journal>['state'], clientMessageId: string) {
+  const item = state.items.get(agentJournalSubmissionKey(clientMessageId))
+  return item && { sequence: item.sequence, observedAt: item.observedAt, scope: item.turnScope }
+}
+
+const IN_TURN: AgentJournalTurnScope = { kind: 'turn', turnItemId: 'orca:turn-1' }
+
+describe('a rejected message', () => {
+  it('sits at the rejection, in no turn, when it was queued', () => {
+    const { state, submission, dispatch, advance } = journal()
+    submission('waiting')
+    advance(300)
+    dispatch('waiting', 'rejected')
+
+    expect(placed(state, 'waiting')).toEqual({
+      sequence: 302,
+      observedAt: 1_302,
+      scope: AGENT_JOURNAL_THREAD_SCOPE
+    })
+  })
+
+  it('reaches a subscriber at the tail, so the newest page holds it', () => {
+    const { state, submission, dispatch, advance } = journal()
+    submission('waiting')
+    advance(300)
+    const rejection = dispatch('waiting', 'rejected')
+
+    const projected = projectJournalBatch({
+      rows: [rejection],
+      snapshot: renderJournalState(state),
+      afterSequence: 301
+    })
+    expect(projected.ok && projected.batch.items.map((item) => item.sequence)).toEqual([302])
+    expect(renderJournalState(state).items.at(-1)?.itemId).toBe(
+      agentJournalSubmissionKey('waiting')
+    )
+  })
+
+  it('sits at the rejection, out of the turn it was handed into, when it was a steer', () => {
+    const { state, submission, dispatch, advance } = journal()
+    submission('steer')
+    advance(10)
+    dispatch('steer', 'pending', IN_TURN)
+    expect(placed(state, 'steer')?.scope).toEqual(IN_TURN)
+    advance(10)
+    dispatch('steer', 'rejected')
+
+    expect(placed(state, 'steer')).toEqual({
+      sequence: 23,
+      observedAt: 1_023,
+      scope: AGENT_JOURNAL_THREAD_SCOPE
+    })
+  })
+
+  it('sits at the rejection when it was sent directly', () => {
+    const { state, submission, dispatch, advance } = journal()
+    submission('direct', false)
+    advance(10)
+    dispatch('direct', 'rejected')
+
+    expect(placed(state, 'direct')?.sequence).toBe(12)
+  })
+})
+
+describe('a message in doubt', () => {
+  it('stays where it was handed over, a plain bubble in its turn: it may have reached the agent', () => {
+    const { state, submission, dispatch, advance } = journal()
+    submission('steer')
+    advance(10)
+    dispatch('steer', 'pending', IN_TURN)
+    advance(10)
+    dispatch('steer', 'unknown')
+
+    expect(placed(state, 'steer')).toEqual({ sequence: 12, observedAt: 1_012, scope: IN_TURN })
+    const { items, submissions } = renderJournalState(state)
+    const drawn = projectStructuredAgentSessionMessages(items, [], submissions, {
+      rejectedInPlace: true
+    }).find((message) => message.id === agentJournalSubmissionKey('steer'))
+    expect(drawn).toBeDefined()
+    expect(drawn?.unsent).toBeUndefined()
+  })
+})
diff --git a/src/main/native-chat/agent-session-journal/journal-row-writer.test.ts b/src/main/native-chat/agent-session-journal/journal-row-writer.test.ts
index c0824a2e4ca..3671ce46cfc 100644
--- a/src/main/native-chat/agent-session-journal/journal-row-writer.test.ts
+++ b/src/main/native-chat/agent-session-journal/journal-row-writer.test.ts
@@ -93,4 +93,17 @@ describe('journal row writer', () => {
       kind: 'item'
     })
   })
+
+  it('writes several rows as one: a failure on the last leaves none', async () => {
+    const { writer, committedRows } = writerHarness()
+    // Sequence 2 is taken, so the second of the two rows violates the primary key.
+    insertTestJournalRow(database.db, SESSION_ID, row(2, 1))
+
+    await expect(writer.enqueueRows(() => [row, row])).rejects.toThrow()
+
+    expect(committedRows).toHaveLength(0)
+    expect(readTestJournalRows(database.db, SESSION_ID, EPOCH).map((stored) => stored.seq)).toEqual(
+      [2]
+    )
+  })
 })
diff --git a/src/main/native-chat/agent-session-journal/journal-row-writer.ts b/src/main/native-chat/agent-session-journal/journal-row-writer.ts
index ca274120a7b..dde1a66741d 100644
--- a/src/main/native-chat/agent-session-journal/journal-row-writer.ts
+++ b/src/main/native-chat/agent-session-journal/journal-row-writer.ts
@@ -71,6 +71,40 @@ export class JournalRowWriter {
     })
   }
 
+  /** Several rows in ONE transaction, in order, planned once the lane is this append's: none is
+   *  durable unless all are, so no reader ever meets some without the rest. */
+  enqueueRows(
+    plan: () => readonly ((seq: number, ts: number) => JournalRow)[]
+  ): Promise<JournalRow[]> {
+    return this.deps.serialize(() => {
+      assertJournalWritable(this.deps.readOnly(), this.deps.sessionId)
+      const first = this.deps.nextSequence()
+      const ts = this.deps.now()
+      const rows = plan().map((build, index) => build(first + index, ts))
+      if (rows.length === 0) {
+        return rows
+      }
+      for (const row of rows) {
+        assertJournalFence(row.fence, this.deps.highestFence())
+      }
+      try {
+        this.deps.database().transaction((db) => {
+          for (const row of rows) {
+            insertJournalRow(db, this.deps.sessionId, row)
+            this.runBookkeeping(db, row)
+          }
+        })
+      } catch (error) {
+        this.deps.rolledBack?.()
+        throw error
+      }
+      for (const row of rows) {
+        this.deps.commit(row)
+      }
+      return rows
+    })
+  }
+
   /** Assign the next sequence, make the row durable, and fold it through the SAME reducer
    *  replay uses — all inside one serialized step — answering where the row landed. */
   append(
diff --git a/src/main/native-chat/agent-session-journal/journal-store-collaborators.ts b/src/main/native-chat/agent-session-journal/journal-store-collaborators.ts
index 65ea665879b..ba879696469 100644
--- a/src/main/native-chat/agent-session-journal/journal-store-collaborators.ts
+++ b/src/main/native-chat/agent-session-journal/journal-store-collaborators.ts
@@ -92,6 +92,20 @@ export function createJournalStoreCollaborators(host: JournalStoreHost): Journal
     wroteBeforeOpen: (sequence) => host.journal().wroteBeforeOpen(sequence),
     committed: host.notifyCommitted
   })
+  const rowWriter = new JournalRowWriter({
+    sessionId: host.identity.sessionId,
+    now: host.now,
+    serialize: host.serialize,
+    database: host.database,
+    readOnly: host.readOnly,
+    highestFence: () => host.state().highestFence,
+    nextSequence: () => host.state().lastSequence + 1,
+    commit: host.commit,
+    // Every rejection is a dispatch row through this one writer; the draft
+    // returned-transition rides it so no path can bypass the hook.
+    inTransaction: (db, row) => queuedMessages.onRowInTransaction(db, row),
+    rolledBack: () => queuedMessages.invalidate()
+  })
   return {
     epochController,
     queuedMessages,
@@ -102,20 +116,7 @@ export function createJournalStoreCollaborators(host: JournalStoreHost): Journal
       restoreJournalStore(host, { epochController }).then(() =>
         queuedMessages.repairAndPruneAtOpen()
       ),
-    rowWriter: new JournalRowWriter({
-      sessionId: host.identity.sessionId,
-      now: host.now,
-      serialize: host.serialize,
-      database: host.database,
-      readOnly: host.readOnly,
-      highestFence: () => host.state().highestFence,
-      nextSequence: () => host.state().lastSequence + 1,
-      commit: host.commit,
-      // Every rejection is a dispatch row through this one writer; the draft
-      // returned-transition rides it so no path can bypass the hook.
-      inTransaction: (db, row) => queuedMessages.onRowInTransaction(db, row),
-      rolledBack: () => queuedMessages.invalidate()
-    }),
+    rowWriter,
     itemAppender: new JournalItemAppender({
       state: host.state,
       enqueue: host.enqueue
@@ -123,7 +124,8 @@ export function createJournalStoreCollaborators(host: JournalStoreHost): Journal
     lifecycleBatchAppender: new JournalLifecycleBatchAppender({
       state: host.state,
       cursor: host.cursor,
-      enqueue: host.enqueue
+      enqueue: host.enqueue,
+      enqueueRows: (plan) => rowWriter.enqueueRows(plan)
     })
   }
 }
diff --git a/src/main/native-chat/agent-session-journal/journal-store-contracts.ts b/src/main/native-chat/agent-session-journal/journal-store-contracts.ts
index 85e6b99f902..cb86a7a8e5d 100644
--- a/src/main/native-chat/agent-session-journal/journal-store-contracts.ts
+++ b/src/main/native-chat/agent-session-journal/journal-store-contracts.ts
@@ -70,6 +70,10 @@ export type JournalLifecycleBatchInput = {
   mutations: readonly JournalLifecycleMutationInput[]
   fence: number
   recovered?: true
+  /** Rejects the sends still queued with this first, in the same append: a failed start's row
+   *  follows the messages it failed, and no reader meets one without the other. With none still
+   *  queued, the batch is not written either. */
+  rejectsQueued?: AgentJournalDispatchRejection
 }
 
 export type JournalSubmissionInput = {
diff --git a/src/main/native-chat/agent-session-journal/journal-submission-fold.ts b/src/main/native-chat/agent-session-journal/journal-submission-fold.ts
index 04323e36bb2..c04e354fb89 100644
--- a/src/main/native-chat/agent-session-journal/journal-submission-fold.ts
+++ b/src/main/native-chat/agent-session-journal/journal-submission-fold.ts
@@ -70,6 +70,28 @@ export function placeHandedOverMessage(
   })
 }
 
+/** A rejected message — queued, handed over, or sent directly — joins the conversation where it was
+ *  rejected, in no turn: what happened before the rejection happened before it, and the newest page
+ *  holds a recent one. Only a rejection: one in doubt may have reached the agent, so it stays. */
+export function placeRejectedMessage(
+  state: JournalReducerState,
+  submission: AgentJournalSubmission,
+  row: Extract<JournalRow, { kind: 'dispatch' }>
+): void {
+  const itemId = agentJournalSubmissionKey(submission.clientMessageId)
+  const item = state.items.get(itemId)
+  if (row.state !== 'rejected' || !item) {
+    return
+  }
+  const { sequenceIndex: _placed, ...rest } = item
+  state.items.set(itemId, {
+    ...rest,
+    sequence: row.seq,
+    observedAt: row.ts,
+    turnScope: AGENT_JOURNAL_THREAD_SCOPE
+  })
+}
+
 export function acceptSubmissionFromProviderItem(
   state: JournalReducerState,
   providerItemId: string,
diff --git a/src/main/native-chat/agent-session-journal/journal-turn-scope.test.ts b/src/main/native-chat/agent-session-journal/journal-turn-scope.test.ts
index 2b8e4b80a76..4674f6de929 100644
--- a/src/main/native-chat/agent-session-journal/journal-turn-scope.test.ts
+++ b/src/main/native-chat/agent-session-journal/journal-turn-scope.test.ts
@@ -163,7 +163,9 @@ describe('stated turn scope', () => {
     const expected = [agentJournalItemKey(row('result')), agentJournalSubmissionKey('held')]
     const onPhone = () => {
       const { items, submissions } = renderJournalState(state)
-      return projectStructuredAgentSessionMessages(items, [], submissions)
+      return projectStructuredAgentSessionMessages(items, [], submissions, {
+        rejectedInPlace: false
+      })
     }
     // Still waiting: drawn after everything the agent did, the command's result included.
     expect(drawn(onPhone())).toEqual(expected)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-close-verdict.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-close-verdict.test.ts
index 33ef8080c03..b1922b913ed 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-close-verdict.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-close-verdict.test.ts
@@ -12,6 +12,7 @@ import {
 import type { AgentSessionStatusEvent } from '../../../shared/agent-session-wire'
 import { readAgentJournalTurn } from '../../../shared/agent-session-turn-record'
 import { describeNativeChatTurnStatus } from '../../../shared/native-chat-turn-status'
+import { withNativeChatCutTurnNotices } from '../../../shared/native-chat-cut-turn-notice'
 import { selectStructuredAgentSettledTurns } from '../../../shared/structured-agent-session-turn-timing'
 import { AgentSessionRecoveryCapsule } from '../../runtime/agent-session-recovery-capsule'
 import { openTestJournalHostDatabase } from '../agent-session-journal/journal-host-database-test-support'
@@ -121,9 +122,19 @@ async function settledTurn() {
   const { items } = await host.journalSnapshot(SESSION)
   const turn = items.map((item) => readAgentJournalTurn(item.body)).find(Boolean)
   const [settled] = [...selectStructuredAgentSettledTurns(items).values()]
-  return { turn, settled }
+  const label = settled && describeNativeChatTurnStatus({ elapsedSeconds: 0, ...settled }).key
+  // Every error row a reader's transcript shows, the cut turn's derived notice included.
+  const notices = withNativeChatCutTurnNotices(items, { agentName: 'Codex' }).flatMap((item) =>
+    item.body.kind === 'status' && item.body.tone === 'error' ? [item.body.text] : []
+  )
+  return { turn, settled, label, notices }
 }
 
+/** A turn nobody stopped reads like a finished one, with exactly one row saying it stopped. */
+const ONE_NOTICE = [
+  'Codex stopped while this response was in progress. You can continue in this conversation.'
+]
+
 function lastSummary(statuses: AgentSessionStatusEvent[]) {
   const last = statuses.at(-1)
   return last?.type === 'status' ? last.session : null
@@ -136,11 +147,11 @@ describe('a turn cut short by closing its provider', () => {
     await host.close(SESSION, 'user-close')
 
     expect(lastSummary(statuses)).toMatchObject({ status: 'idle', turnOutcome: 'cancellation' })
-    const { turn, settled } = await settledTurn()
+    const { turn, label, notices } = await settledTurn()
     expect(turn).toMatchObject({ state: 'interrupted', outcome: 'cancellation' })
-    expect(
-      settled && describeNativeChatTurnStatus({ elapsedSeconds: 0, ...settled })
-    ).toMatchObject({ key: 'interruptedAfter' })
+    expect(label).toBe('interruptedAfter')
+    // The person's own close explains itself.
+    expect(notices).toEqual([])
   })
 
   it('leaves a close the user did not aim at this chat as news', async () => {
@@ -150,12 +161,12 @@ describe('a turn cut short by closing its provider', () => {
     await host.close(SESSION, 'evict')
 
     expect(lastSummary(statuses)).toMatchObject({ status: 'idle', turnOutcome: 'interruption' })
-    const { turn, settled } = await settledTurn()
+    const { turn, label, notices } = await settledTurn()
     expect(turn).toMatchObject({ state: 'interrupted' })
     expect(turn).not.toHaveProperty('outcome')
-    expect(
-      settled && describeNativeChatTurnStatus({ elapsedSeconds: 0, ...settled })
-    ).toMatchObject({ key: 'failedAfter' })
+    // News for the sidebar; the turn reads like a finished one beside its one notice.
+    expect(label).toBe('workedFor')
+    expect(notices).toEqual(ONE_NOTICE)
   })
 
   it("records the user's close on a turn no adapter settled, through the host's fallback", async () => {
@@ -247,10 +258,9 @@ describe('a turn cut short by closing its provider', () => {
     expect(statuses.findLast((event) => event.type === 'status')).toMatchObject({
       session: { status: 'idle', turnOutcome: 'interruption' }
     })
-    const { settled } = await settledTurn()
-    expect(
-      settled && describeNativeChatTurnStatus({ elapsedSeconds: 0, ...settled })
-    ).toMatchObject({ key: 'failedAfter' })
+    const { label, notices } = await settledTurn()
+    expect(label).toBe('workedFor')
+    expect(notices).toEqual(ONE_NOTICE)
   })
 
   it("keeps the user's cancellation when a close aborts after the provider settled, then retries", async () => {
@@ -297,9 +307,10 @@ describe('a turn cut short by closing its provider', () => {
       await host.collaboratorsForTests().lifetime.idleSweep.tick()
 
       expect(closeCalls).toBe(1)
-      const { turn } = await settledTurn()
+      const { turn, notices } = await settledTurn()
       expect(turn).toMatchObject({ state: 'interrupted' })
       expect(turn?.outcome).toBe(verdict.outcome)
+      expect(notices).toEqual(cause === 'evict' ? ONE_NOTICE : [])
     }
   )
 
@@ -309,9 +320,10 @@ describe('a turn cut short by closing its provider', () => {
 
     await host.flushAllStreamedEvents({ trigger: 'quit' })
 
-    const { turn } = await settledTurn()
+    const { turn, notices } = await settledTurn()
     expect(turn).toMatchObject({ state: 'interrupted' })
     expect(turn).not.toHaveProperty('outcome')
+    expect(notices).toEqual(ONE_NOTICE)
   })
 
   it('leaves a crash the provider saw before the user closed the chat as news', async () => {
@@ -319,9 +331,10 @@ describe('a turn cut short by closing its provider', () => {
     await runningTurn()
     // The provider reports its own exit, which it saw first, as it closes: no verdict.
     await host.close(SESSION, 'user-close')
-    const { turn } = await settledTurn()
+    const { turn, notices } = await settledTurn()
     expect(turn).toMatchObject({ state: 'interrupted' })
     expect(turn).not.toHaveProperty('outcome')
+    expect(notices).toEqual(ONE_NOTICE)
   })
 
   it.each(['user-close', 'evict'] as const)(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-close.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-close.test.ts
index c084d2b2e07..2dac4cacb7d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-close.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-close.test.ts
@@ -241,16 +241,16 @@ describe('a start that never finishes (P2-15)', () => {
       providerChildPhase: 'starting' as const
     }))
     Object.assign(rig.host.deps.adapter, { awaitStarted: () => started.promise })
-    const reject = AgentSessionJournal.prototype.rejectQueuedSubmissions
-    vi.spyOn(AgentSessionJournal.prototype, 'rejectQueuedSubmissions').mockImplementation(function (
+    // The loop rejects the queued messages in the same append as its row.
+    const append = AgentSessionJournal.prototype.appendLifecycleBatch
+    vi.spyOn(AgentSessionJournal.prototype, 'appendLifecycleBatch').mockImplementation(function (
       this: AgentSessionJournal,
       ...args
     ) {
-      // Not the open's sweep of an earlier process's leftovers.
-      if (args[1].rejection.kind !== 'hostRestarted') {
-        order.push(`rejected: ${args[1].reason}`)
+      if (args[0].rejectsQueued) {
+        order.push(`rejected: ${args[0].rejectsQueued.reason}`)
       }
-      return reject.apply(this, args)
+      return append.apply(this, args)
     })
     const reader = collectSubscriber()
     const attached = await rig.host.attach(CALLER, hostTestAttachParams(null))
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-crash-turn-end.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-crash-turn-end.test.ts
index 7e237615089..d31a79e5f54 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-crash-turn-end.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-crash-turn-end.test.ts
@@ -38,6 +38,7 @@ import {
 } from './structured-agent-session-adapter'
 import { resettleOpenStructuredAgentSessionConversation } from './structured-agent-session-conversation-open'
 import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import { withNativeChatCutTurnNotices } from '../../../shared/native-chat-cut-turn-notice'
 import { STRUCTURED_AGENT_SESSION_IDLE_MS } from './structured-agent-session-idle-sweep'
 import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host-types'
 import {
@@ -216,6 +217,34 @@ describe('a turn a crash cut short mid-tool', () => {
     expect(completedStructuredAgentTurnSeconds(timing)).toBe(27)
   })
 
+  // The turn bar reads like a finished turn, so this row is the one place the chat says why.
+  it('explains the cut once, with one notice row and a turn bar that does not repeat it', async () => {
+    openHost({ probeOwner: async () => ({ outcome: 'pid-absent' }) })
+
+    await host.restoreReadableSessions()
+
+    const { items } = await host.journalSnapshot(SESSION)
+    // As a reader's transcript shows it: the stored row is the explanation, so none is derived.
+    const statusRows = withNativeChatCutTurnNotices(items, { agentName: 'Claude' }).flatMap(
+      (item) => (item.body.kind === 'status' ? [item.body] : [])
+    )
+    expect(statusRows).toEqual([
+      expect.objectContaining({
+        text: 'Claude stopped while this response was in progress. You can continue in this conversation.',
+        failure: expect.objectContaining({ kind: 'providerExited' }),
+        tone: 'error'
+      })
+    ])
+    const [timing] = selectStructuredAgentTurnTimings(items).values()
+    expect(
+      describeNativeChatTurnStatus({
+        elapsedSeconds: 0,
+        workedSeconds: completedStructuredAgentTurnSeconds(timing),
+        verdict: timing?.verdict
+      })
+    ).toEqual({ key: 'workedFor', duration: '27s' })
+  })
+
   it('ends at the pre-crash renewal when the child outlived Orca and recovery stopped it', async () => {
     // The orphan is alive at relaunch, but its output went nowhere: none of that is work shown.
     let alive = true
@@ -298,7 +327,7 @@ describe('a turn a read reached before the reconcile proved its owner dead', ()
     unsubscribe()
   })
 
-  it('reports the revision to the status feed as an interruption, which the chat folds as failed', async () => {
+  it('reports the revision to the status feed as an interruption, which the chat folds as worked', async () => {
     const published: AgentSessionStatusSummary[] = []
     openHost({
       probeOwner: async () => ({ outcome: 'pid-absent' }),
@@ -314,7 +343,7 @@ describe('a turn a read reached before the reconcile proved its owner dead', ()
     await host.reconcileRestartLeases()
     await drainSession()
 
-    // The sidebar's red Failed, then the folded "Failed after 27s".
+    // The sidebar's red Failed until seen; the turn folds as "Worked for 27s" beside its notice row.
     await vi.waitFor(() => expect(outcomes().at(-1)).toBe('interruption'))
     const [timing] = selectStructuredAgentTurnTimings(
       (await host.journalSnapshot(SESSION)).items
@@ -325,7 +354,7 @@ describe('a turn a read reached before the reconcile proved its owner dead', ()
         workedSeconds: completedStructuredAgentTurnSeconds(timing),
         verdict: timing?.verdict
       })
-    ).toEqual({ key: 'failedAfter', duration: '27s' })
+    ).toEqual({ key: 'workedFor', duration: '27s' })
   })
 
   it('revises nothing twice, whoever re-runs the settle', async () => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
index 39ff1c7ba51..f0372c8e58d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
@@ -4,6 +4,7 @@ import {
   type SubmissionRejectionFact
 } from '../../../shared/agent-session-failure'
 import { parseAgentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
+import { STALE_SESSION_ROW_PREFIX } from '../../../shared/agent-session-stop-row-identity'
 import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session-queued-submission'
 import {
   AGENT_JOURNAL_THREAD_SCOPE,
@@ -229,7 +230,7 @@ export async function settleStaleStructuredAgentSessionState(input: {
     )
   // Per attempt: a retry re-partitions only what is left, and a reused chunk id would skip it.
   const generation = input.acquisitionGeneration ?? `seq-${journal.cursor().sequence}`
-  const settlementId = `stale-session:${input.sessionId}:${input.fence}:${generation}`
+  const settlementId = `${STALE_SESSION_ROW_PREFIX}${input.sessionId}:${input.fence}:${generation}`
   const mutations: JournalLifecycleMutationInput[] = []
   for (const item of items) {
     const identity = parseAgentJournalItemKey(item.itemId)
@@ -261,7 +262,7 @@ export async function settleStaleStructuredAgentSessionState(input: {
       // Named by the death it explains, so a retry after a partly written settle adds no second row.
       identity: {
         provider: 'orca',
-        clientMessageId: `stale-session:${input.sessionId}:death-${evidence.ownerFence ?? 'unowned'}-${evidence.observedAt}`
+        clientMessageId: `${STALE_SESSION_ROW_PREFIX}${input.sessionId}:death-${evidence.ownerFence ?? 'unowned'}-${evidence.observedAt}`
       },
       // The death evidence is Orca's log text, never a sentence for a person: the row says only
       // that the provider stopped.
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-test-data.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-test-data.ts
index 959a02919a2..a96388ac4ca 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-test-data.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-test-data.ts
@@ -84,6 +84,8 @@ export function hostTestDrawnRowIds(
     state: 'dispatching' as const
   }))
   return projectNativeChatTranscriptMessages(
-    projectStructuredAgentSessionMessages(snapshot.items, outbox, snapshot.submissions)
+    projectStructuredAgentSessionMessages(snapshot.items, outbox, snapshot.submissions, {
+      rejectedInPlace: true
+    })
   ).map(({ id }) => id)
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-options-read.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-options-read.test.ts
new file mode 100644
index 00000000000..5657fcfb4d8
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-options-read.test.ts
@@ -0,0 +1,48 @@
+// A chat's options at rest come from the host catalog without waiting on a listing.
+
+import { describe, expect, it, vi } from 'vitest'
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import { createAgentModelCatalogService } from '../agent-model-catalog/agent-model-catalog-service'
+import {
+  AgentModelCatalogStore,
+  type AgentModelCatalogSuccess
+} from '../agent-model-catalog/agent-model-catalog-store'
+import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
+import { readStructuredAgentSessionOptions } from './structured-agent-session-options-read'
+
+const SESSION = 'session-1'
+
+function restingRecord(): AgentSessionRecord {
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the resting read and the catalog key touch only these fields.
+  return {
+    provider: 'codex',
+    accountHome: { variable: 'CODEX_HOME', path: '/homes/a' },
+    location: { wslDistro: null },
+    options: {}
+  } as unknown as AgentSessionRecord
+}
+
+describe('options at rest', () => {
+  it('answers while the first catalog listing is still running', async () => {
+    const record = restingRecord()
+    const probe = vi.fn(() => new Promise<AgentModelCatalogSuccess>(() => {}))
+    const modelCatalog = createAgentModelCatalogService({
+      store: new AgentModelCatalogStore(),
+      getRecord: () => record,
+      resolveAccountHome: async () => ({ variable: 'CODEX_HOME', path: '/homes/a' }),
+      probes: { codex: probe }
+    })
+    const resting = { child: null, params: { provider: 'codex' } }
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the resting read touches only these members.
+    const context = {
+      deps: { adapter: {}, store: { getRecord: () => record }, modelCatalog },
+      serialize: (_sessionId: string, task: () => Promise<unknown>) => task(),
+      openConversation: async () => resting,
+      conversation: async () => resting
+    } as unknown as StructuredAgentSessionMutationContext
+
+    const result = await readStructuredAgentSessionOptions(context, SESSION)
+    expect(probe).toHaveBeenCalledTimes(1)
+    expect(result.models).toEqual([])
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-recovered-turn-clock.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-recovered-turn-clock.test.ts
index e8dfe9f7f5e..0857e3565d6 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-recovered-turn-clock.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-recovered-turn-clock.test.ts
@@ -183,8 +183,8 @@ describe('a turn recovery settled after its host went away', () => {
     }
   )
 
-  // The chat's turn bar and the tab's mark read one verdict: a turn nobody stopped failed, and
-  // must never show the done tick of a finished turn.
+  // The tab's mark reads a turn nobody stopped as failed; the chat's turn bar reads it like a
+  // finished turn, since the chat's notice row says why it stopped.
   it.each([
     [
       'a restart',
@@ -208,7 +208,7 @@ describe('a turn recovery settled after its host went away', () => {
         )
     ]
   ] as const)(
-    'reads Failed after N, marked failed, for a turn cut off by %s',
+    'reads Worked for N, marked failed, for a turn cut off by %s',
     async (_label, cut) => {
       const session = await sessionWithRunningTurn()
       session.recoverAt(RECOVERED)
@@ -221,7 +221,7 @@ describe('a turn recovery settled after its host went away', () => {
         ...selectStructuredAgentSettledTurns(session.journal.snapshot().items).values()
       ]
       expect(settled && formatNativeChatTurnStatusLabel({ elapsedSeconds: 0, ...settled })).toBe(
-        'Failed after 1s'
+        'Worked for 1s'
       )
     }
   )
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-continuation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-continuation.ts
index 27c09bc2bbe..c748748ccd4 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-continuation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-continuation.ts
@@ -22,6 +22,7 @@ import {
   type AgentSessionSendResult
 } from '../../../shared/agent-session-wire'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import { RESTART_CONTINUATION_ROW_PREFIX } from '../../../shared/agent-session-stop-row-identity'
 import {
   AGENT_SESSION_RESTART_CONTINUATION_NOTE,
   AGENT_SESSION_RESTART_CONTINUATION_REFUSED_NOTE,
@@ -120,7 +121,10 @@ function restartNoteWriter(
       return
     }
     await session.journal.appendItem(
-      { provider: 'orca', clientMessageId: `restart-continuation:${sessionId}:${host.now()}` },
+      {
+        provider: 'orca',
+        clientMessageId: `${RESTART_CONTINUATION_ROW_PREFIX}${sessionId}:${host.now()}`
+      },
       { kind: 'status', text, ...(tone ? { tone } : {}) },
       // About the conversation, not any turn in it.
       { fence, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-failure-filing.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-failure-filing.test.ts
index b1cbc83a48e..4602630960a 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-failure-filing.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-failure-filing.test.ts
@@ -1,12 +1,15 @@
 import { afterEach, expect, it, vi } from 'vitest'
 import { AgentSessionRecoveryCapsule } from '../../runtime/agent-session-recovery-capsule'
 import {
+  AGENT_SESSION_RESTART_CONTINUATION_NOTE,
   AGENT_SESSION_RESTART_CONTINUATION_REFUSED_NOTE,
   AGENT_SESSION_RESTART_CONTINUATION_UNCONFIRMED_NOTE
 } from '../../../shared/agent-session-restart-continuation'
 import { StructuredAgentSessionResumeAdmission } from './structured-agent-session-restart-resume-runner'
 import {
   interruptedRestart,
+  QUIT_CUT_NOTICE,
+  readerNotes,
   statusNotes,
   throwAfterContinuationAccepted
 } from './structured-agent-session-restart-interruption-test-harness'
@@ -43,6 +46,8 @@ it('files nothing for a chat the user moved on in before its attempt, and spends
   expect(await capsule.listFailed(NOW)).toEqual([])
   expect(await capsule.list(NOW)).toEqual([])
   expect(await statusNotes(host)).toEqual([])
+  // No note took over, so the cut turn keeps its one notice.
+  expect(await readerNotes(host)).toEqual([QUIT_CUT_NOTICE])
 })
 
 // The continuation is accepted and its agent then fails to start: the message is rejected with the
@@ -51,6 +56,8 @@ it('says so in the chat when the agent cannot start for the continuation', async
   const { host, acquire } = await interruptedRestart()
   await host.restartResume.list()
   acquire.mockRejectedValueOnce(new Error('provider could not reconnect'))
+  // Before the action, the quit's cut reads with its one notice.
+  expect(await readerNotes(host)).toEqual([QUIT_CUT_NOTICE])
 
   await host.restartResume.continueAfterRestart([SESSION], 'modal')
 
@@ -61,6 +68,24 @@ it('says so in the chat when the agent cannot start for the continuation', async
     text: AGENT_SESSION_RESTART_CONTINUATION_REFUSED_NOTE,
     tone: 'error'
   })
+  // The refusal note is now the one explanation: the cut is not said a second time beside it.
+  expect(await readerNotes(host)).toEqual(await statusNotes(host))
+})
+
+// A continuation that carries on, chosen in the prompt or automatically at launch, does not stand in
+// for the cut: its note is written after its own message, so the cut keeps its notice throughout.
+it("keeps the quit's notice through a continuation that carries the chat on", async () => {
+  const { host } = await interruptedRestart()
+  await host.restartResume.list()
+  expect(await readerNotes(host)).toEqual([QUIT_CUT_NOTICE])
+
+  const result = await host.restartResume.continueAfterRestart([SESSION], 'modal')
+
+  expect(result.continued).toMatchObject([{ outcome: 'continued' }])
+  expect(await readerNotes(host)).toEqual([
+    QUIT_CUT_NOTICE,
+    { text: AGENT_SESSION_RESTART_CONTINUATION_NOTE, tone: undefined }
+  ])
 })
 
 // A send that throws after Orca may have taken it cannot be proven undelivered: filed unconfirmed,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-interruption-test-harness.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-interruption-test-harness.ts
index fe97834a189..59d478cbb40 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-interruption-test-harness.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-interruption-test-harness.ts
@@ -1,4 +1,8 @@
-import { AGENT_JOURNAL_THREAD_SCOPE } from '../../../shared/agent-session-journal-types'
+import {
+  AGENT_JOURNAL_THREAD_SCOPE,
+  type AgentJournalRenderItem
+} from '../../../shared/agent-session-journal-types'
+import { withNativeChatCutTurnNotices } from '../../../shared/native-chat-cut-turn-notice'
 // A chat interrupted mid-turn by a restart, rebuilt on a fresh host over the same store, for the
 // restart-resume ownership and failure tests.
 
@@ -177,11 +181,30 @@ export function throwAfterContinuationAccepted(): void {
 }
 
 export async function statusNotes(host: StructuredAgentSessionHost) {
-  return (await host.journalSnapshot(SESSION)).items.flatMap((item) =>
+  return notesOf((await host.journalSnapshot(SESSION)).items)
+}
+
+/** The notes a reader's transcript shows, the cut turn's derived notice included. */
+export async function readerNotes(host: StructuredAgentSessionHost) {
+  return notesOf(
+    withNativeChatCutTurnNotices((await host.journalSnapshot(SESSION)).items, {
+      agentName: 'Codex'
+    })
+  )
+}
+
+function notesOf(items: readonly AgentJournalRenderItem[]) {
+  return items.flatMap((item) =>
     item.body.kind === 'status' ? [{ text: item.body.text, tone: item.body.tone }] : []
   )
 }
 
+/** The one row the quit's cut turn reads with when nothing else explains it. */
+export const QUIT_CUT_NOTICE = {
+  text: 'Codex stopped while this response was in progress. You can continue in this conversation.',
+  tone: 'error'
+}
+
 /** A continuation the host refuses because the user's own message was accepted first: another
  *  client's send lands after the action reserved the offer, just before the continuation is
  *  accepted. `userAnswers` instead has the user send before or after the whole attempt. */
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-start-failure-row.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-start-failure-row.ts
index 12fa05710f0..9206f95fde0 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-start-failure-row.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-start-failure-row.ts
@@ -42,9 +42,9 @@ export function hasStructuredAgentSessionStartFailureRow(
 }
 
 /**
- * A start the delivery loop needed and did not get: the start's row, and every queued message
- * rejected with the same words. Writes nothing when nothing is still queued: a start whose
- * messages Stop withdrew did not fail anyone.
+ * A start the delivery loop needed and did not get: every queued message rejected with the same
+ * words, then the start's row. Writes nothing when nothing is still queued: a start whose messages
+ * Stop withdrew did not fail anyone.
  */
 export async function recordStructuredAgentSessionStartFailure(
   session: Pick<StructuredAgentSessionHostSession, 'journal'> & { fence: number },
@@ -59,11 +59,8 @@ export async function recordStructuredAgentSessionStartFailure(
     settlementId: `start-failure:${startKey}`,
     fence: session.fence,
     recovered: true,
-    mutations: [structuredAgentSessionStartFailureRow(startKey, failure)]
-  })
-  await session.journal.rejectQueuedSubmissions(session.fence, {
-    reason: failure.reason,
-    rejection: failure.rejection
+    mutations: [structuredAgentSessionStartFailureRow(startKey, failure)],
+    rejectsQueued: { reason: failure.reason, rejection: failure.rejection }
   })
 }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-restart.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-restart.test.ts
index 4ae9f59a015..50056eedd03 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-restart.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-restart.test.ts
@@ -158,7 +158,8 @@ describe('a restart between a Stop and its turn end', () => {
     expect(errorRows).toEqual([])
   })
 
-  it('reads Failed after N, marked failed, when nobody stopped it', async () => {
+  // The notice row is the one explanation; the turn bar reads like a finished turn.
+  it('reads Worked for N, marked failed, when nobody stopped it', async () => {
     await runningTurn(CODEX_TURN)
 
     await restartAndSettle()
@@ -166,7 +167,7 @@ describe('a restart between a Stop and its turn end', () => {
     const { turn, label, mark, errorRows } = settled()
     expect(turn).toMatchObject({ state: 'interrupted' })
     expect(turn).not.toHaveProperty('outcome')
-    expect(label).toMatch(/^Failed after /)
+    expect(label).toMatch(/^Worked for /)
     expect(mark).toBe('failed')
     expect(errorRows).toEqual([
       expect.stringContaining('stopped while this response was in progress')
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-subscriber-journal-retention.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-subscriber-journal-retention.test.ts
index 37ee57e79ed..8760e378525 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-subscriber-journal-retention.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-subscriber-journal-retention.test.ts
@@ -1,3 +1,4 @@
+import '../../runtime/rpc/unused-default-rpc-methods.test-fixture'
 import { createHash } from 'node:crypto'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { AGENT_JOURNAL_THREAD_SCOPE } from '../../../shared/agent-session-journal-types'
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
index 232b101e603..5a0b2f6de30 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
@@ -1,4 +1,5 @@
 import type { AgentSessionFailureWordsContext } from '../../../shared/agent-session-failure-words'
+import { PROVIDER_EXIT_ROW_PREFIX } from '../../../shared/agent-session-stop-row-identity'
 import { structuredAgentSessionFailureWordsContext } from './structured-agent-session-send-preparation'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import type { StructuredAgentSessionEndedEvent } from './structured-agent-session-adapter'
@@ -193,5 +194,5 @@ function logExitFailure(
 }
 
 function providerExitSettlementId(event: UnexpectedExitLifecycleEvent): string {
-  return `provider-exit:${event.sessionId}:${event.fence}:${event.acquisitionGeneration}`
+  return `${PROVIDER_EXIT_ROW_PREFIX}${event.sessionId}:${event.fence}:${event.acquisitionGeneration}`
 }
diff --git a/src/main/opencode/hook-service.ts b/src/main/opencode/hook-service.ts
index 7a6d137ebfa..b4b30912b09 100644
--- a/src/main/opencode/hook-service.ts
+++ b/src/main/opencode/hook-service.ts
@@ -121,7 +121,11 @@ export class OpenCodeHookService {
     }
   }
 
-  buildPtyEnv(ptyId: string, existingConfigDir?: string | undefined): Record<string, string> {
+  buildPtyEnv(
+    ptyId: string,
+    existingConfigDir?: string | undefined,
+    defaultConfigDir?: string
+  ): Record<string, string> {
     if (!isUsableId(ptyId)) {
       // Why: on a bad id, still preserve a user-set OPENCODE_CONFIG_DIR; only the Orca status plugin is forfeited.
       return existingConfigDir ? { OPENCODE_CONFIG_DIR: existingConfigDir } : {}
@@ -131,7 +135,7 @@ export class OpenCodeHookService {
     const managedConfigDir = this.getSharedConfigDir()
     if (!existingConfigDir || existingConfigDir === managedConfigDir) {
       try {
-        this.writePluginToConfigDir(resolveOpenCodeConfigDirectory())
+        this.writePluginToConfigDir(defaultConfigDir ?? resolveOpenCodeConfigDirectory())
         return {}
       } catch {
         return {}
diff --git a/src/main/opencode/opencode-launch-model-config.test.ts b/src/main/opencode/opencode-launch-model-config.test.ts
new file mode 100644
index 00000000000..65d183e156f
--- /dev/null
+++ b/src/main/opencode/opencode-launch-model-config.test.ts
@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest'
+import { resolveOpenCodeLaunchModelConfig } from './opencode-launch-model-config'
+
+describe('per-launch OpenCode model config', () => {
+  it('retains credentials, permissions and other agents while overriding the resolved primary model', () => {
+    const original = {
+      model: 'provider/old',
+      default_agent: 'reviewer',
+      providers: {
+        custom: { apiKey: 'placeholder-key', models: { preferred: { name: 'Preferred' } } }
+      },
+      permissions: [{ tool: 'shell', action: 'ask' }],
+      agents: {
+        reviewer: { model: 'provider/agent-old', system: 'Review only', permissions: [] },
+        build: { model: 'provider/build', steps: 5 },
+        nested: { mode: 'subagent', model: 'provider/nested' }
+      }
+    }
+    const configContent = JSON.stringify(original)
+    const merged = resolveOpenCodeLaunchModelConfig({
+      configContent,
+      primaryAgent: 'reviewer',
+      model: 'provider/preferred'
+    })
+    expect(merged).not.toBeNull()
+    expect(JSON.parse(merged ?? 'null')).toEqual({
+      ...original,
+      model: 'provider/preferred',
+      agents: {
+        ...original.agents,
+        reviewer: { ...original.agents.reviewer, model: 'provider/preferred' }
+      }
+    })
+    expect(configContent).toBe(JSON.stringify(original))
+  })
+
+  it('adds an override for the externally resolved built-in primary agent without guessing its name', () => {
+    expect(
+      resolveOpenCodeLaunchModelConfig({
+        configContent: undefined,
+        primaryAgent: 'plan',
+        model: 'provider/preferred'
+      })
+    ).toBe('{"model":"provider/preferred","agents":{"plan":{"model":"provider/preferred"}}}')
+  })
+
+  it.each(['{', 'null', '[]', '{"agents":[]}', '{"agents":{"build":null}}'])(
+    'refuses malformed inline config %s',
+    (configContent) => {
+      expect(
+        resolveOpenCodeLaunchModelConfig({
+          configContent,
+          primaryAgent: 'build',
+          model: 'provider/a'
+        })
+      ).toBeNull()
+    }
+  )
+
+  it('refuses oversized config and absent resolved preferences', () => {
+    expect(
+      resolveOpenCodeLaunchModelConfig({
+        configContent: ' '.repeat(1_048_577),
+        primaryAgent: 'build',
+        model: 'provider/a'
+      })
+    ).toBeNull()
+    expect(
+      resolveOpenCodeLaunchModelConfig({
+        configContent: '{}',
+        primaryAgent: '',
+        model: 'provider/a'
+      })
+    ).toBeNull()
+  })
+})
diff --git a/src/main/opencode/opencode-launch-model-config.ts b/src/main/opencode/opencode-launch-model-config.ts
new file mode 100644
index 00000000000..c8a1d75f5ae
--- /dev/null
+++ b/src/main/opencode/opencode-launch-model-config.ts
@@ -0,0 +1,33 @@
+import { z } from 'zod'
+
+const launchConfig = z
+  .object({ agents: z.record(z.string(), z.record(z.string(), z.unknown())).optional() })
+  .passthrough()
+
+export function resolveOpenCodeLaunchModelConfig(options: {
+  configContent: string | undefined
+  primaryAgent: string
+  model: string
+}): string | null {
+  if (!options.primaryAgent || !options.model || (options.configContent?.length ?? 0) > 1_048_576) {
+    return null
+  }
+  try {
+    const raw: unknown = options.configContent?.trim() ? JSON.parse(options.configContent) : {}
+    const parsed = launchConfig.safeParse(raw)
+    if (!parsed.success) {
+      return null
+    }
+    const config = parsed.data
+    return JSON.stringify({
+      ...config,
+      model: options.model,
+      agents: {
+        ...config.agents,
+        [options.primaryAgent]: { ...config.agents?.[options.primaryAgent], model: options.model }
+      }
+    })
+  } catch {
+    return null
+  }
+}
diff --git a/src/main/opencode/opencode-launch-model-context-cleanup.test.ts b/src/main/opencode/opencode-launch-model-context-cleanup.test.ts
new file mode 100644
index 00000000000..4acf1ba72de
--- /dev/null
+++ b/src/main/opencode/opencode-launch-model-context-cleanup.test.ts
@@ -0,0 +1,137 @@
+import { z } from 'zod'
+import { ChildProcess } from 'node:child_process'
+import { PassThrough } from 'node:stream'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { spawnProcess } from '../../shared/child-process/run-process'
+import {
+  forceTerminateProcessTree,
+  signalProcessTree
+} from '../../shared/child-process/process-tree-termination'
+import { probeOpenCodeLaunchModelContext } from './opencode-launch-model-context'
+import { readFetchResponseJsonWithinLimit } from '../../shared/fetch-response-body'
+
+vi.mock('../../shared/child-process/run-process', () => ({ spawnProcess: vi.fn() }))
+vi.mock('../../shared/child-process/process-tree-termination', () => ({
+  signalProcessTree: vi.fn(),
+  forceTerminateProcessTree: vi.fn()
+}))
+
+vi.mock('../../shared/fetch-response-body', () => ({ readFetchResponseJsonWithinLimit: vi.fn() }))
+
+class ProbeChild extends ChildProcess {
+  override stdin = new PassThrough()
+  override stdout = new PassThrough()
+  override stderr = new PassThrough()
+  override pid = 123456
+  override exitCode: number | null = null
+  override stdio: [PassThrough, PassThrough, PassThrough, undefined, undefined] = [
+    this.stdin,
+    this.stdout,
+    this.stderr,
+    undefined,
+    undefined
+  ]
+}
+
+const directory = '/private/project'
+const model = { id: 'model-b', providerID: 'private-proof', enabled: true }
+const snapshot = {
+  model: { location: { directory }, data: [model] },
+  agent: {
+    location: { directory },
+    data: [{ id: 'build', mode: 'primary', hidden: false, model }]
+  },
+  'model/default': { location: { directory }, data: model },
+  config: [{ type: 'document', info: { default_agent: 'build' } }]
+}
+const platform = Object.getOwnPropertyDescriptor(process, 'platform')
+let child: ProbeChild
+let closeDuringFetch = false
+function close() {
+  child.exitCode = 0
+  child.emit('exit', 0, null)
+  child.emit('close', 0, null)
+}
+const options = { executable: '/private/opencode', cwd: directory, env: {} }
+
+describe('OpenCode model probe termination evidence', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.mocked(readFetchResponseJsonWithinLimit).mockImplementation((response) => response.json())
+    child = new ProbeChild()
+    closeDuringFetch = false
+    vi.mocked(spawnProcess).mockImplementation(() => {
+      queueMicrotask(() => child.stdout.write('server listening on http://127.0.0.1:45678\n'))
+      return child
+    })
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (input: URL) => {
+        const endpoint = z
+          .enum(['model', 'agent', 'model/default', 'config'])
+          .parse(input.pathname.slice('/api/'.length))
+        const response = snapshot[endpoint]
+        if (closeDuringFetch && endpoint === 'config') {
+          queueMicrotask(close)
+        }
+        return new Response(JSON.stringify(response), { status: 200 })
+      })
+    )
+    vi.mocked(signalProcessTree).mockImplementation(async () => {
+      close()
+      return true
+    })
+    vi.mocked(forceTerminateProcessTree).mockResolvedValue(false)
+  })
+
+  afterEach(() => {
+    if (platform) {
+      Object.defineProperty(process, 'platform', platform)
+    }
+    vi.unstubAllGlobals()
+  })
+
+  it('cancels all unread responses if the bounded body reader fails', async () => {
+    const cancel = vi.fn()
+    vi.mocked(readFetchResponseJsonWithinLimit).mockRejectedValue(new Error('body_reader_failed'))
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => new Response(new ReadableStream({ cancel }), { status: 200 }))
+    )
+    expect(await probeOpenCodeLaunchModelContext(options)).toBeNull()
+    expect(cancel).toHaveBeenCalledTimes(4)
+    expect(signalProcessTree).toHaveBeenCalledOnce()
+  })
+
+  it('accepts an already-closed Windows probe without signaling its former pid', async () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' })
+    closeDuringFetch = true
+    vi.mocked(signalProcessTree).mockResolvedValue(false)
+    expect(await probeOpenCodeLaunchModelContext(options)).toMatchObject({ primaryAgent: 'build' })
+    expect(signalProcessTree).not.toHaveBeenCalled()
+    expect(forceTerminateProcessTree).not.toHaveBeenCalled()
+  })
+
+  it('does not force a POSIX group after the graceful close', async () => {
+    Object.defineProperty(process, 'platform', { value: 'darwin' })
+    expect(await probeOpenCodeLaunchModelContext(options)).toMatchObject({ primaryAgent: 'build' })
+    expect(signalProcessTree).toHaveBeenCalledOnce()
+    expect(forceTerminateProcessTree).not.toHaveBeenCalled()
+  })
+
+  it('keeps a root exit with inherited pipes unverified and avoids its former pid', async () => {
+    vi.mocked(signalProcessTree).mockImplementation(async () => {
+      child.exitCode = 0
+      child.emit('exit', 0, null)
+      return false
+    })
+    expect(await probeOpenCodeLaunchModelContext(options)).toBeNull()
+    expect(forceTerminateProcessTree).not.toHaveBeenCalled()
+  })
+
+  it('requires verified termination when a still-live probe does not close', async () => {
+    vi.mocked(signalProcessTree).mockResolvedValue(true)
+    expect(await probeOpenCodeLaunchModelContext(options)).toBeNull()
+    expect(forceTerminateProcessTree).toHaveBeenCalledOnce()
+  })
+})
diff --git a/src/main/opencode/opencode-launch-model-context.test.ts b/src/main/opencode/opencode-launch-model-context.test.ts
new file mode 100644
index 00000000000..faf19bfdedf
--- /dev/null
+++ b/src/main/opencode/opencode-launch-model-context.test.ts
@@ -0,0 +1,142 @@
+import { mkdtemp, mkdir, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import {
+  parseOpenCodeLaunchModelContext,
+  probeOpenCodeLaunchModelContext
+} from './opencode-launch-model-context'
+import { resolveOpenCodeLaunchModelConfig } from './opencode-launch-model-config'
+
+const directory = '/private/project'
+const snapshot = {
+  directory,
+  models: {
+    location: { directory },
+    data: [
+      { id: 'one', providerID: 'provider', enabled: true },
+      { id: 'disabled', providerID: 'provider', enabled: false }
+    ]
+  },
+  agents: {
+    location: { directory },
+    data: [
+      {
+        id: 'reviewer',
+        mode: 'primary',
+        hidden: false,
+        model: { id: 'one', providerID: 'provider' }
+      },
+      { id: 'build', mode: 'primary', hidden: false },
+      { id: 'hidden', mode: 'primary', hidden: true },
+      { id: 'child', mode: 'subagent', hidden: false }
+    ]
+  },
+  config: [{ type: 'document', info: { default_agent: 'reviewer' } }],
+  defaultModel: {
+    location: { directory },
+    data: { id: 'one', providerID: 'provider', enabled: true }
+  }
+}
+
+describe('OpenCode execution-host model context', () => {
+  it('uses the configured visible primary and exact enabled provider/model pairs', () => {
+    expect(parseOpenCodeLaunchModelContext(snapshot)).toEqual({
+      primaryAgent: 'reviewer',
+      availableModels: ['provider/one'],
+      primaryModel: 'provider/one'
+    })
+  })
+
+  it('uses actual returned primary ordering and skips hidden agents and children', () => {
+    const agents = {
+      location: { directory },
+      data: [...snapshot.agents.data.slice(2), ...snapshot.agents.data.slice(0, 2)]
+    }
+    expect(parseOpenCodeLaunchModelContext({ ...snapshot, agents })?.primaryAgent).toBe('reviewer')
+    expect(
+      parseOpenCodeLaunchModelContext({
+        ...snapshot,
+        defaultModel: { location: { directory }, data: null }
+      })
+    ).toBeNull()
+  })
+
+  it('refuses an uninitialized, malformed or foreign-location response', () => {
+    for (const models of [
+      null,
+      { location: { directory }, data: [] },
+      { location: { directory: '/other' }, data: snapshot.models.data }
+    ]) {
+      expect(parseOpenCodeLaunchModelContext({ ...snapshot, models })).toBeNull()
+    }
+    expect(
+      parseOpenCodeLaunchModelContext({
+        ...snapshot,
+        agents: { location: { directory }, data: [] }
+      })
+    ).toBeNull()
+  })
+})
+
+describe.skipIf(!process.env.ORCA_REAL_OPENCODE_CLI_TEST)(
+  'real current OpenCode model preflight',
+  () => {
+    it('waits for initialization and verifies a custom primary before and after a private overlay', async () => {
+      const executable = process.env.ORCA_REAL_OPENCODE_CLI_TEST
+      if (!executable) {
+        throw new Error('Real OpenCode executable required')
+      }
+      const home = await mkdtemp(join(tmpdir(), 'orca-opencode-model-context-'))
+      try {
+        const env: NodeJS.ProcessEnv = {}
+        for (const [key, value] of Object.entries(process.env)) {
+          if (!/API_KEY|TOKEN|SECRET|AUTH|CREDENTIAL|OPENCODE_|ORCA_/.test(key)) {
+            env[key] = value
+          }
+        }
+        for (const [key, child] of [
+          ['HOME', 'home'],
+          ['XDG_CONFIG_HOME', 'config'],
+          ['XDG_DATA_HOME', 'data'],
+          ['XDG_STATE_HOME', 'state'],
+          ['XDG_CACHE_HOME', 'cache']
+        ]) {
+          const path = join(home, child)
+          await mkdir(path, { mode: 0o700 })
+          env[key] = path
+        }
+        env.ORCA_BACKGROUND_LAUNCH = '1'
+        env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+          default_agent: 'reviewer',
+          model: 'opencode/big-pickle',
+          agents: {
+            reviewer: { mode: 'primary', system: 'Review only', model: 'opencode/big-pickle' }
+          }
+        })
+        const options = { executable, cwd: process.cwd(), env }
+        const before = await probeOpenCodeLaunchModelContext(options)
+        expect(before?.primaryAgent).toBe('reviewer')
+        expect(before?.primaryModel).toBe('opencode/big-pickle')
+        expect(before?.availableModels).toContain('opencode/fledge-alpha-free')
+        const config = resolveOpenCodeLaunchModelConfig({
+          configContent: env.OPENCODE_CONFIG_CONTENT,
+          primaryAgent: before?.primaryAgent ?? '',
+          model: 'opencode/fledge-alpha-free'
+        })
+        expect(config).not.toBeNull()
+        const after = await probeOpenCodeLaunchModelContext({
+          ...options,
+          env: { ...env, OPENCODE_CONFIG_CONTENT: config ?? '' },
+          expectedPrimaryAgent: 'reviewer',
+          expectedPrimaryModel: 'opencode/fledge-alpha-free'
+        })
+        expect(after?.primaryAgent).toBe('reviewer')
+        expect(after?.primaryModel).toBe('opencode/fledge-alpha-free')
+        expect(env.OPENCODE_CONFIG_CONTENT).toContain('opencode/big-pickle')
+      } finally {
+        await rm(home, { recursive: true, force: true })
+      }
+    }, 30_000)
+  }
+)
diff --git a/src/main/opencode/opencode-launch-model-context.ts b/src/main/opencode/opencode-launch-model-context.ts
new file mode 100644
index 00000000000..ce1098d8acf
--- /dev/null
+++ b/src/main/opencode/opencode-launch-model-context.ts
@@ -0,0 +1,206 @@
+import { randomBytes } from 'node:crypto'
+import { setTimeout as delay } from 'node:timers/promises'
+import { z } from 'zod'
+import { spawnProcess } from '../../shared/child-process/run-process'
+import {
+  forceTerminateProcessTree,
+  signalProcessTree
+} from '../../shared/child-process/process-tree-termination'
+import { withTimeout } from '../../shared/promise-timeout-fallback'
+import { createOutputSink } from '../../shared/child-process/bounded-output-sink'
+import { readFetchResponseJsonWithinLimit } from '../../shared/fetch-response-body'
+import { cancelUnreadResponseBody } from '../lib/unread-response-body'
+
+const model = z.object({ id: z.string(), providerID: z.string() })
+const availableModel = model.extend({ enabled: z.boolean() })
+const agent = z.object({
+  id: z.string(),
+  mode: z.enum(['primary', 'subagent', 'all']),
+  hidden: z.boolean(),
+  model: model.optional()
+})
+const location = z.object({ directory: z.string() })
+const modelResponse = z.object({ location, data: availableModel.array() })
+const agentResponse = z.object({ location, data: agent.array() })
+const defaultModelResponse = z.object({ location, data: availableModel.nullable() })
+const configResponse = z.array(
+  z.object({
+    type: z.enum(['directory', 'document']),
+    info: z.object({ default_agent: z.string().optional() }).optional()
+  })
+)
+
+export type OpenCodeLaunchModelContext = {
+  primaryAgent: string
+  availableModels: string[]
+  primaryModel: string | null
+}
+
+export function parseOpenCodeLaunchModelContext(options: {
+  directory: string
+  models: unknown
+  agents: unknown
+  defaultModel: unknown
+  config: unknown
+}): OpenCodeLaunchModelContext | null {
+  const models = modelResponse.safeParse(options.models)
+  const agents = agentResponse.safeParse(options.agents)
+  const defaultModel = defaultModelResponse.safeParse(options.defaultModel)
+  const config = configResponse.safeParse(options.config)
+  if (
+    !models.success ||
+    !agents.success ||
+    !defaultModel.success ||
+    !config.success ||
+    models.data.location.directory !== options.directory ||
+    agents.data.location.directory !== options.directory ||
+    defaultModel.data.location.directory !== options.directory ||
+    !defaultModel.data.data?.enabled ||
+    agents.data.data.length === 0
+  ) {
+    return null
+  }
+  // Installed 2.0.16 returns the selected default first; newer source has a different order.
+  const primary = agents.data.data.find((item) => item.mode !== 'subagent' && !item.hidden)
+  const configured = config.data.reduce<string | undefined>(
+    (value, entry) => entry.info?.default_agent ?? value,
+    undefined
+  )
+  const available = models.data.data.filter((item) => item.enabled)
+  if (
+    !primary ||
+    (configured !== undefined && primary.id !== configured) ||
+    !available.some(
+      (item) =>
+        item.id === defaultModel.data.data?.id &&
+        item.providerID === defaultModel.data.data?.providerID
+    )
+  ) {
+    return null
+  }
+  return {
+    primaryAgent: primary.id,
+    availableModels: available.map((item) => `${item.providerID}/${item.id}`),
+    primaryModel: primary.model ? `${primary.model.providerID}/${primary.model.id}` : null
+  }
+}
+
+export async function probeOpenCodeLaunchModelContext(options: {
+  executable: string
+  cwd: string
+  env: NodeJS.ProcessEnv
+  signal?: AbortSignal
+  expectedPrimaryAgent?: string
+  expectedPrimaryModel?: string
+}): Promise<OpenCodeLaunchModelContext | null> {
+  const password = randomBytes(32).toString('base64url')
+  const child = spawnProcess({
+    program: options.executable,
+    args: ['serve', '--hostname', '127.0.0.1', '--port', '0'],
+    cwd: options.cwd,
+    env: {
+      ...options.env,
+      OPENCODE_SERVER_USERNAME: 'opencode',
+      OPENCODE_SERVER_PASSWORD: password
+    },
+    detached: true
+  })
+  const output = createOutputSink(4096)
+  let childClosed = false
+  let rootExited = false
+  const closed = new Promise<boolean>((resolve) => {
+    child.once('close', () => {
+      childClosed = true
+      resolve(true)
+    })
+  })
+  let failed = false
+  child.on('error', () => {
+    failed = true
+  })
+  child.once('exit', () => {
+    rootExited = true
+    failed = true
+  })
+  child.stdout.on('data', output.write)
+  child.stdout.on('error', () => {
+    failed = true
+  })
+  child.stderr.on('error', () => {
+    failed = true
+  })
+  child.stderr.resume()
+  child.stdin.on('error', () => {
+    failed = true
+  })
+  child.stdin.end()
+  const signal = AbortSignal.any([
+    AbortSignal.timeout(10_000),
+    ...(options.signal ? [options.signal] : [])
+  ])
+  let context: OpenCodeLaunchModelContext | null = null
+  let stopped = false
+  try {
+    while (!failed && !signal.aborted && !output.truncated()) {
+      const address = output
+        .text()
+        .match(/^server listening on (http:\/\/127\.0\.0\.1:\d+)\s*$/m)?.[1]
+      if (address) {
+        const read = async (endpoint: string): Promise<unknown> => {
+          const url = new URL(`/api/${endpoint}`, address)
+          url.searchParams.set('location[directory]', options.cwd)
+          const response = await fetch(url, {
+            headers: {
+              Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString('base64')}`
+            },
+            redirect: 'error',
+            signal
+          })
+          try {
+            if (!response.ok) {
+              throw new Error('OpenCode model preflight refused')
+            }
+            return await readFetchResponseJsonWithinLimit<unknown>(response, 1_048_576)
+          } finally {
+            await cancelUnreadResponseBody(response)
+          }
+        }
+        const [models, agents, defaultModel, config] = await Promise.all([
+          read('model'),
+          read('agent'),
+          read('model/default'),
+          read('config')
+        ])
+        context = parseOpenCodeLaunchModelContext({
+          directory: options.cwd,
+          models,
+          agents,
+          defaultModel,
+          config
+        })
+        if (
+          context &&
+          (!options.expectedPrimaryAgent ||
+            context.primaryAgent === options.expectedPrimaryAgent) &&
+          (!options.expectedPrimaryModel || context.primaryModel === options.expectedPrimaryModel)
+        ) {
+          break
+        }
+        context = null
+      }
+      await delay(100, undefined, { signal })
+    }
+  } catch {
+    context = null
+  } finally {
+    if (!childClosed && !rootExited) {
+      await signalProcessTree(child, 'SIGTERM')
+    }
+    stopped = childClosed || (await withTimeout(closed, 1_500, false))
+    // A reaped root's PID can be reused while descendants still hold its pipes.
+    if (!stopped && !rootExited) {
+      stopped = await forceTerminateProcessTree(child)
+    }
+  }
+  return stopped ? context : null
+}
diff --git a/src/main/opencode/opencode-model-availability.test.ts b/src/main/opencode/opencode-model-availability.test.ts
new file mode 100644
index 00000000000..f8b3fdf552c
--- /dev/null
+++ b/src/main/opencode/opencode-model-availability.test.ts
@@ -0,0 +1,105 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { runProcess } from '../../shared/child-process/run-process'
+import { resolveCommandOnLocalPath } from '../ipc/command-path-resolver'
+import {
+  probeOpenCodeModelAvailability,
+  resolveOpenCodeDirectModelExecutable
+} from './opencode-model-availability'
+vi.mock('../../shared/child-process/run-process', () => ({ runProcess: vi.fn() }))
+vi.mock('../ipc/command-path-resolver', () => ({ resolveCommandOnLocalPath: vi.fn() }))
+const options = {
+  command: '/private/opencode',
+  model: 'opencode/fledge-alpha-free',
+  cwd: '/tmp/project',
+  env: { OPENCODE_CONFIG_DIR: '/private/config', XDG_DATA_HOME: '/private/account' }
+}
+describe('OpenCode model catalog validation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(resolveCommandOnLocalPath).mockResolvedValue('/resolved/opencode')
+    vi.mocked(runProcess).mockResolvedValue({
+      code: 0,
+      timedOut: false,
+      stdout: 'opencode/fledge-alpha-free\nopencode/big-pickle\n',
+      stderr: '',
+      signal: null
+    })
+  })
+  it('checks exact catalog membership using the execution scope', async () => {
+    expect(await probeOpenCodeModelAvailability(options)).toBe(true)
+    expect(runProcess).toHaveBeenCalledWith(
+      expect.objectContaining({
+        program: '/resolved/opencode',
+        args: ['models'],
+        cwd: options.cwd,
+        env: options.env
+      })
+    )
+  })
+  it('resolves the default PATH executable before checking model availability', async () => {
+    expect(await resolveOpenCodeDirectModelExecutable({ ...options, command: 'opencode' })).toBe(
+      '/resolved/opencode'
+    )
+    expect(resolveCommandOnLocalPath).toHaveBeenCalledWith('opencode', {
+      env: options.env,
+      cwd: options.cwd
+    })
+  })
+  it('rejects the real invalid selector that falls back to Big Pickle', async () => {
+    expect(await probeOpenCodeModelAvailability({ ...options, model: 'gpt-5-nano' })).toBe(false)
+  })
+  it('does not accept substrings or verbose metadata', async () => {
+    expect(await probeOpenCodeModelAvailability({ ...options, model: 'fledge-alpha-free' })).toBe(
+      false
+    )
+  })
+  it('refuses timed out catalog probes even with matching partial output', async () => {
+    vi.mocked(runProcess).mockResolvedValue({
+      code: 0,
+      timedOut: true,
+      stdout: options.model,
+      stderr: '',
+      signal: null
+    })
+    expect(await probeOpenCodeModelAvailability(options)).toBe(false)
+  })
+  it('refuses a truncated catalog even when its retained head contains the model', async () => {
+    vi.mocked(runProcess).mockResolvedValue({
+      code: 0,
+      timedOut: false,
+      outputTruncated: true,
+      stdout: `${options.model}\n`,
+      stderr: '',
+      signal: null
+    })
+    expect(await probeOpenCodeModelAvailability(options)).toBe(false)
+  })
+  it('refuses the unterminated catalog shape captured from OpenCode 2.0.16', async () => {
+    vi.mocked(runProcess).mockResolvedValue({
+      code: 0,
+      timedOut: false,
+      outputTruncated: false,
+      stdout: `${options.model}\npriv`,
+      stderr: '',
+      signal: null
+    })
+    expect(await probeOpenCodeModelAvailability(options)).toBe(false)
+  })
+  it.each(['\n', '\r\n'])('accepts a complete catalog with %j line endings', async (ending) => {
+    vi.mocked(runProcess).mockResolvedValue({
+      code: 0,
+      timedOut: false,
+      outputTruncated: false,
+      stdout: `${options.model}${ending}`,
+      stderr: '',
+      signal: null
+    })
+    expect(await probeOpenCodeModelAvailability(options)).toBe(true)
+  })
+  it('refuses WSL until its exact guest launch environment is available', async () => {
+    expect(await probeOpenCodeModelAvailability({ ...options, wsl: { distro: 'Ubuntu' } })).toBe(
+      false
+    )
+    expect(runProcess).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/main/opencode/opencode-model-availability.ts b/src/main/opencode/opencode-model-availability.ts
new file mode 100644
index 00000000000..ce507de9969
--- /dev/null
+++ b/src/main/opencode/opencode-model-availability.ts
@@ -0,0 +1,59 @@
+import { resolveStartupShell, tokenizeStartupCommand } from '../../shared/tui-agent-startup-shell'
+import { runProcess } from '../../shared/child-process/run-process'
+import { resolveCommandOnLocalPath } from '../ipc/command-path-resolver'
+
+export async function resolveOpenCodeDirectModelExecutable(options: {
+  command: string | undefined
+  model: string
+  env: NodeJS.ProcessEnv
+  cwd?: string
+  wsl?: { distro?: string }
+}): Promise<string | null> {
+  // WSL needs the same guest account/profile environment as its actual launch.
+  if (options.wsl || !options.cwd) {
+    return null
+  }
+  const parsed = tokenizeStartupCommand(
+    options.command ?? '',
+    resolveStartupShell(process.platform)
+  )
+  if (
+    !parsed.ok ||
+    parsed.tokens.length !== 1 ||
+    parsed.spans.some((span) => span.divergesFromShell)
+  ) {
+    return null
+  }
+  return resolveCommandOnLocalPath(parsed.tokens[0], {
+    env: options.env,
+    cwd: options.cwd
+  })
+}
+
+export async function probeOpenCodeModelAvailability(
+  options: Parameters<typeof resolveOpenCodeDirectModelExecutable>[0]
+): Promise<boolean> {
+  const executable = await resolveOpenCodeDirectModelExecutable(options)
+  if (!executable) {
+    return false
+  }
+  try {
+    const result = await runProcess({
+      program: executable,
+      args: ['models'],
+      cwd: options.cwd,
+      env: options.env,
+      timeoutMs: 10_000,
+      maxOutputBytes: 1_048_576
+    })
+    return (
+      result.code === 0 &&
+      !result.timedOut &&
+      !result.outputTruncated &&
+      result.stdout.endsWith('\n') &&
+      result.stdout.split(/\r?\n/).some((line) => line === options.model)
+    )
+  } catch {
+    return false
+  }
+}
diff --git a/src/main/opencode/opencode-model-startup-plan.test.ts b/src/main/opencode/opencode-model-startup-plan.test.ts
new file mode 100644
index 00000000000..46771e630bc
--- /dev/null
+++ b/src/main/opencode/opencode-model-startup-plan.test.ts
@@ -0,0 +1,216 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { resolveAgentStartupPlanInputs } from '../../shared/agent-startup-plan-inputs'
+import { applyManagedDataAccountEnvironment } from '../managed-data-accounts/launch-environment'
+import { probeOpenCodeLaunchCapabilities } from './opencode-launch-capabilities'
+import {
+  probeOpenCodeModelAvailability,
+  resolveOpenCodeDirectModelExecutable
+} from './opencode-model-availability'
+import { probeOpenCodeLaunchModelContext } from './opencode-launch-model-context'
+import { buildExecutionHostAgentStartupPlan } from './opencode-model-startup-plan'
+
+vi.mock('../managed-data-accounts/launch-environment', () => ({
+  applyManagedDataAccountEnvironment: vi.fn()
+}))
+vi.mock('./opencode-launch-capabilities', () => ({ probeOpenCodeLaunchCapabilities: vi.fn() }))
+vi.mock('./opencode-model-availability', () => ({
+  resolveOpenCodeDirectModelExecutable: vi.fn(),
+  probeOpenCodeModelAvailability: vi.fn()
+}))
+vi.mock('./opencode-launch-model-context', () => ({ probeOpenCodeLaunchModelContext: vi.fn() }))
+
+const preferred = 'opencode/fledge-alpha-free'
+const original = JSON.stringify({
+  default_agent: 'reviewer',
+  providers: { custom: { apiKey: 'placeholder' } },
+  agents: { reviewer: { system: 'Review only', model: 'opencode/big-pickle' } }
+})
+function scope() {
+  return {
+    inputs: resolveAgentStartupPlanInputs({
+      agent: 'opencode',
+      settings: {
+        agentCmdOverrides: {},
+        agentDefaultEnv: { opencode: { OPENCODE_CONFIG_CONTENT: original } }
+      },
+      platform: process.platform,
+      isRemote: false,
+      sessionOptions: { model: preferred }
+    }),
+    cwd: '/private/project',
+    prompt: 'Read only',
+    hostIdentity: 'host'
+  }
+}
+
+describe('execution-host OpenCode model startup', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.mocked(resolveOpenCodeDirectModelExecutable).mockResolvedValue('/private/opencode')
+    vi.mocked(probeOpenCodeLaunchCapabilities).mockResolvedValue({
+      version: '2.0.16',
+      pluginApi: 'v2',
+      promptMode: 'prefill'
+    })
+    vi.mocked(probeOpenCodeModelAvailability).mockResolvedValue(true)
+    vi.mocked(probeOpenCodeLaunchModelContext)
+      .mockResolvedValueOnce({
+        primaryAgent: 'reviewer',
+        availableModels: [preferred],
+        primaryModel: 'opencode/big-pickle'
+      })
+      .mockResolvedValue({
+        primaryAgent: 'reviewer',
+        availableModels: [preferred],
+        primaryModel: preferred
+      })
+  })
+
+  it('refuses unsupported effort preferences before probing or dropping them', async () => {
+    const options = scope()
+    options.inputs.sessionOptions = { model: preferred, effort: 'high' }
+    await expect(buildExecutionHostAgentStartupPlan(options)).rejects.toMatchObject({
+      code: 'capability_unsupported'
+    })
+    expect(probeOpenCodeLaunchModelContext).not.toHaveBeenCalled()
+    expect(probeOpenCodeLaunchCapabilities).not.toHaveBeenCalled()
+  })
+
+  it('launches current v2 in isolation and keeps one-time model preferences out of resume state', async () => {
+    const options = scope()
+    const plan = await buildExecutionHostAgentStartupPlan(options)
+    expect(plan?.launchCommand).toContain('--standalone')
+    expect(plan?.launchCommand).not.toContain('--model')
+    expect(plan?.sessionOptions).toEqual({ model: preferred })
+    expect(JSON.parse(plan?.env?.OPENCODE_CONFIG_CONTENT ?? 'null')).toEqual({
+      default_agent: 'reviewer',
+      model: preferred,
+      providers: { custom: { apiKey: 'placeholder' } },
+      agents: { reviewer: { system: 'Review only', model: preferred } }
+    })
+    expect(plan?.launchConfig).toEqual({
+      agentCommand: 'opencode',
+      agentArgs: '',
+      agentEnv: { OPENCODE_CONFIG_CONTENT: original }
+    })
+    expect(options.inputs.agentEnv.OPENCODE_CONFIG_CONTENT).toBe(original)
+  })
+
+  it('uses the selected account environment in both authoritative probes', async () => {
+    vi.mocked(applyManagedDataAccountEnvironment).mockImplementation((env) => {
+      env.XDG_DATA_HOME = '/selected/data'
+      env.OPENCODE_DB = 'opencode.db'
+    })
+    await buildExecutionHostAgentStartupPlan(scope())
+    for (const call of vi.mocked(probeOpenCodeLaunchModelContext).mock.calls) {
+      expect(call[0].env).toMatchObject({
+        XDG_DATA_HOME: '/selected/data',
+        OPENCODE_DB: 'opencode.db'
+      })
+    }
+  })
+
+  it.each(['1.18.30', '1.18.32'])(
+    'preserves the verified legacy launch route %s',
+    async (version) => {
+      vi.mocked(probeOpenCodeLaunchCapabilities).mockResolvedValue({
+        version,
+        pluginApi: 'v1',
+        promptMode: 'submit'
+      })
+      expect((await buildExecutionHostAgentStartupPlan(scope()))?.launchCommand).toContain(
+        '--model'
+      )
+      expect(probeOpenCodeLaunchModelContext).not.toHaveBeenCalled()
+    }
+  )
+
+  it('preserves ordinary launches without any private server probe', async () => {
+    const options = scope()
+    options.inputs.sessionOptions = undefined
+    expect((await buildExecutionHostAgentStartupPlan(options))?.launchCommand).not.toContain(
+      '--standalone'
+    )
+    expect(probeOpenCodeLaunchCapabilities).not.toHaveBeenCalled()
+  })
+
+  it.each(['--agent build', '--continue', '--server http://localhost'])(
+    'refuses current-v2 manual launch arguments %s',
+    async (agentArgs) => {
+      const options = scope()
+      options.inputs.agentArgs = agentArgs
+      await expect(buildExecutionHostAgentStartupPlan(options)).rejects.toMatchObject({
+        code: 'capability_unsupported'
+      })
+      expect(probeOpenCodeLaunchModelContext).not.toHaveBeenCalled()
+    }
+  )
+
+  it('refuses unavailable models and mismatched observed model preferences', async () => {
+    vi.mocked(probeOpenCodeLaunchModelContext)
+      .mockReset()
+      .mockResolvedValue({ primaryAgent: 'reviewer', availableModels: [], primaryModel: null })
+    await expect(buildExecutionHostAgentStartupPlan(scope())).rejects.toMatchObject({
+      code: 'capability_unsupported'
+    })
+    vi.mocked(probeOpenCodeLaunchModelContext)
+      .mockReset()
+      .mockResolvedValue({
+        primaryAgent: 'reviewer',
+        availableModels: [preferred],
+        primaryModel: 'opencode/big-pickle'
+      })
+    await expect(buildExecutionHostAgentStartupPlan(scope())).rejects.toMatchObject({
+      code: 'capability_unsupported'
+    })
+  })
+
+  it('refuses remote and WSL execution before touching the local binary', async () => {
+    const options = scope()
+    options.inputs.isRemote = true
+    await expect(buildExecutionHostAgentStartupPlan(options)).rejects.toMatchObject({
+      code: 'capability_unsupported'
+    })
+    options.inputs.isRemote = false
+    await expect(
+      buildExecutionHostAgentStartupPlan({ ...options, isWsl: true })
+    ).rejects.toMatchObject({ code: 'capability_unsupported' })
+    expect(resolveOpenCodeDirectModelExecutable).not.toHaveBeenCalled()
+  })
+
+  it.each(['1.18.31', '1.18.33', '2.0.17'])(
+    'refuses unverified version %s before model probing',
+    async (version) => {
+      vi.mocked(probeOpenCodeLaunchCapabilities).mockResolvedValue({
+        version,
+        pluginApi: 'v2',
+        promptMode: 'prefill'
+      })
+      await expect(buildExecutionHostAgentStartupPlan(scope())).rejects.toMatchObject({
+        code: 'capability_unsupported'
+      })
+      expect(probeOpenCodeLaunchModelContext).not.toHaveBeenCalled()
+      expect(probeOpenCodeModelAvailability).not.toHaveBeenCalled()
+    }
+  )
+
+  it('resolves the default bare launch command through the execution host', async () => {
+    await buildExecutionHostAgentStartupPlan(scope())
+    expect(resolveOpenCodeDirectModelExecutable).toHaveBeenCalledWith(
+      expect.objectContaining({ command: 'opencode' })
+    )
+  })
+
+  it.each(['blank-model', 'effort-only'])(
+    'refuses invalid preferences before probing',
+    async (scenario) => {
+      const options = scope()
+      options.inputs.sessionOptions =
+        scenario === 'blank-model' ? { model: '' } : { effort: 'high' }
+      await expect(buildExecutionHostAgentStartupPlan(options)).rejects.toMatchObject({
+        code: 'capability_unsupported'
+      })
+      expect(resolveOpenCodeDirectModelExecutable).not.toHaveBeenCalled()
+    }
+  )
+})
diff --git a/src/main/opencode/opencode-model-startup-plan.ts b/src/main/opencode/opencode-model-startup-plan.ts
new file mode 100644
index 00000000000..f0878bd5177
--- /dev/null
+++ b/src/main/opencode/opencode-model-startup-plan.ts
@@ -0,0 +1,175 @@
+import type { AgentStartupPlanInputs } from '../../shared/agent-startup-plan-inputs'
+import { buildAgentDraftLaunchPlan, buildAgentStartupPlan } from '../../shared/tui-agent-startup'
+import { buildSleepingAgentLaunchConfig } from '../../shared/sleeping-agent-launch-config'
+import type { SleepingAgentLaunchConfig } from '../../shared/agent-session-resume'
+import type { TuiAgent } from '../../shared/tui-agent'
+import { probeOpenCodeLaunchModelContext } from './opencode-launch-model-context'
+import { resolveOpenCodeLaunchModelConfig } from './opencode-launch-model-config'
+import { isVerifiedOpenCodeLegacyModelVersion } from './opencode-model-version-policy'
+import { getTuiAgentLaunchCommand, TUI_AGENT_CONFIG } from '../../shared/tui-agent-config'
+import { applyManagedDataAccountEnvironment } from '../managed-data-accounts/launch-environment'
+import { OrchestrationError } from '../runtime/orchestration/orchestration-error'
+import { probeOpenCodeLaunchCapabilities } from './opencode-launch-capabilities'
+import {
+  probeOpenCodeModelAvailability,
+  resolveOpenCodeDirectModelExecutable
+} from './opencode-model-availability'
+
+type StartupScope = {
+  inputs: AgentStartupPlanInputs
+  cwd: string
+  isWsl?: boolean
+  hostIdentity?: string
+  signal?: AbortSignal
+}
+
+function refuseModel(): never {
+  throw new OrchestrationError(
+    'capability_unsupported',
+    'The execution host cannot verify this OpenCode model launch.'
+  )
+}
+
+export async function prepareOpenCodeModelStartupInputs(
+  options: StartupScope
+): Promise<{ inputs: AgentStartupPlanInputs; launchConfig?: SleepingAgentLaunchConfig }> {
+  const { inputs } = options
+  const model = inputs.sessionOptions?.model
+  if (
+    inputs.agent !== 'opencode' ||
+    !Object.values(inputs.sessionOptions ?? {}).some((value) => value !== undefined)
+  ) {
+    return { inputs }
+  }
+  if (typeof model !== 'string' || model.trim().length === 0) {
+    refuseModel()
+  }
+  if (
+    Object.entries(inputs.sessionOptions ?? {}).some(
+      ([key, value]) => key !== 'model' && value !== undefined
+    ) ||
+    inputs.isRemote ||
+    options.isWsl ||
+    inputs.platform !== process.platform ||
+    options.signal?.aborted
+  ) {
+    refuseModel()
+  }
+  const command =
+    inputs.cmdOverrides.opencode ||
+    getTuiAgentLaunchCommand(TUI_AGENT_CONFIG.opencode, inputs.platform)
+  const env: Record<string, string> = {}
+  for (const [key, value] of Object.entries({ ...process.env, ...inputs.agentEnv })) {
+    if (value !== undefined) {
+      env[key] = value
+    }
+  }
+  applyManagedDataAccountEnvironment(env, { launchAgent: 'opencode' })
+  const executable = await resolveOpenCodeDirectModelExecutable({
+    command,
+    model,
+    cwd: options.cwd,
+    env
+  })
+  if (!executable) {
+    refuseModel()
+  }
+  const capabilities = await probeOpenCodeLaunchCapabilities({
+    command,
+    agent: 'opencode',
+    cwd: options.cwd,
+    env,
+    hostIdentity: options.hostIdentity
+  })
+  if (isVerifiedOpenCodeLegacyModelVersion(capabilities?.version)) {
+    if (!(await probeOpenCodeModelAvailability({ command, model, cwd: options.cwd, env }))) {
+      refuseModel()
+    }
+    return { inputs }
+  }
+  if (capabilities?.version !== '2.0.16' || inputs.agentArgs?.trim()) {
+    refuseModel()
+  }
+  const before = await probeOpenCodeLaunchModelContext({
+    executable,
+    cwd: options.cwd,
+    env,
+    signal: options.signal
+  }).catch(() => null)
+  if (!before?.availableModels.includes(model)) {
+    refuseModel()
+  }
+  const configContent = resolveOpenCodeLaunchModelConfig({
+    configContent: env.OPENCODE_CONFIG_CONTENT,
+    primaryAgent: before.primaryAgent,
+    model
+  })
+  if (configContent === null) {
+    refuseModel()
+  }
+  const after = await probeOpenCodeLaunchModelContext({
+    executable,
+    cwd: options.cwd,
+    env: { ...env, OPENCODE_CONFIG_CONTENT: configContent },
+    expectedPrimaryAgent: before.primaryAgent,
+    expectedPrimaryModel: model,
+    signal: options.signal
+  }).catch(() => null)
+  if (
+    after?.primaryAgent !== before.primaryAgent ||
+    after.primaryModel !== model ||
+    !after.availableModels.includes(model)
+  ) {
+    refuseModel()
+  }
+  return {
+    inputs: {
+      ...inputs,
+      agentArgs: '--standalone',
+      agentEnv: { ...inputs.agentEnv, OPENCODE_CONFIG_CONTENT: configContent },
+      sessionOptions: undefined
+    },
+    launchConfig: buildSleepingAgentLaunchConfig({
+      agentCommand: command,
+      agentArgs: inputs.agentArgs,
+      agentEnv: inputs.agentEnv
+    })
+  }
+}
+
+export async function buildExecutionHostAgentStartupPlan(
+  options: StartupScope & {
+    prompt: string
+    promptDelivery?: 'auto-submit' | 'draft'
+  }
+) {
+  const prepared = await prepareOpenCodeModelStartupInputs(options)
+  if (prepared.launchConfig && options.promptDelivery === 'draft') {
+    refuseModel()
+  }
+  const plan =
+    options.promptDelivery === 'draft'
+      ? buildAgentDraftLaunchPlan({ ...prepared.inputs, draft: options.prompt })
+      : buildAgentStartupPlan({
+          ...prepared.inputs,
+          prompt: options.prompt,
+          allowEmptyPromptLaunch: true
+        })
+  if (plan && prepared.launchConfig) {
+    plan.launchConfig = prepared.launchConfig
+    plan.sessionOptions = { ...options.inputs.sessionOptions }
+  }
+  return plan
+}
+
+export function assertOpenCodeModelLaunchPreferencesAbsent(
+  agent: TuiAgent | undefined,
+  preferences: Readonly<Record<string, unknown>> | undefined
+): void {
+  if (
+    agent === 'opencode' &&
+    Object.values(preferences ?? {}).some((value) => value !== undefined)
+  ) {
+    refuseModel()
+  }
+}
diff --git a/src/main/opencode/opencode-model-version-policy.test.ts b/src/main/opencode/opencode-model-version-policy.test.ts
new file mode 100644
index 00000000000..8c8c4f7247e
--- /dev/null
+++ b/src/main/opencode/opencode-model-version-policy.test.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+import { isVerifiedOpenCodeLegacyModelVersion } from './opencode-model-version-policy'
+
+describe('verified legacy OpenCode model versions', () => {
+  it.each(['1.18.30', '1.18.32'])('supports the verified model semantics of %s', (version) => {
+    expect(isVerifiedOpenCodeLegacyModelVersion(version)).toBe(true)
+  })
+
+  it.each([null, undefined, '1.18.29', '1.18.31', '1.18.33', '1.18.32-beta', '2.0.16'])(
+    'keeps unverified version %s unsupported',
+    (version) => {
+      expect(isVerifiedOpenCodeLegacyModelVersion(version)).toBe(false)
+    }
+  )
+})
diff --git a/src/main/opencode/opencode-model-version-policy.ts b/src/main/opencode/opencode-model-version-policy.ts
new file mode 100644
index 00000000000..e741a50f89e
--- /dev/null
+++ b/src/main/opencode/opencode-model-version-policy.ts
@@ -0,0 +1,6 @@
+const VERIFIED_LEGACY_MODEL_VERSIONS = new Set(['1.18.30', '1.18.32'])
+
+export function isVerifiedOpenCodeLegacyModelVersion(version: string | null | undefined): boolean {
+  // Plugin API compatibility alone does not verify model selection or invalid-model behavior.
+  return typeof version === 'string' && VERIFIED_LEGACY_MODEL_VERSIONS.has(version)
+}
diff --git a/src/main/opencode/opencode-pty-launch.test.ts b/src/main/opencode/opencode-pty-launch.test.ts
index 854882d287f..21ec4ee0936 100644
--- a/src/main/opencode/opencode-pty-launch.test.ts
+++ b/src/main/opencode/opencode-pty-launch.test.ts
@@ -91,32 +91,40 @@ describe('execution-host OpenCode launch preparation', () => {
     expect(finalEnv.OPENCODE_CONFIG_DIR).toBe('/private/owned-overlay')
     expect(finalEnv.ORCA_OPENCODE_SOURCE_CONFIG_DIR).toBe('/private/real-source')
   })
-  it('removes only the automatic verified v2 prompt argument, retaining explicit run and manual flags', async () => {
-    probe.mockResolvedValue(getOpenCodeCliCapabilities('2.0.16'))
-    const env = {
-      ORCA_AGENT_LAUNCH_TOKEN: 'admitted-launch',
-      [OPENCODE_STARTUP_PROMPT_SHA256_ENV]: createHash('sha256').update('task').digest('hex'),
-      [OPENCODE_STARTUP_PROMPT_BODY_ENV]: 'task',
-      [OPENCODE_STARTUP_PROMPT_SHELL_ENV]: 'posix'
+  it.each(['2.0.12', '2.0.16'])(
+    'removes only the automatic %s prompt argument, retaining explicit run and manual flags',
+    async (version) => {
+      probe.mockResolvedValue(getOpenCodeCliCapabilities(version))
+      const env = {
+        ORCA_AGENT_LAUNCH_TOKEN: 'admitted-launch',
+        [OPENCODE_STARTUP_PROMPT_SHA256_ENV]: createHash('sha256').update('task').digest('hex'),
+        [OPENCODE_STARTUP_PROMPT_BODY_ENV]: 'task',
+        [OPENCODE_STARTUP_PROMPT_SHELL_ENV]: 'posix'
+      }
+      const options = { env, envToDelete: [], isFreshLaunch: true }
+      expect(
+        (
+          await prepareOpenCodePtyLaunch({
+            ...options,
+            command: "opencode --standalone --prompt 'task'"
+          })
+        ).command
+      ).toBe('opencode --standalone')
+      expect(
+        (await prepareOpenCodePtyLaunch({ ...options, command: "opencode run --prompt 'task'" }))
+          .command
+      ).toBe("opencode run --prompt 'task'")
+      expect(
+        (
+          await prepareOpenCodePtyLaunch({
+            ...options,
+            env: {},
+            command: "opencode --prompt 'task'"
+          })
+        ).command
+      ).toBe("opencode --prompt 'task'")
     }
-    const options = { env, envToDelete: [], isFreshLaunch: true }
-    expect(
-      (
-        await prepareOpenCodePtyLaunch({
-          ...options,
-          command: "opencode --standalone --prompt 'task'"
-        })
-      ).command
-    ).toBe('opencode --standalone')
-    expect(
-      (await prepareOpenCodePtyLaunch({ ...options, command: "opencode run --prompt 'task'" }))
-        .command
-    ).toBe("opencode run --prompt 'task'")
-    expect(
-      (await prepareOpenCodePtyLaunch({ ...options, env: {}, command: "opencode --prompt 'task'" }))
-        .command
-    ).toBe("opencode --prompt 'task'")
-  })
+  )
   it.each(['inherited', 'explicit', 'deleted'] as const)(
     'passes the %s config environment used by the execution-host version probe to the prompt installer',
     async (selection) => {
@@ -178,9 +186,16 @@ describe('execution-host OpenCode launch preparation', () => {
       expect(result.env).not.toHaveProperty('ORCA_OPENCODE_STARTUP_PROMPT_NONCE')
     }
   )
-  it.each(['1.1.23', '2.0.16', '2.0.17', 'unknown'])(
-    'gates native intent against the executing %s capability',
-    async (version) => {
+  it.each([
+    { version: '1.1.23', nativeIntent: false },
+    { version: '2.0.12', nativeIntent: true },
+    { version: '2.0.16', nativeIntent: true },
+    { version: '2.0.17', nativeIntent: false },
+    { version: '2.0.21', nativeIntent: false },
+    { version: 'unknown', nativeIntent: false }
+  ])(
+    'gates native intent against the executing $version capability',
+    async ({ version, nativeIntent }) => {
       probe.mockResolvedValue(getOpenCodeCliCapabilities(version))
       const envToDelete: string[] = []
       const fingerprint = createHash('sha256').update('task').digest('hex')
@@ -195,10 +210,8 @@ describe('execution-host OpenCode launch preparation', () => {
         envToDelete,
         isFreshLaunch: true
       })
-      expect(env?.[OPENCODE_STARTUP_PROMPT_SHA256_ENV]).toBe(
-        version === '2.0.16' ? fingerprint : undefined
-      )
-      expect(envToDelete.includes(OPENCODE_STARTUP_PROMPT_SHA256_ENV)).toBe(version !== '2.0.16')
+      expect(env?.[OPENCODE_STARTUP_PROMPT_SHA256_ENV]).toBe(nativeIntent ? fingerprint : undefined)
+      expect(envToDelete.includes(OPENCODE_STARTUP_PROMPT_SHA256_ENV)).toBe(!nativeIntent)
     }
   )
 
@@ -266,7 +279,7 @@ describe('execution-host OpenCode launch preparation', () => {
     expect(finalEnv).not.toHaveProperty('KEEP_DELETED')
   })
 
-  it.each(['1.1.23', '2.0.16'])(
+  it.each(['1.1.23', '2.0.12', '2.0.16'])(
     'selects the probed %s plugin for the execution host',
     async (version) => {
       const capabilities = getOpenCodeCliCapabilities(version)
diff --git a/src/main/opencode/opencode-startup-prompt-source.test.ts b/src/main/opencode/opencode-startup-prompt-source.test.ts
index 2e505ee2a8f..ec241a35a6b 100644
--- a/src/main/opencode/opencode-startup-prompt-source.test.ts
+++ b/src/main/opencode/opencode-startup-prompt-source.test.ts
@@ -42,7 +42,7 @@ class Editor extends EventEmitter {
 
 type FixtureLocation = { directory: string; workspaceID?: string }
 
-function fixture() {
+function fixture(version = '2.0.16') {
   const editor = new Editor()
   const input = new EventEmitter()
   const memory = { settled: false, expiresAt: Date.now() + 20000 }
@@ -52,7 +52,7 @@ function fixture() {
   const sync = vi.fn(async (_location: FixtureLocation) => {})
   const dispatch = vi.fn(() => editor.replace(''))
   const ctx = {
-    app: { version: '2.0.16' },
+    app: { version },
     renderer: { keyInput: input, currentFocusedEditor: editor },
     storage: { memory: () => [memory, (mutate: (draft: typeof memory) => void) => mutate(memory)] },
     keymap: { dispatch },
@@ -90,6 +90,41 @@ afterEach(() => {
 })
 
 describe('installed-version native prompt intent plugin', () => {
+  it.each(['2.0.12', '2.0.16'])(
+    'hydrates the source-reviewed %s location and delivers the same intent only once',
+    async (version) => {
+      const f = fixture(version)
+      let hydrate = () => {}
+      f.sync.mockImplementation(
+        () =>
+          new Promise<void>((resolve) => {
+            hydrate = resolve
+          })
+      )
+      const insert = vi.spyOn(f.editor, 'insertText')
+      const dispose = await setup(f.ctx)
+      try {
+        await vi.advanceTimersByTimeAsync(500)
+        expect(f.sync).toHaveBeenCalledExactlyOnceWith(f.ctx.location)
+        expect(claim).not.toHaveBeenCalled()
+        expect(insert).not.toHaveBeenCalled()
+        hydrate()
+        await vi.advanceTimersByTimeAsync(1000)
+        await vi.waitFor(() => expect(claim).toHaveBeenCalledTimes(1))
+        expect(insert).toHaveBeenCalledExactlyOnceWith(prompt)
+        expect(f.dispatch).toHaveBeenCalledExactlyOnceWith('prompt.submit')
+        expect(f.memory.settled).toBe(true)
+        const reloadDispose = await setup(f.ctx)
+        await vi.advanceTimersByTimeAsync(500)
+        expect(claim).toHaveBeenCalledTimes(1)
+        expect(f.dispatch).toHaveBeenCalledTimes(1)
+        await reloadDispose()
+      } finally {
+        await dispose()
+      }
+    }
+  )
+
   it('waits for the current home location after the startup directory changes', async () => {
     const f = fixture()
     let location: FixtureLocation = { directory: '/private/home/private-folder' }
diff --git a/src/main/opencode/opencode-startup-prompt-source.ts b/src/main/opencode/opencode-startup-prompt-source.ts
index 4bb37861102..94e08869d6d 100644
--- a/src/main/opencode/opencode-startup-prompt-source.ts
+++ b/src/main/opencode/opencode-startup-prompt-source.ts
@@ -1,3 +1,4 @@
+import { OPENCODE_NATIVE_PROMPT_VERSIONS } from '../../shared/opencode-cli-version'
 import { cancelUnreadResponseBody } from '../lib/unread-response-body'
 import { parseAgentHookEndpointFile } from '../../shared/agent-hook-endpoint-file'
 import {
@@ -40,7 +41,7 @@ async function submitStartupPrompt(ctx) {
   const nonce = process.env.${OPENCODE_STARTUP_PROMPT_NONCE_ENV};
   const endpoint = process.env.${OPENCODE_STARTUP_PROMPT_ENDPOINT_ENV};
   const prompt = process.env.${OPENCODE_STARTUP_PROMPT_BODY_ENV};
-  if (ctx?.app?.version !== "2.0.16" || !/^[a-f0-9]{64}$/.test(digest || "") || !nonce || !endpoint || !prompt) return noop;
+  if (!${JSON.stringify(OPENCODE_NATIVE_PROMPT_VERSIONS)}.includes(ctx?.app?.version) || !/^[a-f0-9]{64}$/.test(digest || "") || !nonce || !endpoint || !prompt) return noop;
   const input = ctx.renderer?.keyInput;
   if (typeof ctx.storage?.memory !== "function" || typeof input?.on !== "function" ||
       typeof input?.off !== "function" || typeof ctx.keymap?.dispatch !== "function" ||
diff --git a/src/main/persistence/loading-store/pty-binding-persistence.ts b/src/main/persistence/loading-store/pty-binding-persistence.ts
index c90544f7502..c75d238dee8 100644
--- a/src/main/persistence/loading-store/pty-binding-persistence.ts
+++ b/src/main/persistence/loading-store/pty-binding-persistence.ts
@@ -4,6 +4,8 @@ import { isTerminalLeafId } from '../../../shared/stable-pane-id'
 import type { WorkspaceSessionState } from '../../../shared/workspace-session-state-types'
 import { rollbackFailedPtyBinding } from './pty-binding-write-rollback'
 import { cloneWorkspaceSessionState } from '../restoring-sessions/session-owner-fields'
+import { rollbackWorkspaceSessionAfterFailedAsyncWrite } from '../restoring-sessions/workspace-session-write-rollback'
+import { clearReplacedPaneBinding } from './replaced-pane-binding'
 
 import type { PtyBindingSourceExpectation } from './store'
 
@@ -67,6 +69,59 @@ export class PtyBindingPersistenceOperations {
     this[ptyBindingPersistenceOperationsContext] = { runtime, sessions }
   }
 
+  /** Clears a stopped process's binding, keeping the pane; fenced on the id, which is dead in any incarnation. */
+  async retirePtyBinding(
+    binding: Pick<PersistPtyBindingArgs, 'worktreeId' | 'tabId' | 'leafId' | 'ptyId'>,
+    hostId?: string | null
+  ): Promise<boolean> {
+    const { runtime, sessions } = this[ptyBindingPersistenceOperationsContext]
+    const resolved = resolveHostId(hostId)
+    const publish = (session: WorkspaceSessionState): void => {
+      if (resolved === LOCAL_EXECUTION_HOST_ID) {
+        runtime.state.workspaceSession = session
+      } else {
+        runtime.state.workspaceSessionsByHostId = {
+          ...runtime.state.workspaceSessionsByHostId,
+          [resolved]: session
+        }
+      }
+      runtime.dirtyProfileStateDomains?.add(
+        resolved === LOCAL_EXECUTION_HOST_ID ? 'workspaceSession' : 'workspaceSessionsByHostId'
+      )
+    }
+    return runtime.runDurableMutation(() => {
+      const session = sessions.getWorkspaceSession(resolved)
+      const currentId =
+        session.terminalLayoutsByTabId[binding.tabId]?.ptyIdsByLeafId?.[binding.leafId]
+      if (!currentId) {
+        return { value: true, persist: 'if-dirty' }
+      }
+      if (currentId !== binding.ptyId) {
+        return { value: false, persist: false }
+      }
+      if (!session.tabsByWorktree[binding.worktreeId]?.some((tab) => tab.id === binding.tabId)) {
+        return { value: false, persist: false }
+      }
+      const before = cloneWorkspaceSessionState(session)
+      const retired = clearReplacedPaneBinding(session, { ...binding, parentTabId: binding.tabId })
+      // Host retirement must not run renderer snapshot repair, which would put the old binding back.
+      publish(retired)
+      const staged = cloneWorkspaceSessionState(retired)
+      return {
+        value: true,
+        rollback: () => {
+          publish(
+            rollbackWorkspaceSessionAfterFailedAsyncWrite(
+              before,
+              staged,
+              sessions.getWorkspaceSession(resolved)
+            )
+          )
+        }
+      }
+    })
+  }
+
   async persistPtyBinding(
     input: PersistPtyBindingArgs | (() => PersistPtyBindingArgs | null),
     hostId?: string | null
diff --git a/src/main/persistence/loading-store/pty-binding-restart-retirement.test.ts b/src/main/persistence/loading-store/pty-binding-restart-retirement.test.ts
new file mode 100644
index 00000000000..2f34af1fb0d
--- /dev/null
+++ b/src/main/persistence/loading-store/pty-binding-restart-retirement.test.ts
@@ -0,0 +1,83 @@
+import { expect, it, vi } from 'vitest'
+import { fixture } from './profile-state-delayed-authority-fixture'
+import { TEST_LEAF_1 } from '../../persistence-session-fixtures'
+import { ProfileStateWriterError } from '../profile-state/profile-state-writer-errors'
+
+vi.mock('../../telemetry/client', () => ({ track: vi.fn() }))
+vi.mock('../../telemetry/cohort-classifier', () => ({
+  getCohortAtEmit: () => ({ nth_repo_added: 2 })
+}))
+vi.mock('../../ssh/ssh-config-parser', () => ({
+  loadUserSshConfig: () => ({ hosts: [] }),
+  sshConfigHostsToTargets: () => []
+}))
+
+const binding = {
+  worktreeId: 'repo-local::/fixture/local',
+  tabId: 'restart-tab',
+  leafId: TEST_LEAF_1,
+  ptyId: 'old',
+  incarnationId: 'old-incarnation'
+}
+
+it.each([undefined, 'ssh:restart'])(
+  'durably retires only the process binding on %s',
+  async (hostId) => {
+    const { store, readState } = await fixture()
+    await store.persistPtyBinding(binding, hostId)
+    const before = structuredClone(store.getWorkspaceSession(hostId))
+    expect(await store.retirePtyBinding(binding, hostId)).toBe(true)
+    const retired = store.getWorkspaceSession(hostId)
+    expect(retired.terminalLayoutsByTabId[binding.tabId]).toEqual({
+      ...before.terminalLayoutsByTabId[binding.tabId],
+      ptyIdsByLeafId: {}
+    })
+    expect(retired.tabsByWorktree[binding.worktreeId]).toEqual(
+      before.tabsByWorktree[binding.worktreeId].map((tab) =>
+        tab.id === binding.tabId ? { ...tab, ptyId: null } : tab
+      )
+    )
+    const durable = hostId
+      ? readState().workspaceSessionsByHostId?.[hostId]
+      : readState().workspaceSession
+    expect(durable?.terminalLayoutsByTabId[binding.tabId].ptyIdsByLeafId).toEqual({})
+    await store.persistPtyBinding(
+      { ...binding, ptyId: 'new', incarnationId: 'new-incarnation' },
+      hostId
+    )
+    expect(await store.retirePtyBinding(binding, hostId)).toBe(false)
+    expect(
+      store.getWorkspaceSession(hostId).terminalLayoutsByTabId[binding.tabId].ptyIdsByLeafId?.[
+        binding.leafId
+      ]
+    ).toBe('new')
+  }
+)
+
+it('clears the stopped id whatever incarnation the binding carries', async () => {
+  const { store } = await fixture()
+  await store.persistPtyBinding({ ...binding, incarnationId: 'republished-incarnation' })
+  expect(await store.retirePtyBinding(binding)).toBe(true)
+  expect(store.getWorkspaceSession().terminalLayoutsByTabId[binding.tabId].ptyIdsByLeafId).toEqual(
+    {}
+  )
+})
+
+it('restores the old binding after a known save failure and allows another attempt', async () => {
+  const { store, authority } = await fixture()
+  vi.spyOn(console, 'error').mockImplementation(() => {})
+  await store.persistPtyBinding(binding)
+  const gate = authority.pause()
+  const rejected = expect(store.retirePtyBinding(binding)).rejects.toThrow('disk refused')
+  await gate.started.promise
+  gate.finish.reject(
+    new ProfileStateWriterError('test-disk-failure', 'disk refused', 'known-failure')
+  )
+  await rejected
+  expect(
+    store.getWorkspaceSession().terminalLayoutsByTabId[binding.tabId].ptyIdsByLeafId?.[
+      binding.leafId
+    ]
+  ).toBe('old')
+  expect(await store.retirePtyBinding(binding)).toBe(true)
+})
diff --git a/src/main/persistence/loading-store/replaced-pane-binding.ts b/src/main/persistence/loading-store/replaced-pane-binding.ts
new file mode 100644
index 00000000000..5cefc332677
--- /dev/null
+++ b/src/main/persistence/loading-store/replaced-pane-binding.ts
@@ -0,0 +1,33 @@
+import type { WorkspaceSessionState } from '../../../shared/workspace-session-state-types'
+import type { RetiredTerminalSurface } from '../../runtime/mobile-session-terminal-retirement'
+
+/** The caller fences the old owner; a restart keeps the pane and removes only its process binding. */
+export function clearReplacedPaneBinding(
+  session: WorkspaceSessionState,
+  surface: RetiredTerminalSurface
+): WorkspaceSessionState {
+  const layout = session.terminalLayoutsByTabId[surface.parentTabId]
+  if (!layout || layout.ptyIdsByLeafId?.[surface.leafId] !== surface.ptyId) {
+    return session
+  }
+  const ptyIdsByLeafId = { ...layout.ptyIdsByLeafId }
+  delete ptyIdsByLeafId[surface.leafId]
+  const terminalPtyIncarnationsByPaneKey = { ...session.terminalPtyIncarnationsByPaneKey }
+  delete terminalPtyIncarnationsByPaneKey[`${surface.parentTabId}:${surface.leafId}`]
+  return {
+    ...session,
+    terminalPtyIncarnationsByPaneKey,
+    terminalLayoutsByTabId: {
+      ...session.terminalLayoutsByTabId,
+      [surface.parentTabId]: { ...layout, ptyIdsByLeafId }
+    },
+    tabsByWorktree: {
+      ...session.tabsByWorktree,
+      [surface.worktreeId]: (session.tabsByWorktree[surface.worktreeId] ?? []).map((tab) =>
+        tab.id === surface.parentTabId && tab.ptyId === surface.ptyId
+          ? { ...tab, ptyId: null }
+          : tab
+      )
+    }
+  }
+}
diff --git a/src/main/preflight/agent-command-detection.ts b/src/main/preflight/agent-command-detection.ts
new file mode 100644
index 00000000000..3712036337c
--- /dev/null
+++ b/src/main/preflight/agent-command-detection.ts
@@ -0,0 +1,48 @@
+import { z } from 'zod'
+import { getActiveMultiplexer } from '../ssh/ssh-target-registry'
+import { detectWslCommandsOnPath } from '../ipc/preflight-wsl-agent-detection'
+import { detectCommandsInInstallDirs } from '../ipc/local-agent-install-dir-detection'
+import {
+  getPreflightWslTarget,
+  type PreflightRuntimeContext
+} from '../ipc/preflight-runtime-target'
+import { isCommandOnPath } from '../ipc/preflight-command-exec'
+
+export async function detectAgentCommandsOnHost(
+  commands: readonly string[],
+  options: { connectionId?: string | null; context?: PreflightRuntimeContext } = {}
+): Promise<Set<string>> {
+  if (options.connectionId) {
+    const mux = getActiveMultiplexer(options.connectionId)
+    if (!mux || mux.isDisposed()) {
+      throw new Error('Agent command resolution requires the execution host connection.')
+    }
+    const result = z.object({ agents: z.array(z.string()) }).parse(
+      await mux.request('preflight.detectAgents', {
+        commands: commands.map((cmd) => ({ id: cmd, cmd }))
+      })
+    )
+    return new Set(result.agents.filter((cmd) => commands.includes(cmd)))
+  }
+  const context = options.context
+  const wslTarget = getPreflightWslTarget(context)
+  if (wslTarget) {
+    return detectWslCommandsOnPath(wslTarget, commands)
+  }
+  const pathChecks = await Promise.all(
+    commands.map(async (cmd) => ({
+      cmd,
+      installedOnPath: await isCommandOnPath(cmd)
+    }))
+  )
+  const missedCommands = pathChecks.filter((check) => !check.installedOnPath).map(({ cmd }) => cmd)
+  // Why: PATH may still be unhydrated on a cold GUI launch; bulk resolution
+  // computes user install dirs once instead of blocking once per missed CLI.
+  const installDirCommands = detectCommandsInInstallDirs(missedCommands)
+  const foundCommands = new Set(
+    pathChecks
+      .filter(({ cmd, installedOnPath }) => installedOnPath || installDirCommands.has(cmd))
+      .map(({ cmd }) => cmd)
+  )
+  return foundCommands
+}
diff --git a/src/main/preflight/agent-detection.ts b/src/main/preflight/agent-detection.ts
index c06f9ee7f12..92484812c3b 100644
--- a/src/main/preflight/agent-detection.ts
+++ b/src/main/preflight/agent-detection.ts
@@ -16,11 +16,7 @@ import { getGiteaAuthStatus } from '../gitea/client'
 import { _resetKnownHostsCache } from '../gitlab/gl-utils'
 import { mergePersistedWindowsPathAsync } from '../pty/windows-environment-path'
 import { getActiveMultiplexer } from '../ssh/ssh-target-registry'
-import {
-  detectWslCommandsOnPath,
-  type WslPreflightTarget
-} from '../ipc/preflight-wsl-agent-detection'
-import { detectCommandsInInstallDirs } from '../ipc/local-agent-install-dir-detection'
+import type { WslPreflightTarget } from '../ipc/preflight-wsl-agent-detection'
 import {
   getPreflightWslTarget,
   type PreflightRuntimeContext
@@ -33,7 +29,6 @@ import {
   execLocalPreflightCommandOrThrow,
   findRunnableLocalCommand,
   isCommandAvailable,
-  isCommandOnPath,
   shellQuote
 } from '../ipc/preflight-command-exec'
 import {
@@ -47,6 +42,8 @@ import {
 } from '../ipc/tui-agent-detection-commands'
 import { invalidateWslGuestEnvironment } from '../wsl/wsl-guest-environment'
 import { prunePreflightWslCache } from '../preflight-wsl-cache'
+import { detectAgentCommandsOnHost } from './agent-command-detection'
+export { detectAgentCommandsOnHost } from './agent-command-detection'
 
 export type PreflightStatus = {
   git: { installed: boolean }
@@ -148,38 +145,14 @@ async function detectCommandRuntime(
 }
 
 export async function detectInstalledAgents(context?: PreflightRuntimeContext): Promise<string[]> {
-  const wslTarget = getPreflightWslTarget(context)
-  if (wslTarget) {
-    const foundCommands = await detectWslCommandsOnPath(
-      wslTarget,
-      getTuiAgentDetectionProbeCommands(KNOWN_TUI_AGENT_DETECTION_COMMANDS, 'wsl')
-    )
-    return resolveDetectedTuiAgentIds(KNOWN_TUI_AGENT_DETECTION_COMMANDS, foundCommands, 'wsl')
-  }
-
-  const probeCommands = getTuiAgentDetectionProbeCommands(
+  const commands = getTuiAgentDetectionProbeCommands(
     KNOWN_TUI_AGENT_DETECTION_COMMANDS,
-    process.platform
-  )
-  const pathChecks = await Promise.all(
-    probeCommands.map(async (cmd) => ({
-      cmd,
-      installedOnPath: await isCommandOnPath(cmd)
-    }))
-  )
-  const missedCommands = pathChecks.filter((check) => !check.installedOnPath).map(({ cmd }) => cmd)
-  // Why: PATH may still be unhydrated on a cold GUI launch; bulk resolution
-  // computes user install dirs once instead of blocking once per missed CLI.
-  const installDirCommands = detectCommandsInInstallDirs(missedCommands)
-  const foundCommands = new Set(
-    pathChecks
-      .filter(({ cmd, installedOnPath }) => installedOnPath || installDirCommands.has(cmd))
-      .map(({ cmd }) => cmd)
+    getPreflightWslTarget(context) ? 'wsl' : process.platform
   )
   return resolveDetectedTuiAgentIds(
     KNOWN_TUI_AGENT_DETECTION_COMMANDS,
-    foundCommands,
-    process.platform
+    await detectAgentCommandsOnHost(commands, { context }),
+    getPreflightWslTarget(context) ? 'wsl' : process.platform
   )
 }
 
diff --git a/src/main/providers/agent-foreground-process-pi.test.ts b/src/main/providers/agent-foreground-process-pi.test.ts
index 691ee63e748..7ae8ec3f3fc 100644
--- a/src/main/providers/agent-foreground-process-pi.test.ts
+++ b/src/main/providers/agent-foreground-process-pi.test.ts
@@ -33,60 +33,64 @@ describe('Pi Windows foreground recognition', () => {
     }
   })
 
-  it('recognizes the npm entrypoint within the active ConPTY', async () => {
-    const rows = [
-      {
-        pid: 100,
-        ppid: 99,
-        name: 'bash.exe',
-        commandLine: '"C:\\Program Files\\Git\\usr\\bin\\bash.exe"'
-      },
-      {
-        pid: 101,
-        ppid: 100,
-        name: 'node.exe',
-        commandLine:
-          'node.exe C:\\Users\\dev\\AppData\\Roaming\\npm\\node_modules\\@earendil-works\\pi-coding-agent\\dist\\cli.js'
-      }
-    ]
-    getAllProcessesMock.mockImplementation((cb: (snapshot: unknown) => void) => {
-      cb(withSelf(rows))
-    })
-    const readWindowsConsoleAttachedProcessIds = vi.fn(async () => new Set([100, 101]))
-
-    await expect(
-      resolveAgentForegroundProcessWithAvailability(100, 'node.exe', {
-        fresh: true,
-        readWindowsConsoleAttachedProcessIds
+  it.each(['cli.js', String.raw`bundle\cli.js`])(
+    'recognizes the npm entrypoint dist/%s within the active ConPTY',
+    async (entrypoint) => {
+      const rows = [
+        {
+          pid: 100,
+          ppid: 99,
+          name: 'bash.exe',
+          commandLine: '"C:\\Program Files\\Git\\usr\\bin\\bash.exe"'
+        },
+        {
+          pid: 101,
+          ppid: 100,
+          name: 'node.exe',
+          commandLine: `node.exe C:\\Users\\dev\\AppData\\Roaming\\npm\\node_modules\\@earendil-works\\pi-coding-agent\\dist\\${entrypoint}`
+        }
+      ]
+      getAllProcessesMock.mockImplementation((cb: (snapshot: unknown) => void) => {
+        cb(withSelf(rows))
       })
-    ).resolves.toEqual({ available: true, processName: 'pi', processId: 101 })
-    expect(readWindowsConsoleAttachedProcessIds).toHaveBeenCalledTimes(1)
-  })
+      const readWindowsConsoleAttachedProcessIds = vi.fn(async () => new Set([100, 101]))
 
-  it('anchors a collapsed omp name to the omp pid, not the embedded pi leaf', async () => {
-    // Pi restarts under a live OMP; an anchor on pi's pid would read that as
-    // OMP's exit and fire a false "agent done" when the next snapshot degrades.
-    const rows = [
-      { pid: 100, ppid: 99, name: 'powershell.exe', commandLine: 'powershell.exe' },
-      { pid: 101, ppid: 100, name: 'omp.exe', commandLine: 'omp' },
-      {
-        pid: 102,
-        ppid: 101,
-        name: 'node.exe',
-        commandLine:
-          'node.exe C:\\npm\\node_modules\\@earendil-works\\pi-coding-agent\\dist\\cli.js'
-      }
-    ]
-    getAllProcessesMock.mockImplementation((cb: (snapshot: unknown) => void) => {
-      cb(withSelf(rows))
-    })
-    const readWindowsConsoleAttachedProcessIds = vi.fn(async () => new Set([100, 101, 102]))
+      await expect(
+        resolveAgentForegroundProcessWithAvailability(100, 'node.exe', {
+          fresh: true,
+          readWindowsConsoleAttachedProcessIds
+        })
+      ).resolves.toEqual({ available: true, processName: 'pi', processId: 101 })
+      expect(readWindowsConsoleAttachedProcessIds).toHaveBeenCalledTimes(1)
+    }
+  )
 
-    await expect(
-      resolveAgentForegroundProcessWithAvailability(100, 'powershell.exe', {
-        fresh: true,
-        readWindowsConsoleAttachedProcessIds
+  it.each(['cli.js', String.raw`bundle\cli.js`])(
+    'anchors a collapsed omp name to the omp pid, not the embedded pi leaf at dist/%s',
+    async (entrypoint) => {
+      // Pi restarts under a live OMP; an anchor on pi's pid would read that as
+      // OMP's exit and fire a false "agent done" when the next snapshot degrades.
+      const rows = [
+        { pid: 100, ppid: 99, name: 'powershell.exe', commandLine: 'powershell.exe' },
+        { pid: 101, ppid: 100, name: 'omp.exe', commandLine: 'omp' },
+        {
+          pid: 102,
+          ppid: 101,
+          name: 'node.exe',
+          commandLine: `node.exe C:\\npm\\node_modules\\@earendil-works\\pi-coding-agent\\dist\\${entrypoint}`
+        }
+      ]
+      getAllProcessesMock.mockImplementation((cb: (snapshot: unknown) => void) => {
+        cb(withSelf(rows))
       })
-    ).resolves.toEqual({ available: true, processName: 'omp', processId: 101 })
-  })
+      const readWindowsConsoleAttachedProcessIds = vi.fn(async () => new Set([100, 101, 102]))
+
+      await expect(
+        resolveAgentForegroundProcessWithAvailability(100, 'powershell.exe', {
+          fresh: true,
+          readWindowsConsoleAttachedProcessIds
+        })
+      ).resolves.toEqual({ available: true, processName: 'omp', processId: 101 })
+    }
+  )
 })
diff --git a/src/main/providers/agent-foreground-process-remote-evidence.test.ts b/src/main/providers/agent-foreground-process-remote-evidence.test.ts
index 274a24271b7..2e28a9c6107 100644
--- a/src/main/providers/agent-foreground-process-remote-evidence.test.ts
+++ b/src/main/providers/agent-foreground-process-remote-evidence.test.ts
@@ -75,6 +75,71 @@ describe('host-stamped remote foreground resolver', () => {
     expect(evidence).toMatchObject({ verdict: 'unverifiable', reason })
   })
 
+  it.each(['?', '??', '-', '0', '0,0'])(
+    'keeps the OpenCode TUI live beside a detached service with tty %s',
+    (tty) => {
+      const rows = rowsFor(['opencode'], { tty: 'ttys096' })
+      rows.push({
+        pid: 102,
+        ppid: 101,
+        pgid: 102,
+        tpgid: 0,
+        tty,
+        startTime: 'service-start',
+        stat: 'Ss',
+        command: 'opencode serve --hostname 127.0.0.1 --port 59374'
+      })
+      expect(
+        resolveRemoteForegroundEvidence(
+          { rootPid: 100, fallbackProcess: 'zsh' },
+          { ...metadata, platform: 'darwin' },
+          rows
+        )
+      ).toMatchObject({
+        verdict: 'live',
+        processName: 'opencode',
+        fence: { process: { pid: 101, startTime: 'candidate-0' }, tty: 'ttys096' }
+      })
+    }
+  )
+
+  it.each(['?', '??', '-', '0', '0,0'])(
+    'refuses a foreground-group member whose controlling tty is %s',
+    (tty) => {
+      const rows = rowsFor(['opencode'])
+      rows[1].tty = tty
+      expect(
+        resolveRemoteForegroundEvidence({ rootPid: 100, fallbackProcess: 'zsh' }, metadata, rows)
+      ).toMatchObject({ verdict: 'unverifiable', reason: 'fence_incomplete' })
+    }
+  )
+
+  it.each(['?', '??', '-', '0', '0,0'])('refuses a root without a controlling tty: %s', (tty) => {
+    const rows = rowsFor(['opencode'], { tty })
+    expect(
+      resolveRemoteForegroundEvidence({ rootPid: 100, fallbackProcess: 'zsh' }, metadata, rows)
+    ).toMatchObject({ verdict: 'unverifiable', reason: 'fence_incomplete' })
+  })
+
+  it('refuses a descendant attached to another real terminal', () => {
+    const rows = rowsFor(['opencode', '/bin/bash'])
+    rows[2].pgid = 102
+    rows[2].tty = '/dev/pts/3'
+    expect(
+      resolveRemoteForegroundEvidence({ rootPid: 100, fallbackProcess: 'zsh' }, metadata, rows)
+    ).toMatchObject({ verdict: 'unverifiable', reason: 'tty_boundary' })
+  })
+
+  it('still refuses a detached multiplexer without a session fence', () => {
+    const rows = rowsFor(['opencode', 'tmux new-session'])
+    rows[2].pgid = 102
+    rows[2].tpgid = 0
+    rows[2].tty = '??'
+    expect(
+      resolveRemoteForegroundEvidence({ rootPid: 100, fallbackProcess: 'zsh' }, metadata, rows)
+    ).toMatchObject({ verdict: 'unverifiable', reason: 'multiplexer_boundary' })
+  })
+
   it('always degrades SSH-to-Windows without a job/console foreground primitive', () => {
     expect(
       resolveRemoteForegroundEvidence(
diff --git a/src/main/providers/agent-foreground-process-remote-evidence.ts b/src/main/providers/agent-foreground-process-remote-evidence.ts
index 90c5e794fbd..fd34cc19731 100644
--- a/src/main/providers/agent-foreground-process-remote-evidence.ts
+++ b/src/main/providers/agent-foreground-process-remote-evidence.ts
@@ -1,3 +1,4 @@
+import { hasControllingTty } from '../../shared/posix-controlling-terminal'
 import { recognizeAgentProcessFromCommandLine } from '../../shared/agent-process-recognition'
 import type {
   PosixFence,
@@ -58,7 +59,7 @@ export function resolveRemoteForegroundEvidenceFromRows(
   if (!root || root.pgid === undefined || root.tpgid === undefined) {
     return { ...metadata, verdict: 'unverifiable', reason: 'anchor_missing' }
   }
-  if (!root.tty || root.tty === '?' || root.tpgid <= 0 || !root.startTime) {
+  if (!hasControllingTty(root.tty) || root.tpgid <= 0 || !root.startTime) {
     return { ...metadata, verdict: 'unverifiable', reason: 'fence_incomplete' }
   }
   const index = buildProcessTableIndex(rows)
@@ -73,7 +74,7 @@ export function resolveRemoteForegroundEvidenceFromRows(
   const descendants = collectDescendantRows(index, root.pid)
   // A child that owns another terminal/session is outside this PTY's
   // authority. Do not silently treat it as an idle shell.
-  if (descendants.some((row) => row.tty !== undefined && row.tty !== '?' && row.tty !== root.tty)) {
+  if (descendants.some((row) => hasControllingTty(row.tty) && row.tty !== root.tty)) {
     return { ...metadata, verdict: 'unverifiable', reason: 'tty_boundary' }
   }
   // Multiplexers can make a descendant appear foreground while the user is
@@ -82,9 +83,7 @@ export function resolveRemoteForegroundEvidenceFromRows(
   if ([root, ...descendants].some((row) => /(?:^|\s)(?:tmux|screen)(?:\s|$)/i.test(row.command))) {
     return { ...metadata, verdict: 'unverifiable', reason: 'multiplexer_boundary' }
   }
-  if (
-    descendants.some((row) => row.pgid === root.tpgid && (row.tty === undefined || row.tty === '?'))
-  ) {
+  if (descendants.some((row) => row.pgid === root.tpgid && !hasControllingTty(row.tty))) {
     return { ...metadata, verdict: 'unverifiable', reason: 'fence_incomplete' }
   }
   const foreground = descendants.filter((row) => row.pgid === root.tpgid && row.tty === root.tty)
diff --git a/src/main/proxy-guarded-fetch-call-site-audit.test.ts b/src/main/proxy-guarded-fetch-call-site-audit.test.ts
index b92b266f427..53d22bad37f 100644
--- a/src/main/proxy-guarded-fetch-call-site-audit.test.ts
+++ b/src/main/proxy-guarded-fetch-call-site-audit.test.ts
@@ -14,7 +14,7 @@ import { describe, expect, it } from 'vitest'
 // means a call site was added, removed, or moved: re-audit the file and update the count.
 const AUDITED_NON_NET_FETCH_CALLS = new Map<string, number>([
   // Isolated cookie-jar session, proxied by createOpenCodeRequestSession before any request.
-  ['main/rate-limits/opencode-go-usage-fetcher.ts', 2],
+  ['main/rate-limits/opencode-go-usage-fetcher.ts', 3],
   // Isolated cookie-jar session that does NOT apply the proxy — a pre-existing gap, not a
   // regression: no proxy has ever reached this partition. Keep it listed so it stays visible.
   ['main/rate-limits/minimax/minimax-request-context.ts', 2],
diff --git a/src/main/pty/posix-pty-process-groups.ts b/src/main/pty/posix-pty-process-groups.ts
index 1f7f05f73a1..2607875b269 100644
--- a/src/main/pty/posix-pty-process-groups.ts
+++ b/src/main/pty/posix-pty-process-groups.ts
@@ -1,3 +1,4 @@
+import { hasControllingTty } from '../../shared/posix-controlling-terminal'
 import { recordSelfInitiatedTreeKill } from '../crash-reporting/self-initiated-tree-kill-log'
 import { waitForPromiseWithSignal } from '../../shared/abort-signal-reason'
 import {
@@ -68,10 +69,6 @@ function readSelectionResult(result: ProcessResult, option: 'p' | 't'): string {
   return output
 }
 
-function hasControllingTty(tty: string): boolean {
-  return tty !== '?' && tty !== '??' && tty !== '-' && tty !== '0' && !/^0,\d+$/.test(tty)
-}
-
 function* processTableQueries(rootPid: number): Generator<string[], string, ProcessResult> {
   if (psDialect !== 'all') {
     try {
diff --git a/src/main/qoder/real-cli.test.ts b/src/main/qoder/real-cli.test.ts
index 7cd1e8a139d..5048c14bef0 100644
--- a/src/main/qoder/real-cli.test.ts
+++ b/src/main/qoder/real-cli.test.ts
@@ -9,14 +9,13 @@ import {
   stat,
   writeFile
 } from 'node:fs/promises'
-import { createServer } from 'node:http'
+import { randomUUID } from 'node:crypto'
 import { homedir, tmpdir } from 'node:os'
 import type * as Os from 'node:os'
 import { join } from 'node:path'
 import { expect, it, vi } from 'vitest'
 import { runProcess } from '../../shared/child-process/run-process'
-import { createHookListenerState } from '../../shared/agent-hook-listener/listener-state'
-import { normalizeAndAccept } from '../../shared/agent-hook-listener-test-harness'
+import { makePaneKey } from '../../shared/stable-pane-id'
 import { parseQoderSessionFile } from '../ai-vault/session-scanner-qoder-parser'
 
 const sandbox = vi.hoisted(() => ({ home: '' }))
@@ -27,6 +26,7 @@ vi.mock('node:os', async (importOriginal) => {
 vi.mock('electron', () => ({ app: { getPath: () => sandbox.home } }))
 import { qoderHookService } from './hook-service'
 import { markQoderWorkspaceTrusted } from './workspace-trust'
+import { AgentHookServer } from '../agent-hooks/server'
 
 it.skipIf(process.env.ORCA_REAL_QODER_CLI_TEST !== '1')(
   'generates and resumes a real task through managed hooks',
@@ -35,28 +35,22 @@ it.skipIf(process.env.ORCA_REAL_QODER_CLI_TEST !== '1')(
     sandbox.home = await realpath(await mkdtemp(join(tmpdir(), 'orca-qoder-real-')))
     const config = join(sandbox.home, '.qoder')
     const workspace = join(sandbox.home, 'folder')
+    const proofFile = `qoder-proof-${randomUUID()}.txt`
+    const marker = `QODER_MANAGED_PROOF_${randomUUID()}`
     const statuses: {
       event: unknown
       state: unknown
       agent: unknown
       session: string | undefined
     }[] = []
-    const listener = createHookListenerState()
-    const server = createServer(async (request, response) => {
-      let content = ''
-      for await (const chunk of request) {
-        content += chunk
-      }
-      const fields = new URLSearchParams(content)
-      const payload = JSON.parse(fields.get('payload') ?? '{}')
-      const normalized = normalizeAndAccept(listener, 'qoder', payload)
+    const server = new AgentHookServer()
+    server.subscribeEnrichedStatus((normalized) => {
       statuses.push({
-        event: payload.hook_event_name,
-        state: normalized?.payload.state,
-        agent: normalized?.payload.agentType,
-        session: normalized?.providerSession?.id
+        event: normalized.hookEventName,
+        state: normalized.payload.state,
+        agent: normalized.payload.agentType,
+        session: normalized.providerSession?.id
       })
-      response.writeHead(request.url === '/hook/qoder' ? 200 : 404).end()
     })
     try {
       await mkdir(workspace)
@@ -68,23 +62,18 @@ it.skipIf(process.env.ORCA_REAL_QODER_CLI_TEST !== '1')(
       )
       expect(qoderHookService.install().state).toBe('installed')
       markQoderWorkspaceTrusted(workspace, sandbox.home)
-      await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
-      const address = server.address()
-      if (!address || typeof address === 'string') {
-        throw new Error('No test receiver port')
-      }
+      await server.start({ env: 'production', userDataPath: join(sandbox.home, 'orca') })
       const env = {
         ...process.env,
         HOME: sandbox.home,
         USERPROFILE: sandbox.home,
-        ORCA_AGENT_HOOK_PORT: String(address.port),
-        ORCA_AGENT_HOOK_TOKEN: 'test-token',
-        ORCA_PANE_KEY: 'qoder-proof-pane',
-        ORCA_AGENT_HOOK_ENDPOINT: '',
-        ORCA_AGENT_HOOK_TRANSPORT: '',
+        ...server.buildPtyEnv(),
+        ORCA_PANE_KEY: makePaneKey(randomUUID(), randomUUID()),
         ORCA_BACKGROUND_LAUNCH: '1'
       }
       const command = process.env.ORCA_QODER_CLI_PATH ?? join(realHome, '.local', 'bin', 'qodercli')
+      const version = await runProcess({ program: command, args: ['--version'], env })
+      expect(version.code).toBe(0)
       const args = [
         '--config-dir',
         config,
@@ -100,15 +89,14 @@ it.skipIf(process.env.ORCA_REAL_QODER_CLI_TEST !== '1')(
           ...args,
           '--permission-mode',
           'accept_edits',
-          'Create proof.txt containing exactly QODER_MANAGED_PROOF. Then reply QODER_MANAGED_COMPLETE.'
+          `Create ${proofFile} containing exactly ${marker}. Then reply QODER_MANAGED_COMPLETE.`
         ],
         env,
         timeoutMs: 90000
       })
       expect(generated.code).toBe(0)
-      expect((await readFile(join(workspace, 'proof.txt'), 'utf8')).trim()).toBe(
-        'QODER_MANAGED_PROOF'
-      )
+      expect(generated.stdout.trim()).toBe('QODER_MANAGED_COMPLETE')
+      expect((await readFile(join(workspace, proofFile), 'utf8')).trim()).toBe(marker)
       const session = statuses.find((s) => s.event === 'SessionStart')?.session
       expect(session).toBeTruthy()
       if (!session) {
@@ -120,13 +108,18 @@ it.skipIf(process.env.ORCA_REAL_QODER_CLI_TEST !== '1')(
           ...args,
           '--resume',
           session,
-          'What exact marker did you write? Reply only with that marker.'
+          '--permission-mode',
+          'accept_edits',
+          `Recall the exact marker you wrote earlier without reading any file. Create resumed.txt containing that marker followed by a newline and QODER_RESUMED_CHANGE. Reply only with the original marker.`
         ],
         env,
         timeoutMs: 90000
       })
       expect(resumed.code).toBe(0)
-      expect(resumed.stdout.trim()).toBe('QODER_MANAGED_PROOF')
+      expect(resumed.stdout.trim()).toBe(marker)
+      expect((await readFile(join(workspace, 'resumed.txt'), 'utf8')).trim()).toBe(
+        `${marker}\nQODER_RESUMED_CHANGE`
+      )
       const projects = join(config, 'projects')
       const transcript = (await readdir(projects, { recursive: true })).find(
         (path) => path.endsWith(`${session}.jsonl`) && !path.includes('subagents')
@@ -142,8 +135,17 @@ it.skipIf(process.env.ORCA_REAL_QODER_CLI_TEST !== '1')(
         modifiedAt: modified.mtime.toISOString()
       })
       expect(history).toMatchObject({ agent: 'qoder', sessionId: session, cwd: workspace })
-      expect(history?.previewMessages.at(-1)?.text).toBe('QODER_MANAGED_PROOF')
+      expect(history?.previewMessages.at(-1)?.text).toBe(marker)
       expect(history?.resumeCommand).toContain(`qodercli --resume '${session}'`)
+      expect(server.getStatusSnapshot()).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            agentType: 'qoder',
+            state: 'done',
+            providerSession: expect.objectContaining({ id: session })
+          })
+        ])
+      )
       expect(statuses).toEqual(
         expect.arrayContaining([
           expect.objectContaining({
@@ -162,9 +164,20 @@ it.skipIf(process.env.ORCA_REAL_QODER_CLI_TEST !== '1')(
           evidencePath,
           JSON.stringify(
             {
+              command,
+              version: version.stdout.trim(),
+              proofFile,
+              marker,
+              generatedExitCode: generated.code,
+              resumedExitCode: resumed.code,
               generated: generated.stdout.trim(),
               resumed: resumed.stdout.trim(),
               statuses,
+              canonicalSnapshot: server.getStatusSnapshot().map((row) => ({
+                agent: row.agentType,
+                state: row.state,
+                session: row.providerSession?.id
+              })),
               history: {
                 agent: history?.agent,
                 sessionId: history?.sessionId,
@@ -178,7 +191,7 @@ it.skipIf(process.env.ORCA_REAL_QODER_CLI_TEST !== '1')(
         )
       }
     } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
+      server.stop()
       await rm(sandbox.home, { recursive: true, force: true })
       sandbox.home = ''
     }
diff --git a/src/main/rate-limits/claude-fetcher-extra-usage.test.ts b/src/main/rate-limits/claude-fetcher-extra-usage.test.ts
new file mode 100644
index 00000000000..fb56512bd8c
--- /dev/null
+++ b/src/main/rate-limits/claude-fetcher-extra-usage.test.ts
@@ -0,0 +1,302 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest'
+import { fetchClaudeRateLimits } from './claude-fetcher'
+import { primeClaudeFetcherMocks, restorePlatform } from './claude-fetcher-test-harness'
+import { readActiveClaudeKeychainCredentialsStrict } from '../claude-accounts/keychain'
+import type { ClaudeRuntimeAuthPreparation } from '../claude-accounts/runtime-auth-service'
+
+const { netFetchMock, readFileMock, resolveProxyMock, setProxyMock, appGetPathMock } = vi.hoisted(
+  () => ({
+    netFetchMock: vi.fn(),
+    readFileMock: vi.fn(),
+    resolveProxyMock: vi.fn(),
+    setProxyMock: vi.fn(),
+    appGetPathMock: vi.fn()
+  })
+)
+
+vi.mock('node:fs/promises', () => ({
+  readFile: readFileMock
+}))
+
+vi.mock('electron', () => ({
+  app: {
+    getPath: appGetPathMock
+  },
+  net: {
+    fetch: netFetchMock
+  },
+  session: {
+    defaultSession: {
+      resolveProxy: resolveProxyMock,
+      setProxy: setProxyMock
+    }
+  }
+}))
+
+vi.mock('./claude-pty', () => ({
+  fetchViaPty: vi.fn()
+}))
+
+vi.mock('../claude-accounts/keychain', () => ({
+  deleteActiveClaudeKeychainCredentialsStrict: vi.fn(),
+  readActiveClaudeKeychainCredentials: vi.fn(),
+  readActiveClaudeKeychainCredentialsStrict: vi.fn(),
+  readManagedClaudeKeychainCredentials: vi.fn(),
+  writeActiveClaudeKeychainCredentials: vi.fn(),
+  writeManagedClaudeKeychainCredentials: vi.fn()
+}))
+
+function oauthPrep(): ClaudeRuntimeAuthPreparation {
+  return {
+    configDir: '/Users/test/.claude',
+    envPatch: { CLAUDE_CONFIG_DIR: '/Users/test/.claude' },
+    stripAuthEnv: false,
+    provenance: 'system'
+  }
+}
+
+async function fetchUsageResponse(body: string) {
+  vi.mocked(readActiveClaudeKeychainCredentialsStrict).mockResolvedValueOnce(
+    JSON.stringify({
+      claudeAiOauth: { accessToken: 'oauth-token', expiresAt: Date.now() + 60_000 }
+    })
+  )
+  netFetchMock.mockResolvedValueOnce(new Response(body, { status: 200 }))
+  return fetchClaudeRateLimits({ authPreparation: oauthPrep() })
+}
+
+describe('fetchClaudeRateLimits extra usage', () => {
+  beforeEach(() => {
+    primeClaudeFetcherMocks({
+      netFetchMock,
+      readFileMock,
+      resolveProxyMock,
+      setProxyMock,
+      appGetPathMock
+    })
+  })
+
+  afterEach(() => {
+    restorePlatform()
+  })
+
+  it('maps the usage-credits spend object into a capped balance in major units', async () => {
+    vi.mocked(readActiveClaudeKeychainCredentialsStrict).mockResolvedValueOnce(
+      JSON.stringify({
+        claudeAiOauth: {
+          accessToken: 'oauth-token',
+          expiresAt: Date.now() + 60_000
+        }
+      })
+    )
+    netFetchMock.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          five_hour: { utilization: 10 },
+          spend: {
+            used: { amount_minor: 5000, currency: 'EUR', exponent: 2 },
+            limit: { amount_minor: 200000, currency: 'EUR', exponent: 2 },
+            percent: 2.5,
+            enabled: true,
+            balance: { amount_minor: 1000, currency: 'EUR', exponent: 2 }
+          }
+        }),
+        { status: 200 }
+      )
+    )
+
+    await expect(fetchClaudeRateLimits({ authPreparation: oauthPrep() })).resolves.toMatchObject({
+      provider: 'claude',
+      status: 'ok',
+      extraUsage: {
+        balance: 10,
+        spent: 50,
+        spendLimit: 2000,
+        spentPercent: 2.5,
+        currencyCode: 'EUR',
+        enabled: true,
+        disabledReason: null,
+        resetsAt: null
+      }
+    })
+  })
+
+  it('keeps the usage-credits cap visible without inventing an out-of-credits balance', async () => {
+    vi.mocked(readActiveClaudeKeychainCredentialsStrict).mockResolvedValueOnce(
+      JSON.stringify({
+        claudeAiOauth: {
+          accessToken: 'oauth-token',
+          expiresAt: Date.now() + 60_000
+        }
+      })
+    )
+    netFetchMock.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          five_hour: { utilization: 10 },
+          spend: {
+            used: { amount_minor: 0, currency: 'EUR', exponent: 2 },
+            limit: { amount_minor: 200000, currency: 'EUR', exponent: 2 },
+            percent: 0,
+            enabled: false,
+            disabled_reason: 'out_of_credits',
+            balance: null
+          }
+        }),
+        { status: 200 }
+      )
+    )
+
+    await expect(fetchClaudeRateLimits({ authPreparation: oauthPrep() })).resolves.toMatchObject({
+      provider: 'claude',
+      status: 'ok',
+      extraUsage: {
+        balance: null,
+        spent: 0,
+        spendLimit: 2000,
+        spentPercent: 0,
+        currencyCode: 'EUR',
+        enabled: false,
+        disabledReason: 'out_of_credits'
+      }
+    })
+  })
+
+  it('keeps legacy extra_usage spend data without inventing a missing balance', async () => {
+    vi.mocked(readActiveClaudeKeychainCredentialsStrict).mockResolvedValueOnce(
+      JSON.stringify({
+        claudeAiOauth: {
+          accessToken: 'oauth-token',
+          expiresAt: Date.now() + 60_000
+        }
+      })
+    )
+    netFetchMock.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          five_hour: { utilization: 10 },
+          extra_usage: {
+            is_enabled: true,
+            monthly_limit: 200000,
+            used_credits: 5000,
+            utilization: 2.5,
+            currency: 'EUR',
+            decimal_places: 2
+          }
+        }),
+        { status: 200 }
+      )
+    )
+
+    await expect(fetchClaudeRateLimits({ authPreparation: oauthPrep() })).resolves.toMatchObject({
+      provider: 'claude',
+      status: 'ok',
+      extraUsage: {
+        balance: null,
+        spent: 50,
+        spendLimit: 2000,
+        spentPercent: 2.5,
+        currencyCode: 'EUR',
+        enabled: true
+      }
+    })
+  })
+  it('keeps a missing balance unknown while preserving a known cap', async () => {
+    const result = await fetchUsageResponse(
+      '{"five_hour":{"utilization":10},"spend":{"limit":{"amount_minor":200000,"currency":"EUR"},"enabled":true}}'
+    )
+    expect(result.extraUsage).toMatchObject({
+      balance: null,
+      spendLimit: 2000,
+      currencyCode: 'EUR'
+    })
+  })
+
+  it.each([1000, 0])('preserves a balance-only EUR amount of %s minor units', async (amount) => {
+    const result = await fetchUsageResponse(
+      JSON.stringify({
+        five_hour: { utilization: 10 },
+        spend: { balance: { amount_minor: amount, currency: 'EUR' }, enabled: true }
+      })
+    )
+    expect(result.extraUsage).toMatchObject({
+      balance: amount / 100,
+      currencyCode: 'EUR',
+      spendLimit: null
+    })
+  })
+
+  it('keeps a numeric overflow balance unknown and derives a finite percentage', async () => {
+    const result = await fetchUsageResponse(
+      '{"five_hour":{"utilization":10},"spend":{"used":{"amount_minor":5000},"limit":{"amount_minor":200000},"balance":{"amount_minor":1e309},"percent":1e309,"enabled":true}}'
+    )
+    expect(result.extraUsage).toMatchObject({
+      balance: null,
+      spent: 50,
+      spendLimit: 2000,
+      spentPercent: 2.5
+    })
+  })
+
+  it('keeps nullable legacy spend unknown despite a supplied percentage', async () => {
+    const result = await fetchUsageResponse(
+      '{"five_hour":{"utilization":10},"extra_usage":{"monthly_limit":200000,"used_credits":null,"utilization":10,"currency":"EUR","is_enabled":true}}'
+    )
+    expect(result.extraUsage).toMatchObject({
+      balance: null,
+      spent: null,
+      spendLimit: 2000,
+      spentPercent: 10
+    })
+  })
+
+  it('derives legacy percentage when the response percentage overflows', async () => {
+    const result = await fetchUsageResponse(
+      '{"five_hour":{"utilization":10},"extra_usage":{"monthly_limit":200000,"used_credits":5000,"utilization":1e309,"currency":"EUR","is_enabled":true}}'
+    )
+    expect(result.extraUsage).toMatchObject({
+      balance: null,
+      spent: 50,
+      spendLimit: 2000,
+      spentPercent: 2.5
+    })
+  })
+
+  it('does not turn an overflowing legacy spend into a known amount', async () => {
+    const result = await fetchUsageResponse(
+      '{"five_hour":{"utilization":10},"extra_usage":{"monthly_limit":200000,"used_credits":1e309,"currency":"EUR","is_enabled":true}}'
+    )
+    expect(result.extraUsage).toMatchObject({
+      balance: null,
+      spent: null,
+      spendLimit: 2000,
+      spentPercent: null
+    })
+  })
+
+  it.each(['null', '1e309'])('omits a legacy cap whose amount is %s', async (limit) => {
+    const result = await fetchUsageResponse(
+      `{"five_hour":{"utilization":10},"extra_usage":{"monthly_limit":${limit},"used_credits":5000,"currency":"EUR","is_enabled":true}}`
+    )
+    expect(result.extraUsage ?? null).toBeNull()
+  })
+
+  it.each([-1, 0.5, 309])(
+    'omits malformed legacy precision %s rather than displaying zero',
+    async (exponent) => {
+      const result = await fetchUsageResponse(
+        JSON.stringify({
+          five_hour: { utilization: 10 },
+          extra_usage: {
+            monthly_limit: 200000,
+            used_credits: 5000,
+            decimal_places: exponent,
+            currency: 'EUR',
+            is_enabled: true
+          }
+        })
+      )
+      expect(result.extraUsage ?? null).toBeNull()
+    }
+  )
+})
diff --git a/src/main/rate-limits/claude-oauth-usage-request.ts b/src/main/rate-limits/claude-oauth-usage-request.ts
index 9565a064514..b3bca9298aa 100644
--- a/src/main/rate-limits/claude-oauth-usage-request.ts
+++ b/src/main/rate-limits/claude-oauth-usage-request.ts
@@ -4,6 +4,11 @@ import { ensureElectronProxyFromEnvironment } from '../network/proxy-settings'
 import { createOAuthUsageError } from './claude-oauth-usage-error'
 import { mapClaudeUsageWindow, type ClaudeUsageWindowInput } from './claude-usage-window'
 import { abortedClaudeRateLimitResult } from './claude-usage-result'
+import {
+  mapClaudeExtraUsage,
+  type ClaudeOAuthExtraUsage,
+  type ClaudeOAuthSpend
+} from './claude-usage-credits'
 
 const OAUTH_USAGE_URL = 'https://api.anthropic.com/api/oauth/usage'
 const API_TIMEOUT_MS = 10_000
@@ -22,6 +27,8 @@ type OAuthUsageResponse = {
   fable_weekly?: ClaudeUsageWindowInput
   fable_seven_day?: ClaudeUsageWindowInput
   seven_day_fable?: ClaudeUsageWindowInput
+  spend?: ClaudeOAuthSpend
+  extra_usage?: ClaudeOAuthExtraUsage
   limits?: OAuthUsageLimit[] | null
 }
 
@@ -90,6 +97,7 @@ export async function fetchClaudeOAuthUsage(
       session: mapClaudeUsageWindow(data.five_hour, 300),
       weekly: mapClaudeUsageWindow(data.seven_day, 10080),
       fableWeekly: mapFableWeeklyWindow(data),
+      extraUsage: mapClaudeExtraUsage(data),
       updatedAt: Date.now(),
       error: null,
       status: 'ok'
diff --git a/src/main/rate-limits/claude-usage-credits.ts b/src/main/rate-limits/claude-usage-credits.ts
new file mode 100644
index 00000000000..9f01fd63064
--- /dev/null
+++ b/src/main/rate-limits/claude-usage-credits.ts
@@ -0,0 +1,127 @@
+import type { ExtraUsageBalance } from '../../shared/rate-limit-types'
+
+// Money is reported as minor units plus an exponent (e.g. 200000 @ exp 2 = €2000).
+type OAuthMoney = {
+  amount_minor?: number
+  currency?: string
+  exponent?: number
+}
+
+// Optional richer spend fields are retained for response compatibility.
+export type ClaudeOAuthSpend = {
+  used?: OAuthMoney
+  limit?: OAuthMoney
+  percent?: number
+  enabled?: boolean
+  disabled_reason?: string | null
+  cap?: { money?: OAuthMoney | null } | null
+  balance?: OAuthMoney | number | null
+}
+
+// Legacy shape kept as a fallback for older responses that only send `extra_usage`.
+export type ClaudeOAuthExtraUsage = {
+  is_enabled?: boolean
+  monthly_limit?: number | null
+  used_credits?: number | null
+  utilization?: number | null
+  currency?: string
+  decimal_places?: number
+  disabled_reason?: string | null
+}
+
+function clampPercent(value: number): number {
+  return Math.min(100, Math.max(0, value))
+}
+
+function moneyToMajor(money: OAuthMoney | number | null | undefined): number | null {
+  if (typeof money === 'number') {
+    return Number.isFinite(money) ? money : null
+  }
+  if (!money || typeof money.amount_minor !== 'number' || !Number.isFinite(money.amount_minor)) {
+    return null
+  }
+  const exponent = typeof money.exponent === 'number' ? money.exponent : 2
+  if (!Number.isInteger(exponent) || exponent < 0 || exponent > 6) {
+    return null
+  }
+  return money.amount_minor / 10 ** exponent
+}
+
+// Prefer the richer `spend` object; fall back to the legacy `extra_usage` shape.
+export function mapClaudeExtraUsage(data: {
+  spend?: ClaudeOAuthSpend
+  extra_usage?: ClaudeOAuthExtraUsage
+}): ExtraUsageBalance | null {
+  return mapSpend(data.spend) ?? mapLegacyExtraUsage(data.extra_usage)
+}
+
+function mapSpend(spend: ClaudeOAuthSpend | undefined): ExtraUsageBalance | null {
+  if (!spend) {
+    return null
+  }
+  const spent = moneyToMajor(spend.used)
+  const spendLimit = moneyToMajor(spend.limit) ?? moneyToMajor(spend.cap?.money)
+  const balance = moneyToMajor(spend.balance)
+  // Nothing worth showing when the account has neither a configured cap nor a balance.
+  if (spendLimit === null && balance === null) {
+    return null
+  }
+  const spentPercent =
+    typeof spend.percent === 'number' && Number.isFinite(spend.percent)
+      ? clampPercent(spend.percent)
+      : spendLimit !== null && spendLimit > 0 && spent !== null
+        ? clampPercent((spent / spendLimit) * 100)
+        : null
+  return {
+    balance,
+    unit: 'currency',
+    currencyCode:
+      spend.used?.currency ??
+      spend.limit?.currency ??
+      spend.cap?.money?.currency ??
+      (typeof spend.balance === 'object' && spend.balance !== null
+        ? spend.balance.currency
+        : undefined) ??
+      'USD',
+    enabled: spend.enabled === true,
+    disabledReason: spend.disabled_reason ?? null,
+    spent,
+    spendLimit,
+    spentPercent,
+    resetsAt: null
+  }
+}
+
+function mapLegacyExtraUsage(extra: ClaudeOAuthExtraUsage | undefined): ExtraUsageBalance | null {
+  if (!extra) {
+    return null
+  }
+  const spendLimit = moneyToMajor({
+    amount_minor: extra.monthly_limit ?? undefined,
+    exponent: extra.decimal_places
+  })
+  if (spendLimit === null) {
+    return null
+  }
+  const spent = moneyToMajor({
+    amount_minor: extra.used_credits ?? undefined,
+    exponent: extra.decimal_places
+  })
+  const spentPercent =
+    typeof extra.utilization === 'number' && Number.isFinite(extra.utilization)
+      ? clampPercent(extra.utilization)
+      : spendLimit > 0 && spent !== null
+        ? clampPercent((spent / spendLimit) * 100)
+        : null
+  return {
+    balance: null,
+    unit: 'currency',
+    currencyCode: extra.currency?.trim() || 'USD',
+    enabled: extra.is_enabled === true,
+    disabledReason: extra.disabled_reason ?? null,
+    spent,
+    spendLimit,
+    spentPercent,
+    resetsAt: null
+  }
+}
diff --git a/src/main/rate-limits/claude-usage-result.ts b/src/main/rate-limits/claude-usage-result.ts
index aea522e673b..a29cb38d4aa 100644
--- a/src/main/rate-limits/claude-usage-result.ts
+++ b/src/main/rate-limits/claude-usage-result.ts
@@ -112,7 +112,9 @@ export function mergeClaudeUsageWindows(
     ...primary,
     session: primary.session ?? supplement.session,
     weekly: primary.weekly ?? supplement.weekly,
-    fableWeekly: primary.fableWeekly ?? supplement.fableWeekly ?? null
+    fableWeekly: primary.fableWeekly ?? supplement.fableWeekly ?? null,
+    // Only OAuth reports the extra-usage cap; keep it when the CLI supplements windows.
+    extraUsage: primary.extraUsage ?? supplement.extraUsage ?? null
   }
 }
 
diff --git a/src/main/rate-limits/codex-credit-balance.ts b/src/main/rate-limits/codex-credit-balance.ts
new file mode 100644
index 00000000000..ece52f2df64
--- /dev/null
+++ b/src/main/rate-limits/codex-credit-balance.ts
@@ -0,0 +1,29 @@
+import type { ExtraUsageBalance } from '../../shared/rate-limit-types'
+import type { CodexRateLimitWindowsSnapshot } from './codex-rate-limit-window-classification'
+
+// Codex's pay-as-you-go credit balance, reported alongside the rate windows.
+// `balance` is a plain credit count (string), not a currency amount.
+type RpcCredits = NonNullable<CodexRateLimitWindowsSnapshot['credits']>
+
+// Codex credits are a unitless count, not currency. Only surface the balance
+// when the account actually has credits (or unlimited) so accounts that never
+// bought any don't get an empty "0 credits" row.
+export function mapCodexCredits(raw: RpcCredits | null | undefined): ExtraUsageBalance | null {
+  if (!raw || (raw.hasCredits !== true && raw.unlimited !== true)) {
+    return null
+  }
+  const parsed =
+    typeof raw.balance === 'string' && raw.balance.trim() !== '' ? Number(raw.balance) : raw.balance
+  if ((typeof parsed !== 'number' || !Number.isFinite(parsed)) && raw.unlimited !== true) {
+    return null
+  }
+  const balance = typeof parsed === 'number' && Number.isFinite(parsed) ? Math.max(0, parsed) : 0
+  return {
+    balance,
+    unit: 'credits',
+    unlimited: raw.unlimited === true,
+    enabled: raw.hasCredits === true || raw.unlimited === true,
+    disabledReason: null,
+    resetsAt: null
+  }
+}
diff --git a/src/main/rate-limits/codex-fetcher-credit-balance.test.ts b/src/main/rate-limits/codex-fetcher-credit-balance.test.ts
new file mode 100644
index 00000000000..780687c9a09
--- /dev/null
+++ b/src/main/rate-limits/codex-fetcher-credit-balance.test.ts
@@ -0,0 +1,137 @@
+import { EventEmitter } from 'node:events'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { childSpawnMock, readFileMock } = vi.hoisted(() => ({
+  childSpawnMock: vi.fn(),
+  readFileMock: vi.fn()
+}))
+
+vi.mock('node:child_process', () => ({ spawn: childSpawnMock }))
+vi.mock('node:fs/promises', () => ({ readFile: readFileMock }))
+vi.mock('../codex-cli/command', () => ({ resolveCodexCommand: () => 'codex' }))
+vi.mock('node-pty', () => ({ spawn: vi.fn() }))
+vi.mock('./codex-auth-presence', () => ({
+  probeCodexAuthPresence: vi.fn(async () => 'present')
+}))
+
+import { fetchCodexRateLimits } from './codex-fetcher'
+
+function parseRpcRequest(line: string): { id?: number; method?: string } {
+  const parsed: unknown = JSON.parse(line)
+  if (typeof parsed !== 'object' || parsed === null) {
+    return {}
+  }
+  return {
+    id: 'id' in parsed && typeof parsed.id === 'number' ? parsed.id : undefined,
+    method: 'method' in parsed && typeof parsed.method === 'string' ? parsed.method : undefined
+  }
+}
+
+// Like the real app-server, the fake dies on stdin EOF or a signal.
+class FakeRpcChild extends EventEmitter {
+  readonly stdout = new EventEmitter()
+  readonly stderr = new EventEmitter()
+  exitCode: number | null = null
+  rateLimits: unknown = null
+  readonly kill = vi.fn(() => {
+    this.exitNow()
+    return true
+  })
+  readonly stdin = Object.assign(new EventEmitter(), {
+    end: vi.fn(() => this.exitNow()),
+    write: vi.fn((line: string) => {
+      const request = parseRpcRequest(line)
+      if (request.method === 'initialize') {
+        this.reply(request.id, {})
+      }
+      if (request.method === 'account/rateLimits/read') {
+        this.reply(request.id, { rateLimits: this.rateLimits })
+      }
+    })
+  })
+
+  private reply(id: number | undefined, result: unknown): void {
+    setTimeout(() => {
+      this.stdout.emit('data', Buffer.from(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`))
+    }, 0)
+  }
+
+  private exitNow(): void {
+    this.exitCode = 0
+    this.emit('exit', 0, null)
+  }
+}
+
+async function fetchWithRateLimits(rateLimits: unknown) {
+  const child = new FakeRpcChild()
+  child.rateLimits = rateLimits
+  childSpawnMock.mockReturnValue(child)
+  const resultPromise = fetchCodexRateLimits()
+  await vi.advanceTimersByTimeAsync(1)
+  await vi.advanceTimersByTimeAsync(1)
+  return resultPromise
+}
+
+describe('fetchCodexRateLimits credit balance', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.clearAllMocks()
+    readFileMock.mockRejectedValue(new Error('no auth fixture'))
+    vi.stubGlobal('fetch', vi.fn())
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.unstubAllGlobals()
+  })
+
+  it('maps the RPC credits object into a Codex credit-count balance', async () => {
+    const result = await fetchWithRateLimits({
+      primary: { usedPercent: 20, windowDurationMins: 10079 },
+      secondary: null,
+      credits: { hasCredits: true, unlimited: false, balance: '500' }
+    })
+
+    expect(result.extraUsage).toMatchObject({
+      balance: 500,
+      unit: 'credits',
+      unlimited: false,
+      enabled: true
+    })
+  })
+
+  it('omits the Codex balance when the account has no credits', async () => {
+    const result = await fetchWithRateLimits({
+      primary: { usedPercent: 20, windowDurationMins: 10079 },
+      credits: { hasCredits: false, unlimited: false, balance: '0' }
+    })
+
+    expect(result.extraUsage ?? null).toBeNull()
+  })
+  it.each([undefined, null, '', '  ', 'invalid', 'Infinity', '1e999'])(
+    'omits unavailable credit balance %s despite hasCredits',
+    async (balance) => {
+      const result = await fetchWithRateLimits({
+        primary: { usedPercent: 20, windowDurationMins: 10079 },
+        credits: { hasCredits: true, unlimited: false, balance }
+      })
+      expect(result.extraUsage ?? null).toBeNull()
+    }
+  )
+
+  it('preserves an explicitly reported zero credit balance', async () => {
+    const result = await fetchWithRateLimits({
+      primary: { usedPercent: 20, windowDurationMins: 10079 },
+      credits: { hasCredits: true, unlimited: false, balance: '0' }
+    })
+    expect(result.extraUsage).toMatchObject({ unit: 'credits', unlimited: false, balance: 0 })
+  })
+
+  it('keeps the unlimited indication without requiring a numeric balance', async () => {
+    const result = await fetchWithRateLimits({
+      primary: { usedPercent: 20, windowDurationMins: 10079 },
+      credits: { hasCredits: false, unlimited: true, balance: null }
+    })
+    expect(result.extraUsage).toMatchObject({ unit: 'credits', unlimited: true, enabled: true })
+  })
+})
diff --git a/src/main/rate-limits/codex-rate-limit-window-classification.ts b/src/main/rate-limits/codex-rate-limit-window-classification.ts
index cdf667b6306..a19363bed8a 100644
--- a/src/main/rate-limits/codex-rate-limit-window-classification.ts
+++ b/src/main/rate-limits/codex-rate-limit-window-classification.ts
@@ -13,6 +13,12 @@ export type CodexRateWindowSnapshot = {
 export type CodexRateLimitWindowsSnapshot = {
   primary?: CodexRateWindowSnapshot | null
   secondary?: CodexRateWindowSnapshot | null
+  /** Pay-as-you-go credit balance, when the app-server reports one. */
+  credits?: {
+    hasCredits?: boolean
+    unlimited?: boolean
+    balance?: string | number
+  } | null
 }
 
 type MappableCodexRateWindowSnapshot = CodexRateWindowSnapshot & { usedPercent: number }
diff --git a/src/main/rate-limits/codex-rpc-rate-limit-probe.ts b/src/main/rate-limits/codex-rpc-rate-limit-probe.ts
index ededfa9c349..0c59403c35f 100644
--- a/src/main/rate-limits/codex-rpc-rate-limit-probe.ts
+++ b/src/main/rate-limits/codex-rpc-rate-limit-probe.ts
@@ -12,6 +12,7 @@ import {
   CODEX_WEEKLY_WINDOW_MINUTES,
   type CodexRateLimitWindowsSnapshot
 } from './codex-rate-limit-window-classification'
+import { mapCodexCredits } from './codex-credit-balance'
 import type { CodexRateLimitFetchOptions } from './codex-rate-limit-fetch-options'
 import { abortedCodexRateLimitResult } from './codex-rate-limit-fetch-result'
 import { mapCodexRateLimitWindow } from './codex-rate-limit-window-mapper'
@@ -244,12 +245,14 @@ export function readCodexRateLimitsViaRpc(
           const wrapper = message.result as RpcRateLimitsResponse | undefined
           const classified = classifyCodexRateLimitWindows(wrapper?.rateLimits)
           const credits = mapRpcRateLimitResetCredits(wrapper?.rateLimitResetCredits)
+          const extraUsage = mapCodexCredits(wrapper?.rateLimits?.credits)
           settle(
             {
               provider: 'codex',
               session: mapCodexRateLimitWindow(classified.session, CODEX_SESSION_WINDOW_MINUTES),
               weekly: mapCodexRateLimitWindow(classified.weekly, CODEX_WEEKLY_WINDOW_MINUTES),
               ...(credits !== undefined ? { rateLimitResetCredits: credits } : {}),
+              ...(extraUsage ? { extraUsage } : {}),
               updatedAt: Date.now(),
               error: null,
               status: 'ok'
diff --git a/src/main/rate-limits/cursor-fetcher.test.ts b/src/main/rate-limits/cursor-fetcher.test.ts
index bb07fb90b05..a075c37db99 100644
--- a/src/main/rate-limits/cursor-fetcher.test.ts
+++ b/src/main/rate-limits/cursor-fetcher.test.ts
@@ -78,6 +78,7 @@ describe('fetchCursorRateLimits', () => {
     await fetchCursorRateLimits({ authReadResult: session() })
     const [url, init] = netFetchMock.mock.calls[0] ?? []
     expect(url).toBe('https://cursor.com/api/usage-summary')
+    expect(init?.credentials).toBe('omit')
     expect(init?.headers).toMatchObject({
       Origin: 'https://cursor.com',
       Referer: 'https://cursor.com/dashboard',
diff --git a/src/main/rate-limits/cursor-fetcher.ts b/src/main/rate-limits/cursor-fetcher.ts
index 82bbf1c0e48..d6cbe09cfad 100644
--- a/src/main/rate-limits/cursor-fetcher.ts
+++ b/src/main/rate-limits/cursor-fetcher.ts
@@ -84,6 +84,8 @@ async function fetchDashboardJson(
   const res = await net.fetch(url, {
     // Keep dashboard redirects visible without forwarding session credentials.
     redirect: 'manual',
+    // The selected account's Cookie must not be replaced by Electron's session jar.
+    credentials: 'omit',
     headers: requestHeaders(session),
     signal: requestSignal
   })
diff --git a/src/main/rate-limits/opencode-go-status-parsing.test.ts b/src/main/rate-limits/opencode-go-status-parsing.test.ts
index 1116dcad71b..b77f12f80c8 100644
--- a/src/main/rate-limits/opencode-go-status-parsing.test.ts
+++ b/src/main/rate-limits/opencode-go-status-parsing.test.ts
@@ -1,5 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import {
+  isOpenCodeGoExplicitNoAccessPayload,
+  parseOpenCodeGoBillingStatusPayload,
   parseOpenCodeGoStatusPayload,
   parseOpenCodeGoUsageApiPayload
 } from './opencode-go-status-parsing'
@@ -120,6 +122,76 @@ describe('parseOpenCodeGoStatusPayload', () => {
   })
 })
 
+describe('parseOpenCodeGoBillingStatusPayload', () => {
+  it('maps the verified PAYG micro-cent string into USD major units', () => {
+    expect(
+      parseOpenCodeGoBillingStatusPayload(
+        JSON.stringify({
+          billingMode: 'prepaid',
+          mode: 'pay-as-you-go',
+          balanceMicroCents: '2786781005'
+        })
+      )
+    ).toBe(27.86781005)
+  })
+
+  it('preserves zero and negative balances', () => {
+    expect(
+      parseOpenCodeGoBillingStatusPayload(
+        JSON.stringify({
+          billingMode: 'prepaid',
+          mode: 'pay-as-you-go',
+          balanceMicroCents: '0'
+        })
+      )
+    ).toBe(0)
+    expect(
+      parseOpenCodeGoBillingStatusPayload(
+        JSON.stringify({
+          billingMode: 'prepaid',
+          mode: 'pay-as-you-go',
+          balanceMicroCents: '-125000000'
+        })
+      )
+    ).toBe(-1.25)
+  })
+
+  it.each([
+    { billingMode: 'credit', mode: 'pay-as-you-go', balanceMicroCents: '100000000' },
+    { billingMode: 'seat', mode: 'pay-as-you-go', balanceMicroCents: '100000000' },
+    { billingMode: 'prepaid', mode: 'invoiceable', balanceMicroCents: '100000000' },
+    { billingMode: 'prepaid', mode: 'pay-as-you-go', balanceMicroCents: 100000000 },
+    { billingMode: 'prepaid', mode: 'pay-as-you-go', balanceMicroCents: '1.5' },
+    {
+      billingMode: 'prepaid',
+      mode: 'pay-as-you-go',
+      balanceMicroCents: '9007199254740992'
+    }
+  ])('rejects unsupported or unsafe billing payloads: $billingMode/$mode', (payload) => {
+    expect(parseOpenCodeGoBillingStatusPayload(JSON.stringify(payload))).toBeNull()
+  })
+
+  it('fails closed for malformed and non-object bodies', () => {
+    expect(parseOpenCodeGoBillingStatusPayload('{not json')).toBeNull()
+    expect(parseOpenCodeGoBillingStatusPayload('[]')).toBeNull()
+    expect(parseOpenCodeGoBillingStatusPayload('')).toBeNull()
+  })
+})
+
+describe('isOpenCodeGoExplicitNoAccessPayload', () => {
+  it('accepts only explicit JSON null or access:null without an error verdict', () => {
+    expect(isOpenCodeGoExplicitNoAccessPayload('null')).toBe(true)
+    expect(isOpenCodeGoExplicitNoAccessPayload('{"access":null}')).toBe(true)
+    expect(
+      isOpenCodeGoExplicitNoAccessPayload('{"access":null,"error":{"type":"AuthError"}}')
+    ).toBe(false)
+    expect(isOpenCodeGoExplicitNoAccessPayload('{"access":{}}')).toBe(false)
+    expect(isOpenCodeGoExplicitNoAccessPayload('{}')).toBe(false)
+    expect(isOpenCodeGoExplicitNoAccessPayload('<html></html>')).toBe(false)
+    expect(isOpenCodeGoExplicitNoAccessPayload('{not json')).toBe(false)
+  })
+})
+
 describe('parseOpenCodeGoUsageApiPayload', () => {
   it('clamps an out-of-range percent and tolerates a missing resetsAt', () => {
     const parsed = parseOpenCodeGoUsageApiPayload(
diff --git a/src/main/rate-limits/opencode-go-status-parsing.ts b/src/main/rate-limits/opencode-go-status-parsing.ts
index cc98fd477ed..c4635792fc9 100644
--- a/src/main/rate-limits/opencode-go-status-parsing.ts
+++ b/src/main/rate-limits/opencode-go-status-parsing.ts
@@ -1,4 +1,4 @@
-import type { RateLimitWindow } from '../../shared/rate-limit-types'
+import type { ExtraUsageBalance, RateLimitWindow } from '../../shared/rate-limit-types'
 
 const SESSION_WINDOW_MINUTES = 300
 const WEEKLY_WINDOW_MINUTES = 10_080
@@ -100,6 +100,61 @@ export function parseOpenCodeGoUsageApiPayload(text: string): OpenCodeGoUsageWin
   }
 }
 
+// Console BillingStatus uses integer-string LedgerMicroCents (100,000,000 per USD).
+export function parseOpenCodeGoBillingStatusPayload(text: string): number | null {
+  if (!text || text.length > MAX_STATUS_PAYLOAD_CHARS) {
+    return null
+  }
+  let payload: unknown
+  try {
+    payload = JSON.parse(text)
+  } catch {
+    return null
+  }
+  if (
+    !isRecord(payload) ||
+    payload.billingMode !== 'prepaid' ||
+    payload.mode !== 'pay-as-you-go' ||
+    typeof payload.balanceMicroCents !== 'string' ||
+    !/^-?\d+$/.test(payload.balanceMicroCents)
+  ) {
+    return null
+  }
+  const microCents = Number(payload.balanceMicroCents)
+  return Number.isSafeInteger(microCents) ? microCents / 100_000_000 : null
+}
+
+export function makeOpenCodeGoZenBalance(
+  balance: number | null,
+  disabledReason: string | null = null
+): ExtraUsageBalance {
+  return {
+    balance,
+    unit: 'currency',
+    currencyCode: 'USD',
+    enabled: balance !== null,
+    disabledReason,
+    spent: null,
+    spendLimit: null,
+    spentPercent: null,
+    resetsAt: null
+  }
+}
+
+export function isOpenCodeGoExplicitNoAccessPayload(text: string): boolean {
+  if (!text || text.length > MAX_STATUS_PAYLOAD_CHARS) {
+    return false
+  }
+  try {
+    const payload: unknown = JSON.parse(text)
+    return (
+      payload === null || (isRecord(payload) && payload.access === null && !('error' in payload))
+    )
+  } catch {
+    return false
+  }
+}
+
 export function parseOpenCodeGoStatusPayload(text: string): OpenCodeGoUsageWindows | null {
   if (!text || text.length > MAX_STATUS_PAYLOAD_CHARS) {
     return null
diff --git a/src/main/rate-limits/opencode-go-usage-fetcher.test.ts b/src/main/rate-limits/opencode-go-usage-fetcher.test.ts
index 9e07f83f472..0c65c2fb788 100644
--- a/src/main/rate-limits/opencode-go-usage-fetcher.test.ts
+++ b/src/main/rate-limits/opencode-go-usage-fetcher.test.ts
@@ -15,6 +15,7 @@ import { fetchOpenCodeGoRateLimits, normalizeCookieInput } from './opencode-go-u
 
 const WORKSPACES_SERVER_ID = 'def39973159c7f0483d8793a822b8dbb10d067e12c65455fcb4608459ba0234f'
 const CONSOLE_STATUS_URL = 'https://opencode.ai/console/api/go/status'
+const CONSOLE_BILLING_STATUS_URL = 'https://opencode.ai/console/api/billing/status'
 const LEGACY_WORKSPACE_GO_URL = /https:\/\/opencode\.ai\/workspace\/[^/]+\/go/
 
 function makeResponse(body: string, status = 200): Response {
@@ -259,8 +260,10 @@ describe('fetchOpenCodeGoRateLimits', () => {
     netFetchMock
       .mockResolvedValueOnce(makeResponse(WORKSPACES_RESPONSE))
       .mockResolvedValueOnce(makeJsonResponse(STATUS_WITH_MONTHLY))
+      .mockResolvedValueOnce(makeResponse('unavailable', 503))
       .mockResolvedValueOnce(makeResponse(WORKSPACES_RESPONSE))
       .mockResolvedValueOnce(makeJsonResponse(STATUS_WITH_MONTHLY))
+      .mockResolvedValueOnce(makeResponse('unavailable', 503))
 
     const proxySettings = {
       httpProxyUrl: 'http://proxy.example:8080',
@@ -343,6 +346,254 @@ describe('fetchOpenCodeGoRateLimits', () => {
     })
   })
 
+  it.each(['discovery', 'override'])('accepts an org_ workspace from %s', async (source) => {
+    netFetchMock.mockImplementation(async (url) => {
+      if (String(url).startsWith('https://opencode.ai/_server')) {
+        return makeResponse('id: "org_CONSOLE123"')
+      }
+      return url === CONSOLE_STATUS_URL
+        ? makeJsonResponse(STATUS_WITH_MONTHLY)
+        : makeJsonResponse({
+            billingMode: 'prepaid',
+            mode: 'pay-as-you-go',
+            balanceMicroCents: '2786781005'
+          })
+    })
+
+    const result = await fetchOpenCodeGoRateLimits(
+      '__Host-console_session=placeholder',
+      source === 'override' ? 'org_CONSOLE123' : undefined
+    )
+
+    expect(result.status).toBe('ok')
+    expect(result.session?.usedPercent).toBe(30)
+    expect(result.extraUsage?.balance).toBe(27.86781005)
+    expect(netFetchMock).toHaveBeenCalledWith(
+      CONSOLE_BILLING_STATUS_URL,
+      expect.objectContaining({
+        headers: expect.objectContaining({ 'x-org-id': 'org_CONSOLE123' })
+      })
+    )
+  })
+
+  it('enriches the selected cookie workspace with its verified PAYG Zen balance', async () => {
+    netFetchMock.mockResolvedValueOnce(makeJsonResponse(STATUS_WITH_MONTHLY)).mockResolvedValueOnce(
+      makeJsonResponse({
+        billingMode: 'prepaid',
+        mode: 'pay-as-you-go',
+        balanceMicroCents: '2786781005'
+      })
+    )
+
+    const result = await fetchOpenCodeGoRateLimits(
+      '__Host-console_session=consoleTok',
+      'wrk_OVERRIDE123'
+    )
+
+    expect(netFetchMock).toHaveBeenNthCalledWith(
+      2,
+      CONSOLE_BILLING_STATUS_URL,
+      expect.objectContaining({
+        method: 'GET',
+        headers: expect.objectContaining({
+          'x-org-id': 'wrk_OVERRIDE123',
+          Accept: 'application/json'
+        })
+      })
+    )
+    expect(netFetchMock.mock.calls[1][1].headers).not.toHaveProperty('Cookie')
+    expect(result.extraUsage).toEqual({
+      balance: 27.86781005,
+      unit: 'currency',
+      currencyCode: 'USD',
+      enabled: true,
+      disabledReason: null,
+      spent: null,
+      spendLimit: null,
+      spentPercent: null,
+      resetsAt: null
+    })
+  })
+
+  it.each([
+    [
+      'unsupported mode',
+      makeJsonResponse({ billingMode: 'seat', mode: 'pay-as-you-go' }),
+      'billing-unavailable'
+    ],
+    ['billing failure', makeResponse('unavailable', 503), 'refresh-failed']
+  ])(
+    'keeps valid quota when optional billing has an %s',
+    async (_label, billingResponse, disabledReason) => {
+      netFetchMock
+        .mockResolvedValueOnce(makeJsonResponse(STATUS_WITH_MONTHLY))
+        .mockResolvedValueOnce(billingResponse)
+
+      const result = await fetchOpenCodeGoRateLimits('auth=mytoken', 'wrk_OVERRIDE123')
+
+      expect(result.status).toBe('ok')
+      expect(result.session?.usedPercent).toBe(30)
+      expect(result.extraUsage).toEqual(
+        expect.objectContaining({ balance: null, enabled: false, disabledReason })
+      )
+    }
+  )
+
+  it('returns a verified balance-only snapshot for explicit access:null', async () => {
+    netFetchMock.mockResolvedValueOnce(makeJsonResponse({ access: null })).mockResolvedValueOnce(
+      makeJsonResponse({
+        billingMode: 'prepaid',
+        mode: 'pay-as-you-go',
+        balanceMicroCents: '0'
+      })
+    )
+
+    const result = await fetchOpenCodeGoRateLimits('auth=mytoken', 'wrk_OVERRIDE123')
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        provider: 'opencode-go',
+        session: null,
+        weekly: null,
+        monthly: null,
+        error: null,
+        status: 'ok',
+        extraUsage: expect.objectContaining({ balance: 0, currencyCode: 'USD' })
+      })
+    )
+  })
+
+  it('returns a verified balance-only snapshot for an explicit JSON null status', async () => {
+    netFetchMock.mockResolvedValueOnce(makeJsonResponse(null)).mockResolvedValueOnce(
+      makeJsonResponse({
+        billingMode: 'prepaid',
+        mode: 'pay-as-you-go',
+        balanceMicroCents: '-125000000'
+      })
+    )
+
+    const result = await fetchOpenCodeGoRateLimits('auth=mytoken', 'wrk_OVERRIDE123')
+
+    expect(result.status).toBe('ok')
+    expect(result.session).toBeNull()
+    expect(result.extraUsage).toEqual(expect.objectContaining({ balance: -1.25 }))
+  })
+
+  it('aborts billing before returning a generic malformed-usage error', async () => {
+    let billingSignal: AbortSignal | undefined
+    netFetchMock
+      .mockResolvedValueOnce(makeJsonResponse({ access: {} }))
+      .mockImplementationOnce((_url, init: RequestInit) => {
+        billingSignal = init.signal ?? undefined
+        return new Promise<Response>((resolve, reject) => {
+          billingSignal?.addEventListener('abort', () => reject(new Error('aborted')), {
+            once: true
+          })
+          setTimeout(
+            () =>
+              resolve(
+                makeJsonResponse({
+                  billingMode: 'prepaid',
+                  mode: 'pay-as-you-go',
+                  balanceMicroCents: '100000000'
+                })
+              ),
+            100
+          )
+        })
+      })
+
+    const resultPromise = fetchOpenCodeGoRateLimits('auth=mytoken', 'wrk_OVERRIDE123')
+    await vi.advanceTimersByTimeAsync(0)
+    const abortedBeforeBillingResponse = billingSignal?.aborted
+    await vi.advanceTimersByTimeAsync(100)
+    const result = await resultPromise
+
+    expect(abortedBeforeBillingResponse).toBe(true)
+    expect(result.status).toBe('error')
+    expect(result.error).toBe('Could not parse usage data')
+    expect(clearStorageDataMock).toHaveBeenCalledTimes(2)
+  })
+
+  it('prefers a later valid Go workspace over an earlier balance-only candidate', async () => {
+    netFetchMock
+      .mockResolvedValueOnce(makeResponse('id: "wrk_FIRST" id: "wrk_SECOND"'))
+      .mockResolvedValueOnce(makeJsonResponse({ access: null }))
+      .mockResolvedValueOnce(
+        makeJsonResponse({
+          billingMode: 'prepaid',
+          mode: 'pay-as-you-go',
+          balanceMicroCents: '900000000'
+        })
+      )
+      .mockResolvedValueOnce(makeJsonResponse(STATUS_NO_MONTHLY))
+      .mockResolvedValueOnce(makeResponse('unavailable', 503))
+
+    const result = await fetchOpenCodeGoRateLimits('auth=mytoken')
+
+    expect(result.status).toBe('ok')
+    expect(result.session?.usedPercent).toBe(10)
+    expect(result.extraUsage).toEqual(
+      expect.objectContaining({ balance: null, enabled: false, disabledReason: 'refresh-failed' })
+    )
+    expect(netFetchMock).toHaveBeenNthCalledWith(
+      4,
+      CONSOLE_STATUS_URL,
+      expect.objectContaining({ headers: expect.objectContaining({ 'x-org-id': 'wrk_SECOND' }) })
+    )
+  })
+
+  it('aborts and settles an optional billing timeout before clearing the cookie jar', async () => {
+    let billingSignal: AbortSignal | undefined
+    netFetchMock
+      .mockResolvedValueOnce(makeJsonResponse(STATUS_WITH_MONTHLY))
+      .mockImplementationOnce((_url, init: RequestInit) => {
+        billingSignal = init.signal ?? undefined
+        return new Promise<Response>((_resolve, reject) => {
+          billingSignal?.addEventListener('abort', () => reject(new Error('aborted')), {
+            once: true
+          })
+        })
+      })
+
+    const resultPromise = fetchOpenCodeGoRateLimits('auth=mytoken', 'wrk_OVERRIDE123')
+    await vi.advanceTimersByTimeAsync(5_000)
+    const result = await resultPromise
+
+    expect(result.status).toBe('ok')
+    expect(result.session?.usedPercent).toBe(30)
+    expect(billingSignal?.aborted).toBe(true)
+    expect(clearStorageDataMock).toHaveBeenCalledTimes(2)
+  })
+
+  it('aborts and settles billing before continuing after a non-ok usage response', async () => {
+    let billingSignal: AbortSignal | undefined
+    let billingSettled = false
+    netFetchMock
+      .mockResolvedValueOnce(makeResponse('Unauthorized', 401))
+      .mockImplementationOnce((_url, init: RequestInit) => {
+        billingSignal = init.signal ?? undefined
+        return new Promise<Response>((_resolve, reject) => {
+          billingSignal?.addEventListener(
+            'abort',
+            () => {
+              billingSettled = true
+              reject(new Error('aborted'))
+            },
+            { once: true }
+          )
+        })
+      })
+
+    const result = await fetchOpenCodeGoRateLimits('auth=mytoken', 'wrk_OVERRIDE123')
+
+    expect(result.status).toBe('error')
+    expect(result.error).toContain('Usage fetch failed (401)')
+    expect(billingSignal?.aborted).toBe(true)
+    expect(billingSettled).toBe(true)
+    expect(clearStorageDataMock).toHaveBeenCalledTimes(2)
+  })
+
   it('returns ok with null monthly when the month meter is absent', async () => {
     netFetchMock
       .mockResolvedValueOnce(makeResponse(WORKSPACES_RESPONSE))
@@ -400,7 +651,7 @@ describe('fetchOpenCodeGoRateLimits', () => {
 
     const result = await fetchOpenCodeGoRateLimits('auth=mytoken', 'wrk_OVERRIDE123')
 
-    expect(netFetchMock).toHaveBeenCalledTimes(1)
+    expect(netFetchMock).toHaveBeenCalledTimes(2)
     expect(requestedUrls().some((url) => LEGACY_WORKSPACE_GO_URL.test(url))).toBe(false)
     expect(netFetchMock).toHaveBeenCalledWith(
       CONSOLE_STATUS_URL,
diff --git a/src/main/rate-limits/opencode-go-usage-fetcher.ts b/src/main/rate-limits/opencode-go-usage-fetcher.ts
index 451d2f316bc..d8ebf61d17d 100644
--- a/src/main/rate-limits/opencode-go-usage-fetcher.ts
+++ b/src/main/rate-limits/opencode-go-usage-fetcher.ts
@@ -1,17 +1,24 @@
 import type { Session } from 'electron'
 import { randomUUID } from 'node:crypto'
 import type { NetworkProxySettings } from '../../shared/network-proxy'
-import type { ProviderRateLimits } from '../../shared/rate-limit-types'
+import type { ExtraUsageBalance, ProviderRateLimits } from '../../shared/rate-limit-types'
 import {
   clearOpenCodeSessionCookies,
   createOpenCodeRequestSession,
   OPENCODE_BASE_URL
 } from './opencode-go-request-session'
-import { parseOpenCodeGoStatusPayload } from './opencode-go-status-parsing'
+import {
+  isOpenCodeGoExplicitNoAccessPayload,
+  makeOpenCodeGoZenBalance,
+  parseOpenCodeGoBillingStatusPayload,
+  parseOpenCodeGoStatusPayload
+} from './opencode-go-status-parsing'
 
 const OPENCODE_SERVER_URL = 'https://opencode.ai/_server'
 const OPENCODE_GO_STATUS_URL = `${OPENCODE_BASE_URL}/console/api/go/status`
+const OPENCODE_BILLING_STATUS_URL = `${OPENCODE_BASE_URL}/console/api/billing/status`
 const API_TIMEOUT_MS = 15_000
+const OPTIONAL_BILLING_TIMEOUT_MS = 5_000
 
 // Server-function hash for the workspaces endpoint — stable identifier used by
 // the opencode.ai SST/TanStack router server-fn protocol.
@@ -59,12 +66,9 @@ function parseAuthCookies(raw: string): { name: string; value: string }[] {
 }
 
 function parseWorkspaceIds(text: string): string[] {
-  // Match id:"wrk_..." or id: "wrk_..." patterns in JS-serialized output.
-  // Why: Workspace IDs follow a 'wrk_xxx' or 'wk_xxx' pattern. Using a
-  // more specific regex with word boundaries avoids picking up unrelated
-  // object properties that might match a generic ID pattern.
+  // Console uses org_/wrk_; wk_ remains accepted for older workspace responses.
   const ids: string[] = []
-  const workspaceIdRegex = /\bid\s*:\s*["']((?:wrk|wk)_[a-zA-Z0-9]+)["']/g
+  const workspaceIdRegex = /\bid\s*:\s*["']((?:org|wrk|wk)_[a-zA-Z0-9]+)["']/g
   for (const match of text.matchAll(workspaceIdRegex)) {
     const id = match[1]
     if (id && !ids.includes(id)) {
@@ -126,6 +130,35 @@ export async function fetchOpenCodeGoRateLimits(
   }
 }
 
+function startOptionalBillingFetch(openCodeSession: Session, workspaceId: string) {
+  const abortController = new AbortController()
+  const promise = (async (): Promise<ExtraUsageBalance> => {
+    const timeout = setTimeout(() => abortController.abort(), OPTIONAL_BILLING_TIMEOUT_MS)
+    try {
+      const response = await openCodeSession.fetch(OPENCODE_BILLING_STATUS_URL, {
+        method: 'GET',
+        headers: {
+          Accept: 'application/json',
+          Origin: OPENCODE_BASE_URL,
+          Referer: `${OPENCODE_BASE_URL}/console/${workspaceId}/billing`,
+          'x-org-id': workspaceId
+        },
+        signal: abortController.signal
+      })
+      if (!response.ok) {
+        return makeOpenCodeGoZenBalance(null, 'refresh-failed')
+      }
+      const balance = parseOpenCodeGoBillingStatusPayload(await response.text())
+      return makeOpenCodeGoZenBalance(balance, balance === null ? 'billing-unavailable' : null)
+    } catch {
+      return makeOpenCodeGoZenBalance(null, 'refresh-failed')
+    } finally {
+      clearTimeout(timeout)
+    }
+  })()
+  return { promise, abort: () => abortController.abort() }
+}
+
 function makeOpenCodeError(error: unknown): ProviderRateLimits {
   return {
     provider: 'opencode-go',
@@ -147,14 +180,14 @@ async function fetchOpenCodeGoRateLimitsWithSession(
   const override = workspaceIdOverride?.trim()
 
   if (override) {
-    if (!/^(wrk|wk)_[A-Za-z0-9]+$/.test(override)) {
+    if (!/^(org|wrk|wk)_[A-Za-z0-9]+$/.test(override)) {
       return {
         provider: 'opencode-go',
         session: null,
         weekly: null,
         monthly: null,
         updatedAt: Date.now(),
-        error: 'Invalid workspace ID format: must match ^(wrk|wk)_[A-Za-z0-9]+$',
+        error: 'Invalid workspace ID format: must match ^(org|wrk|wk)_[A-Za-z0-9]+$',
         status: 'error'
       }
     }
@@ -221,9 +254,11 @@ async function fetchOpenCodeGoRateLimitsWithSession(
   // Why: /workspace/<id>/go now 302s to console login. Usage is JSON at
   // /console/api/go/status, scoped by x-org-id and authed by the console session.
   let lastError = ''
+  let balanceOnlyResult: ProviderRateLimits | null = null
   for (const candidateId of ids) {
+    let billingTask: ReturnType<typeof startOptionalBillingFetch> | null = null
     try {
-      const statusRes = await openCodeSession.fetch(OPENCODE_GO_STATUS_URL, {
+      const statusPromise = openCodeSession.fetch(OPENCODE_GO_STATUS_URL, {
         method: 'GET',
         headers: {
           Accept: 'application/json',
@@ -233,8 +268,11 @@ async function fetchOpenCodeGoRateLimitsWithSession(
         },
         signal: AbortSignal.timeout(API_TIMEOUT_MS)
       })
-
+      billingTask = startOptionalBillingFetch(openCodeSession, candidateId)
+      const statusRes = await statusPromise
       if (!statusRes.ok) {
+        billingTask.abort()
+        await billingTask.promise
         lastError =
           statusRes.status === 401
             ? 'Usage fetch failed (401) — paste the full Cookie header including __Host-console_session (auth alone is not enough)'
@@ -242,25 +280,56 @@ async function fetchOpenCodeGoRateLimitsWithSession(
         continue
       }
 
-      const parsed = parseOpenCodeGoStatusPayload(await statusRes.text())
+      const statusText = await statusRes.text()
+      const parsed = parseOpenCodeGoStatusPayload(statusText)
+      const explicitNoAccess = isOpenCodeGoExplicitNoAccessPayload(statusText)
+      if (!parsed && !explicitNoAccess) {
+        billingTask.abort()
+        await billingTask.promise
+        lastError = 'Could not parse usage data'
+        continue
+      }
+
+      const balance = await billingTask.promise
       if (parsed) {
         return {
           provider: 'opencode-go',
           session: parsed.session,
           weekly: parsed.weekly,
           monthly: parsed.monthly,
+          extraUsage: balance,
           updatedAt: Date.now(),
           error: null,
           status: 'ok'
         }
       }
-      lastError = 'Could not parse usage data'
+      if (balance.balance !== null) {
+        balanceOnlyResult ??= {
+          provider: 'opencode-go',
+          session: null,
+          weekly: null,
+          monthly: null,
+          extraUsage: balance,
+          updatedAt: Date.now(),
+          error: null,
+          status: 'ok'
+        }
+      } else {
+        lastError = 'Could not parse usage data'
+      }
     } catch (err) {
+      if (billingTask) {
+        billingTask.abort()
+        await billingTask.promise
+      }
       const message = err instanceof Error ? err.message : 'Unknown error'
       lastError = message
     }
   }
 
+  if (balanceOnlyResult) {
+    return balanceOnlyResult
+  }
   return {
     provider: 'opencode-go',
     session: null,
diff --git a/src/main/rate-limits/opencode-go-usage-source-selection.test.ts b/src/main/rate-limits/opencode-go-usage-source-selection.test.ts
index 64b7ac622ca..44cc775afa4 100644
--- a/src/main/rate-limits/opencode-go-usage-source-selection.test.ts
+++ b/src/main/rate-limits/opencode-go-usage-source-selection.test.ts
@@ -66,6 +66,9 @@ describe('fetchOpenCodeGoUsage', () => {
     expect(result.status).toBe('ok')
     expect(result.session).toEqual(WINDOWS.session)
     expect(result.usageMetadata?.credentialSource).toBe('environment')
+    expect(result.extraUsage).toEqual(
+      expect.objectContaining({ balance: null, enabled: false, disabledReason: 'api-key-source' })
+    )
   })
 
   it('passes the settings override down as the highest-precedence tier', async () => {
diff --git a/src/main/rate-limits/opencode-go-usage-source-selection.ts b/src/main/rate-limits/opencode-go-usage-source-selection.ts
index c38fc1dc844..5973d8c1e91 100644
--- a/src/main/rate-limits/opencode-go-usage-source-selection.ts
+++ b/src/main/rate-limits/opencode-go-usage-source-selection.ts
@@ -4,7 +4,7 @@ import {
   resolveOpenCodeGoApiKey,
   type OpenCodeGoApiKeyResolution
 } from './opencode-go-api-key-source'
-import type { OpenCodeGoUsageWindows } from './opencode-go-status-parsing'
+import { makeOpenCodeGoZenBalance, type OpenCodeGoUsageWindows } from './opencode-go-status-parsing'
 import type { OpenCodeCredentialBackend } from '../opencode/opencode-credential-backend'
 import {
   fetchOpenCodeGoUsageWithApiKey,
@@ -52,6 +52,7 @@ function usageResult(
     session: windows.session,
     weekly: windows.weekly,
     monthly: windows.monthly,
+    extraUsage: makeOpenCodeGoZenBalance(null, 'api-key-source'),
     updatedAt: Date.now(),
     error: null,
     status: 'ok',
diff --git a/src/main/ripgrep/text-search-unicode-real.test.ts b/src/main/ripgrep/text-search-unicode-real.test.ts
index b56c1794a19..b2cc22c1aeb 100644
--- a/src/main/ripgrep/text-search-unicode-real.test.ts
+++ b/src/main/ripgrep/text-search-unicode-real.test.ts
@@ -108,6 +108,17 @@ describe('ripgrep Unicode match coordinates', () => {
     expect(result.truncated).toBe(false)
   })
 
+  it('keeps clipped emoji context intact around a real match', async () => {
+    const prefix = '😀'.repeat(300)
+    await writeFile(join(root, 'emoji.txt'), `${prefix}x${prefix}\n`)
+    const match = (await search('x')).files[0]?.matches[0]
+    expect(match?.column).toBe(601)
+    expect(match?.matchLength).toBe(1)
+    expect(match?.lineContent.isWellFormed()).toBe(true)
+    expect(match?.lineContent.length).toBeLessThanOrEqual(502)
+    expect(match?.lineContent.slice((match.displayColumn ?? 1) - 1, match.displayColumn)).toBe('x')
+  })
+
   it('ignores external rg config while retaining workspace ignore files', async () => {
     const config = join(root, 'config')
     await writeFile(config, '--invert-match\n')
diff --git a/src/main/runtime/browser-screencast-driver-attribution.test.ts b/src/main/runtime/browser-screencast-driver-attribution.test.ts
index 59a8b6b98ca..678cb2caa0c 100644
--- a/src/main/runtime/browser-screencast-driver-attribution.test.ts
+++ b/src/main/runtime/browser-screencast-driver-attribution.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 /**
  * `browser.screencast` is the one stream a phone, a paired desktop client, the web client and the
  * CLI all open against the same host page. Stamping every subscriber as the mobile driver put the
diff --git a/src/main/runtime/claude-structured-session-integration.test.ts b/src/main/runtime/claude-structured-session-integration.test.ts
index a12fc06c479..b75b4a06024 100644
--- a/src/main/runtime/claude-structured-session-integration.test.ts
+++ b/src/main/runtime/claude-structured-session-integration.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 import { mkdir, mkdtemp, rm } from 'node:fs/promises'
 import { homedir, tmpdir } from 'node:os'
 import { join } from 'node:path'
diff --git a/src/main/runtime/opencode-model-worktree-create.test.ts b/src/main/runtime/opencode-model-worktree-create.test.ts
new file mode 100644
index 00000000000..078a5c5e5e3
--- /dev/null
+++ b/src/main/runtime/opencode-model-worktree-create.test.ts
@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const resolveRepo = vi.hoisted(() => vi.fn())
+vi.mock('./orca-runtime-get-worktree-terminal-provisioning-host', () => ({
+  OrcaRuntimeWithGetWorktreeTerminalProvisioningHost: class {
+    store = { getSettings: () => ({ disabledTuiAgents: [] }) }
+    resolveRepoSelector = resolveRepo
+  }
+}))
+vi.mock('../workspace-create-telemetry', () => ({
+  trackRuntimeWorkspaceCreate: (
+    _request: unknown,
+    execute: (events: { begin: ReturnType<typeof vi.fn> }) => Promise<unknown>
+  ) => execute({ begin: vi.fn() })
+}))
+vi.mock('electron', () => ({
+  app: { getPath: () => '/private/test', isPackaged: false },
+  BrowserWindow: { fromId: vi.fn() },
+  ipcMain: { on: vi.fn(), removeListener: vi.fn() }
+}))
+
+import { OrcaRuntimeWithCreateManagedWorktree } from './orca-runtime-create-managed-worktree'
+
+describe('unverified OpenCode model worktree creation', () => {
+  beforeEach(() => {
+    resolveRepo.mockReset()
+    resolveRepo.mockRejectedValue(new Error('repo_read_before_model_refusal'))
+  })
+
+  it.each(['local-repo', 'folder-repo', 'ssh-repo'])(
+    'refuses %s before resolving or creating its workspace',
+    async (repoSelector) => {
+      const runtime = new OrcaRuntimeWithCreateManagedWorktree()
+      await expect(
+        runtime.createManagedWorktree({
+          repoSelector,
+          name: 'unverified-model',
+          startupAgent: 'opencode',
+          startupLaunchPreferences: { model: 'private-proof/model-b' }
+        })
+      ).rejects.toMatchObject({ code: 'capability_unsupported' })
+      expect(resolveRepo).not.toHaveBeenCalled()
+    }
+  )
+
+  it('preserves worktree creation without a model preference', async () => {
+    const runtime = new OrcaRuntimeWithCreateManagedWorktree()
+    await expect(
+      runtime.createManagedWorktree({
+        repoSelector: 'local-repo',
+        name: 'ordinary',
+        startupAgent: 'opencode'
+      })
+    ).rejects.toThrow('repo_read_before_model_refusal')
+    expect(resolveRepo).toHaveBeenCalledOnce()
+  })
+})
diff --git a/src/main/runtime/orca-runtime-create-agent-session.ts b/src/main/runtime/orca-runtime-create-agent-session.ts
index 36e4d3f41a1..b2ba25b7d73 100644
--- a/src/main/runtime/orca-runtime-create-agent-session.ts
+++ b/src/main/runtime/orca-runtime-create-agent-session.ts
@@ -17,7 +17,7 @@ import {
 } from './orca-runtime-core'
 import { isTuiAgentEnabled } from '../../shared/tui-agent-selection'
 import { resolveAgentStartupPlanInputs } from '../../shared/agent-startup-plan-inputs'
-import { buildAgentDraftLaunchPlan, buildAgentStartupPlan } from '../../shared/tui-agent-startup'
+import { buildExecutionHostAgentStartupPlan } from '../opencode/opencode-model-startup-plan'
 import type { RuntimeTerminalCreate } from '../../shared/runtime-types'
 import type {
   AgentSessionCreateOperation,
@@ -159,14 +159,14 @@ export class OrcaRuntimeWithCreateAgentSession extends OrcaRuntimeWithGetAgentSe
         ...(request.agentArgs !== undefined ? { agentArgs: request.agentArgs } : {}),
         sessionOptions: this.toAgentSessionOptions(request.launchPreferences)
       })
-      const startup =
-        request.promptDelivery === 'draft'
-          ? buildAgentDraftLaunchPlan({ ...startupArgs, draft: request.prompt ?? '' })
-          : buildAgentStartupPlan({
-              ...startupArgs,
-              prompt: request.prompt ?? '',
-              allowEmptyPromptLaunch: true
-            })
+      const startup = await buildExecutionHostAgentStartupPlan({
+        inputs: startupArgs,
+        cwd: startupCwd ?? workspace.path,
+        prompt: request.prompt ?? '',
+        promptDelivery: request.promptDelivery,
+        hostIdentity: this.runtimeId,
+        signal: caller.signal
+      })
       if (!startup) {
         throw new Error('agent_session_identity_required')
       }
diff --git a/src/main/runtime/orca-runtime-create-managed-worktree.ts b/src/main/runtime/orca-runtime-create-managed-worktree.ts
index 63e3a010772..5e8cf5e9d8a 100644
--- a/src/main/runtime/orca-runtime-create-managed-worktree.ts
+++ b/src/main/runtime/orca-runtime-create-managed-worktree.ts
@@ -13,15 +13,15 @@ import { prepareRuntimeLocalWorktreeSetup } from './runtime-local-worktree-setup
 import { invalidateAuthorizedRootsCacheForRepo } from '../ipc/filesystem-auth'
 import { startRuntimeLocalWorktreeTerminals } from './runtime-local-worktree-terminal-startup'
 import { trackRuntimeWorkspaceCreate } from '../workspace-create-telemetry'
+import { assertOpenCodeModelLaunchPreferencesAbsent } from '../opencode/opencode-model-startup-plan'
+import { resolveWorktreeCreateAgentStartup } from './runtime-worktree-agent-startup'
 import type { RuntimeWorkspaceCreateEvents } from '../workspace-create-telemetry'
 
 export class OrcaRuntimeWithCreateManagedWorktree extends OrcaRuntimeWithGetWorktreeTerminalProvisioningHost {
   async createManagedWorktree(
     args: RuntimeManagedWorktreeCreateArgs
   ): Promise<CreateWorktreeResult> {
-    // Why a holder fired in `finally`: consuming a prepared checkout empties a pool slot, so a
-    // create that fails anywhere after that — include copy, push target, terminal startup — must
-    // still arm the replacement. On success it fires last, once the startup terminals are up.
+    // Re-arm a consumed checkout after terminal startup, including failed creates.
     const rearm: PreparationRearmHolder = { fire: () => {} }
     try {
       return await trackRuntimeWorkspaceCreate(args, (events) =>
@@ -41,6 +41,11 @@ export class OrcaRuntimeWithCreateManagedWorktree extends OrcaRuntimeWithGetWork
       throw new Error('runtime_unavailable')
     }
 
+    assertOpenCodeModelLaunchPreferencesAbsent(
+      args.startupAgent ?? args.createdWithAgent,
+      args.startupLaunchPreferences
+    )
+
     const repo = await this.resolveRepoSelector(args.repoSelector)
     const createSettings = this.store.getSettings()
     const requestedAgent = args.startupAgent ?? args.createdWithAgent
@@ -58,19 +63,9 @@ export class OrcaRuntimeWithCreateManagedWorktree extends OrcaRuntimeWithGetWork
     ) {
       throw new Error('Selected agent is disabled. Choose an enabled agent before creating.')
     }
-    const agentStartup =
-      !args.startup && args.startupAgent
-        ? this.buildStartupForAgent(
-            repo,
-            args.startupAgent,
-            args.startupPrompt,
-            args.startupLaunchPreferences,
-            {
-              ...(args.startupAgentArgs !== undefined ? { agentArgs: args.startupAgentArgs } : {}),
-              ...(args.startupLaunchSource ? { launchSource: args.startupLaunchSource } : {})
-            }
-          )
-        : null
+    const agentStartup = resolveWorktreeCreateAgentStartup(args, (...inputs) =>
+      this.buildStartupForAgent(repo, ...inputs)
+    )
     const draftStartup =
       !args.startup && !agentStartup && args.startupDraft
         ? await this.buildStartupForDraft(
@@ -88,10 +83,7 @@ export class OrcaRuntimeWithCreateManagedWorktree extends OrcaRuntimeWithGetWork
         draftStartup?.agent ??
         (requestedAgentEnabled ? requestedAgent : undefined))
     const effectiveDraftPaste = args.startupDraftPaste ?? draftStartup?.draftPaste
-    // Resolve the execution host once, shared with the `worktrees:create` IPC entry point so the
-    // two cannot answer differently for the same repo. Reading the raw `connectionId` field routes
-    // an `executionHostId: 'ssh:*'`-only repo down the local path, which runs `git worktree add` on
-    // the client against a remote path.
+    // Match IPC routing: executionHostId-only SSH repos must not create locally.
     const createRoute = resolveWorktreeCreateRoute(repo)
     if (isFolderRepo(repo)) {
       // A folder workspace is a registration, not a filesystem create, so it is host-agnostic.
diff --git a/src/main/runtime/orca-runtime-create-runtime-owned-mobile-session-terminal.ts b/src/main/runtime/orca-runtime-create-runtime-owned-mobile-session-terminal.ts
index f1b8fa16af5..0799fd1b17a 100644
--- a/src/main/runtime/orca-runtime-create-runtime-owned-mobile-session-terminal.ts
+++ b/src/main/runtime/orca-runtime-create-runtime-owned-mobile-session-terminal.ts
@@ -9,6 +9,8 @@ import type {
   RuntimeMobileSessionTerminalTab
 } from '../../shared/runtime-types'
 import { randomUUID } from 'node:crypto'
+import { copySleepingAgentLaunchConfig } from './runtime-agent-launch-resolution'
+import { deriveRemoteRuntimeTerminalCreateHandle } from './remote-runtime-terminal-create-identity'
 import { parsePaneKey } from '../../shared/stable-pane-id'
 import { placeCreatedSessionTab } from '../../shared/session-tab-placement'
 import {
@@ -17,7 +19,28 @@ import {
   getHeadlessMobileSessionGroupId
 } from './mobile-session-layout-projection'
 
+const OWNED_MOBILE_DISPATCH_RECIPE_TTL_MS = 15 * 60_000
+
 export class OrcaRuntimeWithCreateRuntimeOwnedMobileSessionTerminal extends OrcaRuntimeWithResolveMobileSessionTerminalCommand {
+  private readonly ownedMobileDispatchRecipes = new Map<
+    string,
+    {
+      launchConfig?: SleepingAgentLaunchConfig
+      launchAgent?: TuiAgent
+      connectionId: string | null
+      recordedAt: number
+    }
+  >()
+
+  private pruneOwnedMobileDispatchRecipes(): void {
+    const now = Date.now()
+    for (const [handle, recipe] of this.ownedMobileDispatchRecipes) {
+      if (now - recipe.recordedAt >= OWNED_MOBILE_DISPATCH_RECIPE_TTL_MS) {
+        this.ownedMobileDispatchRecipes.delete(handle)
+      }
+    }
+  }
+
   protected async createRuntimeOwnedMobileSessionTerminal(
     worktreeId: string,
     activate: boolean,
@@ -29,6 +52,7 @@ export class OrcaRuntimeWithCreateRuntimeOwnedMobileSessionTerminal extends Orca
       envToDelete?: string[]
       startupCommandDelivery?: WorktreeStartupLaunch['startupCommandDelivery']
       identity?: { tabId: string; leafId: string; sessionId?: string }
+      createMutation?: { clientIdentity: string; id: string }
       launchAgent?: TuiAgent
       viewMode?: 'terminal' | 'chat'
       targetGroupId?: string
@@ -37,41 +61,122 @@ export class OrcaRuntimeWithCreateRuntimeOwnedMobileSessionTerminal extends Orca
       signal?: AbortSignal
     } = {}
   ): Promise<RuntimeMobileSessionCreateTerminalResult> {
+    this.pruneOwnedMobileDispatchRecipes()
     const workspace = await this.resolveTerminalWorkspaceLaunchScope(`id:${worktreeId}`)
     const cwd = this.resolveWorkspaceTerminalStartupCwd(workspace, opts.cwd)
     // Why: SshPtyProvider treats sessionId as a relay reattach; only synthesize local serve ids so SSH fresh terminals still call pty.spawn.
     const stableSessionId =
       opts.identity?.sessionId ?? (workspace.connectionId ? undefined : `serve-${randomUUID()}`)
     const isNewSession = stableSessionId !== undefined && opts.identity?.sessionId === undefined
-    const terminal = await this.createTerminal(`id:${worktreeId}`, {
-      focus: false,
-      command: opts.command,
-      cwd,
-      env: opts.env,
-      envToDelete: opts.envToDelete,
-      ...(opts.launchConfig ? { launchConfig: opts.launchConfig } : {}),
-      ...(opts.launchAgent ? { launchAgent: opts.launchAgent } : {}),
-      ...(opts.viewMode ? { viewMode: opts.viewMode } : {}),
-      startupCommandDelivery: opts.startupCommandDelivery,
-      ...(opts.identity
-        ? {
-            tabId: opts.identity.tabId,
-            leafId: opts.identity.leafId,
-            ...(stableSessionId ? { sessionId: stableSessionId } : {})
-          }
-        : stableSessionId
-          ? { sessionId: stableSessionId }
+    const mutationHandle = opts.createMutation
+      ? deriveRemoteRuntimeTerminalCreateHandle(
+          opts.createMutation.clientIdentity,
+          worktreeId,
+          opts.createMutation.id
+        )
+      : undefined
+    const create = (preAllocatedHandle?: string) =>
+      this.createTerminal(`id:${worktreeId}`, {
+        focus: false,
+        ...(mutationHandle
+          ? {
+              onPtySpawnDispatched: (launch) => {
+                if (!launch) {
+                  return
+                }
+                if (
+                  !this.ownedMobileDispatchRecipes.has(mutationHandle) &&
+                  this.ownedMobileDispatchRecipes.size >= 4096
+                ) {
+                  throw new Error('runtime_unavailable')
+                }
+                // Retain original dispatch evidence across an ambiguous response; retry payloads cannot replace it.
+                this.ownedMobileDispatchRecipes.set(mutationHandle, {
+                  connectionId: workspace.connectionId ?? null,
+                  recordedAt: Date.now(),
+                  ...(launch.launchConfig
+                    ? { launchConfig: copySleepingAgentLaunchConfig(launch.launchConfig) }
+                    : {}),
+                  ...(launch.launchAgent ? { launchAgent: launch.launchAgent } : {})
+                })
+              }
+            }
           : {}),
-      ...(isNewSession ? { isNewSession: true } : {}),
-      persistHostSessionBinding: true,
-      // Why: this method publishes the authoritative snapshot below; skip the intermediate publish to avoid a wrong-group flash.
-      deferMobileSessionPublish: true,
-      signal: opts.signal
-    })
+        ...(preAllocatedHandle ? { preAllocatedHandle } : {}),
+        command: opts.command,
+        cwd,
+        env: opts.env,
+        envToDelete: opts.envToDelete,
+        ...(opts.launchConfig ? { launchConfig: opts.launchConfig } : {}),
+        ...(opts.launchAgent ? { launchAgent: opts.launchAgent } : {}),
+        ...(opts.viewMode ? { viewMode: opts.viewMode } : {}),
+        startupCommandDelivery: opts.startupCommandDelivery,
+        ...(opts.identity
+          ? {
+              tabId: opts.identity.tabId,
+              leafId: opts.identity.leafId,
+              ...(stableSessionId ? { sessionId: stableSessionId } : {})
+            }
+          : stableSessionId
+            ? { sessionId: stableSessionId }
+            : {}),
+        ...(isNewSession ? { isNewSession: true } : {}),
+        persistHostSessionBinding: true,
+        // Why: this method publishes the authoritative snapshot below; skip the intermediate publish to avoid a wrong-group flash.
+        deferMobileSessionPublish: true,
+        signal: opts.signal
+      })
+    const terminal = opts.createMutation
+      ? await this.dedupeTerminalCreate(
+          opts.createMutation.clientIdentity,
+          `id:${worktreeId}`,
+          opts.createMutation.id,
+          true,
+          (_selector, handle) => create(handle)
+        )
+      : await create()
     const livePty = this.getLivePtyForHandle(terminal.handle)
     if (!livePty) {
       throw new Error('terminal_handle_stale')
     }
+    if (opts.createMutation) {
+      if (
+        livePty.pty.launchAgent &&
+        opts.launchAgent &&
+        livePty.pty.launchAgent !== opts.launchAgent
+      ) {
+        throw new Error('terminal_create_identity_conflict')
+      }
+      const dispatchedRecipe =
+        mutationHandle === terminal.handle && this.ownedMobileDispatchRecipes.get(terminal.handle)
+      const recipe =
+        dispatchedRecipe &&
+        dispatchedRecipe.connectionId === (workspace.connectionId ?? null) &&
+        (!livePty.pty.launchAgent || livePty.pty.launchAgent === dispatchedRecipe.launchAgent)
+          ? dispatchedRecipe
+          : null
+      if (opts.launchConfig && !livePty.pty.launchConfig && !recipe?.launchConfig) {
+        // Missing original dispatch evidence cannot authorize a retry's captured recipe.
+        throw new Error('runtime_unavailable')
+      }
+      if (recipe) {
+        livePty.pty.launchAgent ??= recipe.launchAgent ?? null
+        if (!livePty.pty.launchConfig && recipe.launchConfig) {
+          livePty.pty.launchConfig = copySleepingAgentLaunchConfig(recipe.launchConfig)
+        }
+      }
+      livePty.pty.runtimeSessionOwned = true
+      if (mutationHandle) {
+        this.ownedMobileDispatchRecipes.delete(mutationHandle)
+      }
+    }
+    if (opts.createMutation && opts.identity && terminal.ptyId) {
+      this.registerPty(terminal.ptyId, worktreeId, workspace.connectionId ?? null, {
+        tabId: opts.identity.tabId,
+        leafId: opts.identity.leafId,
+        terminalHandle: terminal.handle
+      })
+    }
     const parentTabId = livePty.pty.tabId ?? `pty:${livePty.pty.ptyId}`
     const leafId = parsePaneKey(livePty.pty.paneKey ?? '')?.leafId ?? randomUUID()
     if (opts.viewMode) {
diff --git a/src/main/runtime/orca-runtime-create-terminal.ts b/src/main/runtime/orca-runtime-create-terminal.ts
index 4b8ff9cc744..eba6d03a29a 100644
--- a/src/main/runtime/orca-runtime-create-terminal.ts
+++ b/src/main/runtime/orca-runtime-create-terminal.ts
@@ -121,7 +121,8 @@ export class OrcaRuntimeWithCreateTerminal extends OrcaRuntimeWithTerminalCreate
         }
         let result: Awaited<ReturnType<NonNullable<dependencies.RuntimePtyController['spawn']>>>
         try {
-          launchOpts.onPtySpawnDispatched?.()
+          const { launchAgent } = launchOpts
+          launchOpts.onPtySpawnDispatched?.({ launchConfig: effectiveLaunchConfig, launchAgent })
           result = await this.ptyController.spawn({
             cols: 120,
             rows: 40,
diff --git a/src/main/runtime/orca-runtime-files-ssh-chunk-reads.test.ts b/src/main/runtime/orca-runtime-files-ssh-chunk-reads.test.ts
index 13e5bbb8682..edb546b0396 100644
--- a/src/main/runtime/orca-runtime-files-ssh-chunk-reads.test.ts
+++ b/src/main/runtime/orca-runtime-files-ssh-chunk-reads.test.ts
@@ -1,11 +1,6 @@
 import { createHash } from 'node:crypto'
 import { describe, expect, it, vi } from 'vitest'
-import {
-  enoent,
-  openMock,
-  resolveAuthorizedPathMock,
-  statMock
-} from './orca-runtime-files-mock-registry'
+import { enoent, openMock, resolveAuthorizedPathMock } from './orca-runtime-files-mock-registry'
 import {
   createRuntimeFileCommands,
   useRuntimeFileCommandsLifecycle
@@ -313,9 +308,9 @@ describe('RuntimeFileCommands.readFileExplorerChunk over SSH', () => {
     const contents = remoteFileBytes(2048)
     const { commands } = createRuntimeFileCommands()
     resolveAuthorizedPathMock.mockResolvedValue('/repo/local.bin')
-    statMock.mockResolvedValue({ isDirectory: () => false, size: contents.byteLength })
     const close = vi.fn(async () => undefined)
     openMock.mockResolvedValue({
+      stat: vi.fn(async () => ({ isFile: () => true, size: contents.byteLength })),
       read: vi.fn(
         async (buffer: Buffer, bufferOffset: number, length: number, position: number) => {
           const bytesRead = contents.copy(buffer, bufferOffset, position, position + length)
diff --git a/src/main/runtime/orca-runtime-get-agent-session-execution-namespace.ts b/src/main/runtime/orca-runtime-get-agent-session-execution-namespace.ts
index 7f968a6ba7d..8b03eebd650 100644
--- a/src/main/runtime/orca-runtime-get-agent-session-execution-namespace.ts
+++ b/src/main/runtime/orca-runtime-get-agent-session-execution-namespace.ts
@@ -13,6 +13,7 @@ import { canonicalizeAgentSessionIdentity } from './agent-session-claim-identity
 import { isTuiAgentEnabled } from '../../shared/tui-agent-selection'
 import { resolveLocalWindowsAgentStartupShell } from '../../shared/windows-terminal-shell'
 import { buildAgentResumeStartupPlan } from '../../shared/tui-agent-startup'
+import { OrchestrationError } from './orchestration/orchestration-error'
 import {
   resolveTuiAgentLaunchArgs,
   resolveTuiAgentLaunchEnv
@@ -93,6 +94,15 @@ export class OrcaRuntimeWithGetAgentSessionExecutionNamespace extends OrcaRuntim
       // Legacy renderer sleep records are migration evidence, not host authority.
       throw new Error('agent_session_resume_not_authorized')
     }
+    if (
+      request.agent === 'opencode' &&
+      Object.values(request.launchPreferences ?? {}).some((value) => value !== undefined)
+    ) {
+      throw new OrchestrationError(
+        'capability_unsupported',
+        'OpenCode resume preferences are not verified by this execution host.'
+      )
+    }
     if (!this.store) {
       throw new Error('runtime_unavailable')
     }
diff --git a/src/main/runtime/orca-runtime-get-terminal-interactive-wait.ts b/src/main/runtime/orca-runtime-get-terminal-interactive-wait.ts
index 82969ecb1da..567cbe6896d 100644
--- a/src/main/runtime/orca-runtime-get-terminal-interactive-wait.ts
+++ b/src/main/runtime/orca-runtime-get-terminal-interactive-wait.ts
@@ -19,6 +19,11 @@ import { resolveLocalWindowsAgentStartupShell } from '../../shared/windows-termi
 import { resolveStartupShell, type AgentStartupShell } from '../../shared/tui-agent-startup-shell'
 import { isTuiAgent } from '../../shared/tui-agent-config'
 import { resolveConfiguredWorkerAgent } from './orchestration/configured-worker-agent-selector'
+import { parseWslUncPath } from '../../shared/wsl-paths'
+import { resolveLocalProjectRuntimeForRepo } from '../project-runtime-git-options'
+
+import { prepareOpenCodeModelStartupInputs } from '../opencode/opencode-model-startup-plan'
+import { resolveAgentStartupPlanInputs } from '../../shared/agent-startup-plan-inputs'
 
 export class OrcaRuntimeWithGetTerminalInteractiveWait extends OrcaRuntimeWithAdoptTerminalOrphansFromInventory {
   async getTerminalInteractiveWait(
@@ -223,6 +228,58 @@ export class OrcaRuntimeWithGetTerminalInteractiveWait extends OrcaRuntimeWithAd
     return this.resolveOrchestrationAgentLauncher(selector, platform, shell)
   }
 
+  async probeOrchestrationOpenCodeModelLaunchSupport(target: {
+    worktree?: string
+    model?: string
+  }): Promise<boolean> {
+    if (!target.model || !target.worktree) {
+      return false
+    }
+    const workspace = await this.resolveTerminalWorkspaceLaunchScope(target.worktree)
+    const executionRepo = workspace?.repo
+    if (
+      workspace?.connectionId ||
+      (executionRepo?.executionHostId && executionRepo.executionHostId !== 'local')
+    ) {
+      return false
+    }
+    const store = this.requireStore()
+    const settings = store.getSettings()
+    const path = workspace?.path
+    const unc = path ? parseWslUncPath(path) : null
+    const projectRuntime = executionRepo
+      ? resolveLocalProjectRuntimeForRepo(store, executionRepo)
+      : null
+    if (projectRuntime?.status === 'repair-required') {
+      return false
+    }
+    const wsl = unc
+      ? { distro: unc.distro }
+      : projectRuntime?.runtime.kind === 'wsl'
+        ? { distro: projectRuntime.runtime.distro }
+        : undefined
+    if (!path) {
+      return false
+    }
+    try {
+      await prepareOpenCodeModelStartupInputs({
+        inputs: resolveAgentStartupPlanInputs({
+          agent: 'opencode',
+          settings,
+          platform: wsl ? 'linux' : process.platform,
+          isRemote: false,
+          sessionOptions: { model: target.model }
+        }),
+        cwd: path,
+        isWsl: Boolean(wsl),
+        hostIdentity: this.getRuntimeId()
+      })
+      return true
+    } catch {
+      return false
+    }
+  }
+
   validateOrchestrationAgentLauncher(agent: TuiAgent): void {
     const settings = this.store?.getSettings()
     if (!settings) {
diff --git a/src/main/runtime/orca-runtime-resolve-worktree-removal-target.ts b/src/main/runtime/orca-runtime-resolve-worktree-removal-target.ts
index 71b919bbf1b..115a5be8f0d 100644
--- a/src/main/runtime/orca-runtime-resolve-worktree-removal-target.ts
+++ b/src/main/runtime/orca-runtime-resolve-worktree-removal-target.ts
@@ -20,14 +20,9 @@ import type {
 import type { RuntimeTerminalRename } from '../../shared/runtime-types'
 import type { TerminalWorkspaceLaunchScope } from './runtime-legacy-worker-terminal-recovery-types'
 import type { TerminalCreateOptions } from './runtime-terminal-contracts'
-import { isTuiAgentEnabled } from '../../shared/tui-agent-selection'
 import { terminalShellOverrideRefusal } from './terminal-shell-override-host-support'
 import { resolveTerminalStartupCwd } from '../../shared/terminal-startup-cwd'
 import { resolveLocalProjectRuntimeForWorktreeId } from '../local-project-runtime-resolution'
-import { resolveBareAgentLaunchCommand } from './runtime-agent-launch-resolution'
-import { buildAgentStartupPlan } from '../../shared/tui-agent-startup'
-import { resolveAgentStartupPlanInputs } from '../../shared/agent-startup-plan-inputs'
-import { agentStartedTelemetry } from '../agent-launch/agent-started-telemetry'
 import { LOCAL_EXECUTION_HOST_ID, parseExecutionHostId } from '../../shared/execution-host'
 import { invalidateAuthorizedRootsCache } from '../ipc/filesystem-auth'
 import {
@@ -38,6 +33,8 @@ import {
 import { interruptedLocalWorktreeRemovalJob } from './runtime-interrupted-local-worktree-removal'
 import { retryFailedRemovalUnlessRegistered } from '../worktree-removal-table'
 import type { GitWorktreeInfo } from '../../shared/worktree/types'
+import { resolveQoderTerminalCommandForWorkspace } from './qoder-terminal-command-resolution'
+import { buildRuntimeAgentTerminalStartupOptions } from './runtime-agent-terminal-startup'
 
 export class OrcaRuntimeWithResolveWorktreeRemovalTarget extends OrcaRuntimeWithRemoveManagedWorktree {
   protected async resolveWorktreeRemovalTarget(
@@ -243,6 +240,19 @@ export class OrcaRuntimeWithResolveWorktreeRemovalTarget extends OrcaRuntimeWith
   protected async resolveAgentTerminalCreateOptions(
     workspace: TerminalWorkspaceLaunchScope,
     opts: TerminalCreateOptions
+  ): Promise<TerminalCreateOptions> {
+    const launch = await this.buildAgentTerminalCreateOptions(workspace, opts)
+    return resolveQoderTerminalCommandForWorkspace(
+      launch,
+      workspace,
+      this.store,
+      this.getAgentLaunchPlatformForWorkspace(workspace)
+    )
+  }
+
+  protected async buildAgentTerminalCreateOptions(
+    workspace: TerminalWorkspaceLaunchScope,
+    opts: TerminalCreateOptions
   ): Promise<TerminalCreateOptions> {
     // Before any early return: every create lane funnels through here, and a host that cannot
     // apply the requested shell must refuse rather than spawn its default one.
@@ -287,63 +297,13 @@ export class OrcaRuntimeWithResolveWorktreeRemovalTarget extends OrcaRuntimeWith
       return opts
     }
 
-    const settings = store.getSettings()
-    const platform = this.getAgentLaunchPlatformForWorkspace(workspace)
-    // Why: `workspace.repo` is display metadata and may be a row from another host; the launch
-    // shape must match the PTY route this scope already resolved.
-    const isRemote = Boolean(workspace.connectionId)
-    if (opts.startupAgent && !isTuiAgentEnabled(opts.startupAgent, settings.disabledTuiAgents)) {
-      throw new Error(`Agent ${opts.startupAgent} is disabled. Choose an enabled agent.`)
-    }
-    const agent =
-      opts.startupAgent ??
-      resolveBareAgentLaunchCommand({
-        command: opts.command,
-        settings,
-        platform,
-        isRemote
-      })
-    if (!agent) {
-      return opts
-    }
-
-    const startupPlan = buildAgentStartupPlan({
-      ...resolveAgentStartupPlanInputs({
-        agent,
-        settings,
-        platform,
-        isRemote,
-        ...(opts.agentArgs !== undefined ? { agentArgs: opts.agentArgs } : {}),
-        // A requested shell is the one this PTY will actually be, so it owns the quoting family.
-        windowsShellOverride: opts.shellOverride,
-        sessionOptions: this.toAgentSessionOptions(opts.launchPreferences)
-      }),
-      prompt: opts.startupPrompt ?? '',
-      allowEmptyPromptLaunch: true
-    })
-    if (!startupPlan) {
-      // Why: an explicit agent that yields no plan would otherwise spawn a bare
-      // shell that never reaches agent readiness.
-      if (opts.startupAgent) {
-        throw new Error(`Could not build launch command for ${opts.startupAgent}.`)
-      }
-      return opts
-    }
-    // A prompt this launch command cannot carry has nowhere to go from here — the create returns
-    // options, not a live PTY — so refuse rather than spawn the agent and drop the text.
-    if (opts.startupPrompt && startupPlan.followupPrompt) {
-      throw new Error(`Agent ${agent} does not take a startup prompt on its launch command.`)
-    }
-
-    return {
-      ...opts,
-      command: startupPlan.launchCommand,
-      ...(startupPlan.env ? { env: startupPlan.env } : {}),
-      launchConfig: startupPlan.launchConfig,
-      launchAgent: agent,
-      startupCommandDelivery: startupPlan.startupCommandDelivery,
-      // A bare command the user typed stays out of launch accounting, as before.
-      ...(opts.startupAgent ? { telemetry: agentStartedTelemetry(agent, opts.launchSource) } : {})
-    }
+    return buildRuntimeAgentTerminalStartupOptions(
+      workspace,
+      opts,
+      store.getSettings(),
+      this.getAgentLaunchPlatformForWorkspace(workspace),
+      this.toAgentSessionOptions(opts.launchPreferences),
+      this.runtimeId
+    )
   }
 }
diff --git a/src/main/runtime/orca-runtime-run-create-mobile-session-terminal.ts b/src/main/runtime/orca-runtime-run-create-mobile-session-terminal.ts
index 193bf3cb12d..5e3c6458252 100644
--- a/src/main/runtime/orca-runtime-run-create-mobile-session-terminal.ts
+++ b/src/main/runtime/orca-runtime-run-create-mobile-session-terminal.ts
@@ -13,6 +13,7 @@ import {
   isClientDisconnectedError
 } from './orca-runtime-core'
 import { rendererPublicationThrottle } from '../window/renderer-publication-throttle'
+import { deterministicAgentSessionUuid } from './runtime-agent-launch-resolution'
 
 export class OrcaRuntimeWithRunCreateMobileSessionTerminal extends OrcaRuntimeWithCreateMobileSessionTerminal {
   protected async runCreateMobileSessionTerminal(
@@ -66,6 +67,29 @@ export class OrcaRuntimeWithRunCreateMobileSessionTerminal extends OrcaRuntimeWi
     if (opts.signal?.aborted) {
       throw new Error('client_disconnected')
     }
+    if (opts.clientMutationId && startupCommand.command && startupCommand.launchAgent === 'qoder') {
+      const clientIdentity = opts.clientNavigationId ?? 'local'
+      const seed = `${clientIdentity}\0${worktreeId}\0${opts.clientMutationId}`
+      // A command-bearing retry must reconcile the owning PTY before delivering the resume again.
+      return await this.createRuntimeOwnedMobileSessionTerminal(
+        worktreeId,
+        opts.activate !== false,
+        afterTabId,
+        {
+          ...startupCommand,
+          cwd,
+          identity: {
+            tabId: deterministicAgentSessionUuid(`mobile-qoder-tab\0${seed}`),
+            leafId: deterministicAgentSessionUuid(`mobile-qoder-leaf\0${seed}`)
+          },
+          createMutation: { clientIdentity, id: opts.clientMutationId },
+          viewMode: opts.viewMode,
+          targetGroupId: opts.targetGroupId,
+          supportsSplitGroupPlacement: opts.supportsSplitGroupPlacement,
+          signal: opts.signal
+        }
+      )
+    }
     const win = this.getAvailableAuthoritativeWindow()
     if (!win) {
       return await this.createRuntimeOwnedMobileSessionTerminal(
diff --git a/src/main/runtime/orca-runtime-terminal-create-deduplication.ts b/src/main/runtime/orca-runtime-terminal-create-deduplication.ts
index 59e13676e63..64041d6d8da 100644
--- a/src/main/runtime/orca-runtime-terminal-create-deduplication.ts
+++ b/src/main/runtime/orca-runtime-terminal-create-deduplication.ts
@@ -101,7 +101,11 @@ export class OrcaRuntimeWithTerminalCreateDeduplication extends OrcaRuntimeWithC
     this.adoptControllerTerminalHandle(session.id, terminalHandle)
     const pty = this.recordPtyWorktree(session.id, worktreeId, {
       connected: true,
-      title: session.title
+      title: session.title,
+      ...(session.incarnationId ? { incarnationId: session.incarnationId } : {}),
+      ...(session.wslDistro !== undefined
+        ? { wslDistro: session.wslDistro, isWsl: session.wslDistro !== null }
+        : {})
     })
     const adoptedHandle = this.issuePtyHandle(pty)
     if (adoptedHandle !== terminalHandle) {
diff --git a/src/main/runtime/orca-runtime-test-mocks/setup.spec.ts b/src/main/runtime/orca-runtime-test-mocks/setup.spec.ts
index 30d6c61ff79..93ef7412f47 100644
--- a/src/main/runtime/orca-runtime-test-mocks/setup.spec.ts
+++ b/src/main/runtime/orca-runtime-test-mocks/setup.spec.ts
@@ -350,6 +350,7 @@ vi.mock('../../ssh/ssh-target-registry', () => ({
 }))
 
 vi.mock('../../preflight/agent-detection', () => ({
+  detectAgentCommandsOnHost: vi.fn(async () => new Set(['qodercli'])),
   detectInstalledAgentsWithShellPathHydration: detectInstalledAgentsWithShellPathHydrationMock,
   detectRemoteAgents: detectRemoteAgentsMock
 }))
diff --git a/src/main/runtime/orca-runtime-tests/terminal-creation-and-readiness-part-03.spec.ts b/src/main/runtime/orca-runtime-tests/terminal-creation-and-readiness-part-03.spec.ts
index 47d7236dd9d..de21af9f013 100644
--- a/src/main/runtime/orca-runtime-tests/terminal-creation-and-readiness-part-03.spec.ts
+++ b/src/main/runtime/orca-runtime-tests/terminal-creation-and-readiness-part-03.spec.ts
@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from 'vitest'
+import { detectAgentCommandsOnHost } from '../../preflight/agent-detection'
 import {
   FLOATING_TERMINAL_WORKTREE_ID,
   OrcaRuntimeService,
@@ -28,6 +29,29 @@ import {
 } from '../orca-runtime-test-fixtures.spec'
 
 describe('OrcaRuntimeService', () => {
+  it.each(['qoder', 'qodercli'] as const)(
+    'spawns the available Qoder command for a captured same-session resume: %s',
+    async (command) => {
+      vi.mocked(detectAgentCommandsOnHost).mockResolvedValueOnce(new Set([command]))
+      const spawn = vi.fn().mockResolvedValue({ id: 'pty-qoder-resume' })
+      const runtime = new OrcaRuntimeService(store)
+      runtime.setPtyController({
+        spawn,
+        write: () => true,
+        kill: () => true,
+        getForegroundProcess: async () => null
+      })
+      await runtime.createTerminal(`path:${TEST_WORKTREE_PATH}`, {
+        launchAgent: 'qoder',
+        command: "qodercli --resume 'existing-qoder-session'",
+        launchConfig: { agentCommand: 'qodercli', agentArgs: '', agentEnv: {} }
+      })
+      expect(spawn).toHaveBeenCalledWith(
+        expect.objectContaining({ command: `${command} --resume 'existing-qoder-session'` })
+      )
+    }
+  )
+
   it('does not use the local Windows shell setting for remote Windows bare agent creates', async () => {
     const remoteRepo = {
       id: TEST_REPO_ID,
diff --git a/src/main/runtime/orchestration-mailbox-notification-consistency.test.ts b/src/main/runtime/orchestration-mailbox-notification-consistency.test.ts
index 161ccbeb9b1..3475ae70eb0 100644
--- a/src/main/runtime/orchestration-mailbox-notification-consistency.test.ts
+++ b/src/main/runtime/orchestration-mailbox-notification-consistency.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 import { settledWriteStub } from '../providers/settled-pty-write-stub'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
diff --git a/src/main/runtime/orchestration-message-delivery-identity.test.ts b/src/main/runtime/orchestration-message-delivery-identity.test.ts
index 21c8a64f56a..d5dd60788af 100644
--- a/src/main/runtime/orchestration-message-delivery-identity.test.ts
+++ b/src/main/runtime/orchestration-message-delivery-identity.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 import { settledWriteStub } from '../providers/settled-pty-write-stub'
 import { spawn } from 'node:child_process'
 import { existsSync, mkdtempSync, rmSync } from 'node:fs'
diff --git a/src/main/runtime/orchestration-opencode-model-host.test.ts b/src/main/runtime/orchestration-opencode-model-host.test.ts
new file mode 100644
index 00000000000..6d12025e232
--- /dev/null
+++ b/src/main/runtime/orchestration-opencode-model-host.test.ts
@@ -0,0 +1,98 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { OrcaRuntimeService } from './orca-runtime'
+import {
+  probeOpenCodeModelAvailability,
+  resolveOpenCodeDirectModelExecutable
+} from '../opencode/opencode-model-availability'
+import { probeOpenCodeLaunchCapabilities } from '../opencode/opencode-launch-capabilities'
+import { resolveLocalProjectRuntimeForRepo } from '../project-runtime-git-options'
+
+vi.mock('../opencode/opencode-launch-capabilities', () => ({
+  probeOpenCodeLaunchCapabilities: vi.fn()
+}))
+vi.mock('../opencode/opencode-model-availability', () => ({
+  probeOpenCodeModelAvailability: vi.fn(),
+  resolveOpenCodeDirectModelExecutable: vi.fn()
+}))
+vi.mock('../managed-data-accounts/launch-environment', () => ({
+  applyManagedDataAccountEnvironment: vi.fn()
+}))
+vi.mock('../project-runtime-git-options', () => ({ resolveLocalProjectRuntimeForRepo: vi.fn() }))
+
+function host(
+  scope: { path: string; connectionId?: string; repo?: { executionHostId?: string } } = {
+    path: '/tmp/folder'
+  }
+) {
+  return {
+    resolveTerminalWorkspaceLaunchScope: vi.fn(async () => scope),
+    resolveRepoSelector: vi.fn(async () => scope),
+    requireStore: () => ({
+      getSettings: () => ({
+        agentCmdOverrides: { opencode: '/tmp/private-opencode' },
+        agentDefaultEnv: { opencode: { OPENCODE_CONFIG_DIR: '/tmp/private-config' } }
+      })
+    }),
+    getRuntimeId: () => 'host-1'
+  }
+}
+function probe(
+  runtime: ReturnType<typeof host>,
+  target = { worktree: 'id:folder', model: 'opencode/fledge-alpha-free' }
+) {
+  return OrcaRuntimeService.prototype.probeOrchestrationOpenCodeModelLaunchSupport.call(
+    runtime,
+    target
+  )
+}
+
+describe('OpenCode worker model execution host', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(probeOpenCodeModelAvailability).mockResolvedValue(true)
+    vi.mocked(resolveOpenCodeDirectModelExecutable).mockResolvedValue('/tmp/private-opencode')
+    vi.mocked(resolveLocalProjectRuntimeForRepo).mockReturnValue(undefined)
+    vi.mocked(probeOpenCodeLaunchCapabilities).mockResolvedValue({
+      version: '1.18.30',
+      pluginApi: 'v1',
+      promptMode: 'submit'
+    })
+  })
+  it('probes a local folder with its configured command and environment', async () => {
+    expect(await probe(host())).toBe(true)
+    expect(probeOpenCodeLaunchCapabilities).toHaveBeenCalledWith(
+      expect.objectContaining({
+        command: '/tmp/private-opencode',
+        cwd: '/tmp/folder',
+        hostIdentity: 'host-1',
+        env: expect.objectContaining({ OPENCODE_CONFIG_DIR: '/tmp/private-config' })
+      })
+    )
+  })
+  it('rejects an unknown selector rather than claiming the fallback model', async () => {
+    vi.mocked(probeOpenCodeModelAvailability).mockResolvedValue(false)
+    expect(await probe(host())).toBe(false)
+  })
+  it.each(['v2', 'unknown'] as const)('refuses %s CLI model selection', async (pluginApi) => {
+    vi.mocked(probeOpenCodeLaunchCapabilities).mockResolvedValue({
+      version: null,
+      pluginApi,
+      promptMode: 'unknown'
+    })
+    expect(await probe(host())).toBe(false)
+  })
+  it('never probes the client executable for an SSH workspace', async () => {
+    expect(await probe(host({ path: '/remote/folder', connectionId: 'ssh-1' }))).toBe(false)
+    expect(probeOpenCodeLaunchCapabilities).not.toHaveBeenCalled()
+  })
+  it('never probes the client executable for a foreign execution host', async () => {
+    expect(
+      await probe(host({ path: '/remote/folder', repo: { executionHostId: 'remote-host' } }))
+    ).toBe(false)
+    expect(probeOpenCodeLaunchCapabilities).not.toHaveBeenCalled()
+  })
+  it('refuses WSL without probing a different profile', async () => {
+    expect(await probe(host({ path: '\\\\wsl.localhost\\Ubuntu\\home\\repo' }))).toBe(false)
+    expect(probeOpenCodeLaunchCapabilities).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/main/runtime/qoder-independent-spawn-review.test.ts b/src/main/runtime/qoder-independent-spawn-review.test.ts
new file mode 100644
index 00000000000..bfc32c1f78c
--- /dev/null
+++ b/src/main/runtime/qoder-independent-spawn-review.test.ts
@@ -0,0 +1,329 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
+import { beforeEach, expect, it, vi } from 'vitest'
+import filesystem from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { buildAgentResumeStartupPlan } from '../../shared/tui-agent-startup'
+import { buildAiVaultResumeShellCommand } from '../../shared/ai-vault-resume-command'
+
+await import('./orca-runtime-test-mocks.spec')
+await import('./orca-runtime-test-lifecycle.spec')
+const { OrcaRuntimeService } = await import('./orca-runtime-test-mocks.spec')
+const {
+  store,
+  TEST_WORKTREE_PATH,
+  TEST_FOLDER_WORKSPACE_KEY,
+  createFolderWorkspaceRuntimeStore,
+  makeFolderWorkspace,
+  makeFolderProjectGroup
+} = await import('./orca-runtime-test-fixtures.spec')
+const { detectAgentCommandsOnHost } = await import('../preflight/agent-detection')
+beforeEach(() =>
+  vi
+    .mocked(detectAgentCommandsOnHost)
+    .mockReset()
+    .mockResolvedValue(new Set(['qodercli']))
+)
+
+it.each([
+  ['modern-only', ['qoder'], 'qoder'],
+  ['legacy-only', ['qodercli'], 'qodercli'],
+  ['both', ['qoder', 'qodercli'], 'qodercli']
+] as const)(
+  'fresh managed start reaches the production spawn boundary: %s',
+  async (_, found, selected) => {
+    vi.mocked(detectAgentCommandsOnHost).mockResolvedValueOnce(new Set(found))
+    const spawn = vi.fn().mockResolvedValue({ id: 'pty-independent-start' })
+    const runtime = new OrcaRuntimeService({
+      ...store,
+      getSettings: () => ({ ...store.getSettings(), disabledTuiAgents: [], agentCmdOverrides: {} })
+    })
+    runtime.setPtyController({
+      spawn,
+      write: () => true,
+      kill: () => true,
+      getForegroundProcess: async () => null
+    })
+    await runtime.createTerminal(`path:${TEST_WORKTREE_PATH}`, {
+      startupAgent: 'qoder',
+      agentArgs: null,
+      launchSource: 'orchestration',
+      startupPrompt: 'qodercli remains prompt text'
+    })
+    expect(spawn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        launchAgent: 'qoder',
+        command: `${selected} --prompt-interactive 'qodercli remains prompt text'`
+      })
+    )
+    expect(spawn).toHaveBeenCalledTimes(1)
+    expect(spawn.mock.calls[0]?.[0].telemetry).toEqual({
+      agent_kind: 'qoder',
+      launch_source: 'orchestration',
+      request_kind: 'new'
+    })
+  }
+)
+
+it('a modern-only repo-less folder start reaches the same production spawn boundary', async () => {
+  vi.mocked(detectAgentCommandsOnHost).mockResolvedValueOnce(new Set(['qoder']))
+  const spawn = vi.fn().mockResolvedValue({ id: 'pty-independent-folder' })
+  const createTempDirectory = filesystem.mkdtemp
+  const guard = vi.spyOn(filesystem, 'mkdtemp').mockImplementation((prefix, options) => {
+    // CI has no .context parent; reject that prerequisite even on a developer checkout.
+    expect(String(prefix)).not.toContain('.context')
+    return createTempDirectory(prefix, options)
+  })
+  let folderPath: string | undefined
+  try {
+    folderPath = await filesystem.mkdtemp(join(tmpdir(), 'qoder-independent-folder-'))
+    const folderStore = createFolderWorkspaceRuntimeStore(
+      makeFolderWorkspace({ folderPath }),
+      makeFolderProjectGroup({ parentPath: folderPath })
+    )
+    const runtime = new OrcaRuntimeService({
+      ...folderStore,
+      getSettings: () => ({ ...store.getSettings(), disabledTuiAgents: [], agentCmdOverrides: {} })
+    })
+    runtime.setPtyController({
+      spawn,
+      write: () => true,
+      kill: () => true,
+      getForegroundProcess: async () => null
+    })
+    await runtime.createTerminal(`id:${TEST_FOLDER_WORKSPACE_KEY}`, {
+      startupAgent: 'qoder',
+      agentArgs: null
+    })
+    expect(spawn).toHaveBeenCalledWith(
+      expect.objectContaining({ launchAgent: 'qoder', command: 'qoder' })
+    )
+    expect(spawn).toHaveBeenCalledTimes(1)
+    expect(spawn.mock.calls[0]?.[0].cwd).toBe(folderPath)
+    expect(spawn.mock.calls[0]?.[0].telemetry).toEqual({
+      agent_kind: 'qoder',
+      launch_source: 'unknown',
+      request_kind: 'new'
+    })
+    expect((await filesystem.stat(folderPath)).isDirectory()).toBe(true)
+    await expect(filesystem.stat(join(folderPath, '.git'))).rejects.toMatchObject({
+      code: 'ENOENT'
+    })
+  } finally {
+    guard.mockRestore()
+    if (folderPath) {
+      await filesystem.rm(folderPath, { recursive: true, force: true })
+    }
+  }
+})
+
+it('selects the installed command for a mobile Qoder history resume at creation', async () => {
+  vi.mocked(detectAgentCommandsOnHost).mockResolvedValueOnce(new Set(['qoder']))
+  const spawn = vi.fn().mockResolvedValue({ id: 'pty-mobile-qoder-resume' })
+  const runtime = new OrcaRuntimeService(store)
+  runtime.setPtyController({
+    spawn,
+    write: () => true,
+    kill: () => true,
+    getForegroundProcess: async () => null
+  })
+  const plan = buildAgentResumeStartupPlan({
+    agent: 'qoder',
+    providerSession: { key: 'session_id', id: 'same-qoder-session' },
+    cmdOverrides: {},
+    platform: 'darwin'
+  })
+  if (!plan) {
+    throw new Error('Missing Qoder resume plan')
+  }
+  const launch = {
+    command: buildAiVaultResumeShellCommand({
+      resumeCommand: plan.launchCommand,
+      cwd: TEST_WORKTREE_PATH,
+      platform: 'darwin'
+    }),
+    launchAgent: plan.agent,
+    launchConfig: plan.launchConfig
+  }
+  await runtime.createTerminal(`path:${TEST_WORKTREE_PATH}`, {
+    command: launch.command,
+    launchAgent: launch.launchAgent,
+    launchConfig: launch.launchConfig
+  })
+  expect(spawn).toHaveBeenCalledTimes(1)
+  expect(spawn).toHaveBeenCalledWith(
+    expect.objectContaining({
+      command: launch.command.replace(/qodercli(?=\s)/, 'qoder'),
+      launchAgent: 'qoder'
+    })
+  )
+})
+
+it('host discovery refusal prevents any production spawn', async () => {
+  vi.mocked(detectAgentCommandsOnHost).mockRejectedValueOnce(
+    new Error('execution host unavailable')
+  )
+  const spawn = vi.fn()
+  const runtime = new OrcaRuntimeService(store)
+  runtime.setPtyController({
+    spawn,
+    write: () => true,
+    kill: () => true,
+    getForegroundProcess: async () => null
+  })
+  await expect(
+    runtime.createTerminal(`path:${TEST_WORKTREE_PATH}`, {
+      launchAgent: 'qoder',
+      command: 'qodercli --resume original-id'
+    })
+  ).rejects.toThrow('execution host unavailable')
+  expect(spawn).not.toHaveBeenCalled()
+})
+
+it('caller-owned explicit executable survives production resume without discovery', async () => {
+  const detect = vi.mocked(detectAgentCommandsOnHost)
+  detect.mockClear()
+  const spawn = vi.fn().mockResolvedValue({ id: 'pty-independent-explicit' })
+  const runtime = new OrcaRuntimeService(store)
+  runtime.setPtyController({
+    spawn,
+    write: () => true,
+    kill: () => true,
+    getForegroundProcess: async () => null
+  })
+  await runtime.createTerminal(`path:${TEST_WORKTREE_PATH}`, {
+    launchAgent: 'qoder',
+    command: '/caller/qodercli --resume original-id'
+  })
+  expect(spawn).toHaveBeenCalledWith(
+    expect.objectContaining({ command: '/caller/qodercli --resume original-id' })
+  )
+  expect(detect).not.toHaveBeenCalled()
+  expect(spawn).toHaveBeenCalledTimes(1)
+  expect(spawn.mock.calls[0]?.[0].telemetry).toBeUndefined()
+})
+
+it.each([
+  ['bare', 'qodercli'],
+  ['resume', 'qodercli --resume original-id']
+] as const)('does not falsely attribute a %s command as a fresh start', async (_, command) => {
+  const spawn = vi.fn().mockResolvedValue({ id: 'pty-independent-unattributed' })
+  const runtime = new OrcaRuntimeService(store)
+  runtime.setPtyController({
+    spawn,
+    write: () => true,
+    kill: () => true,
+    getForegroundProcess: async () => null
+  })
+  await runtime.createTerminal(`path:${TEST_WORKTREE_PATH}`, {
+    command,
+    agentArgs: null,
+    launchSource: 'orchestration',
+    ...(command.includes('--resume') ? { launchAgent: 'qoder' as const } : {})
+  })
+  expect(spawn).toHaveBeenCalledTimes(1)
+  expect(spawn.mock.calls[0]?.[0].command).toBe(command)
+  expect(spawn.mock.calls[0]?.[0].telemetry).toBeUndefined()
+})
+
+it.each(['offline', 'legacy-identity'])(
+  'refuses a Qoder command-bearing create with unverifiable inventory: %s',
+  async (state) => {
+    const { TEST_WORKTREE_ID } = await import('./orca-runtime-test-fixtures.spec')
+    const runtime = new OrcaRuntimeService(store)
+    runtime.syncWindowGraph(0, { tabs: [], leaves: [] })
+    const spawn = vi.fn()
+    const kill = vi.fn()
+    runtime.setPtyController({
+      spawn,
+      kill,
+      write: () => true,
+      getForegroundProcess: async () => null,
+      listProcesses: async () => {
+        if (state === 'offline') {
+          throw new Error('host offline')
+        }
+        return [
+          {
+            id: 'older-live-pty',
+            cwd: TEST_WORKTREE_PATH,
+            title: 'shell',
+            worktreeId: TEST_WORKTREE_ID
+          }
+        ]
+      }
+    })
+    await expect(
+      runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+        command: "qodercli '--resume' 'same-session'",
+        launchAgent: 'qoder',
+        clientNavigationId: 'paired-phone',
+        clientMutationId: 'same-resume',
+        select: false,
+        activate: false
+      })
+    ).rejects.toThrow('runtime_unavailable')
+    expect(spawn).not.toHaveBeenCalled()
+    expect(kill).not.toHaveBeenCalled()
+  }
+)
+
+it('reconciles after the reply-cache expires and isolates deliberate forks and paired callers', async () => {
+  const { TEST_WORKTREE_ID } = await import('./orca-runtime-test-fixtures.spec')
+  vi.useFakeTimers()
+  try {
+    const runtime = new OrcaRuntimeService(store)
+    runtime.syncWindowGraph(0, { tabs: [], leaves: [] })
+    const live: {
+      id: string
+      cwd: string
+      title: string
+      worktreeId: string
+      terminalHandle: string
+    }[] = []
+    const spawn = vi.fn(async (args: { preAllocatedHandle?: string }) => {
+      const id = `qoder-${live.length + 1}`
+      live.push({
+        id,
+        cwd: TEST_WORKTREE_PATH,
+        title: 'Qoder',
+        worktreeId: TEST_WORKTREE_ID,
+        terminalHandle: args.preAllocatedHandle ?? ''
+      })
+      return { id }
+    })
+    runtime.setPtyController({
+      spawn,
+      listProcesses: async () => live,
+      kill: vi.fn(),
+      write: () => true,
+      getForegroundProcess: async () => null
+    })
+    const resume = {
+      command: "qodercli '--resume' 'same-session'",
+      launchAgent: 'qoder' as const,
+      clientNavigationId: 'phone-a',
+      clientMutationId: 'resume-a',
+      select: false,
+      activate: false
+    }
+    const first = await runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, resume)
+    await vi.advanceTimersByTimeAsync(61_000)
+    const retry = await runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, resume)
+    expect(retry.tab.id).toBe(first.tab.id)
+    expect(retry.tab.ptyId).toBe(first.tab.ptyId)
+    expect(spawn).toHaveBeenCalledTimes(1)
+    const fork = await runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+      ...resume,
+      clientMutationId: 'resume-b'
+    })
+    const otherPhone = await runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+      ...resume,
+      clientNavigationId: 'phone-b'
+    })
+    expect(spawn).toHaveBeenCalledTimes(3)
+    expect(new Set([first.tab.id, fork.tab.id, otherPhone.tab.id]).size).toBe(3)
+  } finally {
+    vi.useRealTimers()
+  }
+})
diff --git a/src/main/runtime/qoder-mobile-resume-adoption.test.ts b/src/main/runtime/qoder-mobile-resume-adoption.test.ts
new file mode 100644
index 00000000000..2f244313a9b
--- /dev/null
+++ b/src/main/runtime/qoder-mobile-resume-adoption.test.ts
@@ -0,0 +1,450 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
+import { expect, it, vi } from 'vitest'
+import type { SleepingAgentLaunchConfig } from '../../shared/agent-session-resume'
+import { buildAgentResumeStartupPlan } from '../../shared/tui-agent-startup'
+
+await import('./orca-runtime-test-mocks.spec')
+await import('./orca-runtime-test-lifecycle.spec')
+const { OrcaRuntimeService } = await import('./orca-runtime-test-mocks.spec')
+const { store, TEST_WORKTREE_PATH } = await import('./orca-runtime-test-fixtures.spec')
+const { detectAgentCommandsOnHost } = await import('../preflight/agent-detection')
+
+class QoderAdoptionRuntime extends OrcaRuntimeService {
+  retainedRecipe(ptyId: string, worktreeId: string) {
+    return this.recordPtyWorktree(ptyId, worktreeId)
+  }
+}
+
+it.each([
+  'client_disconnected',
+  'Terminal creation timed out',
+  'quoted-agent-command',
+  'wsl-inventory',
+  'changed-replay',
+  'inventory-outage',
+  'surviving-recipe'
+])('reconciles a paired Qoder resume after ambiguous creation: %s', async (scenario) => {
+  const failure = scenario === 'Terminal creation timed out' ? scenario : 'client_disconnected'
+  const { withPlatform } = await import('./orca-runtime-test-fixtures.spec')
+  await withPlatform(scenario === 'wsl-inventory' ? 'win32' : 'darwin', async () => {
+    vi.useFakeTimers()
+    try {
+      const { electronMocks } = await import('./orca-runtime-test-mocks.spec')
+      const { TEST_WORKTREE_ID } = await import('./orca-runtime-test-fixtures.spec')
+      vi.mocked(detectAgentCommandsOnHost).mockResolvedValue(new Set(['qoder']))
+      const runtime = new QoderAdoptionRuntime(store)
+      runtime.syncWindowGraph(0, { tabs: [], leaves: [] })
+      let revealedRecipe: SleepingAgentLaunchConfig | undefined
+      const revealTerminalSession = vi.fn(
+        (_workspace: string, reveal: { launchConfig?: SleepingAgentLaunchConfig }) => {
+          revealedRecipe = reveal.launchConfig
+        }
+      )
+      runtime.setNotifier({
+        focusTerminal: vi.fn(),
+        worktreesChanged: vi.fn(),
+        reposChanged: vi.fn(),
+        activateWorktree: vi.fn(),
+        createTerminal: vi.fn(),
+        revealTerminalSession,
+        splitTerminal: vi.fn(),
+        renameTerminal: vi.fn(),
+        closeTerminal: vi.fn(),
+        closeSessionTab: vi.fn(),
+        sleepWorktree: vi.fn(),
+        terminalFitOverrideChanged: vi.fn(),
+        terminalDriverChanged: vi.fn()
+      })
+      const acceptedCommands: string[] = []
+      const live: {
+        id: string
+        cwd: string
+        title: string
+        worktreeId: string
+        terminalHandle: string
+        wslDistro?: string
+      }[] = []
+      let connection = new AbortController()
+      let inventoryUnavailable = false
+      const kill = vi.fn((id: string) => {
+        const index = live.findIndex((entry) => entry.id === id)
+        if (index !== -1) {
+          live.splice(index, 1)
+        }
+        return true
+      })
+      const spawn = vi.fn(async (args: { command?: string; preAllocatedHandle?: string }) => {
+        if (args.command) {
+          acceptedCommands.push(args.command)
+        }
+        live.push({
+          id: 'qoder-live-resume',
+          cwd: TEST_WORKTREE_PATH,
+          title: 'Qoder',
+          worktreeId: TEST_WORKTREE_ID,
+          terminalHandle: args.preAllocatedHandle ?? '',
+          ...(scenario === 'wsl-inventory' ? { wslDistro: 'Ubuntu-Orca' } : {})
+        })
+        if (scenario === 'surviving-recipe') {
+          const retained = runtime.retainedRecipe('qoder-live-resume', TEST_WORKTREE_ID)
+          retained.launchAgent = 'qoder'
+          retained.launchConfig = {
+            agentCommand: 'trusted-qoder',
+            agentArgs: 'trusted args',
+            agentEnv: { TRUSTED: 'retained' }
+          }
+        }
+        if (failure === 'client_disconnected') {
+          connection.abort()
+        }
+        throw new Error(failure)
+      })
+      runtime.setPtyController({
+        spawn,
+        listProcesses: async () => {
+          if (inventoryUnavailable) {
+            throw new Error('host offline')
+          }
+          return live
+        },
+        write: () => true,
+        kill,
+        getForegroundProcess: async () => null
+      })
+      const send = vi.fn((channel: string, payload: { command?: string }) => {
+        if (channel === 'terminal:requestTabCreate') {
+          if (payload.command) {
+            acceptedCommands.push(payload.command)
+          }
+          if (failure === 'client_disconnected') {
+            connection.abort()
+          }
+        }
+      })
+      runtime.attachWindow(1)
+      runtime.syncWindowGraph(1, { tabs: [], leaves: [] })
+      electronMocks.BrowserWindow.fromId.mockReturnValue({
+        isDestroyed: () => false,
+        webContents: { isDestroyed: () => false, send, setBackgroundThrottling: vi.fn() }
+      })
+      const plan = buildAgentResumeStartupPlan({
+        agent: 'qoder',
+        providerSession: { key: 'session_id', id: 'same-qoder-session' },
+        cmdOverrides: {},
+        platform: 'darwin',
+        agentArgs: '--captured-option',
+        ...(scenario === 'quoted-agent-command' ? { agentCommand: "'qodercli'" } : {})
+      })
+      expect(plan).not.toBeNull()
+      if (!plan) {
+        throw new Error('missing resume plan')
+      }
+      const resume = {
+        command: plan.launchCommand,
+        launchAgent: 'qoder' as const,
+        launchConfig: { ...plan.launchConfig, agentEnv: { OWNED_RECIPE: 'original value' } },
+        activate: false,
+        select: false,
+        navigation: 'caller' as const,
+        clientNavigationId: 'paired-phone',
+        clientMutationId: 'stable-resume-mutation'
+      }
+      const first = runtime
+        .createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+          ...resume,
+          signal: connection.signal
+        })
+        .then(
+          () => null,
+          (error: unknown) => error
+        )
+      await vi.advanceTimersByTimeAsync(10_001)
+      expect(await first).toBeInstanceOf(Error)
+      expect(kill).not.toHaveBeenCalled()
+      connection = new AbortController()
+      if (scenario === 'inventory-outage') {
+        inventoryUnavailable = true
+        await expect(
+          runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+            ...resume,
+            signal: connection.signal
+          })
+        ).rejects.toThrow('runtime_unavailable')
+        inventoryUnavailable = false
+      }
+      const retryPromise = runtime
+        .createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+          ...resume,
+          ...(scenario === 'changed-replay'
+            ? { launchConfig: { ...resume.launchConfig, agentEnv: { CHANGED: 'retry' } } }
+            : {}),
+          signal: connection.signal
+        })
+        .catch(() => null)
+      await vi.advanceTimersByTimeAsync(10_001)
+      const retry = await retryPromise
+      expect(acceptedCommands).toHaveLength(1)
+      expect(acceptedCommands[0]).toBe(
+        scenario === 'quoted-agent-command'
+          ? "qoder '--resume' 'same-qoder-session'"
+          : "qoder '--captured-option' '--resume' 'same-qoder-session'"
+      )
+      expect(retry?.tab).toMatchObject({ ptyId: 'qoder-live-resume', launchAgent: 'qoder' })
+      expect(spawn).toHaveBeenCalledTimes(1)
+      expect(send).not.toHaveBeenCalled()
+      if (!retry) {
+        throw new Error('missing adopted resume')
+      }
+      const pane = runtime.resolveTerminalPane(`${retry.tab.parentTabId}:${retry.tab.leafId}`)
+      await runtime.focusTerminal(pane.handle)
+      expect(revealTerminalSession).toHaveBeenCalledWith(
+        TEST_WORKTREE_ID,
+        expect.objectContaining({
+          launchAgent: 'qoder',
+          launchConfig:
+            scenario === 'surviving-recipe'
+              ? {
+                  agentCommand: 'trusted-qoder',
+                  agentArgs: 'trusted args',
+                  agentEnv: { TRUSTED: 'retained' }
+                }
+              : expect.objectContaining({
+                  agentCommand:
+                    scenario === 'quoted-agent-command'
+                      ? "'qodercli'"
+                      : "qoder '--captured-option'",
+                  agentArgs: plan.launchConfig.agentArgs,
+                  agentEnv: { OWNED_RECIPE: 'original value' }
+                })
+        })
+      )
+      if (!revealedRecipe) {
+        throw new Error('missing revealed recipe')
+      }
+      const relaunch = buildAgentResumeStartupPlan({
+        agent: 'qoder',
+        providerSession: { key: 'session_id', id: 'same-qoder-session' },
+        cmdOverrides: { qoder: 'changed-default-command' },
+        platform: 'darwin',
+        agentCommand: revealedRecipe.agentCommand,
+        agentArgs: revealedRecipe.agentArgs,
+        agentEnv: revealedRecipe.agentEnv
+      })
+      if (!relaunch) {
+        throw new Error('missing relaunch')
+      }
+      const restoredSpawn = vi.fn().mockResolvedValue({ id: 'intentional-restored-qoder' })
+      runtime.setPtyController({
+        spawn: restoredSpawn,
+        write: () => true,
+        kill,
+        getForegroundProcess: async () => null
+      })
+      await runtime.createTerminal(`id:${TEST_WORKTREE_ID}`, {
+        command: relaunch.launchCommand,
+        launchAgent: 'qoder',
+        launchConfig: relaunch.launchConfig,
+        env: relaunch.env,
+        focus: false
+      })
+      expect(restoredSpawn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          command:
+            scenario === 'surviving-recipe'
+              ? "trusted-qoder '--resume' 'same-qoder-session'"
+              : acceptedCommands[0],
+          env: expect.objectContaining(
+            scenario === 'surviving-recipe'
+              ? { TRUSTED: 'retained' }
+              : { OWNED_RECIPE: 'original value' }
+          )
+        })
+      )
+      expect(kill).not.toHaveBeenCalled()
+      if (scenario === 'wsl-inventory' && retry) {
+        expect(
+          runtime.resolveTerminalPane(`${retry.tab.parentTabId}:${retry.tab.leafId}`).hostPlatform
+        ).toBe('linux')
+      }
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+it.each(['missing-original', 'different-agent'])(
+  'refuses unproven adopted launch recipe: %s',
+  async (state) => {
+    const { TEST_WORKTREE_ID } = await import('./orca-runtime-test-fixtures.spec')
+    const { deriveRemoteRuntimeTerminalCreateHandle } =
+      await import('./remote-runtime-terminal-create-identity')
+    const handle = deriveRemoteRuntimeTerminalCreateHandle(
+      'owned-phone',
+      TEST_WORKTREE_ID,
+      'unknown-operation'
+    )
+    const runtime = new QoderAdoptionRuntime(store)
+    runtime.syncWindowGraph(0, { tabs: [], leaves: [] })
+    const tabId = 'original-owned-tab'
+    const leafId = '55555555-5555-4555-8555-555555555555'
+    runtime.registerPty('unknown-owned-pty', TEST_WORKTREE_ID, null, {
+      tabId,
+      leafId,
+      terminalHandle: handle,
+      incarnationId: 'owned-prior-incarnation'
+    })
+    const retained = runtime.retainedRecipe('unknown-owned-pty', TEST_WORKTREE_ID)
+    const originalPaneKey = retained.paneKey
+    const originalOwnership = retained.runtimeSessionOwned
+    if (state === 'different-agent') {
+      retained.launchAgent = 'codex'
+    }
+    const spawn = vi.fn()
+    const kill = vi.fn()
+    runtime.setPtyController({
+      spawn,
+      kill,
+      write: () => true,
+      getForegroundProcess: async () => null,
+      listProcesses: async () => [
+        {
+          id: 'unknown-owned-pty',
+          worktreeId: TEST_WORKTREE_ID,
+          terminalHandle: handle,
+          cwd: TEST_WORKTREE_PATH,
+          title: 'Unknown'
+        }
+      ]
+    })
+    await expect(
+      runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+        command: 'qodercli --resume original',
+        launchAgent: 'qoder',
+        launchConfig: {
+          agentCommand: "'qodercli'",
+          agentArgs: '--guessed-retry',
+          agentEnv: { GUESSED: 'not-authoritative' }
+        },
+        clientNavigationId: 'owned-phone',
+        clientMutationId: 'unknown-operation',
+        select: false
+      })
+    ).rejects.toThrow(
+      state === 'different-agent' ? 'terminal_create_identity_conflict' : 'runtime_unavailable'
+    )
+    expect(spawn).not.toHaveBeenCalled()
+    expect(kill).not.toHaveBeenCalled()
+    expect(retained.launchConfig).toBeNull()
+    expect(retained.launchAgent).toBe(state === 'different-agent' ? 'codex' : null)
+    expect(retained.launchToken).toBeNull()
+    expect(retained.launchIncarnationId).toBeNull()
+    expect(retained.tabId).toBe(tabId)
+    expect(retained.paneKey).toBe(originalPaneKey)
+    expect(retained.runtimeSessionOwned).toBe(originalOwnership)
+    expect(runtime.resolveTerminalPane(`${tabId}:${leafId}`).handle).toBe(handle)
+  }
+)
+
+it('releases abandoned dispatch capacity without guessing an expired live recipe', async () => {
+  vi.useFakeTimers()
+  try {
+    const { TEST_WORKTREE_ID } = await import('./orca-runtime-test-fixtures.spec')
+    const { deriveRemoteRuntimeTerminalCreateHandle } =
+      await import('./remote-runtime-terminal-create-identity')
+    vi.mocked(detectAgentCommandsOnHost)
+      .mockReset()
+      .mockResolvedValue(new Set(['qoder']))
+    const runtime = new OrcaRuntimeService(store)
+    runtime.syncWindowGraph(0, { tabs: [], leaves: [] })
+    let accept = false
+    const inventory: {
+      id: string
+      worktreeId: string
+      terminalHandle: string
+      cwd: string
+      title: string
+    }[] = []
+    const spawn = vi.fn(async () => {
+      if (accept) {
+        return { id: 'fresh-after-expiry' }
+      }
+      throw new Error('abandoned-create')
+    })
+    const kill = vi.fn()
+    runtime.setPtyController({
+      spawn,
+      kill,
+      write: () => true,
+      getForegroundProcess: async () => null,
+      listProcesses: async () => inventory
+    })
+    const request = {
+      command: 'qodercli --resume original',
+      launchAgent: 'qoder' as const,
+      launchConfig: {
+        agentCommand: 'qodercli',
+        agentArgs: '--original',
+        agentEnv: { ORIGINAL: 'owned' }
+      },
+      clientNavigationId: 'owned-phone',
+      select: false
+    }
+    for (let index = 0; index < 4096; index++) {
+      await runtime
+        .createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+          ...request,
+          clientMutationId: `abandoned-${index}`
+        })
+        .catch((error: unknown) => {
+          if (!(error instanceof Error) || error.message !== 'abandoned-create') {
+            throw error
+          }
+        })
+    }
+    accept = true
+    await expect(
+      runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+        ...request,
+        clientMutationId: 'fresh-mutation'
+      })
+    ).rejects.toThrow('runtime_unavailable')
+    expect(spawn).toHaveBeenCalledTimes(4096)
+    await vi.advanceTimersByTimeAsync(14 * 60_000)
+    await expect(
+      runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+        ...request,
+        clientMutationId: 'fresh-mutation'
+      })
+    ).rejects.toThrow('runtime_unavailable')
+    expect(spawn).toHaveBeenCalledTimes(4096)
+    await vi.advanceTimersByTimeAsync(2 * 60_000)
+    const fresh = await runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+      ...request,
+      clientMutationId: 'fresh-mutation'
+    })
+    expect(fresh.tab.ptyId).toBe('fresh-after-expiry')
+    inventory.push({
+      id: 'expired-live-pty',
+      worktreeId: TEST_WORKTREE_ID,
+      terminalHandle: deriveRemoteRuntimeTerminalCreateHandle(
+        'owned-phone',
+        TEST_WORKTREE_ID,
+        'abandoned-0'
+      ),
+      cwd: TEST_WORKTREE_PATH,
+      title: 'Qoder'
+    })
+    await expect(
+      runtime.createMobileSessionTerminal(`id:${TEST_WORKTREE_ID}`, {
+        ...request,
+        launchConfig: { ...request.launchConfig, agentEnv: { GUESSED: 'retry' } },
+        clientMutationId: 'abandoned-0'
+      })
+    ).rejects.toThrow('runtime_unavailable')
+    expect(spawn).toHaveBeenCalledTimes(4097)
+    expect(kill).not.toHaveBeenCalled()
+    expect(inventory).toHaveLength(1)
+  } finally {
+    vi.useRealTimers()
+  }
+}, 30_000)
diff --git a/src/main/runtime/qoder-terminal-command-resolution.test.ts b/src/main/runtime/qoder-terminal-command-resolution.test.ts
new file mode 100644
index 00000000000..30c2e189bd0
--- /dev/null
+++ b/src/main/runtime/qoder-terminal-command-resolution.test.ts
@@ -0,0 +1,101 @@
+import { describe, expect, it, vi } from 'vitest'
+import { buildAgentStartupPlan, buildAgentResumeStartupPlan } from '../../shared/tui-agent-startup'
+import { buildAiVaultResumeShellCommand } from '../../shared/ai-vault-resume-command'
+import { resolveQoderTerminalCommand } from './qoder-terminal-command-resolution'
+
+vi.mock('../preflight/agent-detection', () => ({ detectAgentCommandsOnHost: vi.fn() }))
+
+describe('execution-host Qoder command selection', () => {
+  it.each(['darwin', 'linux', 'win32'] as const)(
+    'starts and resumes modern-only and legacy-only installs on %s',
+    async (platform) => {
+      const startup = buildAgentStartupPlan({
+        agent: 'qoder',
+        prompt: 'qodercli is a prompt word',
+        cmdOverrides: {},
+        platform
+      })
+      const resume = buildAgentResumeStartupPlan({
+        agent: 'qoder',
+        providerSession: { key: 'session_id', id: 'existing-session' },
+        cmdOverrides: {},
+        platform
+      })
+      if (!startup || !resume) {
+        throw new Error('Missing Qoder plans')
+      }
+      const shell = platform === 'win32' ? 'powershell' : 'posix'
+      for (const found of [
+        new Set(['qoder']),
+        new Set(['qodercli']),
+        new Set(['qoder', 'qodercli'])
+      ]) {
+        const selected = found.has('qodercli') ? 'qodercli' : 'qoder'
+        const detect = vi.fn(async () => found)
+        for (const plan of [startup, resume]) {
+          const result = await resolveQoderTerminalCommand(
+            { launchAgent: 'qoder', command: plan.launchCommand, launchConfig: plan.launchConfig },
+            { shell },
+            detect
+          )
+          expect(result.command).toBe(plan.launchCommand.replace(/^qodercli/, selected))
+          expect(result.launchConfig?.agentCommand).toBe(selected)
+        }
+        const historyCommand = buildAiVaultResumeShellCommand({
+          resumeCommand: resume.launchCommand,
+          cwd: '/folder workspace',
+          platform,
+          shell
+        })
+        const history = await resolveQoderTerminalCommand(
+          { launchAgent: 'qoder', command: historyCommand, launchConfig: resume.launchConfig },
+          { shell },
+          detect
+        )
+        expect(history.command).toBe(historyCommand.replace(/qodercli(?=\s)/, selected))
+      }
+    }
+  )
+
+  it('queries each execution host without sharing a result or falling back after contact loss', async () => {
+    const options = { launchAgent: 'qoder' as const, command: 'qodercli --resume existing-session' }
+    const detect = vi
+      .fn()
+      .mockResolvedValueOnce(new Set(['qoder']))
+      .mockResolvedValueOnce(new Set(['qodercli']))
+      .mockRejectedValueOnce(new Error('Host disconnected'))
+    const wsl = { shell: 'posix' as const, context: { wslDistro: 'Ubuntu' } }
+    const ssh = { shell: 'posix' as const, connectionId: 'ssh-host' }
+    expect((await resolveQoderTerminalCommand(options, wsl, detect)).command).toBe(
+      'qoder --resume existing-session'
+    )
+    expect((await resolveQoderTerminalCommand(options, ssh, detect)).command).toBe(options.command)
+    await expect(resolveQoderTerminalCommand(options, ssh, detect)).rejects.toThrow(
+      'Host disconnected'
+    )
+    expect(detect.mock.calls).toEqual([
+      [['qodercli', 'qoder'], wsl],
+      [['qodercli', 'qoder'], ssh],
+      [['qodercli', 'qoder'], ssh]
+    ])
+  })
+
+  it.each([
+    '/custom/qodercli --resume id',
+    'qoder --prompt-interactive hello',
+    'echo qodercli',
+    'qodercli-other'
+  ])('preserves explicit paths, modern commands and unrelated commands: %s', async (command) => {
+    const detect = vi.fn()
+    expect(
+      (
+        await resolveQoderTerminalCommand(
+          { launchAgent: 'qoder', command },
+          { shell: 'posix' },
+          detect
+        )
+      ).command
+    ).toBe(command)
+    expect(detect).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/main/runtime/qoder-terminal-command-resolution.ts b/src/main/runtime/qoder-terminal-command-resolution.ts
new file mode 100644
index 00000000000..7e872db933c
--- /dev/null
+++ b/src/main/runtime/qoder-terminal-command-resolution.ts
@@ -0,0 +1,96 @@
+import type { PreflightRuntimeContext } from '../preflight/agent-detection'
+import { detectAgentCommandsOnHost } from '../preflight/agent-detection'
+import { getTuiAgentDetectCommands, TUI_AGENT_CONFIG } from '../../shared/tui-agent-config'
+import {
+  resolveStartupShell,
+  tokenizeStartupCommand,
+  type AgentStartupShell
+} from '../../shared/tui-agent-startup-shell'
+import type { TerminalCreateOptions } from './runtime-terminal-contracts'
+import type { RuntimeStore } from './runtime-store-contract'
+import type { TerminalWorkspaceLaunchScope } from './runtime-legacy-worker-terminal-recovery-types'
+import { resolveLocalProjectRuntimeForWorktreeId } from '../local-project-runtime-resolution'
+import { parseWslUncPath } from '../../shared/wsl-paths'
+import { resolveLocalWindowsAgentStartupShell } from '../../shared/windows-terminal-shell'
+
+export async function resolveQoderTerminalCommandForWorkspace(
+  launch: TerminalCreateOptions,
+  workspace: TerminalWorkspaceLaunchScope,
+  store: RuntimeStore | null | undefined,
+  platform: NodeJS.Platform
+): Promise<TerminalCreateOptions> {
+  if (launch.launchAgent !== 'qoder') {
+    return launch
+  }
+  return resolveQoderTerminalCommand(launch, {
+    connectionId: workspace.connectionId,
+    context:
+      !workspace.connectionId && store
+        ? {
+            projectRuntime: resolveLocalProjectRuntimeForWorktreeId(store, workspace.id),
+            wslDistro: parseWslUncPath(workspace.path)?.distro
+          }
+        : undefined,
+    shell: resolveStartupShell(
+      platform,
+      resolveLocalWindowsAgentStartupShell({
+        platform,
+        isRemote: Boolean(workspace.connectionId),
+        terminalWindowsShell: launch.shellOverride ?? store?.getSettings().terminalWindowsShell
+      })
+    )
+  })
+}
+
+export async function resolveQoderTerminalCommand<
+  T extends Pick<TerminalCreateOptions, 'launchAgent' | 'command' | 'launchConfig'>
+>(
+  options: T,
+  host: {
+    connectionId?: string | null
+    context?: PreflightRuntimeContext
+    shell: AgentStartupShell
+  },
+  detect = detectAgentCommandsOnHost
+): Promise<T> {
+  if (options.launchAgent !== 'qoder' || !options.command) {
+    return options
+  }
+  const parsed = tokenizeStartupCommand(options.command, host.shell)
+  // Explicit paths and configured recipes remain owned by the caller.
+  if (!parsed.ok) {
+    return options
+  }
+  const executableIndex = parsed.tokens.findIndex(
+    (token, index) =>
+      token === TUI_AGENT_CONFIG.qoder.detectCmd &&
+      (index === 0 ||
+        parsed.tokens[index - 1] === '&&' ||
+        (parsed.tokens[0] === 'Set-Location' && parsed.tokens[index - 1].endsWith(';')))
+  )
+  if (executableIndex === -1) {
+    return options
+  }
+  const candidates = getTuiAgentDetectCommands(TUI_AGENT_CONFIG.qoder)
+  const found = await detect(candidates, host)
+  const selected = candidates.find((candidate) => found.has(candidate))
+  if (!selected || selected === parsed.tokens[executableIndex]) {
+    return options
+  }
+  const first = parsed.spans[executableIndex]
+  if (!first) {
+    return options
+  }
+  return {
+    ...options,
+    command: options.command.slice(0, first.start) + selected + options.command.slice(first.end),
+    ...(options.launchConfig
+      ? {
+          launchConfig: {
+            ...options.launchConfig,
+            agentCommand: options.launchConfig.agentCommand?.replace(/^qodercli(?=\s|$)/, selected)
+          }
+        }
+      : {})
+  }
+}
diff --git a/src/main/runtime/rpc/dispatcher-browser-client-automation.test.ts b/src/main/runtime/rpc/dispatcher-browser-client-automation.test.ts
index 959c383ccc3..35d8f5bb097 100644
--- a/src/main/runtime/rpc/dispatcher-browser-client-automation.test.ts
+++ b/src/main/runtime/rpc/dispatcher-browser-client-automation.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { z } from 'zod'
 import type { OrcaRuntimeService } from '../orca-runtime'
diff --git a/src/main/runtime/rpc/dispatcher-computer-errors.test.ts b/src/main/runtime/rpc/dispatcher-computer-errors.test.ts
index bbc37e57ab1..9640352faf7 100644
--- a/src/main/runtime/rpc/dispatcher-computer-errors.test.ts
+++ b/src/main/runtime/rpc/dispatcher-computer-errors.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { z } from 'zod'
 import { RpcDispatcher } from './dispatcher'
diff --git a/src/main/runtime/rpc/dispatcher-feature-interactions.test.ts b/src/main/runtime/rpc/dispatcher-feature-interactions.test.ts
index d0f1e6fbc39..c4c9433b939 100644
--- a/src/main/runtime/rpc/dispatcher-feature-interactions.test.ts
+++ b/src/main/runtime/rpc/dispatcher-feature-interactions.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { z } from 'zod'
 import type { PersistedUIState } from '../../../shared/persisted-ui-state-types'
diff --git a/src/main/runtime/rpc/methods/agent-launch-failure-code.ts b/src/main/runtime/rpc/methods/agent-launch-failure-code.ts
index eac21c7c00e..bf3b4a2ceaa 100644
--- a/src/main/runtime/rpc/methods/agent-launch-failure-code.ts
+++ b/src/main/runtime/rpc/methods/agent-launch-failure-code.ts
@@ -1,3 +1,4 @@
+import { OrchestrationError } from '../../orchestration/orchestration-error'
 import type { AgentLaunchTarget } from '../../../../shared/agent-launch-intent'
 import {
   WorktreeCreateCollisionError,
@@ -27,7 +28,8 @@ const LAUNCH_FAILURE_CODE_MAX_LENGTH = 128
  * the entire store.
  */
 export function agentLaunchFailureCode(error: unknown): string {
-  const code = error instanceof Error ? error.message : ''
+  const code =
+    error instanceof OrchestrationError ? error.code : error instanceof Error ? error.message : ''
   return code.length > 0 ? code.slice(0, LAUNCH_FAILURE_CODE_MAX_LENGTH) : 'agent_launch_failed'
 }
 
diff --git a/src/main/runtime/rpc/methods/agent-launch-pane-reservation.test.ts b/src/main/runtime/rpc/methods/agent-launch-pane-reservation.test.ts
index d1d419a4c56..3cc0806f680 100644
--- a/src/main/runtime/rpc/methods/agent-launch-pane-reservation.test.ts
+++ b/src/main/runtime/rpc/methods/agent-launch-pane-reservation.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 /**
  * The pane a caller reserves for the terminal `agent.launch` creates.
  *
diff --git a/src/main/runtime/rpc/methods/agent-launch-prestart-failure.test.ts b/src/main/runtime/rpc/methods/agent-launch-prestart-failure.test.ts
index cfc14ec5504..15a8b3a8499 100644
--- a/src/main/runtime/rpc/methods/agent-launch-prestart-failure.test.ts
+++ b/src/main/runtime/rpc/methods/agent-launch-prestart-failure.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 /**
  * A terminal launch that fails before its spawn is requested — no launch command, runtime
  * unavailable — created nothing, so a named operation settles as failed with its real cause.
@@ -8,6 +9,7 @@ import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { computeAgentLaunchFingerprint } from '../../../../shared/agent-launch-operation'
 import type { AgentSessionRecordStore } from '../../agent-session-record-store'
 import { openTestAgentSessionRecordStore } from '../../agent-session-record-store-test-harness'
 import { setStructuredAgentSessionHost } from '../../../native-chat/agent-session-wire/structured-agent-session-registry'
@@ -32,7 +34,12 @@ const CREATE_LAUNCH = {
   target: { kind: 'create-worktree', create: { repo: 'id:repo-1', name: 'task' } }
 }
 const NO_LAUNCH_COMMAND = 'Could not build launch command for claude.'
-type Launch = typeof EXISTING_LAUNCH | typeof CREATE_LAUNCH
+type Launch = {
+  agent: string
+  target: { kind: string; worktree?: string; create?: Readonly<Record<string, unknown>> }
+  sessionOptions?: Readonly<Record<string, unknown>>
+  reuseTerminal?: { handle: string }
+}
 
 /** The create throws; `afterDispatch` says whether the spawn request had already left. */
 function failingCreate(runtime: AgentLaunchRuntimeStub, error: Error, afterDispatch: boolean) {
@@ -169,4 +176,75 @@ describe('a launch whose terminal fails', () => {
       error: { code: 'agent_session_operation_unknown' }
     })
   })
+  it.each([
+    { ...CREATE_LAUNCH, agent: 'opencode', sessionOptions: { model: 'private-proof/model-b' } },
+    {
+      ...EXISTING_LAUNCH,
+      agent: 'opencode',
+      reuseTerminal: { handle: 'term_existing' },
+      sessionOptions: { model: 'private-proof/model-b' }
+    }
+  ])('records and replays a model refusal before adapter effects', async (launch) => {
+    const first = runtimeStub({ settings: {} })
+    expect(await replay(first, launch)).toMatchObject({
+      ok: false,
+      error: { code: 'capability_unsupported' }
+    })
+    expect(outcomeOf(OPERATION_ID)).toMatchObject({
+      status: 'failed',
+      code: 'capability_unsupported'
+    })
+    expect(first.showRepo).not.toHaveBeenCalled()
+    expect(first.createManagedWorktree).not.toHaveBeenCalled()
+    expect(first.createTerminal).not.toHaveBeenCalled()
+    const retry = runtimeStub({ settings: {} })
+    expect(await replay(retry, launch)).toMatchObject({
+      ok: false,
+      error: { code: 'capability_unsupported' }
+    })
+    expect(retry.showTerminalWorkspaceLaunchScope).not.toHaveBeenCalled()
+    expect(retry.createManagedWorktree).not.toHaveBeenCalled()
+  })
+
+  it('preserves a successful recorded model launch even when its placement is now refused', async () => {
+    const launch = AGENT_LAUNCH_REPLAY.params.parse({
+      ...CREATE_LAUNCH,
+      agent: 'opencode',
+      sessionOptions: { model: 'private-proof/model-b' },
+      operationId: OPERATION_ID
+    })
+    const callerKey = 'trusted-local:runtime'
+    await store.admitOperation({
+      callerKey,
+      operationId: OPERATION_ID,
+      fingerprint: computeAgentLaunchFingerprint(launch),
+      now: Date.now()
+    })
+    await store.claimOperation({ callerKey, operationId: OPERATION_ID })
+    await store.recordOperationOutcome({
+      callerKey,
+      operationId: OPERATION_ID,
+      outcome: {
+        status: 'succeeded',
+        sessionId: '',
+        launch: {
+          outcome: { kind: 'terminal', handle: 'term_historical' },
+          worktreeId: 'wt_historical',
+          receipt: {
+            mode: 'terminal',
+            preferred: 'terminal',
+            reason: 'user_default',
+            detail: 'Previously recorded launch'
+          }
+        }
+      }
+    })
+    const runtime = runtimeStub({ settings: {} })
+    expect(await replay(runtime, launch)).toMatchObject({
+      ok: true,
+      result: { outcome: { handle: 'term_historical' }, worktreeId: 'wt_historical' }
+    })
+    expect(runtime.showRepo).not.toHaveBeenCalled()
+    expect(runtime.createManagedWorktree).not.toHaveBeenCalled()
+  })
 })
diff --git a/src/main/runtime/rpc/methods/agent-launch-replay.test.ts b/src/main/runtime/rpc/methods/agent-launch-replay.test.ts
index 24d0a80b3d1..9e725c7b517 100644
--- a/src/main/runtime/rpc/methods/agent-launch-replay.test.ts
+++ b/src/main/runtime/rpc/methods/agent-launch-replay.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 /**
  * Replay safety for `agent.launch`, against the real durable ledger.
  *
diff --git a/src/main/runtime/rpc/methods/agent-launch-session-reservation.test.ts b/src/main/runtime/rpc/methods/agent-launch-session-reservation.test.ts
index 528490d1d0a..720f0819383 100644
--- a/src/main/runtime/rpc/methods/agent-launch-session-reservation.test.ts
+++ b/src/main/runtime/rpc/methods/agent-launch-session-reservation.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 /**
  * The chat session a caller reserves for the structured launch `agent.launch` creates.
  *
diff --git a/src/main/runtime/rpc/methods/agent-launch.ts b/src/main/runtime/rpc/methods/agent-launch.ts
index 1c7448e5ca2..574dfd1a30f 100644
--- a/src/main/runtime/rpc/methods/agent-launch.ts
+++ b/src/main/runtime/rpc/methods/agent-launch.ts
@@ -31,6 +31,7 @@ import {
   WorktreeCreateCollisionError,
   WORKTREE_CREATE_COLLISION_CODE
 } from '../../../../shared/new-workspace/worktree-create-collision'
+import { assertOpenCodeModelLaunchPreferencesAbsent } from '../../../opencode/opencode-model-startup-plan'
 import { executeAgentLaunch } from '../../../agent-launch/agent-launch-executor'
 import {
   trackTerminalSpawnDispatch,
@@ -137,6 +138,9 @@ async function resolveUnlaunchedIntent(
   params: AgentLaunchParams,
   runtime: OrcaRuntimeService
 ): Promise<AgentLaunchIntent> {
+  if (params.reuseTerminal || params.target.kind === 'create-worktree') {
+    assertOpenCodeModelLaunchPreferencesAbsent(params.agent, params.sessionOptions)
+  }
   const intent = await agentLaunchIntent(params, runtime)
   await validateReusedTerminal(intent, runtime)
   return intent
@@ -237,7 +241,7 @@ async function executeReplaySafeAgentLaunch(
 ): Promise<AgentLaunchResult> {
   const admission = await admitAgentLaunchOperation(context, params, fingerprint)
   if (admission.decision === 'refuse') {
-    throw new Error(admission.refusal.code)
+    throw Object.assign(new Error(admission.refusal.code), { code: admission.refusal.code })
   }
   if (admission.decision === 'replay') {
     return admission.result
diff --git a/src/main/runtime/rpc/methods/agent-session.test.ts b/src/main/runtime/rpc/methods/agent-session.test.ts
index f234dce1536..ed67179be57 100644
--- a/src/main/runtime/rpc/methods/agent-session.test.ts
+++ b/src/main/runtime/rpc/methods/agent-session.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import {
   AGENT_SESSION_HOST_AUTHORITY_RUNTIME_CAPABILITY,
diff --git a/src/main/runtime/rpc/methods/ai-vault-search.test.ts b/src/main/runtime/rpc/methods/ai-vault-search.test.ts
index c247b0f31b1..7ed8ed4ffa4 100644
--- a/src/main/runtime/rpc/methods/ai-vault-search.test.ts
+++ b/src/main/runtime/rpc/methods/ai-vault-search.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { AI_VAULT_AGENTS } from '../../../../shared/ai-vault-types'
 import { RpcDispatcher } from '../dispatcher'
diff --git a/src/main/runtime/rpc/methods/ai-vault.test.ts b/src/main/runtime/rpc/methods/ai-vault.test.ts
index 7848ddcd033..2a179b847e2 100644
--- a/src/main/runtime/rpc/methods/ai-vault.test.ts
+++ b/src/main/runtime/rpc/methods/ai-vault.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/automation-scoped-list-methods.test.ts b/src/main/runtime/rpc/methods/automation-scoped-list-methods.test.ts
index 6af7ba467e9..7a3eacc7857 100644
--- a/src/main/runtime/rpc/methods/automation-scoped-list-methods.test.ts
+++ b/src/main/runtime/rpc/methods/automation-scoped-list-methods.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 /**
  * The runtime end of the list contract: an old client that sends no params must
  * keep receiving the authority's complete list through the legacy field while
diff --git a/src/main/runtime/rpc/methods/automations.test.ts b/src/main/runtime/rpc/methods/automations.test.ts
index ab768559749..be4d4ac58ca 100644
--- a/src/main/runtime/rpc/methods/automations.test.ts
+++ b/src/main/runtime/rpc/methods/automations.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/browser-client-host-attach-adoption.test.ts b/src/main/runtime/rpc/methods/browser-client-host-attach-adoption.test.ts
index 0d6bf3b80ef..21a5aa508a8 100644
--- a/src/main/runtime/rpc/methods/browser-client-host-attach-adoption.test.ts
+++ b/src/main/runtime/rpc/methods/browser-client-host-attach-adoption.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { BROWSER_CLIENT_HOST_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version'
 import type { BrowserClientHostedPageInventory } from '../../../../shared/browser-client-host-protocol'
diff --git a/src/main/runtime/rpc/methods/browser-client-host-reconciliation.test.ts b/src/main/runtime/rpc/methods/browser-client-host-reconciliation.test.ts
index 5798ff1db42..8dbeedffb45 100644
--- a/src/main/runtime/rpc/methods/browser-client-host-reconciliation.test.ts
+++ b/src/main/runtime/rpc/methods/browser-client-host-reconciliation.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { BROWSER_CLIENT_HOST_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version'
 import { getBrowserHostLeaseRegistry } from '../../browser-host-lease-registry-instance'
diff --git a/src/main/runtime/rpc/methods/browser-client-host.test.ts b/src/main/runtime/rpc/methods/browser-client-host.test.ts
index cfd61e448a4..6226f9c6dd3 100644
--- a/src/main/runtime/rpc/methods/browser-client-host.test.ts
+++ b/src/main/runtime/rpc/methods/browser-client-host.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { BROWSER_CLIENT_HOST_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version'
 import { getBrowserHostLeaseRegistry } from '../../browser-host-lease-registry-instance'
diff --git a/src/main/runtime/rpc/methods/browser-client-page-metadata.test.ts b/src/main/runtime/rpc/methods/browser-client-page-metadata.test.ts
index 589a114aa94..254584ef9c6 100644
--- a/src/main/runtime/rpc/methods/browser-client-page-metadata.test.ts
+++ b/src/main/runtime/rpc/methods/browser-client-page-metadata.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import {
   BROWSER_CLIENT_HOST_RUNTIME_CAPABILITY,
diff --git a/src/main/runtime/rpc/methods/browser-identity-rpc.test.ts b/src/main/runtime/rpc/methods/browser-identity-rpc.test.ts
index c10abb06bb4..f639522339c 100644
--- a/src/main/runtime/rpc/methods/browser-identity-rpc.test.ts
+++ b/src/main/runtime/rpc/methods/browser-identity-rpc.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 
 const mocks = vi.hoisted(() => ({
diff --git a/src/main/runtime/rpc/methods/browser-network-tunnel.test.ts b/src/main/runtime/rpc/methods/browser-network-tunnel.test.ts
index a34ea13602a..47779581881 100644
--- a/src/main/runtime/rpc/methods/browser-network-tunnel.test.ts
+++ b/src/main/runtime/rpc/methods/browser-network-tunnel.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import {
   BROWSER_CLIENT_HOST_RUNTIME_CAPABILITY,
diff --git a/src/main/runtime/rpc/methods/browser.test.ts b/src/main/runtime/rpc/methods/browser.test.ts
index b5df3a6616b..962d2ea1a11 100644
--- a/src/main/runtime/rpc/methods/browser.test.ts
+++ b/src/main/runtime/rpc/methods/browser.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/client-native-chat-settings.test.ts b/src/main/runtime/rpc/methods/client-native-chat-settings.test.ts
index e26ed4acae3..dcd92f86cf6 100644
--- a/src/main/runtime/rpc/methods/client-native-chat-settings.test.ts
+++ b/src/main/runtime/rpc/methods/client-native-chat-settings.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/client-ui-pairing-local-fields.test.ts b/src/main/runtime/rpc/methods/client-ui-pairing-local-fields.test.ts
index c6f4865dce7..5bcaca1fd0e 100644
--- a/src/main/runtime/rpc/methods/client-ui-pairing-local-fields.test.ts
+++ b/src/main/runtime/rpc/methods/client-ui-pairing-local-fields.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { getDefaultUIState } from '../../../../shared/constants'
 import { PAIRING_LOCAL_UI_FIELDS } from '../../../../shared/pairing-local-ui-fields'
diff --git a/src/main/runtime/rpc/methods/client-ui-task-resume-state.test.ts b/src/main/runtime/rpc/methods/client-ui-task-resume-state.test.ts
index 909975923ae..22f3e3a5a7c 100644
--- a/src/main/runtime/rpc/methods/client-ui-task-resume-state.test.ts
+++ b/src/main/runtime/rpc/methods/client-ui-task-resume-state.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { getDefaultUIState } from '../../../../shared/constants'
 import type { OrcaRuntimeService } from '../../orca-runtime'
diff --git a/src/main/runtime/rpc/methods/client-ui.test.ts b/src/main/runtime/rpc/methods/client-ui.test.ts
index e2cf1289636..cf47bc56454 100644
--- a/src/main/runtime/rpc/methods/client-ui.test.ts
+++ b/src/main/runtime/rpc/methods/client-ui.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { getDefaultUIState } from '../../../../shared/constants'
 import { omitPairingLocalUiFields } from '../../../../shared/pairing-local-ui-fields'
diff --git a/src/main/runtime/rpc/methods/clipboard.test.ts b/src/main/runtime/rpc/methods/clipboard.test.ts
index c0d224b85c6..d68f06dbee0 100644
--- a/src/main/runtime/rpc/methods/clipboard.test.ts
+++ b/src/main/runtime/rpc/methods/clipboard.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest, RpcResponse } from '../core'
diff --git a/src/main/runtime/rpc/methods/diagnostics.test.ts b/src/main/runtime/rpc/methods/diagnostics.test.ts
index 82fc1fa9b75..dab6b8fe85d 100644
--- a/src/main/runtime/rpc/methods/diagnostics.test.ts
+++ b/src/main/runtime/rpc/methods/diagnostics.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/files-base64-padding.test.ts b/src/main/runtime/rpc/methods/files-base64-padding.test.ts
index 03f3b73e786..5729c2df071 100644
--- a/src/main/runtime/rpc/methods/files-base64-padding.test.ts
+++ b/src/main/runtime/rpc/methods/files-base64-padding.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import { RpcDispatcher } from '../dispatcher'
diff --git a/src/main/runtime/rpc/methods/files-doc-preview.test.ts b/src/main/runtime/rpc/methods/files-doc-preview.test.ts
index e512856c04a..cd8616ba1a9 100644
--- a/src/main/runtime/rpc/methods/files-doc-preview.test.ts
+++ b/src/main/runtime/rpc/methods/files-doc-preview.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/files-list-all-page-size.test.ts b/src/main/runtime/rpc/methods/files-list-all-page-size.test.ts
index 826d0c0f3f0..bb6f362b2ce 100644
--- a/src/main/runtime/rpc/methods/files-list-all-page-size.test.ts
+++ b/src/main/runtime/rpc/methods/files-list-all-page-size.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 /**
  * #12547: `files.listAll` did not declare `maxResults`, so "the client names its cap and a full page
  * means there is more" was wired only on the Electron IPC hop. Web and mobile were saved incidentally,
diff --git a/src/main/runtime/rpc/methods/files-open-navigation.test.ts b/src/main/runtime/rpc/methods/files-open-navigation.test.ts
index 0d3ee7b1c0d..d7d8809c512 100644
--- a/src/main/runtime/rpc/methods/files-open-navigation.test.ts
+++ b/src/main/runtime/rpc/methods/files-open-navigation.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/files-path-search.test.ts b/src/main/runtime/rpc/methods/files-path-search.test.ts
index 38938228b8c..f5a246ba54a 100644
--- a/src/main/runtime/rpc/methods/files-path-search.test.ts
+++ b/src/main/runtime/rpc/methods/files-path-search.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/files-preview-transport-budget.test.ts b/src/main/runtime/rpc/methods/files-preview-transport-budget.test.ts
index c36a34983a9..51d6ea3a268 100644
--- a/src/main/runtime/rpc/methods/files-preview-transport-budget.test.ts
+++ b/src/main/runtime/rpc/methods/files-preview-transport-budget.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { remoteRpcContentBudget } from '../../../../shared/remote-rpc-content-budget'
 import type { OrcaRuntimeService } from '../../orca-runtime'
diff --git a/src/main/runtime/rpc/methods/files-terminal-path-resolution.test.ts b/src/main/runtime/rpc/methods/files-terminal-path-resolution.test.ts
index d589b74116c..0fccbddb180 100644
--- a/src/main/runtime/rpc/methods/files-terminal-path-resolution.test.ts
+++ b/src/main/runtime/rpc/methods/files-terminal-path-resolution.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/files-watch-cancellation.test.ts b/src/main/runtime/rpc/methods/files-watch-cancellation.test.ts
index 067c23aa83a..95d458c05a4 100644
--- a/src/main/runtime/rpc/methods/files-watch-cancellation.test.ts
+++ b/src/main/runtime/rpc/methods/files-watch-cancellation.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { RpcRequest } from '../core'
 import { RpcDispatcher } from '../dispatcher'
diff --git a/src/main/runtime/rpc/methods/files-watch-cleanup.test.ts b/src/main/runtime/rpc/methods/files-watch-cleanup.test.ts
index 991dc23b732..a16fbacc44a 100644
--- a/src/main/runtime/rpc/methods/files-watch-cleanup.test.ts
+++ b/src/main/runtime/rpc/methods/files-watch-cleanup.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { expect, it, vi } from 'vitest'
 import { WatcherProcessFailure } from '../../../ipc/parcel-watcher-process-failure'
 import type { OrcaRuntimeService } from '../../orca-runtime'
diff --git a/src/main/runtime/rpc/methods/files.test.ts b/src/main/runtime/rpc/methods/files.test.ts
index 2b29e9b65b6..8c95a7cfa33 100644
--- a/src/main/runtime/rpc/methods/files.test.ts
+++ b/src/main/runtime/rpc/methods/files.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/git-diff-transport-budget.test.ts b/src/main/runtime/rpc/methods/git-diff-transport-budget.test.ts
index 72ae885c9b7..13f740259c2 100644
--- a/src/main/runtime/rpc/methods/git-diff-transport-budget.test.ts
+++ b/src/main/runtime/rpc/methods/git-diff-transport-budget.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 // Why: git.diff, git.branchDiff and git.commitDiff all return a GitDiffResult, so capping only the
 // first would leave the other two able to kill a remote socket.
 import { describe, expect, it, vi } from 'vitest'
diff --git a/src/main/runtime/rpc/methods/git.test.ts b/src/main/runtime/rpc/methods/git.test.ts
index 34ec308bfb4..efb6a3fcb5c 100644
--- a/src/main/runtime/rpc/methods/git.test.ts
+++ b/src/main/runtime/rpc/methods/git.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/github-pr-refresh-reason.test.ts b/src/main/runtime/rpc/methods/github-pr-refresh-reason.test.ts
index 967bafa516e..2ae4fc9300f 100644
--- a/src/main/runtime/rpc/methods/github-pr-refresh-reason.test.ts
+++ b/src/main/runtime/rpc/methods/github-pr-refresh-reason.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 // Split from github.test.ts to keep it under its line cap.
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
diff --git a/src/main/runtime/rpc/methods/github.test.ts b/src/main/runtime/rpc/methods/github.test.ts
index 1ed202d2f57..bd333234cd0 100644
--- a/src/main/runtime/rpc/methods/github.test.ts
+++ b/src/main/runtime/rpc/methods/github.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/gitlab.test.ts b/src/main/runtime/rpc/methods/gitlab.test.ts
index a5cda8dc144..ef55c1fc64d 100644
--- a/src/main/runtime/rpc/methods/gitlab.test.ts
+++ b/src/main/runtime/rpc/methods/gitlab.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/host-capabilities.test.ts b/src/main/runtime/rpc/methods/host-capabilities.test.ts
index 8e2f15cd25c..726aa5d90a7 100644
--- a/src/main/runtime/rpc/methods/host-capabilities.test.ts
+++ b/src/main/runtime/rpc/methods/host-capabilities.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/hosted-review.test.ts b/src/main/runtime/rpc/methods/hosted-review.test.ts
index d4c7e6ac645..9d4ca356b0d 100644
--- a/src/main/runtime/rpc/methods/hosted-review.test.ts
+++ b/src/main/runtime/rpc/methods/hosted-review.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/jira.test.ts b/src/main/runtime/rpc/methods/jira.test.ts
index e5e6bfba634..1652819fec0 100644
--- a/src/main/runtime/rpc/methods/jira.test.ts
+++ b/src/main/runtime/rpc/methods/jira.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/linear-agent-access.test.ts b/src/main/runtime/rpc/methods/linear-agent-access.test.ts
index 511378aa141..e44fe0b38dc 100644
--- a/src/main/runtime/rpc/methods/linear-agent-access.test.ts
+++ b/src/main/runtime/rpc/methods/linear-agent-access.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/linear.test.ts b/src/main/runtime/rpc/methods/linear.test.ts
index 1e9b430fa8a..890dc18d43f 100644
--- a/src/main/runtime/rpc/methods/linear.test.ts
+++ b/src/main/runtime/rpc/methods/linear.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/orchestration-dispatch-error-codes.test.ts b/src/main/runtime/rpc/methods/orchestration-dispatch-error-codes.test.ts
index 918724e6aaf..659523822b6 100644
--- a/src/main/runtime/rpc/methods/orchestration-dispatch-error-codes.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration-dispatch-error-codes.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { ORCHESTRATION_CONTRACT_VERSION } from '../../../../shared/protocol-version'
 import {
diff --git a/src/main/runtime/rpc/methods/orchestration/federation/federated-message-targeting.test.ts b/src/main/runtime/rpc/methods/orchestration/federation/federated-message-targeting.test.ts
index 6d3f00abd6a..6d92c69e4b9 100644
--- a/src/main/runtime/rpc/methods/orchestration/federation/federated-message-targeting.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/federation/federated-message-targeting.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { ORCHESTRATION_CONTRACT_VERSION } from '../../../../../../shared/protocol-version'
 import { OrcaRuntimeService } from '../../../../orca-runtime'
diff --git a/src/main/runtime/rpc/methods/orchestration/federation/federation-control-mail.test.ts b/src/main/runtime/rpc/methods/orchestration/federation/federation-control-mail.test.ts
index c95ec9b5630..1579f0132d9 100644
--- a/src/main/runtime/rpc/methods/orchestration/federation/federation-control-mail.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/federation/federation-control-mail.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { ORCHESTRATION_CONTRACT_VERSION } from '../../../../../../shared/protocol-version'
 import type { RuntimeRpcResponse } from '../../../../../../shared/runtime-rpc-envelope'
diff --git a/src/main/runtime/rpc/methods/orchestration/federation/federation-lifecycle-settlement.test.ts b/src/main/runtime/rpc/methods/orchestration/federation/federation-lifecycle-settlement.test.ts
index 94341ac9c6f..33e860b74e6 100644
--- a/src/main/runtime/rpc/methods/orchestration/federation/federation-lifecycle-settlement.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/federation/federation-lifecycle-settlement.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   ORCHESTRATION_CONTRACT_VERSION,
diff --git a/src/main/runtime/rpc/methods/orchestration/federation/federation-output.test.ts b/src/main/runtime/rpc/methods/orchestration/federation/federation-output.test.ts
index cb298ad873f..374a9b9be66 100644
--- a/src/main/runtime/rpc/methods/orchestration/federation/federation-output.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/federation/federation-output.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
diff --git a/src/main/runtime/rpc/methods/orchestration/federation/federation.test.ts b/src/main/runtime/rpc/methods/orchestration/federation/federation.test.ts
index 450f9ff9a5f..a2c692dd0fb 100644
--- a/src/main/runtime/rpc/methods/orchestration/federation/federation.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/federation/federation.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   ORCHESTRATION_CONTRACT_VERSION,
diff --git a/src/main/runtime/rpc/methods/orchestration/federation/federation.ts b/src/main/runtime/rpc/methods/orchestration/federation/federation.ts
index e88004ff89e..0d6bde6e104 100644
--- a/src/main/runtime/rpc/methods/orchestration/federation/federation.ts
+++ b/src/main/runtime/rpc/methods/orchestration/federation/federation.ts
@@ -20,7 +20,7 @@ import {
 } from './federation-setup'
 import { FederationAttachStartParams } from './federation-start-schema'
 import { failFederatedAttachmentWithReceipt } from './federation-start-receipt'
-import { prepareFederationConfiguredWorkerStart } from '../worker/worker-configured-agent-preflight'
+import { prepareFederationWorkerLaunchOnHost } from '../worker/worker-opencode-model-preflight'
 import {
   isWorkerStartTimeoutWithinTimerLimit,
   resolveWorkerStartReadinessTimeoutMs
@@ -54,7 +54,7 @@ export const ORCHESTRATION_FEDERATION_ATTACH_METHODS = [
         )
       }
       const createsWorktree = params.worktree === 'new-top-level'
-      const { agent, launch } = await prepareFederationConfiguredWorkerStart({
+      const { agent, launch } = await prepareFederationWorkerLaunchOnHost({
         params,
         createsWorktree,
         runtime
diff --git a/src/main/runtime/rpc/methods/orchestration/messaging/recipient-routing.test.ts b/src/main/runtime/rpc/methods/orchestration/messaging/recipient-routing.test.ts
index cf78bfa6636..5e45e97fd7a 100644
--- a/src/main/runtime/rpc/methods/orchestration/messaging/recipient-routing.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/messaging/recipient-routing.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { ORCHESTRATION_CONTRACT_VERSION } from '../../../../../../shared/protocol-version'
 import type { RuntimeTerminalSummary } from '../../../../../../shared/runtime-types'
diff --git a/src/main/runtime/rpc/methods/orchestration/messaging/send-invalid-type.test.ts b/src/main/runtime/rpc/methods/orchestration/messaging/send-invalid-type.test.ts
index 3ace8ba5058..d1527338b95 100644
--- a/src/main/runtime/rpc/methods/orchestration/messaging/send-invalid-type.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/messaging/send-invalid-type.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it } from 'vitest'
 import type { RpcRequest } from '../../../core'
 import { ORCHESTRATION_METHODS } from '../../orchestration'
diff --git a/src/main/runtime/rpc/methods/orchestration/messaging/send.test.ts b/src/main/runtime/rpc/methods/orchestration/messaging/send.test.ts
index 6d4e1e1c19b..c3c8f2e1bdf 100644
--- a/src/main/runtime/rpc/methods/orchestration/messaging/send.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/messaging/send.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { RpcContext, RpcRequest } from '../../../core'
 import { ORCHESTRATION_METHODS } from '../../orchestration'
diff --git a/src/main/runtime/rpc/methods/orchestration/runs/migration-behavior.test.ts b/src/main/runtime/rpc/methods/orchestration/runs/migration-behavior.test.ts
index 929dd5c1ee3..d384b2c7255 100644
--- a/src/main/runtime/rpc/methods/orchestration/runs/migration-behavior.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/runs/migration-behavior.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { RuntimeRpcResponse } from '../../../../../../shared/runtime-rpc-envelope'
 import {
diff --git a/src/main/runtime/rpc/methods/orchestration/worker/local-worker-start.ts b/src/main/runtime/rpc/methods/orchestration/worker/local-worker-start.ts
index c6d7ef96f68..c964c6f1e17 100644
--- a/src/main/runtime/rpc/methods/orchestration/worker/local-worker-start.ts
+++ b/src/main/runtime/rpc/methods/orchestration/worker/local-worker-start.ts
@@ -1,3 +1,4 @@
+import { probeWorkerOpenCodeModelLaunchSupport } from './worker-opencode-model-preflight'
 import { resolveWorkerConfiguredAgentParams } from './worker-configured-agent-preflight'
 import { waitForWorkerAgentReady } from '../../../../launched-agent-composer-readiness'
 import type { OrcaRuntimeService } from '../../../../orca-runtime'
@@ -71,10 +72,25 @@ export async function startLocalWorker(args: {
           worktree: requestedWorktree === 'current' ? `id:${callerWorkspaceId}` : requestedWorktree
         }
   })
+  let openCodeModelLaunchSupported = false
+  if (!createsWorktree && launchParams.agent === 'opencode' && launchParams.model) {
+    const callerWorkspaceId = await resolveDispatchCallerWorktreeId(
+      runtime,
+      params.from,
+      callerSession
+    )
+    openCodeModelLaunchSupported = await probeWorkerOpenCodeModelLaunchSupport(
+      runtime,
+      launchParams,
+      { worktree: requestedWorktree === 'current' ? `id:${callerWorkspaceId}` : requestedWorktree }
+    )
+  }
+
   const { agent, launch } = prepareLocalWorkerStart({
     params: launchParams,
     createsWorktree,
-    runtime
+    runtime,
+    openCodeModelLaunchSupported
   })
 
   const coordinatorWorktreeId = await resolveDispatchCallerWorktreeId(
diff --git a/src/main/runtime/rpc/methods/orchestration/worker/worker-launch-preferences.test.ts b/src/main/runtime/rpc/methods/orchestration/worker/worker-launch-preferences.test.ts
index 899a63c0683..f79094d8d86 100644
--- a/src/main/runtime/rpc/methods/orchestration/worker/worker-launch-preferences.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/worker/worker-launch-preferences.test.ts
@@ -117,10 +117,48 @@ describe('orchestration worker launch preferences', () => {
     ).toThrow('does not support effort turbo')
   })
 
-  it('refuses an opencode model because the opencode 2 TUI rejects --model', () => {
+  it('refuses an opencode model until the execution host verifies legacy TUI support', () => {
     expect(() =>
       resolveWorkerLaunchPreferences({ agent: 'opencode', model: 'meta/muse-spark-1.3' })
-    ).toThrow('does not support launch-time model selection')
+    ).toThrow('cannot verify launch-time model selection')
+  })
+
+  it('explains the existing-worktree requirement even if a new-worktree host is verified', () => {
+    expect(() =>
+      resolveWorkerLaunchPreferences({
+        agent: 'opencode',
+        model: 'opencode/fledge-alpha-free',
+        createsWorktree: true,
+        openCodeModelLaunchSupported: true
+      })
+    ).toThrow('requires an existing worktree')
+  })
+
+  it('supports an opaque OpenCode model on a verified legacy host', () => {
+    expect(
+      resolveWorkerLaunchPreferences({
+        agent: 'opencode',
+        model: 'zai-coding-plan/glm-5.3-flash',
+        openCodeModelLaunchSupported: true
+      })
+    ).toEqual({
+      preferences: { model: 'zai-coding-plan/glm-5.3-flash' },
+      receipt: {
+        requested: { agent: 'opencode', model: 'zai-coding-plan/glm-5.3-flash', effort: null },
+        effective: { agent: 'opencode', model: 'zai-coding-plan/glm-5.3-flash', effort: null }
+      }
+    })
+  })
+
+  it('refuses an unverified OpenCode effort on a legacy host', () => {
+    expect(() =>
+      resolveWorkerLaunchPreferences({
+        agent: 'opencode',
+        model: 'opencode/fledge-alpha-free',
+        effort: 'high',
+        openCodeModelLaunchSupported: true
+      })
+    ).toThrow('does not support effort high')
   })
 
   it('does not invent an effort when only a model is requested', () => {
@@ -157,23 +195,28 @@ describe('orchestration worker launch preferences', () => {
     },
     {
       model: 'gpt-5.4',
-      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh'],
-      rejected: ['max', 'ultra', 'future-effort']
+      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+      rejected: ['future-effort']
     },
     {
       model: 'gpt-5.4-mini',
-      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh'],
-      rejected: ['max', 'ultra', 'future-effort']
+      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+      rejected: ['future-effort']
     },
     {
       model: 'gpt-5.3-codex-spark',
-      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh'],
-      rejected: ['max', 'ultra', 'future-effort']
+      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+      rejected: ['future-effort']
+    },
+    {
+      model: 'gpt-6.1-sol',
+      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+      rejected: ['turbo', 'future-effort']
     },
     {
       model: 'future-codex-model',
-      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh'],
-      rejected: ['max', 'ultra', 'future-effort']
+      accepted: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+      rejected: ['future-effort']
     }
   ])('enforces the Codex effort ceiling for $model', ({ model, accepted, rejected }) => {
     const catalog = getAgentSessionOptionCatalog('codex')!
diff --git a/src/main/runtime/rpc/methods/orchestration/worker/worker-launch-preferences.ts b/src/main/runtime/rpc/methods/orchestration/worker/worker-launch-preferences.ts
index d998d8e5e71..a5b12d7d46a 100644
--- a/src/main/runtime/rpc/methods/orchestration/worker/worker-launch-preferences.ts
+++ b/src/main/runtime/rpc/methods/orchestration/worker/worker-launch-preferences.ts
@@ -1,10 +1,12 @@
 import type { AgentLaunchPreferences } from '../../../../../../shared/agent-session-host-authority'
 import {
   findCatalogModel,
-  findCatalogOption,
-  getAgentSessionOptionCatalog
+  findCatalogOption
 } from '../../../../../../shared/agent-session-option-catalog'
-import { resolveAgentSessionOptionLaunch } from '../../../../../../shared/agent-session-option-launch'
+import {
+  getAgentSessionOptionLaunchCatalog,
+  resolveAgentSessionOptionLaunch
+} from '../../../../../../shared/agent-session-option-launch'
 import { ORCHESTRATION_WORKER_LAUNCH_PREFERENCES_RUNTIME_CAPABILITY } from '../../../../../../shared/protocol-version'
 import type { TuiAgent } from '../../../../../../shared/tui-agent'
 import { OrchestrationError } from '../../../../orchestration/orchestration-error'
@@ -50,6 +52,8 @@ export function createPendingWorkerLaunchReceipt(args: {
 
 export function resolveWorkerLaunchPreferences(args: {
   agent: TuiAgent
+  openCodeModelLaunchSupported?: boolean
+  createsWorktree?: boolean
   model?: string
   effort?: string
 }): {
@@ -66,7 +70,21 @@ export function resolveWorkerLaunchPreferences(args: {
     }
   }
 
-  const catalog = getAgentSessionOptionCatalog(args.agent)
+  if (args.agent === 'opencode' && args.createsWorktree) {
+    throw new OrchestrationError(
+      'capability_unsupported',
+      'OpenCode model selection requires an existing worktree. Use --worktree current or an existing worktree selector, or omit --model.'
+    )
+  }
+
+  if (args.agent === 'opencode' && args.openCodeModelLaunchSupported !== true) {
+    throw new OrchestrationError(
+      'capability_unsupported',
+      'This OpenCode TUI cannot verify launch-time model selection. Omit --model or use a supported OpenCode CLI.'
+    )
+  }
+
+  const catalog = getAgentSessionOptionLaunchCatalog(args.agent)
   if (!catalog?.supportsWorkerLaunchPreferences || !catalog.modelApply.launchArgs) {
     throw new OrchestrationError(
       'invalid_argument',
diff --git a/src/main/runtime/rpc/methods/orchestration/worker/worker-opencode-model-preflight.ts b/src/main/runtime/rpc/methods/orchestration/worker/worker-opencode-model-preflight.ts
new file mode 100644
index 00000000000..af0c4aa8db7
--- /dev/null
+++ b/src/main/runtime/rpc/methods/orchestration/worker/worker-opencode-model-preflight.ts
@@ -0,0 +1,36 @@
+import {
+  prepareFederationConfiguredWorkerStart,
+  resolveWorkerConfiguredAgentParams
+} from './worker-configured-agent-preflight'
+import type { prepareFederationAttachmentWorkerStart } from './worker-start-validation'
+import type { OrcaRuntimeService } from '../../../../orca-runtime'
+
+export async function probeWorkerOpenCodeModelLaunchSupport(
+  runtime: OrcaRuntimeService,
+  params: { agent?: string; model?: string },
+  target: { worktree?: string }
+): Promise<boolean> {
+  return Boolean(
+    params.model &&
+    params.agent &&
+    runtime.resolveOrchestrationAgentLauncher(params.agent) === 'opencode' &&
+    (await runtime.probeOrchestrationOpenCodeModelLaunchSupport({ ...target, model: params.model }))
+  )
+}
+
+export async function prepareFederationWorkerLaunchOnHost(
+  args: Omit<
+    Parameters<typeof prepareFederationAttachmentWorkerStart>[0],
+    'openCodeModelLaunchSupported'
+  >
+) {
+  const params = await resolveWorkerConfiguredAgentParams(args.runtime, args.params, async () =>
+    args.createsWorktree ? { repo: args.params.repo } : { worktree: args.params.worktree }
+  )
+  const openCodeModelLaunchSupported =
+    !args.createsWorktree &&
+    (await probeWorkerOpenCodeModelLaunchSupport(args.runtime, params, {
+      worktree: params.worktree
+    }))
+  return prepareFederationConfiguredWorkerStart({ ...args, params, openCodeModelLaunchSupported })
+}
diff --git a/src/main/runtime/rpc/methods/orchestration/worker/worker-start-prompt-contract.test.ts b/src/main/runtime/rpc/methods/orchestration/worker/worker-start-prompt-contract.test.ts
index cba8baad45f..73fa180dc54 100644
--- a/src/main/runtime/rpc/methods/orchestration/worker/worker-start-prompt-contract.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/worker/worker-start-prompt-contract.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
diff --git a/src/main/runtime/rpc/methods/orchestration/worker/worker-start-validation.ts b/src/main/runtime/rpc/methods/orchestration/worker/worker-start-validation.ts
index 1f80eebcb34..b9e39abb859 100644
--- a/src/main/runtime/rpc/methods/orchestration/worker/worker-start-validation.ts
+++ b/src/main/runtime/rpc/methods/orchestration/worker/worker-start-validation.ts
@@ -52,6 +52,7 @@ export function prepareLocalWorkerStart(args: {
   params: WorkerStartInput
   createsWorktree: boolean
   runtime: OrcaRuntimeService
+  openCodeModelLaunchSupported?: boolean
 }): { agent: TuiAgent | undefined; launch: WorkerStartLaunch } {
   const { params, createsWorktree, runtime } = args
   assertWorkerLaunchPreferencesCreateTerminal(params)
@@ -78,6 +79,8 @@ export function prepareLocalWorkerStart(args: {
   }
   return resolveWorkerStartAgent({
     runtime,
+    openCodeModelLaunchSupported: args.openCodeModelLaunchSupported,
+    createsWorktree,
     terminal: params.terminal,
     agent: params.agent,
     model: params.model,
@@ -90,6 +93,7 @@ export function prepareFederationAttachmentWorkerStart(args: {
   params: FederationAttachStartInput
   createsWorktree: boolean
   runtime: OrcaRuntimeService
+  openCodeModelLaunchSupported?: boolean
 }): { agent: TuiAgent | undefined; launch: WorkerStartLaunch } {
   const { params, createsWorktree, runtime } = args
   assertWorkerLaunchPreferencesCreateTerminal(params)
@@ -122,6 +126,8 @@ export function prepareFederationAttachmentWorkerStart(args: {
   }
   return resolveWorkerStartAgent({
     runtime,
+    openCodeModelLaunchSupported: args.openCodeModelLaunchSupported,
+    createsWorktree,
     terminal: params.terminal,
     agent: params.agent,
     model: params.model,
@@ -133,6 +139,8 @@ export function prepareFederationAttachmentWorkerStart(args: {
 
 function resolveWorkerStartAgent(args: {
   runtime: OrcaRuntimeService
+  openCodeModelLaunchSupported?: boolean
+  createsWorktree: boolean
   terminal?: string
   agent?: string
   model?: string
@@ -153,6 +161,8 @@ function resolveWorkerStartAgent(args: {
       agent,
       launch: resolveWorkerLaunchPreferences({
         agent,
+        openCodeModelLaunchSupported: args.openCodeModelLaunchSupported,
+        createsWorktree: args.createsWorktree,
         model: args.model,
         effort: args.effort
       })
diff --git a/src/main/runtime/rpc/methods/orchestration/worker/workers-new-worktree.test.ts b/src/main/runtime/rpc/methods/orchestration/worker/workers-new-worktree.test.ts
index fc7c1f3b26c..f52c50a1f1f 100644
--- a/src/main/runtime/rpc/methods/orchestration/worker/workers-new-worktree.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration/worker/workers-new-worktree.test.ts
@@ -1,3 +1,4 @@
+import '../../../unused-default-rpc-methods.test-fixture'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -8,6 +9,8 @@ import { OrchestrationDb } from '../../../../orchestration/db'
 import { RpcDispatcher } from '../../../dispatcher'
 import type { RpcRequest } from '../../../core'
 import { ORCHESTRATION_METHODS } from '../../orchestration'
+import { prepareFederationWorkerLaunchOnHost } from './worker-opencode-model-preflight'
+import { FederationAttachStartParams } from '../federation/federation-start-schema'
 
 describe('orchestration new-worktree workers', () => {
   type CreateWorktreeResult = Awaited<ReturnType<OrcaRuntimeService['createManagedWorktree']>>
@@ -189,6 +192,67 @@ describe('orchestration new-worktree workers', () => {
     })
   })
 
+  it.each(['new-child', 'new-top-level'])(
+    'refuses an OpenCode model for %s without probing',
+    async (worktree) => {
+      mockCreatedWorktree()
+      const probe = vi
+        .spyOn(runtime, 'probeOrchestrationOpenCodeModelLaunchSupport')
+        .mockResolvedValue(true)
+      await expect(
+        startWorker({
+          worktree,
+          repo: 'repo',
+          agent: 'opencode',
+          model: 'opencode/fledge-alpha-free'
+        })
+      ).rejects.toMatchObject({
+        code: 'capability_unsupported',
+        message: expect.stringContaining('requires an existing worktree')
+      })
+      expect(probe).not.toHaveBeenCalled()
+      expect(runtime.createManagedWorktree).not.toHaveBeenCalled()
+      expect(runtime.createTerminal).not.toHaveBeenCalled()
+      expect(runtime.sendTerminalAgentPrompt).not.toHaveBeenCalled()
+    }
+  )
+
+  it('refuses a federated new-worktree model before probing its repository', async () => {
+    const probe = vi
+      .spyOn(runtime, 'probeOrchestrationOpenCodeModelLaunchSupport')
+      .mockResolvedValue(true)
+    const params = FederationAttachStartParams.parse({
+      dispatchId: 'ctx_new',
+      taskId: 'task_new',
+      taskSpec: 'No effects',
+      protocolVersion: 3,
+      worktree: 'new-top-level',
+      name: 'new-worker',
+      repo: 'repo',
+      agent: 'opencode',
+      model: 'opencode/fledge-alpha-free'
+    })
+    await expect(
+      prepareFederationWorkerLaunchOnHost({ runtime, params, createsWorktree: true })
+    ).rejects.toMatchObject({
+      code: 'capability_unsupported',
+      message: expect.stringContaining('requires an existing worktree')
+    })
+    expect(probe).not.toHaveBeenCalled()
+    expect(runtime.createTerminal).not.toHaveBeenCalled()
+    expect(runtime.sendTerminalAgentPrompt).not.toHaveBeenCalled()
+  })
+
+  it('rejects an unsupported OpenCode model before creating a worker', async () => {
+    const create = vi.spyOn(runtime, 'createManagedWorktree')
+    vi.spyOn(runtime, 'probeOrchestrationOpenCodeModelLaunchSupport').mockResolvedValue(false)
+    await expect(
+      startWorker({ agent: 'opencode', model: 'opencode/fledge-alpha-free' })
+    ).rejects.toMatchObject({ code: 'capability_unsupported' })
+    expect(create).not.toHaveBeenCalled()
+    expect(runtime.createTerminal).not.toHaveBeenCalled()
+  })
+
   it('rejects a new worktree for a folder project before creating effects', async () => {
     vi.mocked(runtime.showRepo).mockResolvedValue({
       id: 'repo',
diff --git a/src/main/runtime/rpc/methods/pairing.test.ts b/src/main/runtime/rpc/methods/pairing.test.ts
index 58a12a1f058..05f896dec4c 100644
--- a/src/main/runtime/rpc/methods/pairing.test.ts
+++ b/src/main/runtime/rpc/methods/pairing.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { OrcaRuntimeService } from '../../orca-runtime'
 import { RpcDispatcher } from '../dispatcher'
diff --git a/src/main/runtime/rpc/methods/preflight.test.ts b/src/main/runtime/rpc/methods/preflight.test.ts
index 5b453f9ce40..88fa0bf2057 100644
--- a/src/main/runtime/rpc/methods/preflight.test.ts
+++ b/src/main/runtime/rpc/methods/preflight.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/repo-badge-color.test.ts b/src/main/runtime/rpc/methods/repo-badge-color.test.ts
index 32b50ab0552..f641a90b933 100644
--- a/src/main/runtime/rpc/methods/repo-badge-color.test.ts
+++ b/src/main/runtime/rpc/methods/repo-badge-color.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/repo.test.ts b/src/main/runtime/rpc/methods/repo.test.ts
index 3de0e8feae0..e111d09c62f 100644
--- a/src/main/runtime/rpc/methods/repo.test.ts
+++ b/src/main/runtime/rpc/methods/repo.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/runtime-client-capabilities.test.ts b/src/main/runtime/rpc/methods/runtime-client-capabilities.test.ts
index c0fb2f250bd..d9a7f59adfa 100644
--- a/src/main/runtime/rpc/methods/runtime-client-capabilities.test.ts
+++ b/src/main/runtime/rpc/methods/runtime-client-capabilities.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version'
 import type { OrcaRuntimeService } from '../../orca-runtime'
diff --git a/src/main/runtime/rpc/methods/session-tab-agent-capability-mutations.test.ts b/src/main/runtime/rpc/methods/session-tab-agent-capability-mutations.test.ts
index 0a1076bd8f6..f0792e20a47 100644
--- a/src/main/runtime/rpc/methods/session-tab-agent-capability-mutations.test.ts
+++ b/src/main/runtime/rpc/methods/session-tab-agent-capability-mutations.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import {
   CLAUDE_STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY,
diff --git a/src/main/runtime/rpc/methods/session-tab-browser-placement-mutations.test.ts b/src/main/runtime/rpc/methods/session-tab-browser-placement-mutations.test.ts
index 4067836d88e..7a4d474806c 100644
--- a/src/main/runtime/rpc/methods/session-tab-browser-placement-mutations.test.ts
+++ b/src/main/runtime/rpc/methods/session-tab-browser-placement-mutations.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { BROWSER_CLIENT_HOST_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version'
 import type { OrcaRuntimeService } from '../../orca-runtime'
diff --git a/src/main/runtime/rpc/methods/session-tabs-inventory-rpc.test.ts b/src/main/runtime/rpc/methods/session-tabs-inventory-rpc.test.ts
index 4afdfd8e960..4d78c642795 100644
--- a/src/main/runtime/rpc/methods/session-tabs-inventory-rpc.test.ts
+++ b/src/main/runtime/rpc/methods/session-tabs-inventory-rpc.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/session-tabs-retirement-proof-delta.test.ts b/src/main/runtime/rpc/methods/session-tabs-retirement-proof-delta.test.ts
index 021b6f20622..00c62dc37ec 100644
--- a/src/main/runtime/rpc/methods/session-tabs-retirement-proof-delta.test.ts
+++ b/src/main/runtime/rpc/methods/session-tabs-retirement-proof-delta.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import { SESSION_TABS_RETIREMENT_PROOF_DELTA_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version'
diff --git a/src/main/runtime/rpc/methods/session-tabs-structured-restore.test.ts b/src/main/runtime/rpc/methods/session-tabs-structured-restore.test.ts
index 3b2f5a5ca1e..0bfc94f3663 100644
--- a/src/main/runtime/rpc/methods/session-tabs-structured-restore.test.ts
+++ b/src/main/runtime/rpc/methods/session-tabs-structured-restore.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/session-tabs-subscribe-admission.test.ts b/src/main/runtime/rpc/methods/session-tabs-subscribe-admission.test.ts
index 2652cdf12fd..6f874b22633 100644
--- a/src/main/runtime/rpc/methods/session-tabs-subscribe-admission.test.ts
+++ b/src/main/runtime/rpc/methods/session-tabs-subscribe-admission.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import type { RuntimeMobileSessionTabsResult } from '../../../../shared/runtime-types'
diff --git a/src/main/runtime/rpc/methods/session-tabs-unsubscribe.test.ts b/src/main/runtime/rpc/methods/session-tabs-unsubscribe.test.ts
index 021224bd649..f279dc3a9de 100644
--- a/src/main/runtime/rpc/methods/session-tabs-unsubscribe.test.ts
+++ b/src/main/runtime/rpc/methods/session-tabs-unsubscribe.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import { RuntimeSubscriptionRegistry } from '../../runtime-subscription-registry'
diff --git a/src/main/runtime/rpc/methods/session-tabs.test.ts b/src/main/runtime/rpc/methods/session-tabs.test.ts
index 44d0dd104eb..0fbab1bb9b0 100644
--- a/src/main/runtime/rpc/methods/session-tabs.test.ts
+++ b/src/main/runtime/rpc/methods/session-tabs.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/speech.test.ts b/src/main/runtime/rpc/methods/speech.test.ts
index dbc06ab8a96..2ef23c69762 100644
--- a/src/main/runtime/rpc/methods/speech.test.ts
+++ b/src/main/runtime/rpc/methods/speech.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/ssh.test.ts b/src/main/runtime/rpc/methods/ssh.test.ts
index 04293d3cca4..b71602fadfa 100644
--- a/src/main/runtime/rpc/methods/ssh.test.ts
+++ b/src/main/runtime/rpc/methods/ssh.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-adoption-replay.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-adoption-replay.test.ts
index 6d1ddf9f359..a68ffe4492e 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-adoption-replay.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-adoption-replay.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-at-rest.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-at-rest.test.ts
index b846be96dd2..d66ef3d2fa1 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-at-rest.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-at-rest.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { AGENT_JOURNAL_THREAD_SCOPE } from '../../../../shared/agent-session-journal-types'
 // A chat at rest, through the RPC surface a client actually calls: opening it starts nothing, what
 // it can answer without an agent it answers, and the first send is what starts one.
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
index 769bd32f17b..5c9633a5690 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 // `agentSession.hold` / `release` are kept answering for clients that still send them, and do
 // nothing else: a view never starts or keeps an agent.
 //
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-options-read.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-options-read.test.ts
index 77d44ece745..459ae5c75a4 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-options-read.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-options-read.test.ts
@@ -56,4 +56,66 @@ describe('agentSession.modelCatalog', () => {
     await call('agentSession.modelCatalog', { agent: 'claude' }, STRUCTURED_CLIENT)
     expect(read).toHaveBeenCalledWith({ agent: 'claude' })
   })
+
+  it('passes a wait for the listing through to the catalog', async () => {
+    await call(
+      'agentSession.modelCatalog',
+      { agent: 'codex', sessionId: SESSION, waitForListing: true },
+      STRUCTURED_CLIENT
+    )
+    expect(read).toHaveBeenCalledWith({ agent: 'codex', sessionId: SESSION, waitForListing: true })
+  })
+})
+
+describe('agentSession.modelCatalog before anything built the host', () => {
+  const read = vi.fn(async () => ({
+    origin: 'probe' as const,
+    models: [{ id: 'gpt-host', label: 'GPT Host', isDefault: true, efforts: [] }],
+    fetchedAt: 1
+  }))
+  const installHost = vi.fn(async () => {
+    setStructuredAgentSessionHost(Object.assign(hostStub(), { deps: { modelCatalog: { read } } }))
+  })
+
+  beforeEach(() => {
+    read.mockClear()
+    installHost.mockClear()
+    clearStructuredHostStub()
+  })
+
+  // A new chat's picker reads before its create lands; on a host with no saved chats nothing else
+  // has built the host yet, and a refusal here left the picker on the client's built-in list.
+  it('builds the host for a structured chat and answers from its catalog', async () => {
+    const reply = await call(
+      'agentSession.modelCatalog',
+      { agent: 'codex', sessionId: SESSION },
+      STRUCTURED_CLIENT,
+      { ensureStructuredAgentSessionHost: installHost }
+    )
+    expect(installHost).toHaveBeenCalledTimes(1)
+    expect(reply).toMatchObject({ ok: true, result: { origin: 'probe' } })
+    expect(read).toHaveBeenCalledWith({ agent: 'codex', sessionId: SESSION })
+  })
+
+  // Terminal-backed chat reads with no session: a host that runs no structured chat keeps its
+  // journal closed, and the read falls back to the CLI listing.
+  it('does not build the host for a read that names no session', async () => {
+    const reply = await call('agentSession.modelCatalog', { agent: 'codex' }, STRUCTURED_CLIENT, {
+      ensureStructuredAgentSessionHost: installHost
+    })
+    expect(installHost).not.toHaveBeenCalled()
+    expect(reply).toMatchObject({ ok: false })
+    expect(read).not.toHaveBeenCalled()
+  })
+
+  it('does not build the host for a client that cannot read structured sessions', async () => {
+    const reply = await call(
+      'agentSession.modelCatalog',
+      { agent: 'codex', sessionId: SESSION },
+      { clientKind: 'runtime', clientCapabilities: [] },
+      { ensureStructuredAgentSessionHost: installHost }
+    )
+    expect(installHost).not.toHaveBeenCalled()
+    expect(reply).toMatchObject({ ok: false })
+  })
 })
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-options-read.ts b/src/main/runtime/rpc/methods/structured-agent-session-options-read.ts
index 19e93689577..3cd86c876ad 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-options-read.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-options-read.ts
@@ -11,7 +11,7 @@
 import { defineMethod } from '../core'
 import {
   requireInstalledStructuredHost,
-  requireStructuredHost as requireHost
+  requireStructuredHost
 } from './structured-agent-session-gate'
 import { ModelCatalogParams, OptionsParams } from './structured-agent-session-schemas'
 
@@ -25,8 +25,14 @@ export const STRUCTURED_AGENT_SESSION_OPTIONS_READ_METHODS = [
   defineMethod({
     name: 'agentSession.modelCatalog',
     params: ModelCatalogParams,
+    // A structured chat's read names its session and builds the host, since it may come first;
+    // terminal-backed chat's session-less read must not open the journal where none runs.
     handler: async ({ worktree, ...params }, ctx) => {
-      const catalog = requireHost(ctx).deps.modelCatalog
+      const host =
+        params.sessionId === undefined
+          ? requireStructuredHost(ctx)
+          : await requireInstalledStructuredHost(ctx)
+      const catalog = host.deps.modelCatalog
       if (!catalog) {
         return { origin: 'unknown' as const }
       }
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-precommit-refusal.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-precommit-refusal.test.ts
index 17aadf32a80..970374824d1 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-precommit-refusal.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-precommit-refusal.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 // The create route's pre-commit boundary: a failure before `attach` must reach the client as a
 // refusal it can classify, and a failure at or after `attach` must not.
 
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-unsubscribe.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-unsubscribe.test.ts
index a31a8bc8d18..22d4d7c6174 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-unsubscribe.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-unsubscribe.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 // A transcript stream ends when its client says so: the host drops that subscriber, so nothing is
 // derived or sent for it any more, and a sibling stream of the same session keeps going.
 
diff --git a/src/main/runtime/rpc/methods/structured-chat-tab-table.test.ts b/src/main/runtime/rpc/methods/structured-chat-tab-table.test.ts
index c97672269eb..4c7fe2103d7 100644
--- a/src/main/runtime/rpc/methods/structured-chat-tab-table.test.ts
+++ b/src/main/runtime/rpc/methods/structured-chat-tab-table.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 /**
  * A chat tab's pointer to the conversation it shows, driven end to end: a real record store on disk,
  * the real structured host, the real runtime, and the real RPC handlers. Only the provider is faked.
diff --git a/src/main/runtime/rpc/methods/terminal-legacy-stream-id-characterization.test.ts b/src/main/runtime/rpc/methods/terminal-legacy-stream-id-characterization.test.ts
index 3f3630b0ffa..48acbbec665 100644
--- a/src/main/runtime/rpc/methods/terminal-legacy-stream-id-characterization.test.ts
+++ b/src/main/runtime/rpc/methods/terminal-legacy-stream-id-characterization.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/terminal-navigation.test.ts b/src/main/runtime/rpc/methods/terminal-navigation.test.ts
index b0aa29828c6..11212e53aac 100644
--- a/src/main/runtime/rpc/methods/terminal-navigation.test.ts
+++ b/src/main/runtime/rpc/methods/terminal-navigation.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/terminal/terminal-viewer-colors-method.test.ts b/src/main/runtime/rpc/methods/terminal/terminal-viewer-colors-method.test.ts
index 9b0d5b4fc18..ca999ce50ef 100644
--- a/src/main/runtime/rpc/methods/terminal/terminal-viewer-colors-method.test.ts
+++ b/src/main/runtime/rpc/methods/terminal/terminal-viewer-colors-method.test.ts
@@ -1,3 +1,4 @@
+import '../../unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it } from 'vitest'
 import type { OrcaRuntimeService } from '../../../orca-runtime'
 import { RpcDispatcher } from '../../dispatcher'
diff --git a/src/main/runtime/rpc/methods/workspace-ports.test.ts b/src/main/runtime/rpc/methods/workspace-ports.test.ts
index 78465ada16b..75ce15053c2 100644
--- a/src/main/runtime/rpc/methods/workspace-ports.test.ts
+++ b/src/main/runtime/rpc/methods/workspace-ports.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/worktree-catalog-snapshot-method.test.ts b/src/main/runtime/rpc/methods/worktree-catalog-snapshot-method.test.ts
index 7bf9cd2734c..f1004b6abe7 100644
--- a/src/main/runtime/rpc/methods/worktree-catalog-snapshot-method.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-catalog-snapshot-method.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import { RpcDispatcher } from '../dispatcher'
diff --git a/src/main/runtime/rpc/methods/worktree-catalog-version-stamp.test.ts b/src/main/runtime/rpc/methods/worktree-catalog-version-stamp.test.ts
index 1d7e1627c36..cbe4bd654b2 100644
--- a/src/main/runtime/rpc/methods/worktree-catalog-version-stamp.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-catalog-version-stamp.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/worktree-create-launch-source.test.ts b/src/main/runtime/rpc/methods/worktree-create-launch-source.test.ts
index 2cfd6c3de92..8cb90745a0b 100644
--- a/src/main/runtime/rpc/methods/worktree-create-launch-source.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-create-launch-source.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { OrcaRuntimeService } from '../../orca-runtime'
diff --git a/src/main/runtime/rpc/methods/worktree-create-navigation.test.ts b/src/main/runtime/rpc/methods/worktree-create-navigation.test.ts
index 39f826986e6..b70d56eee9b 100644
--- a/src/main/runtime/rpc/methods/worktree-create-navigation.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-create-navigation.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/worktree-github-pr-suppression.test.ts b/src/main/runtime/rpc/methods/worktree-github-pr-suppression.test.ts
index 4adaf6f5325..32a118ef00a 100644
--- a/src/main/runtime/rpc/methods/worktree-github-pr-suppression.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-github-pr-suppression.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/worktree-missing-terminal-teardown.test.ts b/src/main/runtime/rpc/methods/worktree-missing-terminal-teardown.test.ts
index 9ea904af68d..1ae125ef814 100644
--- a/src/main/runtime/rpc/methods/worktree-missing-terminal-teardown.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-missing-terminal-teardown.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import { RpcDispatcher } from '../dispatcher'
diff --git a/src/main/runtime/rpc/methods/worktree-retired-names.test.ts b/src/main/runtime/rpc/methods/worktree-retired-names.test.ts
index 3c4c6f3755d..98488fe1c57 100644
--- a/src/main/runtime/rpc/methods/worktree-retired-names.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-retired-names.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/worktree-rm-background-reply.test.ts b/src/main/runtime/rpc/methods/worktree-rm-background-reply.test.ts
index e456e4cbf50..4d45504f77a 100644
--- a/src/main/runtime/rpc/methods/worktree-rm-background-reply.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-rm-background-reply.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import {
   WORKTREE_BACKGROUND_REMOVAL_RUNTIME_CAPABILITY,
diff --git a/src/main/runtime/rpc/methods/worktree-rm-host-qualification.test.ts b/src/main/runtime/rpc/methods/worktree-rm-host-qualification.test.ts
index d96fa04c521..4f9a4acdfec 100644
--- a/src/main/runtime/rpc/methods/worktree-rm-host-qualification.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-rm-host-qualification.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../../orca-runtime'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/worktree-rm-pty-waiver.test.ts b/src/main/runtime/rpc/methods/worktree-rm-pty-waiver.test.ts
index 0c912db53be..35ba7b9f267 100644
--- a/src/main/runtime/rpc/methods/worktree-rm-pty-waiver.test.ts
+++ b/src/main/runtime/rpc/methods/worktree-rm-pty-waiver.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/methods/worktree.test.ts b/src/main/runtime/rpc/methods/worktree.test.ts
index 3b62cbfd7cd..d67ee99193f 100644
--- a/src/main/runtime/rpc/methods/worktree.test.ts
+++ b/src/main/runtime/rpc/methods/worktree.test.ts
@@ -1,3 +1,4 @@
+import '../unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from '../dispatcher'
 import type { RpcRequest } from '../core'
diff --git a/src/main/runtime/rpc/orchestration-commit-notify-characterization.test.ts b/src/main/runtime/rpc/orchestration-commit-notify-characterization.test.ts
index 4ebd49df17e..9c8679e3963 100644
--- a/src/main/runtime/rpc/orchestration-commit-notify-characterization.test.ts
+++ b/src/main/runtime/rpc/orchestration-commit-notify-characterization.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
diff --git a/src/main/runtime/rpc/orchestration-contract-fence.test.ts b/src/main/runtime/rpc/orchestration-contract-fence.test.ts
index 17aee4b0b95..10d4d13b1fe 100644
--- a/src/main/runtime/rpc/orchestration-contract-fence.test.ts
+++ b/src/main/runtime/rpc/orchestration-contract-fence.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { z } from 'zod'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { ORCHESTRATION_CONTRACT_VERSION } from '../../../shared/protocol-version'
diff --git a/src/main/runtime/rpc/orchestration-legacy-coordinator-race.test.ts b/src/main/runtime/rpc/orchestration-legacy-coordinator-race.test.ts
index c57f7876402..55ef7ac2040 100644
--- a/src/main/runtime/rpc/orchestration-legacy-coordinator-race.test.ts
+++ b/src/main/runtime/rpc/orchestration-legacy-coordinator-race.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { createHash } from 'node:crypto'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
diff --git a/src/main/runtime/rpc/orchestration-legacy-question-takeover.test.ts b/src/main/runtime/rpc/orchestration-legacy-question-takeover.test.ts
index 82c59f39587..b044469cc3f 100644
--- a/src/main/runtime/rpc/orchestration-legacy-question-takeover.test.ts
+++ b/src/main/runtime/rpc/orchestration-legacy-question-takeover.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { createHash } from 'node:crypto'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
diff --git a/src/main/runtime/rpc/orchestration-legacy-takeover-current-authority.test.ts b/src/main/runtime/rpc/orchestration-legacy-takeover-current-authority.test.ts
index 4de71ce6f2a..3ae8dc8375c 100644
--- a/src/main/runtime/rpc/orchestration-legacy-takeover-current-authority.test.ts
+++ b/src/main/runtime/rpc/orchestration-legacy-takeover-current-authority.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { createHash } from 'node:crypto'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { AgentHookServer } from '../../agent-hooks/server'
diff --git a/src/main/runtime/rpc/orchestration-legacy-takeover-delivery.test.ts b/src/main/runtime/rpc/orchestration-legacy-takeover-delivery.test.ts
index feb3017b538..4dde47e78df 100644
--- a/src/main/runtime/rpc/orchestration-legacy-takeover-delivery.test.ts
+++ b/src/main/runtime/rpc/orchestration-legacy-takeover-delivery.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { createHash } from 'node:crypto'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
diff --git a/src/main/runtime/rpc/orchestration-legacy-takeover-dispatcher.test.ts b/src/main/runtime/rpc/orchestration-legacy-takeover-dispatcher.test.ts
index e5a05fe7d26..73a27ddc04d 100644
--- a/src/main/runtime/rpc/orchestration-legacy-takeover-dispatcher.test.ts
+++ b/src/main/runtime/rpc/orchestration-legacy-takeover-dispatcher.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { createHash } from 'node:crypto'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
diff --git a/src/main/runtime/rpc/orchestration-mutation-ledger.test.ts b/src/main/runtime/rpc/orchestration-mutation-ledger.test.ts
index 6909b4f3345..3a6b734c259 100644
--- a/src/main/runtime/rpc/orchestration-mutation-ledger.test.ts
+++ b/src/main/runtime/rpc/orchestration-mutation-ledger.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { createHash } from 'node:crypto'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
diff --git a/src/main/runtime/rpc/orchestration-mutation-request-show.test.ts b/src/main/runtime/rpc/orchestration-mutation-request-show.test.ts
index e64fb5b9640..68310db7224 100644
--- a/src/main/runtime/rpc/orchestration-mutation-request-show.test.ts
+++ b/src/main/runtime/rpc/orchestration-mutation-request-show.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 // A lost mutation response must be answerable without mutating again: these cover
 // `orchestration.requestShow` reading the same durable receipt --retry-request replays.
 import { describe, expect, it, vi } from 'vitest'
diff --git a/src/main/runtime/rpc/orchestration-runtime-update-settlement.test.ts b/src/main/runtime/rpc/orchestration-runtime-update-settlement.test.ts
index db1da5c93d0..e9b46098bce 100644
--- a/src/main/runtime/rpc/orchestration-runtime-update-settlement.test.ts
+++ b/src/main/runtime/rpc/orchestration-runtime-update-settlement.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { createHash } from 'node:crypto'
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
diff --git a/src/main/runtime/rpc/orchestration-task-dispatch-invariant.test.ts b/src/main/runtime/rpc/orchestration-task-dispatch-invariant.test.ts
index d09c47939f0..ed10d31f919 100644
--- a/src/main/runtime/rpc/orchestration-task-dispatch-invariant.test.ts
+++ b/src/main/runtime/rpc/orchestration-task-dispatch-invariant.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
diff --git a/src/main/runtime/rpc/runtime-close-attribution-topology.test.ts b/src/main/runtime/rpc/runtime-close-attribution-topology.test.ts
index 098eeeb751a..13009905aad 100644
--- a/src/main/runtime/rpc/runtime-close-attribution-topology.test.ts
+++ b/src/main/runtime/rpc/runtime-close-attribution-topology.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { _resetTracerForTests, setActiveSink, type TracerSink } from '../../observability/tracer'
 import type { OrcaRuntimeService } from '../orca-runtime'
diff --git a/src/main/runtime/rpc/runtime-close-attribution.test.ts b/src/main/runtime/rpc/runtime-close-attribution.test.ts
index dcf9caa658f..12290423a75 100644
--- a/src/main/runtime/rpc/runtime-close-attribution.test.ts
+++ b/src/main/runtime/rpc/runtime-close-attribution.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { _resetTracerForTests, setActiveSink, type TracerSink } from '../../observability/tracer'
 import type { OrcaRuntimeService } from '../orca-runtime'
diff --git a/src/main/runtime/rpc/streaming.test.ts b/src/main/runtime/rpc/streaming.test.ts
index a5a132ae0cd..48afad4f3ac 100644
--- a/src/main/runtime/rpc/streaming.test.ts
+++ b/src/main/runtime/rpc/streaming.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { z } from 'zod'
 import { RpcDispatcher } from './dispatcher'
diff --git a/src/main/runtime/rpc/terminal-agent-prompt-send.test.ts b/src/main/runtime/rpc/terminal-agent-prompt-send.test.ts
index 824513dd999..ba4cd3cb4f6 100644
--- a/src/main/runtime/rpc/terminal-agent-prompt-send.test.ts
+++ b/src/main/runtime/rpc/terminal-agent-prompt-send.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../orca-runtime'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-agent-send-guard.test.ts b/src/main/runtime/rpc/terminal-agent-send-guard.test.ts
index 3128e0e2dc0..602bd3dbb86 100644
--- a/src/main/runtime/rpc/terminal-agent-send-guard.test.ts
+++ b/src/main/runtime/rpc/terminal-agent-send-guard.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../orca-runtime'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-geometry-stale-handle.test.ts b/src/main/runtime/rpc/terminal-geometry-stale-handle.test.ts
index c34ff54f848..15e269a965f 100644
--- a/src/main/runtime/rpc/terminal-geometry-stale-handle.test.ts
+++ b/src/main/runtime/rpc/terminal-geometry-stale-handle.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-lease-stale-handle-survival.test.ts b/src/main/runtime/rpc/terminal-lease-stale-handle-survival.test.ts
index d7921f13135..d56d4bdc61a 100644
--- a/src/main/runtime/rpc/terminal-lease-stale-handle-survival.test.ts
+++ b/src/main/runtime/rpc/terminal-lease-stale-handle-survival.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../orca-runtime'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-list-host-scope-transport.test.ts b/src/main/runtime/rpc/terminal-list-host-scope-transport.test.ts
index fc4fab66147..6b370641897 100644
--- a/src/main/runtime/rpc/terminal-list-host-scope-transport.test.ts
+++ b/src/main/runtime/rpc/terminal-list-host-scope-transport.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { RuntimeTerminalListResult } from '../../../shared/runtime-types'
 import { RpcDispatcher } from './dispatcher'
diff --git a/src/main/runtime/rpc/terminal-multiplex-ack-output-budget.test.ts b/src/main/runtime/rpc/terminal-multiplex-ack-output-budget.test.ts
index f93b772994e..0efaa5b2fe7 100644
--- a/src/main/runtime/rpc/terminal-multiplex-ack-output-budget.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-ack-output-budget.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import { TERMINAL_METHODS } from './methods/terminal'
diff --git a/src/main/runtime/rpc/terminal-multiplex-ack-overflow-recovery.test.ts b/src/main/runtime/rpc/terminal-multiplex-ack-overflow-recovery.test.ts
index 57abea846ae..3c46d16fbf3 100644
--- a/src/main/runtime/rpc/terminal-multiplex-ack-overflow-recovery.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-ack-overflow-recovery.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import { TERMINAL_METHODS } from './methods/terminal'
diff --git a/src/main/runtime/rpc/terminal-multiplex-desktop-resize-routing.test.ts b/src/main/runtime/rpc/terminal-multiplex-desktop-resize-routing.test.ts
index 562181b2752..19e22540c1f 100644
--- a/src/main/runtime/rpc/terminal-multiplex-desktop-resize-routing.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-desktop-resize-routing.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import { TERMINAL_METHODS } from './methods/terminal'
diff --git a/src/main/runtime/rpc/terminal-multiplex-escape-tail.test.ts b/src/main/runtime/rpc/terminal-multiplex-escape-tail.test.ts
index 4b9afed46c6..38f5d9e5cd5 100644
--- a/src/main/runtime/rpc/terminal-multiplex-escape-tail.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-escape-tail.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-multiplex-initial-snapshot-buffering.test.ts b/src/main/runtime/rpc/terminal-multiplex-initial-snapshot-buffering.test.ts
index 38117a7c762..43ef18a7e87 100644
--- a/src/main/runtime/rpc/terminal-multiplex-initial-snapshot-buffering.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-initial-snapshot-buffering.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RuntimeTerminalDataMeta } from '../orca-runtime'
diff --git a/src/main/runtime/rpc/terminal-multiplex-input-write-rejection.test.ts b/src/main/runtime/rpc/terminal-multiplex-input-write-rejection.test.ts
index ae2298a20dc..2b8472524bf 100644
--- a/src/main/runtime/rpc/terminal-multiplex-input-write-rejection.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-input-write-rejection.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { OrcaRuntimeService } from '../orca-runtime'
diff --git a/src/main/runtime/rpc/terminal-multiplex-output-pause-and-viewport.test.ts b/src/main/runtime/rpc/terminal-multiplex-output-pause-and-viewport.test.ts
index eecd7b03859..7f11dbdfed7 100644
--- a/src/main/runtime/rpc/terminal-multiplex-output-pause-and-viewport.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-output-pause-and-viewport.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { OrcaRuntimeService, RuntimeTerminalDataMeta } from '../orca-runtime'
diff --git a/src/main/runtime/rpc/terminal-multiplex-pty-wait-capacity.test.ts b/src/main/runtime/rpc/terminal-multiplex-pty-wait-capacity.test.ts
index 9a8cc77af3e..bbd4c7eca5e 100644
--- a/src/main/runtime/rpc/terminal-multiplex-pty-wait-capacity.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-pty-wait-capacity.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import { TERMINAL_METHODS } from './methods/terminal'
diff --git a/src/main/runtime/rpc/terminal-multiplex-resync-replay-trim.test.ts b/src/main/runtime/rpc/terminal-multiplex-resync-replay-trim.test.ts
index a39f63572f6..266630280f1 100644
--- a/src/main/runtime/rpc/terminal-multiplex-resync-replay-trim.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-resync-replay-trim.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-multiplex-snapshot-serialization.test.ts b/src/main/runtime/rpc/terminal-multiplex-snapshot-serialization.test.ts
index 4ce604ba27d..a55a69dff08 100644
--- a/src/main/runtime/rpc/terminal-multiplex-snapshot-serialization.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-snapshot-serialization.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import { TERMINAL_METHODS } from './methods/terminal'
diff --git a/src/main/runtime/rpc/terminal-multiplex-subscribe-slot-recovery.test.ts b/src/main/runtime/rpc/terminal-multiplex-subscribe-slot-recovery.test.ts
index 7fa6f4a39d2..fa275c0c15e 100644
--- a/src/main/runtime/rpc/terminal-multiplex-subscribe-slot-recovery.test.ts
+++ b/src/main/runtime/rpc/terminal-multiplex-subscribe-slot-recovery.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import { TERMINAL_METHODS } from './methods/terminal'
diff --git a/src/main/runtime/rpc/terminal-opencode-send-guard.integration.test.ts b/src/main/runtime/rpc/terminal-opencode-send-guard.integration.test.ts
index 2671449b606..f485e207efd 100644
--- a/src/main/runtime/rpc/terminal-opencode-send-guard.integration.test.ts
+++ b/src/main/runtime/rpc/terminal-opencode-send-guard.integration.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { OrcaRuntimeService } from '../orca-runtime'
 import { RpcDispatcher } from './dispatcher'
diff --git a/src/main/runtime/rpc/terminal-output-batching.test.ts b/src/main/runtime/rpc/terminal-output-batching.test.ts
index 214a5a2814e..15dcf01ad44 100644
--- a/src/main/runtime/rpc/terminal-output-batching.test.ts
+++ b/src/main/runtime/rpc/terminal-output-batching.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-prompt-delivery-receipt.test.ts b/src/main/runtime/rpc/terminal-prompt-delivery-receipt.test.ts
index e1bc03f18ab..7bb2cf8727c 100644
--- a/src/main/runtime/rpc/terminal-prompt-delivery-receipt.test.ts
+++ b/src/main/runtime/rpc/terminal-prompt-delivery-receipt.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { TuiAgent } from '../../../shared/tui-agent'
 import { createAgentPromptSubmissionRuntime } from '../agent-prompt-submission-runtime-test-fixture'
diff --git a/src/main/runtime/rpc/terminal-provider-snapshot-sequence.test.ts b/src/main/runtime/rpc/terminal-provider-snapshot-sequence.test.ts
index 726141c536d..88113c84cc1 100644
--- a/src/main/runtime/rpc/terminal-provider-snapshot-sequence.test.ts
+++ b/src/main/runtime/rpc/terminal-provider-snapshot-sequence.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-requested-snapshot-unavailability.test.ts b/src/main/runtime/rpc/terminal-requested-snapshot-unavailability.test.ts
index c5f05cb0456..dacf408900c 100644
--- a/src/main/runtime/rpc/terminal-requested-snapshot-unavailability.test.ts
+++ b/src/main/runtime/rpc/terminal-requested-snapshot-unavailability.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-send-launch-draft-resolution.test.ts b/src/main/runtime/rpc/terminal-send-launch-draft-resolution.test.ts
index 9e5cf52384a..61f740ee85c 100644
--- a/src/main/runtime/rpc/terminal-send-launch-draft-resolution.test.ts
+++ b/src/main/runtime/rpc/terminal-send-launch-draft-resolution.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../orca-runtime'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-send.test.ts b/src/main/runtime/rpc/terminal-send.test.ts
index 9aa55eb823e..a6b451b1488 100644
--- a/src/main/runtime/rpc/terminal-send.test.ts
+++ b/src/main/runtime/rpc/terminal-send.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-subscribe-admission.test.ts b/src/main/runtime/rpc/terminal-subscribe-admission.test.ts
index 75df605d1c8..c0046637d27 100644
--- a/src/main/runtime/rpc/terminal-subscribe-admission.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-admission.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { OrcaRuntimeService } from '../orca-runtime'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-subscribe-blank-mount.test.ts b/src/main/runtime/rpc/terminal-subscribe-blank-mount.test.ts
index 3562f9cc3c4..c6bf99e4d44 100644
--- a/src/main/runtime/rpc/terminal-subscribe-blank-mount.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-blank-mount.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 /** STA-1840 regression: missing mobile terminal models request an exact renderer tab mount. */
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
diff --git a/src/main/runtime/rpc/terminal-subscribe-buffer.test.ts b/src/main/runtime/rpc/terminal-subscribe-buffer.test.ts
index a08458d8be5..601d1eaf936 100644
--- a/src/main/runtime/rpc/terminal-subscribe-buffer.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-buffer.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import { RpcDispatcher } from './dispatcher'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-subscribe-lease-only.test.ts b/src/main/runtime/rpc/terminal-subscribe-lease-only.test.ts
index 1ee273d1ca2..3a027ae516b 100644
--- a/src/main/runtime/rpc/terminal-subscribe-lease-only.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-lease-only.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../orca-runtime'
 import type { RpcRequest } from './core'
diff --git a/src/main/runtime/rpc/terminal-subscribe-mount-replay.test.ts b/src/main/runtime/rpc/terminal-subscribe-mount-replay.test.ts
index 6dd443f1402..7371c54472c 100644
--- a/src/main/runtime/rpc/terminal-subscribe-mount-replay.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-mount-replay.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { RuntimeTerminalWait } from '../../../shared/runtime-types'
 import {
diff --git a/src/main/runtime/rpc/terminal-subscribe-mounted-pane.test.ts b/src/main/runtime/rpc/terminal-subscribe-mounted-pane.test.ts
index 56720ff5d48..466cf4b3901 100644
--- a/src/main/runtime/rpc/terminal-subscribe-mounted-pane.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-mounted-pane.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { RuntimeTerminalWait } from '../../../shared/runtime-types'
 import {
diff --git a/src/main/runtime/rpc/terminal-subscribe-ownership.test.ts b/src/main/runtime/rpc/terminal-subscribe-ownership.test.ts
index fefe8efb28d..8c7c87ffeed 100644
--- a/src/main/runtime/rpc/terminal-subscribe-ownership.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-ownership.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../orca-runtime'
 import { RuntimeSubscriptionRegistry } from '../runtime-subscription-registry'
diff --git a/src/main/runtime/rpc/terminal-subscribe-reconnect-rebind.test.ts b/src/main/runtime/rpc/terminal-subscribe-reconnect-rebind.test.ts
index df3bd9bcece..fe7990b71c4 100644
--- a/src/main/runtime/rpc/terminal-subscribe-reconnect-rebind.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-reconnect-rebind.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { RuntimeTerminalWait } from '../../../shared/runtime-types'
 import type { OrcaRuntimeService } from '../orca-runtime'
diff --git a/src/main/runtime/rpc/terminal-subscribe-relay-drop-lease-survival.test.ts b/src/main/runtime/rpc/terminal-subscribe-relay-drop-lease-survival.test.ts
index 5cfab233011..f7c9554c191 100644
--- a/src/main/runtime/rpc/terminal-subscribe-relay-drop-lease-survival.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-relay-drop-lease-survival.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 // Why: the stale-handle survival suite doubles subscribeToPtyExit, so it pins the wiring but
 // not the predicate that decides whether a PTY counts as exited. This wires that one call to
 // a real OrcaRuntimeService, because a relay drop reaches the phone through the predicate.
diff --git a/src/main/runtime/rpc/terminal-subscribe-renderer-recovery-output.test.ts b/src/main/runtime/rpc/terminal-subscribe-renderer-recovery-output.test.ts
index 65701e2a80a..530eaf54171 100644
--- a/src/main/runtime/rpc/terminal-subscribe-renderer-recovery-output.test.ts
+++ b/src/main/runtime/rpc/terminal-subscribe-renderer-recovery-output.test.ts
@@ -1,3 +1,4 @@
+import './unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { RuntimeTerminalWait } from '../../../shared/runtime-types'
 import {
diff --git a/src/main/runtime/rpc/unused-default-rpc-methods.test-fixture.ts b/src/main/runtime/rpc/unused-default-rpc-methods.test-fixture.ts
new file mode 100644
index 00000000000..6e2f54332d7
--- /dev/null
+++ b/src/main/runtime/rpc/unused-default-rpc-methods.test-fixture.ts
@@ -0,0 +1,22 @@
+import { afterEach, expect, vi } from 'vitest'
+import type { RpcAnyMethodDeclaration } from './core'
+
+const unusedDefaultRpcMethods = vi.hoisted(() => {
+  const methods: RpcAnyMethodDeclaration[] = []
+  const consumption = { count: 0 }
+  methods[Symbol.iterator] = (): ArrayIterator<RpcAnyMethodDeclaration> => {
+    consumption.count += 1
+    throw new Error('Explicit-registry tests must not consume the default RPC manifest')
+  }
+  return { methods, consumption }
+})
+
+vi.mock('./methods', () => ({ ALL_RPC_METHODS: unusedDefaultRpcMethods.methods }))
+
+afterEach(() => {
+  try {
+    expect(unusedDefaultRpcMethods.consumption.count).toBe(0)
+  } finally {
+    unusedDefaultRpcMethods.consumption.count = 0
+  }
+})
diff --git a/src/main/runtime/runtime-agent-terminal-startup.ts b/src/main/runtime/runtime-agent-terminal-startup.ts
new file mode 100644
index 00000000000..5cd0c01ae82
--- /dev/null
+++ b/src/main/runtime/runtime-agent-terminal-startup.ts
@@ -0,0 +1,77 @@
+import type { SessionOptionValue } from '../../shared/native-chat-session-options'
+import type { RuntimeStore } from './runtime-store-contract'
+import type { TerminalWorkspaceLaunchScope } from './runtime-legacy-worker-terminal-recovery-types'
+import type { TerminalCreateOptions } from './runtime-terminal-contracts'
+import { isTuiAgentEnabled } from '../../shared/tui-agent-selection'
+import { resolveBareAgentLaunchCommand } from './runtime-agent-launch-resolution'
+import { buildExecutionHostAgentStartupPlan } from '../opencode/opencode-model-startup-plan'
+import { resolveTerminalStartupCwd } from '../../shared/terminal-startup-cwd'
+import { resolveAgentStartupPlanInputs } from '../../shared/agent-startup-plan-inputs'
+import { agentStartedTelemetry } from '../agent-launch/agent-started-telemetry'
+
+export async function buildRuntimeAgentTerminalStartupOptions(
+  workspace: TerminalWorkspaceLaunchScope,
+  opts: TerminalCreateOptions,
+  settings: ReturnType<RuntimeStore['getSettings']>,
+  platform: NodeJS.Platform,
+  sessionOptions: Record<string, SessionOptionValue> | undefined,
+  hostIdentity: string
+): Promise<TerminalCreateOptions> {
+  // Why: `workspace.repo` is display metadata and may be a row from another host; the launch
+  // shape must match the PTY route this scope already resolved.
+  const isRemote = Boolean(workspace.connectionId)
+  if (opts.startupAgent && !isTuiAgentEnabled(opts.startupAgent, settings.disabledTuiAgents)) {
+    throw new Error(`Agent ${opts.startupAgent} is disabled. Choose an enabled agent.`)
+  }
+  const agent =
+    opts.startupAgent ??
+    resolveBareAgentLaunchCommand({
+      command: opts.command,
+      settings,
+      platform,
+      isRemote
+    })
+  if (!agent) {
+    return opts
+  }
+
+  const startupPlan = await buildExecutionHostAgentStartupPlan({
+    inputs: resolveAgentStartupPlanInputs({
+      agent,
+      settings,
+      platform,
+      isRemote,
+      ...(opts.agentArgs !== undefined ? { agentArgs: opts.agentArgs } : {}),
+      // A requested shell is the one this PTY will actually be, so it owns the quoting family.
+      windowsShellOverride: opts.shellOverride,
+      sessionOptions: sessionOptions
+    }),
+    prompt: opts.startupPrompt ?? '',
+    cwd: resolveTerminalStartupCwd(workspace.path, opts.cwd) ?? workspace.path,
+    hostIdentity
+  })
+  if (!startupPlan) {
+    // Why: an explicit agent that yields no plan would otherwise spawn a bare
+    // shell that never reaches agent readiness.
+    if (opts.startupAgent) {
+      throw new Error(`Could not build launch command for ${opts.startupAgent}.`)
+    }
+    return opts
+  }
+  // A prompt this launch command cannot carry has nowhere to go from here — the create returns
+  // options, not a live PTY — so refuse rather than spawn the agent and drop the text.
+  if (opts.startupPrompt && 'followupPrompt' in startupPlan && startupPlan.followupPrompt) {
+    throw new Error(`Agent ${agent} does not take a startup prompt on its launch command.`)
+  }
+
+  return {
+    ...opts,
+    command: startupPlan.launchCommand,
+    ...(startupPlan.env ? { env: startupPlan.env } : {}),
+    launchConfig: startupPlan.launchConfig,
+    launchAgent: agent,
+    startupCommandDelivery: startupPlan.startupCommandDelivery,
+    // A bare command the user typed stays out of launch accounting, as before.
+    ...(opts.startupAgent ? { telemetry: agentStartedTelemetry(agent, opts.launchSource) } : {})
+  }
+}
diff --git a/src/main/runtime/runtime-file-commands-read-file-explorer-preview.ts b/src/main/runtime/runtime-file-commands-read-file-explorer-preview.ts
index 394e6940112..25f7069e213 100644
--- a/src/main/runtime/runtime-file-commands-read-file-explorer-preview.ts
+++ b/src/main/runtime/runtime-file-commands-read-file-explorer-preview.ts
@@ -13,7 +13,7 @@ import {
   readPreviewFileWithinCap
 } from './runtime-file-commands-mobile-file-list-limit'
 import { requireRuntimeFileProvider } from './runtime-file-command-target'
-import { open, stat } from 'node:fs/promises'
+import { readLocalFileRange } from '../ipc/filesystem/local-file-range-read'
 import { resolveAuthorizedPath } from '../ipc/filesystem-auth'
 import { extname } from 'node:path'
 import {
@@ -161,22 +161,6 @@ export class RuntimeFileCommandsWithReadFileExplorerPreview extends RuntimeFileC
     }
 
     const filePath = await resolveAuthorizedPath(target.path, this.host.requireStore())
-    const fileStats = await stat(filePath)
-    if (fileStats.isDirectory()) {
-      throw new Error('Cannot download a directory')
-    }
-    const handle = await open(filePath, 'r')
-    try {
-      const buffer = Buffer.alloc(Math.min(length, Math.max(0, fileStats.size - offset)))
-      const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, offset)
-      const chunk = buffer.subarray(0, bytesRead)
-      return {
-        contentBase64: chunk.toString('base64'),
-        bytesRead,
-        eof: offset + bytesRead >= fileStats.size
-      }
-    } finally {
-      await handle.close()
-    }
+    return readLocalFileRange(filePath, offset, length)
   }
 }
diff --git a/src/main/runtime/runtime-file-path-existence.test.ts b/src/main/runtime/runtime-file-path-existence.test.ts
index d74c58bfdae..24b12e7d5a6 100644
--- a/src/main/runtime/runtime-file-path-existence.test.ts
+++ b/src/main/runtime/runtime-file-path-existence.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 import { afterEach, expect, it, vi } from 'vitest'
 import { mkdtemp, writeFile, rm } from 'node:fs/promises'
 import { join } from 'node:path'
diff --git a/src/main/runtime/runtime-git-status-admission.test.ts b/src/main/runtime/runtime-git-status-admission.test.ts
index b6c92fe7002..e5f50197a0d 100644
--- a/src/main/runtime/runtime-git-status-admission.test.ts
+++ b/src/main/runtime/runtime-git-status-admission.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { GitAdmissionEvent } from '../../shared/git-admission-state'
 import { GitAdmissionScheduler } from '../git/command-runner/git-subprocess-admission'
diff --git a/src/main/runtime/runtime-terminal-contracts.ts b/src/main/runtime/runtime-terminal-contracts.ts
index d623a3f1fd1..ea0803eb4df 100644
--- a/src/main/runtime/runtime-terminal-contracts.ts
+++ b/src/main/runtime/runtime-terminal-contracts.ts
@@ -4,7 +4,10 @@ import type {
   AgentSessionExecutionClaim,
   RuntimeCreateAgentSessionResult
 } from '../../shared/agent-session-host-authority'
-import type { AgentProviderSessionMetadata } from '../../shared/agent-session-resume'
+import type {
+  AgentProviderSessionMetadata,
+  SleepingAgentLaunchConfig
+} from '../../shared/agent-session-resume'
 import type { OrchestrationCompatibilityHostStamp } from '../../shared/orchestration-compatibility-evidence'
 import type { TerminalOscColorQueryReplyColors } from '../../shared/terminal-osc-color-reply'
 import type {
@@ -84,7 +87,10 @@ export type TerminalCreateOptions = {
   signal?: AbortSignal
   onPtySpawnCommitted?: () => void
   /** Called before the spawn request leaves this process; a throw before it proves nothing spawned. */
-  onPtySpawnDispatched?: () => void
+  onPtySpawnDispatched?: (launch?: {
+    launchConfig?: SleepingAgentLaunchConfig
+    launchAgent?: TuiAgent
+  }) => void
   deferMobileSessionPublish?: boolean
 }
 
diff --git a/src/main/runtime/runtime-worktree-agent-startup.ts b/src/main/runtime/runtime-worktree-agent-startup.ts
index a65f2527357..a57beb7efcd 100644
--- a/src/main/runtime/runtime-worktree-agent-startup.ts
+++ b/src/main/runtime/runtime-worktree-agent-startup.ts
@@ -14,6 +14,7 @@ import {
   detectRemoteAgents
 } from '../preflight/agent-detection'
 import type { RuntimeStore } from './runtime-store-contract'
+import type { RuntimeManagedWorktreeCreateArgs } from './runtime-managed-worktree-create-types'
 
 export type WorktreeStartupDraftPaste = { agent: TuiAgent; content: string }
 export type WorktreeStartupFollowup = { expectedProcess: string; prompt: string }
@@ -173,3 +174,21 @@ export function buildWorktreeStartupForAgent(
       : {})
   }
 }
+
+export function resolveWorktreeCreateAgentStartup(
+  args: RuntimeManagedWorktreeCreateArgs,
+  build: (
+    agent: TuiAgent,
+    prompt: string | undefined,
+    preferences: AgentLaunchPreferences | undefined,
+    inputs: { agentArgs?: string | null; launchSource?: string }
+  ) => { agent: TuiAgent; startup: WorktreeStartupLaunch; followup?: WorktreeStartupFollowup }
+) {
+  if (args.startup || !args.startupAgent) {
+    return null
+  }
+  return build(args.startupAgent, args.startupPrompt, args.startupLaunchPreferences, {
+    ...(args.startupAgentArgs !== undefined ? { agentArgs: args.startupAgentArgs } : {}),
+    ...(args.startupLaunchSource ? { launchSource: args.startupLaunchSource } : {})
+  })
+}
diff --git a/src/main/runtime/structured-agent-session-held-signal.test.ts b/src/main/runtime/structured-agent-session-held-signal.test.ts
index 2bf1a423fe1..0bf61aa7843 100644
--- a/src/main/runtime/structured-agent-session-held-signal.test.ts
+++ b/src/main/runtime/structured-agent-session-held-signal.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 /**
  * "This machine holds a structured chat" against a real host and record store. Session history,
  * resume preparation and replay-safe phone launches all build the host for a user who never had a
diff --git a/src/main/runtime/structured-agent-session-integration.test.ts b/src/main/runtime/structured-agent-session-integration.test.ts
index 3d9e72f7404..571e903dde3 100644
--- a/src/main/runtime/structured-agent-session-integration.test.ts
+++ b/src/main/runtime/structured-agent-session-integration.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 // One structured Codex session driven end to end over `agentSession.*`.
 //
 // Nothing here is stubbed except the Codex child itself: the RPC dispatcher, the
diff --git a/src/main/runtime/structured-chat-coordinator-mail.test.ts b/src/main/runtime/structured-chat-coordinator-mail.test.ts
index 49c694b5adb..0ec0418184d 100644
--- a/src/main/runtime/structured-chat-coordinator-mail.test.ts
+++ b/src/main/runtime/structured-chat-coordinator-mail.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 // A worker's result reaching the structured chat that coordinates it, end to end in one process.
 //
 // Real: the structured agent-session host, its record store, journal, lease and Codex adapter; the
@@ -26,7 +27,6 @@ import { OrchestrationDb } from './orchestration/db'
 import { localOrchestrationCliCommand } from './orchestration/cli-command'
 import { formatMessagePointer } from './orchestration/formatter'
 import { currentRunCoordinatorOrcaSessionId } from './orchestration/db/runs/run-coordinator-orca-session'
-import type { RpcRequest } from './rpc/core'
 import { RpcDispatcher } from './rpc/dispatcher'
 import { ORCHESTRATION_METHODS } from './rpc/methods/orchestration'
 import { idOf, isRecord, resultOf } from './rpc/orchestration-session-caller-test-fixture'
@@ -63,7 +63,7 @@ function request(
   method: string,
   params: Record<string, unknown>,
   options: { sessionId?: string } = {}
-): RpcRequest {
+): Parameters<RpcDispatcher['dispatch']>[0] {
   requests += 1
   return {
     id: `rpc-${requests}`,
diff --git a/src/main/runtime/terminal-subscriber-driven-daemon-attach.test.ts b/src/main/runtime/terminal-subscriber-driven-daemon-attach.test.ts
index 9710ba438be..0b2a2e888ee 100644
--- a/src/main/runtime/terminal-subscriber-driven-daemon-attach.test.ts
+++ b/src/main/runtime/terminal-subscriber-driven-daemon-attach.test.ts
@@ -1,3 +1,4 @@
+import './rpc/unused-default-rpc-methods.test-fixture'
 /**
  * Subscriber-driven daemon attach (never-activated tab ingestion).
  *
diff --git a/src/main/ssh/ssh-relay-incumbent-process.test.ts b/src/main/ssh/ssh-relay-incumbent-process.test.ts
index 425e3f5f279..f77cd335174 100644
--- a/src/main/ssh/ssh-relay-incumbent-process.test.ts
+++ b/src/main/ssh/ssh-relay-incumbent-process.test.ts
@@ -65,7 +65,8 @@ async function probe(script: string, listening = false) {
     rmSync(dir, { recursive: true, force: true })
   }
 }
-describe.skipIf(process.platform === 'win32')('real generated incumbent probe', () => {
+// Each probe owns its socket, shim and process group; overlap the real lsof deadlines.
+describe.skipIf(process.platform === 'win32').concurrent('real generated incumbent probe', () => {
   it('bounds hung lsof and preserves live connect evidence', async () => {
     const p = await probe('echo $$ > "$FIXTURE_PID"\nexec sleep 60\n', true)
     expect(p.result.timedOut).toBe(false)
diff --git a/src/main/ssh/ssh-relay-native-deps-install.test.ts b/src/main/ssh/ssh-relay-native-deps-install.test.ts
index 5c1e99eb80d..d48fa1c1e80 100644
--- a/src/main/ssh/ssh-relay-native-deps-install.test.ts
+++ b/src/main/ssh/ssh-relay-native-deps-install.test.ts
@@ -417,10 +417,13 @@ describe('installNativeDeps (via deployAndLaunchRelay)', () => {
     feed([
       '__ORCA_REMOTE_PLATFORM__ Linux x86_64',
       '/home/u',
-      { reject: 'Command "node -e ..." timed out after 30s' } // health probe never answered
+      { reject: 'Command "node -e ..." timed out after 30s' }, // health probe never answered
+      '', // launch namespace marker
+      'DEAD',
+      'READY'
     ])
 
-    await deployAndLaunchRelay(conn).catch(() => {})
+    const outcome = await deployAndLaunchRelay(conn).catch((error: Error) => error)
 
     const execCalls = vi.mocked(execCommand).mock.calls.map(([, c]) => c)
     expect(execCalls.some((c) => c.includes('npm install'))).toBe(false)
@@ -428,9 +431,19 @@ describe('installNativeDeps (via deployAndLaunchRelay)', () => {
 
     const warnMessages = warnSpy.mock.calls.map((args) => String(args[0] ?? ''))
     expect(warnMessages.some((m) => m.includes('Repairing missing native deps'))).toBe(false)
-    // Why no log assertion: the behavioural claim above is the real one. Asserting on warn text
-    // pinned wording that main's landed probe verdict does not use, and #18000 adds its own.
+    // Probe diagnostic wording changes independently of the repair contract.
     expect(execCalls.some((c) => c.includes("rm -rf 'node_modules/node-pty'"))).toBe(false)
+    expect(execCalls.filter((command) => command.includes('ORCA-NATIVE-DEPS-OK'))).toHaveLength(1)
+    const healthProbeIndex = execCalls.findIndex((command) =>
+      command.includes('ORCA-NATIVE-DEPS-OK')
+    )
+    await expect(vi.mocked(execCommand).mock.results[healthProbeIndex].value).rejects.toThrow(
+      'Command "node -e ..." timed out after 30s'
+    )
+    expect(
+      outcome,
+      'an unanswered health probe must still allow an intact relay to launch'
+    ).not.toBeInstanceOf(Error)
   })
 
   it('lets a probe SSH-channel failure bubble up rather than silently mapping to MISSING', async () => {
diff --git a/src/main/ssh/ssh-remote-linear-relation-write.test.ts b/src/main/ssh/ssh-remote-linear-relation-write.test.ts
index 262ec566232..9042e63deca 100644
--- a/src/main/ssh/ssh-remote-linear-relation-write.test.ts
+++ b/src/main/ssh/ssh-remote-linear-relation-write.test.ts
@@ -1,3 +1,4 @@
+import '../runtime/rpc/unused-default-rpc-methods.test-fixture'
 import { describe, expect, it, vi } from 'vitest'
 import type { OrcaRuntimeService } from '../runtime/orca-runtime'
 import { RpcDispatcher } from '../runtime/rpc/dispatcher'
diff --git a/src/main/startup/codex-account-restart-resume.test.ts b/src/main/startup/codex-account-restart-resume.test.ts
new file mode 100644
index 00000000000..197c9281edb
--- /dev/null
+++ b/src/main/startup/codex-account-restart-resume.test.ts
@@ -0,0 +1,117 @@
+import { dirname, join } from 'node:path'
+import { linkSync, readFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+
+const homes = vi.hoisted(() => ({ original: '', selected: '', system: '' }))
+vi.mock('electron', () => ({ app: { getPath: () => homes.system } }))
+vi.mock('./main-process-state', () => ({
+  mainProcessState: {
+    codexRuntimeHome: {
+      isHostSystemDefaultRealHome: () => false,
+      getHostCodexHomePathsForSessionDiscovery: () => [homes.original, homes.selected],
+      resolveSelectedHostAccountCodexHomePathForResume: () => homes.selected || null
+    },
+    store: { getSettings: () => ({}) }
+  }
+}))
+vi.mock('../codex/hook-service', () => ({
+  codexHookService: {
+    installForLaunchPrep: vi.fn(),
+    refreshRuntimeUserHooksForLaunchPrep: vi.fn()
+  }
+}))
+vi.mock('../codex/codex-real-home-hook-install', () => ({
+  ensureRealHomeCodexHookState: vi.fn(),
+  awaitRealHomeCodexHookTrust: vi.fn()
+}))
+vi.mock('../codex/codex-home-paths', () => ({
+  getCodexSessionBackfillStateDirPath: () => join(homes.system, 'backfill'),
+  getSystemCodexHomePath: () => homes.system,
+  getOrcaManagedCodexHomePath: () => join(homes.system, 'legacy')
+}))
+vi.mock('../codex/codex-config-mirror', () => ({ ensureCodexDaemonSocketGuard: vi.fn() }))
+
+import { prepareCodexSessionResumeForLaunch } from './codex-session-resume-launch'
+
+let root: string
+let transcriptPath: string
+const sessionId = 'abcdef00-1234-4321-9999-cafecafecafe'
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), 'orca-account-restart-'))
+  homes.original = join(root, 'codex-accounts', 'old', 'home')
+  homes.selected = join(root, 'codex-accounts', 'new', 'home')
+  homes.system = join(root, 'system')
+  const relativePath = join('sessions', '2026', '10', '05', `rollout-${sessionId}.jsonl`)
+  transcriptPath = join(homes.original, relativePath)
+  const bridged = join(homes.selected, relativePath)
+  mkdirSync(dirname(transcriptPath), { recursive: true })
+  mkdirSync(dirname(bridged), { recursive: true })
+  writeFileSync(transcriptPath, '{"type":"session_meta"}\n')
+  linkSync(transcriptPath, bridged)
+})
+afterEach(() => rmSync(root, { recursive: true, force: true }))
+
+it('resumes an explicit account restart in the selected home using the bridged transcript', async () => {
+  const result = await prepareCodexSessionResumeForLaunch({
+    providerSession: { key: 'session_id', id: sessionId, transcriptPath },
+    target: { runtime: 'host' },
+    useSelectedAccount: true
+  })
+  expect(result).toMatchObject({ outcome: 'resume', codexHomePath: homes.selected })
+})
+
+it('keeps ordinary automatic restores pinned to their original account', async () => {
+  const result = await prepareCodexSessionResumeForLaunch({
+    providerSession: { key: 'session_id', id: sessionId, transcriptPath },
+    target: { runtime: 'host' }
+  })
+  expect(result).toMatchObject({ outcome: 'resume', codexHomePath: homes.original })
+})
+
+it('materializes a rollout when the account bridge has not caught up', async () => {
+  rmSync(join(homes.selected, 'sessions'), { recursive: true })
+  const result = await prepareCodexSessionResumeForLaunch({
+    providerSession: { key: 'session_id', id: sessionId, transcriptPath },
+    target: { runtime: 'host' },
+    useSelectedAccount: true
+  })
+  expect(result).toMatchObject({ codexHomePath: homes.selected })
+  expect(readFileSync(transcriptPath.replace(homes.original, homes.selected), 'utf8')).toBe(
+    readFileSync(transcriptPath, 'utf8')
+  )
+})
+
+it('refuses a conflicting target rollout instead of restarting the old account', async () => {
+  const target = transcriptPath.replace(homes.original, homes.selected)
+  rmSync(target)
+  writeFileSync(target, 'another session')
+  await expect(
+    prepareCodexSessionResumeForLaunch({
+      providerSession: { key: 'session_id', id: sessionId, transcriptPath },
+      target: { runtime: 'host' },
+      useSelectedAccount: true
+    })
+  ).rejects.toThrow('different rollout')
+  expect(readFileSync(target, 'utf8')).toBe('another session')
+})
+
+it('uses the system home when an explicit restart follows deselection', async () => {
+  homes.selected = ''
+  const result = await prepareCodexSessionResumeForLaunch({
+    providerSession: { key: 'session_id', id: sessionId, transcriptPath },
+    target: { runtime: 'host' },
+    useSelectedAccount: true
+  })
+  expect(result).toMatchObject({ codexHomePath: homes.system })
+})
+
+it('leaves WSL preparation on the execution host', async () => {
+  expect(
+    await prepareCodexSessionResumeForLaunch({
+      providerSession: { key: 'session_id', id: sessionId, transcriptPath },
+      target: { runtime: 'wsl', wslDistro: 'Ubuntu' },
+      useSelectedAccount: true
+    })
+  ).toBeNull()
+})
diff --git a/src/main/startup/codex-session-resume-launch.ts b/src/main/startup/codex-session-resume-launch.ts
index f01d17610d7..5feb61df417 100644
--- a/src/main/startup/codex-session-resume-launch.ts
+++ b/src/main/startup/codex-session-resume-launch.ts
@@ -3,7 +3,10 @@ import type { AgentProviderSessionMetadata } from '../../shared/agent-session-re
 import type { CodexAccountSelectionTarget } from '../codex-accounts/runtime-selection'
 import type { CodexSessionResumePreparation } from '../codex/codex-session-resume-home'
 import { prepareCodexSessionResume } from '../codex/codex-session-resume-preparation'
-import { prepareLegacySharedCodexSessionResume } from '../codex/codex-legacy-session-resume'
+import {
+  prepareCodexAccountRestartResume,
+  prepareLegacySharedCodexSessionResume
+} from '../codex/codex-legacy-session-resume'
 import { ManagedCodexHomeTemporarilyUnavailableError } from '../codex-accounts/host-codex-managed-home-ownership'
 import { codexHookService } from '../codex/hook-service'
 import {
@@ -20,6 +23,7 @@ export async function prepareCodexSessionResumeForLaunch(args: {
   providerSession: AgentProviderSessionMetadata
   target: CodexAccountSelectionTarget
   launchEnv?: NodeJS.ProcessEnv
+  useSelectedAccount?: boolean
 }): Promise<CodexSessionResumePreparation | null> {
   const runtimeHome = state.codexRuntimeHome
   const store = state.store
@@ -66,12 +70,7 @@ export async function prepareCodexSessionResumeForLaunch(args: {
           }
         )
       } catch (error) {
-        // Why: this launch path pins CODEX_HOME to the account that OWNS the
-        // rollout and deliberately refuses to repin onto whichever account is
-        // selected now (#10793), so it does not wire
-        // getSelectedHostAccountCodexHomePath and this branch cannot fire today.
-        // It stays as a contract guard: the blanket catch below must never
-        // silently swallow a typed refusal if that ever changes.
+        // A credential-read refusal must never fall back to the old account.
         if (error instanceof ManagedCodexHomeTemporarilyUnavailableError) {
           throw error
         }
@@ -81,7 +80,16 @@ export async function prepareCodexSessionResumeForLaunch(args: {
           error
         )
       }
-      const resumeHome = migrated.useRealCodexHome ? systemHomePath : sessionSource.homePath
+      const resumeHome = args.useSelectedAccount
+        ? await prepareCodexAccountRestartResume({
+            sourceHome: sessionSource.homePath,
+            transcriptPath: sessionSource.transcriptPath,
+            targetHome: selectedAccountCodexHome ?? systemHomePath,
+            systemCodexHomePath: systemHomePath
+          })
+        : migrated.useRealCodexHome
+          ? systemHomePath
+          : sessionSource.homePath
       const isSystemHome =
         normalizeRuntimePathForComparison(resumeHome) ===
         normalizeRuntimePathForComparison(systemHomePath)
diff --git a/src/main/startup/os-opened-document-resolution.test.ts b/src/main/startup/os-opened-document-resolution.test.ts
index 1267d51e5db..6c0f5990128 100644
--- a/src/main/startup/os-opened-document-resolution.test.ts
+++ b/src/main/startup/os-opened-document-resolution.test.ts
@@ -4,14 +4,10 @@ import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { resolveOsOpenedDocuments } from './os-opened-documents'
 
-vi.mock('../ipc/filesystem-auth', () => ({
-  authorizeExternalPath: vi.fn()
-}))
 vi.mock('../ipc/floating-workspace-directory', () => ({
   ensureDefaultFloatingWorkspacePath: vi.fn()
 }))
 
-const { authorizeExternalPath } = await import('../ipc/filesystem-auth')
 const { ensureDefaultFloatingWorkspacePath } = await import('../ipc/floating-workspace-directory')
 
 describe('resolveOsOpenedDocuments', () => {
@@ -19,7 +15,6 @@ describe('resolveOsOpenedDocuments', () => {
   let fileRoot: string
 
   beforeEach(async () => {
-    vi.mocked(authorizeExternalPath).mockClear()
     vi.mocked(ensureDefaultFloatingWorkspacePath).mockClear()
     floatingRoot = await mkdtemp(join(tmpdir(), 'orca-os-open-root-'))
     fileRoot = await mkdtemp(join(tmpdir(), 'orca-os-open-files-'))
@@ -48,17 +43,15 @@ describe('resolveOsOpenedDocuments', () => {
           name: 'design notes'
         }
       ])
-      expect(authorizeExternalPath).toHaveBeenCalledWith(filePath)
     }
   )
 
-  it('never authorizes unsupported or relative files even when they exist', async () => {
+  it('drops unsupported or relative files even when they exist', async () => {
     const filePath = join(fileRoot, 'private.txt')
     await writeFile(filePath, 'private')
     expect(await resolveOsOpenedDocuments([filePath, 'relative.csv', 'file:///%zz.tsv'])).toEqual(
       []
     )
-    expect(authorizeExternalPath).not.toHaveBeenCalled()
     expect(ensureDefaultFloatingWorkspacePath).not.toHaveBeenCalled()
   })
 
@@ -71,21 +64,16 @@ describe('resolveOsOpenedDocuments', () => {
     const documents = await resolveOsOpenedDocuments([bundlePath, filePath])
 
     expect(documents.map((document) => document.filePath)).toEqual([filePath])
-    // Security contract: a path we never validated must never be authorized for renderer reads.
-    expect(authorizeExternalPath).toHaveBeenCalledTimes(1)
-    expect(authorizeExternalPath).toHaveBeenCalledWith(filePath)
   })
 
-  it('drops a path that no longer exists without authorizing it', async () => {
+  it('drops a path that no longer exists', async () => {
     const missingPath = join(fileRoot, 'gone.csv')
 
     expect(await resolveOsOpenedDocuments([missingPath])).toEqual([])
-    expect(authorizeExternalPath).not.toHaveBeenCalled()
   })
 
   it('returns nothing for an empty input without touching the filesystem', async () => {
     expect(await resolveOsOpenedDocuments([])).toEqual([])
     expect(ensureDefaultFloatingWorkspacePath).not.toHaveBeenCalled()
-    expect(authorizeExternalPath).not.toHaveBeenCalled()
   })
 })
diff --git a/src/main/startup/os-opened-documents.ts b/src/main/startup/os-opened-documents.ts
index ec2b9c20e76..cdc78803ef3 100644
--- a/src/main/startup/os-opened-documents.ts
+++ b/src/main/startup/os-opened-documents.ts
@@ -2,7 +2,6 @@ import { stat } from 'node:fs/promises'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { FileDocument } from '../../shared/filesystem-entry-types'
-import { authorizeExternalPath } from '../ipc/filesystem-auth'
 import { ensureDefaultFloatingWorkspacePath } from '../ipc/floating-workspace-directory'
 import { fileDocumentFromFilePath, isMarkdownDocumentName } from '../ipc/markdown-documents'
 
@@ -135,7 +134,7 @@ export class OsOpenedDocumentState {
 
 /**
  * Turns OS-handed paths into the same document shape the floating workspace's own
- * file picker produces, authorizing each one for the renderer's later read.
+ * file picker produces; the floating tab then reads each one as a user-named file.
  */
 export async function resolveOsOpenedDocuments(
   filePaths: readonly string[]
@@ -152,14 +151,13 @@ export async function resolveOsOpenedDocuments(
   for (const filePath of supportedPaths) {
     try {
       // Why: the shell can hand over a directory named like a document, or a path already
-      // deleted by the time we resolve. Authorize only something that is really a file.
+      // deleted by the time we resolve. Open only something that is really a file.
       if (!(await stat(filePath)).isFile()) {
         continue
       }
     } catch {
       continue
     }
-    authorizeExternalPath(filePath)
     documents.push(
       fileDocumentFromFilePath(floatingRoot, filePath, {
         outsideRootRelativePath: 'basename'
diff --git a/src/main/window/clipboard-image-temp-file.test.ts b/src/main/window/clipboard-image-temp-file.test.ts
index 71ca0804c0e..e6fdd9f900b 100644
--- a/src/main/window/clipboard-image-temp-file.test.ts
+++ b/src/main/window/clipboard-image-temp-file.test.ts
@@ -1,13 +1,10 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { authorizeExternalPathMock, writeFileMock, getPathMock, writeFileBase64Mock } = vi.hoisted(
-  () => ({
-    authorizeExternalPathMock: vi.fn(),
-    writeFileMock: vi.fn(),
-    getPathMock: vi.fn(() => '/var/folders/ab/T'),
-    writeFileBase64Mock: vi.fn()
-  })
-)
+const { writeFileMock, getPathMock, writeFileBase64Mock } = vi.hoisted(() => ({
+  writeFileMock: vi.fn(),
+  getPathMock: vi.fn(() => '/var/folders/ab/T'),
+  writeFileBase64Mock: vi.fn()
+}))
 
 vi.mock('node:fs/promises', () => ({ default: { writeFile: writeFileMock } }))
 vi.mock('node:crypto', () => ({ randomUUID: () => 'uuid-1' }))
@@ -20,7 +17,6 @@ vi.mock('../providers/ssh-filesystem-dispatch', () => ({
     writeFileBase64: writeFileBase64Mock
   })
 }))
-vi.mock('../ipc/filesystem-auth', () => ({ authorizeExternalPath: authorizeExternalPathMock }))
 
 import { saveClipboardImageBufferAsTempFile } from './clipboard-image-temp-file'
 
@@ -29,22 +25,20 @@ beforeEach(() => {
 })
 
 describe('saveClipboardImageBufferAsTempFile', () => {
-  it('authorizes the local temp file so the composer can preview what it just wrote', async () => {
+  it('writes the pasted image to the local temp folder', async () => {
     const savedPath = await saveClipboardImageBufferAsTempFile(Buffer.from([1, 2, 3]))
 
+    expect(savedPath.startsWith('/var/folders/ab/T')).toBe(true)
     expect(writeFileMock).toHaveBeenCalledWith(savedPath, Buffer.from([1, 2, 3]))
-    // The OS temp dir is outside every allowed root, so an unauthorized path
-    // makes fs:readFile deny the preview read of Orca's own file.
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith(savedPath)
   })
 
-  it('does not authorize a local path for an SSH save', async () => {
+  it('writes an SSH paste to the remote temp folder', async () => {
     const savedPath = await saveClipboardImageBufferAsTempFile(Buffer.from([1]), {
       connectionId: 'conn-1'
     })
 
     expect(savedPath.startsWith('/remote/tmp/')).toBe(true)
     expect(writeFileBase64Mock).toHaveBeenCalled()
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
+    expect(writeFileMock).not.toHaveBeenCalled()
   })
 })
diff --git a/src/main/window/clipboard-image-temp-file.ts b/src/main/window/clipboard-image-temp-file.ts
index 0024c4b6d1f..cadbd677650 100644
--- a/src/main/window/clipboard-image-temp-file.ts
+++ b/src/main/window/clipboard-image-temp-file.ts
@@ -6,7 +6,6 @@ import { getAppEnvironment } from '../../shared/app-environment'
 import { requireSshFilesystemProvider } from '../providers/ssh-filesystem-dispatch'
 import { isWindowsAbsolutePathLike } from '../../shared/cross-platform-path'
 import { assertClipboardImageByteLengthWithinLimit } from '../../shared/clipboard-image'
-import { authorizeExternalPath } from '../ipc/filesystem-auth'
 
 export type SaveClipboardImageAsTempFileArgs = {
   connectionId?: string | null
@@ -42,8 +41,5 @@ export async function saveClipboardImageBufferAsTempFile(
 
   const tempPath = path.join(getAppEnvironment().getPath('temp'), fileName)
   await fs.writeFile(tempPath, buffer)
-  // Why: the OS temp dir is outside every allowed root, so without this the
-  // composer's own thumbnail/preview read of the file it just wrote is denied.
-  authorizeExternalPath(tempPath)
   return tempPath
 }
diff --git a/src/main/window/clipboard-ipc-handlers.test.ts b/src/main/window/clipboard-ipc-handlers.test.ts
index 1bcf1749c30..79f9eabc066 100644
--- a/src/main/window/clipboard-ipc-handlers.test.ts
+++ b/src/main/window/clipboard-ipc-handlers.test.ts
@@ -13,7 +13,6 @@ const {
   spawnMock,
   childStdinEndMock,
   resolveAuthorizedPathMock,
-  authorizeExternalPathMock,
   fsAccessMock,
   fsLstatMock,
   fsMkdirMock,
@@ -50,7 +49,6 @@ const {
     return child
   }),
   resolveAuthorizedPathMock: vi.fn(),
-  authorizeExternalPathMock: vi.fn(),
   fsAccessMock: vi.fn(),
   fsLstatMock: vi.fn(),
   fsMkdirMock: vi.fn(),
@@ -94,8 +92,7 @@ vi.mock('node:fs/promises', () => ({
 vi.mock('../ipc/filesystem-auth', () => ({
   PATH_ACCESS_DENIED_MESSAGE:
     'Access denied: path resolves outside allowed directories. If this blocks a legitimate workflow, please file a GitHub issue.',
-  resolveAuthorizedPath: resolveAuthorizedPathMock,
-  authorizeExternalPath: authorizeExternalPathMock
+  resolveAuthorizedPath: resolveAuthorizedPathMock
 }))
 
 vi.mock('node:crypto', () => ({
@@ -321,7 +318,7 @@ describe('registerClipboardHandlers', () => {
     ).resolves.toEqual({ ok: true })
 
     expect(fsStatMock).toHaveBeenCalledWith('/tmp/copied-file.txt')
-    expect(resolveAuthorizedPathMock).toHaveBeenCalledWith('/tmp/copied-file.txt', {})
+    expect(resolveAuthorizedPathMock.mock.calls[0]?.[0]).toBe('/tmp/copied-file.txt')
     if (process.platform === 'darwin') {
       expect(clipboardWriteBufferMock).toHaveBeenCalledWith(
         'public.file-url',
diff --git a/src/main/window/clipboard-ipc-handlers.ts b/src/main/window/clipboard-ipc-handlers.ts
index e81140d734a..7873316ef3d 100644
--- a/src/main/window/clipboard-ipc-handlers.ts
+++ b/src/main/window/clipboard-ipc-handlers.ts
@@ -9,7 +9,8 @@ import {
 import { spawn } from 'node:child_process'
 import { open, stat } from 'node:fs/promises'
 import type { Store } from '../persistence'
-import { PATH_ACCESS_DENIED_MESSAGE, resolveAuthorizedPath } from '../ipc/filesystem-auth'
+import { PATH_ACCESS_DENIED_MESSAGE } from '../ipc/filesystem-auth'
+import { resolveDesktopAuthorizedPath } from '../ipc/local-file-access-resolution'
 import { isENOENT } from '../ipc/filesystem-path-containment'
 import {
   assertClipboardTextWriteWithinLimitWithYield,
@@ -170,7 +171,7 @@ export function registerClipboardHandlers(store: Store): void {
       }
       const deps = makeClipboardFileDeps(async (path) => {
         try {
-          const authorizedPath = await resolveAuthorizedPath(path, store)
+          const authorizedPath = await resolveDesktopAuthorizedPath(path, store)
           await stat(authorizedPath)
           return { ok: true, path: authorizedPath }
         } catch (error) {
diff --git a/src/main/window/clipboard-runtime-owned-ssh-paste.test.ts b/src/main/window/clipboard-runtime-owned-ssh-paste.test.ts
index 6e09eb5fd3e..979c5b7d413 100644
--- a/src/main/window/clipboard-runtime-owned-ssh-paste.test.ts
+++ b/src/main/window/clipboard-runtime-owned-ssh-paste.test.ts
@@ -43,8 +43,7 @@ vi.mock('node:fs/promises', () => ({
 }))
 vi.mock('../ipc/filesystem-auth', () => ({
   PATH_ACCESS_DENIED_MESSAGE: 'denied',
-  resolveAuthorizedPath: vi.fn(),
-  authorizeExternalPath: vi.fn()
+  resolveAuthorizedPath: vi.fn()
 }))
 vi.mock('../ipc/runtime-environment-transport-routing', () => ({
   callRuntimeEnvironment: callRuntimeEnvironmentMock
diff --git a/src/main/worker-thread-request-queue.test.ts b/src/main/worker-thread-request-queue.test.ts
index 4bf2188dc54..2046267396c 100644
--- a/src/main/worker-thread-request-queue.test.ts
+++ b/src/main/worker-thread-request-queue.test.ts
@@ -92,9 +92,10 @@ function makeQueue(
 
 function send(
   queue: WorkerThreadRequestQueue<Request, Response>,
-  label: string
+  label: string,
+  owner?: { readonly signal: AbortSignal }
 ): Promise<Response> {
-  return queue.dispatch((id) => ({ id, label }), TIMEOUT_MS)
+  return queue.dispatch((id) => ({ id, label }), TIMEOUT_MS, undefined, owner)
 }
 
 /** Resolve to the response or to the rejection, so a test can assert on either. */
@@ -328,6 +329,161 @@ describe('WorkerThreadRequestQueue', () => {
     expect(await behind).toMatchObject({ label: 'd' })
   })
 
+  it('keeps one owner fault budget across idle batches and refuses a fourth worker', async () => {
+    const workers: FakeWorker[] = []
+    const queue = makeQueue(workers)
+    const owner = { signal: new AbortController().signal }
+    try {
+      for (let fault = 0; fault < 3; fault++) {
+        const call = settle(send(queue, `owned-${fault}`, owner))
+        workers.at(-1)?.emit('error', new Error(`fault-${fault}`))
+        expect(await call).toMatchObject({ message: `fault-${fault}` })
+      }
+      const refused = settle(send(queue, 'fourth', owner))
+      expect(workers).toHaveLength(3)
+      await expect(refused).resolves.toMatchObject({ message: 'crashed repeatedly (fault-2)' })
+      const nextScan = send(queue, 'new-scan', { signal: new AbortController().signal })
+      expect(workers).toHaveLength(4)
+      workers[3].respond()
+      await expect(nextScan).resolves.toMatchObject({ label: 'new-scan' })
+    } finally {
+      queue.dispose()
+    }
+  })
+
+  it('resets only the successful owner and does not count idle worker exits', async () => {
+    const workers: FakeWorker[] = []
+    const queue = makeQueue(workers)
+    const a = { signal: new AbortController().signal }
+    const b = { signal: new AbortController().signal }
+    try {
+      const initial = send(queue, 'initial', a)
+      workers[0].respond()
+      await initial
+      workers[0].emit('exit', 17)
+      for (let fault = 0; fault < 2; fault++) {
+        const call = settle(send(queue, `a-${fault}`, a))
+        workers.at(-1)?.emit('error', new Error(`a-fault-${fault}`))
+        await call
+      }
+      const peer = send(queue, 'b-success', b)
+      workers.at(-1)?.respond()
+      await peer
+      const third = settle(send(queue, 'a-third', a))
+      workers.at(-1)?.emit('error', new Error('a-third-fault'))
+      await third
+      const refused = settle(send(queue, 'a-fourth', a))
+      expect(workers).toHaveLength(4)
+      await expect(refused).resolves.toMatchObject({
+        message: 'crashed repeatedly (a-third-fault)'
+      })
+      const healthy = send(queue, 'b-still-healthy', b)
+      workers.at(-1)?.respond()
+      await expect(healthy).resolves.toMatchObject({ label: 'b-still-healthy' })
+    } finally {
+      queue.dispose()
+    }
+  })
+
+  it('clears a successful owner budget while preserving another owner failure count', async () => {
+    const workers: FakeWorker[] = []
+    const queue = makeQueue(workers)
+    const a = { signal: new AbortController().signal }
+    const b = { signal: new AbortController().signal }
+    try {
+      for (const owner of [a, b]) {
+        for (let fault = 0; fault < 2; fault++) {
+          const call = settle(send(queue, 'failure', owner))
+          workers.at(-1)?.emit('error', new Error('failure'))
+          await call
+        }
+      }
+      const successful = send(queue, 'a-success', a)
+      workers.at(-1)?.respond()
+      await successful
+      const thirdB = settle(send(queue, 'b-third', b))
+      workers.at(-1)?.emit('error', new Error('b-third-fault'))
+      await thirdB
+      for (let fault = 0; fault < 2; fault++) {
+        const call = settle(send(queue, 'a-new-failure', a))
+        workers.at(-1)?.emit('error', new Error('a-new-failure'))
+        await call
+      }
+      const stillAllowed = send(queue, 'a-allowed', a)
+      expect(workers).toHaveLength(8)
+      workers.at(-1)?.respond()
+      await expect(stillAllowed).resolves.toMatchObject({ label: 'a-allowed' })
+      await expect(settle(send(queue, 'b-refused', b))).resolves.toMatchObject({
+        message: 'crashed repeatedly (b-third-fault)'
+      })
+      expect(workers).toHaveLength(8)
+    } finally {
+      queue.dispose()
+    }
+  })
+
+  it('drains only the failing owner while queued peers keep their FIFO order', async () => {
+    const workers: FakeWorker[] = []
+    const queue = makeQueue(workers)
+    const a = { signal: new AbortController().signal }
+    const b = { signal: new AbortController().signal }
+    try {
+      const failed = ['a1', 'a2', 'a3', 'a4'].map((label) => settle(send(queue, label, a)))
+      const peer = settle(send(queue, 'peer', b))
+      const ordinary = settle(send(queue, 'ordinary'))
+      for (let fault = 0; fault < 3; fault++) {
+        workers.at(-1)?.emit('error', new Error(`fault-${fault}`))
+      }
+      expect(workers).toHaveLength(4)
+      expect(labels(workers[3])).toEqual(['peer'])
+      expect((await Promise.all(failed)).at(-1)).toMatchObject({
+        message: 'crashed repeatedly (fault-2)'
+      })
+      workers[3].respond()
+      await expect(peer).resolves.toMatchObject({ label: 'peer' })
+      expect(labels(workers[3])).toEqual(['peer', 'ordinary'])
+      workers[3].respond()
+      await expect(ordinary).resolves.toMatchObject({ label: 'ordinary' })
+    } finally {
+      queue.dispose()
+    }
+  })
+
+  it('keeps retirement refusals out of the owner failure budget', async () => {
+    vi.useFakeTimers()
+    const workers: FakeWorker[] = []
+    let finish: (code: number) => void = () => {}
+    const first = new FakeWorker()
+    first.exit = new Promise((resolve) => {
+      finish = resolve
+    })
+    const queue = makeQueue(workers, {
+      awaitRetirement: true,
+      makeWorker: () => (workers.length === 0 ? first : new FakeWorker())
+    })
+    const owner = { signal: new AbortController().signal }
+    try {
+      const failed = settle(send(queue, 'first', owner))
+      first.emit('error', new Error('first-fault'))
+      await failed
+      for (let attempt = 0; attempt < 4; attempt++) {
+        await expect(settle(send(queue, 'not-executed', owner))).resolves.toMatchObject({
+          message: 'unavailable: previous worker still exiting'
+        })
+      }
+      expect(workers).toHaveLength(1)
+      finish(1)
+      await vi.advanceTimersByTimeAsync(0)
+      const recovered = send(queue, 'recovered', owner)
+      expect(workers).toHaveLength(2)
+      workers[1].respond()
+      await expect(recovered).resolves.toMatchObject({ label: 'recovered' })
+    } finally {
+      finish(1)
+      queue.dispose()
+    }
+  })
+
   describe('awaitRetirement', () => {
     function stalledExit(): { worker: FakeWorker; finish: (code: number) => void } {
       const worker = new FakeWorker()
diff --git a/src/main/worker-thread-request-queue.ts b/src/main/worker-thread-request-queue.ts
index 39561fa80a4..6793d597e27 100644
--- a/src/main/worker-thread-request-queue.ts
+++ b/src/main/worker-thread-request-queue.ts
@@ -42,6 +42,10 @@ export type WorkerThreadRequestQueueOptions<TRequest> = {
   awaitRetirement?: boolean
 }
 
+export type WorkerThreadRequestOwner = { readonly signal: AbortSignal }
+
+type OwnerFailures = { consecutiveDeaths: number; refused: Error | null }
+
 type PendingCall<TRequest, TResponse> = {
   request: TRequest
   timeoutMs: number
@@ -49,6 +53,7 @@ type PendingCall<TRequest, TResponse> = {
   reject: (error: Error) => void
   timer: NodeJS.Timeout | null
   signal?: AbortSignal
+  owner?: WorkerThreadRequestOwner
   cleanupAbort: () => void
 }
 
@@ -59,6 +64,7 @@ export class WorkerThreadRequestQueue<
   private active: PendingCall<TRequest, TResponse> | null = null
   private queue: PendingCall<TRequest, TResponse>[] = []
   private consecutiveDeaths = 0
+  private readonly ownerFailures = new WeakMap<WorkerThreadRequestOwner, OwnerFailures>()
   private nextId = 1
   private disposed = false
   private readonly host: LazyWorkerThreadHost<TResponse>
@@ -85,7 +91,8 @@ export class WorkerThreadRequestQueue<
   dispatch(
     buildRequest: (id: number) => TRequest,
     timeoutMs: number,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    owner?: WorkerThreadRequestOwner
   ): Promise<TResponse> {
     return new Promise((resolve, reject) => {
       if (this.disposed) {
@@ -96,6 +103,11 @@ export class WorkerThreadRequestQueue<
         reject(signal.reason ?? new Error('Worker request aborted'))
         return
       }
+      const refused = owner && this.ownerFailures.get(owner)?.refused
+      if (refused) {
+        reject(refused)
+        return
+      }
       // Built before the cap check so a rejection can name the dropped work;
       // the id it burns is only a correlation token, so a gap costs nothing.
       const request = buildRequest(this.nextId++)
@@ -106,7 +118,7 @@ export class WorkerThreadRequestQueue<
       }
       // A fresh burst from full idle starts new work: clear any death count
       // carried from a prior burst so the respawn cap can't drain it early.
-      if (!this.active && this.queue.length === 0) {
+      if (!owner && !this.active && this.queue.length === 0) {
         this.consecutiveDeaths = 0
       }
       const call: PendingCall<TRequest, TResponse> = {
@@ -116,6 +128,7 @@ export class WorkerThreadRequestQueue<
         reject,
         timer: null,
         signal,
+        owner,
         cleanupAbort: () => signal?.removeEventListener('abort', abort)
       }
       const abort = (): void => {
@@ -201,7 +214,11 @@ export class WorkerThreadRequestQueue<
       this.armDeadline(call)
       return
     }
-    this.consecutiveDeaths = 0
+    if (call.owner) {
+      this.failuresFor(call.owner).consecutiveDeaths = 0
+    } else {
+      this.consecutiveDeaths = 0
+    }
     this.settle(call, () => call.resolve(response))
     this.afterSettle()
   }
@@ -226,12 +243,16 @@ export class WorkerThreadRequestQueue<
   private onWorkerFault(error: Error): void {
     const failed = this.active
     this.host.destroy()
-    this.consecutiveDeaths++
-    if (failed) {
-      this.settle(failed, () => failed.reject(error))
+    if (!failed) {
+      this.pump()
+      return
     }
-    if (this.consecutiveDeaths >= this.options.maxConsecutiveDeaths) {
-      this.drainQueueAfterCrashLoop(error)
+    const deaths = failed.owner
+      ? ++this.failuresFor(failed.owner).consecutiveDeaths
+      : ++this.consecutiveDeaths
+    this.settle(failed, () => failed.reject(error))
+    if (deaths >= this.options.maxConsecutiveDeaths) {
+      this.drainQueueAfterCrashLoop(error, failed.owner)
       return
     }
     if (this.queue.length > 0) {
@@ -239,14 +260,28 @@ export class WorkerThreadRequestQueue<
     }
   }
 
-  private drainQueueAfterCrashLoop(error: Error): void {
-    const pending = this.queue
-    this.queue = []
-    this.consecutiveDeaths = 0
+  private drainQueueAfterCrashLoop(error: Error, owner?: WorkerThreadRequestOwner): void {
+    const pending = this.queue.filter((call) => call.owner === owner)
+    this.queue = this.queue.filter((call) => call.owner !== owner)
     const drainError = new Error(this.options.describeCrashLoop(error.message))
+    if (owner) {
+      this.failuresFor(owner).refused = drainError
+    } else {
+      this.consecutiveDeaths = 0
+    }
     for (const call of pending) {
       this.settle(call, () => call.reject(drainError))
     }
+    this.afterSettle()
+  }
+
+  private failuresFor(owner: WorkerThreadRequestOwner): OwnerFailures {
+    let failures = this.ownerFailures.get(owner)
+    if (!failures) {
+      failures = { consecutiveDeaths: 0, refused: null }
+      this.ownerFailures.set(owner, failures)
+    }
+    return failures
   }
 
   private failQueuedAsUnavailable(): void {
diff --git a/src/main/worktree-root-preparation.test.ts b/src/main/worktree-root-preparation.test.ts
index c5f25eca502..eada5ebc261 100644
--- a/src/main/worktree-root-preparation.test.ts
+++ b/src/main/worktree-root-preparation.test.ts
@@ -2,23 +2,16 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type * as WslModule from './wsl'
 import type { Repo } from '../shared/repo-types'
 
-const { mkdirMock, authorizeExternalPathMock, getWslHomeMock, getWslHomeAsyncMock } = vi.hoisted(
-  () => ({
-    mkdirMock: vi.fn(),
-    authorizeExternalPathMock: vi.fn(),
-    getWslHomeMock: vi.fn(),
-    getWslHomeAsyncMock: vi.fn()
-  })
-)
+const { mkdirMock, getWslHomeMock, getWslHomeAsyncMock } = vi.hoisted(() => ({
+  mkdirMock: vi.fn(),
+  getWslHomeMock: vi.fn(),
+  getWslHomeAsyncMock: vi.fn()
+}))
 
 vi.mock('fs/promises', () => ({
   mkdir: mkdirMock
 }))
 
-vi.mock('./ipc/filesystem-auth', () => ({
-  authorizeExternalPath: authorizeExternalPathMock
-}))
-
 vi.mock('./wsl', async (importOriginal) => ({
   ...(await importOriginal<typeof WslModule>()),
   getWslHome: getWslHomeMock,
@@ -43,7 +36,6 @@ const store = {
 describe('prepareLocalWorktreeRootForRepo', () => {
   beforeEach(() => {
     mkdirMock.mockReset().mockResolvedValue(undefined)
-    authorizeExternalPathMock.mockReset()
     getWslHomeMock.mockReset().mockImplementation(() => {
       throw new Error('synchronous wsl.exe home probe must not run on the main thread')
     })
@@ -114,13 +106,11 @@ describe('prepareLocalWorktreeRootForRepo', () => {
     await prepareLocalWorktreeRootForRepo(store as never, { ...repo, kind: 'folder' })
 
     expect(mkdirMock).not.toHaveBeenCalled()
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
   })
 
   it('does not fail repo setup when root preparation fails', async () => {
     mkdirMock.mockRejectedValueOnce(new Error('permission denied'))
 
     await expect(prepareLocalWorktreeRootForRepo(store as never, repo)).resolves.toBeUndefined()
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
   })
 })
diff --git a/src/preload/api/filesystem-api.ts b/src/preload/api/filesystem-api.ts
index d8b74cd9304..07230ae04ff 100644
--- a/src/preload/api/filesystem-api.ts
+++ b/src/preload/api/filesystem-api.ts
@@ -1,4 +1,5 @@
 import type { PathExistenceResult } from '../../shared/path-existence-batch'
+import type { RuntimeFileReadChunkResult } from '../../shared/runtime-types'
 import type { SearchOptions, SearchResult } from '../../shared/code-search-types'
 import type {
   DirEntry,
@@ -17,6 +18,7 @@ import type {
   LocalLogTailWatchArgs
 } from '../../shared/local-log-tail-types'
 import type { SshMutationExpectation } from '../../shared/ssh-types'
+import type { LocalFileAccess } from '../../shared/local-file-access'
 import type {
   CreateVenvResult,
   KernelFrameEvent,
@@ -37,11 +39,19 @@ export type ExportApi = {
 
 export type FilesystemApi = {
   fs: {
+    readFileChunk: (args: {
+      filePath: string
+      connectionId?: string
+      access?: LocalFileAccess
+      offset: number
+      length: number
+    }) => Promise<RuntimeFileReadChunkResult>
     readDir: (args: { dirPath: string; connectionId?: string }) => Promise<DirEntry[]>
     readFile: (args: {
       filePath: string
       connectionId?: string
       includeLocalLogMetadata?: boolean
+      access?: LocalFileAccess
     }) => Promise<{
       content: string
       isBinary: boolean
@@ -88,6 +98,7 @@ export type FilesystemApi = {
         filePath: string
         content: string
         connectionId?: string
+        access?: LocalFileAccess
       } & SshMutationExpectation
     ) => Promise<void>
     createFile: (
@@ -104,6 +115,7 @@ export type FilesystemApi = {
         oldPath: string
         newPath: string
         connectionId?: string
+        access?: LocalFileAccess
       } & SshMutationExpectation
     ) => Promise<void>
     copy: (
@@ -120,16 +132,20 @@ export type FilesystemApi = {
         recursive?: boolean
       } & SshMutationExpectation
     ) => Promise<void>
-    authorizeExternalPath: (args: { targetPath: string }) => Promise<void>
     stat: (args: {
       filePath: string
       connectionId?: string
+      access?: LocalFileAccess
     }) => Promise<{ size: number; isDirectory: boolean; mtime: number }>
     pathsExist?: (args: {
       filePaths: string[]
       connectionId?: string
     }) => Promise<PathExistenceResult[]>
-    pathExists: (args: { filePath: string; connectionId?: string }) => Promise<boolean>
+    pathExists: (args: {
+      filePath: string
+      connectionId?: string
+      access?: LocalFileAccess
+    }) => Promise<boolean>
     listFiles: (args: {
       rootPath: string
       connectionId?: string
@@ -147,6 +163,7 @@ export type FilesystemApi = {
         destDir: string
         connectionId?: string
         ensureDir?: boolean
+        access?: LocalFileAccess
       } & SshMutationExpectation
     ) => Promise<{ results: ImportItemResult[] }>
     stageExternalPathsForRuntimeUpload: (args: {
diff --git a/src/preload/api/fs-bridge.ts b/src/preload/api/fs-bridge.ts
index d58dd17ff8f..aeea9b07fd0 100644
--- a/src/preload/api/fs-bridge.ts
+++ b/src/preload/api/fs-bridge.ts
@@ -1,6 +1,7 @@
 import type { PathExistenceResult } from '../../shared/path-existence-batch'
 import { ipcRenderer } from 'electron'
 import type { SshMutationExpectation } from '../../shared/ssh-types'
+import type { LocalFileAccess } from '../../shared/local-file-access'
 import type { RuntimeUploadFileStreamRequest } from '../../shared/runtime-upload-staging-contract'
 import type { SearchResult } from '../../shared/code-search-types'
 import type { FsChangedPayload } from '../../shared/filesystem-entry-types'
@@ -18,6 +19,13 @@ import type {
 import type { PreloadApi } from '../api-types'
 
 export const fsApi = {
+  readFileChunk: (args: {
+    filePath: string
+    connectionId?: string
+    access?: LocalFileAccess
+    offset: number
+    length: number
+  }) => ipcRenderer.invoke('fs:readFileChunk', args),
   readDir: (args: {
     dirPath: string
     connectionId?: string
@@ -27,6 +35,7 @@ export const fsApi = {
     filePath: string
     connectionId?: string
     includeLocalLogMetadata?: boolean
+    access?: LocalFileAccess
   }): Promise<{
     content: string
     isBinary: boolean
@@ -91,6 +100,7 @@ export const fsApi = {
       filePath: string
       content: string
       connectionId?: string
+      access?: LocalFileAccess
     } & SshMutationExpectation
   ): Promise<void> => ipcRenderer.invoke('fs:writeFile', args),
   createFile: (
@@ -100,7 +110,12 @@ export const fsApi = {
     args: { dirPath: string; connectionId?: string } & SshMutationExpectation
   ): Promise<void> => ipcRenderer.invoke('fs:createDir', args),
   rename: (
-    args: { oldPath: string; newPath: string; connectionId?: string } & SshMutationExpectation
+    args: {
+      oldPath: string
+      newPath: string
+      connectionId?: string
+      access?: LocalFileAccess
+    } & SshMutationExpectation
   ): Promise<void> => ipcRenderer.invoke('fs:rename', args),
   copy: (
     args: {
@@ -116,19 +131,21 @@ export const fsApi = {
       recursive?: boolean
     } & SshMutationExpectation
   ): Promise<void> => ipcRenderer.invoke('fs:deletePath', args),
-  authorizeExternalPath: (args: { targetPath: string }): Promise<void> =>
-    ipcRenderer.invoke('fs:authorizeExternalPath', args),
   stat: (args: {
     filePath: string
     connectionId?: string
+    access?: LocalFileAccess
   }): Promise<{ size: number; isDirectory: boolean; mtime: number }> =>
     ipcRenderer.invoke('fs:stat', args),
   pathsExist: (args: {
     filePaths: string[]
     connectionId?: string
   }): Promise<PathExistenceResult[]> => ipcRenderer.invoke('fs:pathsExist', args),
-  pathExists: (args: { filePath: string; connectionId?: string }): Promise<boolean> =>
-    ipcRenderer.invoke('fs:pathExists', args),
+  pathExists: (args: {
+    filePath: string
+    connectionId?: string
+    access?: LocalFileAccess
+  }): Promise<boolean> => ipcRenderer.invoke('fs:pathExists', args),
   listFiles: (args: {
     rootPath: string
     connectionId?: string
@@ -157,6 +174,7 @@ export const fsApi = {
       destDir: string
       connectionId?: string
       ensureDir?: boolean
+      access?: LocalFileAccess
     } & SshMutationExpectation
   ): Promise<{ results: ImportItemResult[] }> => ipcRenderer.invoke('fs:importExternalPaths', args),
   stageExternalPathsForRuntimeUpload: (args: {
diff --git a/src/preload/api/jira-api.ts b/src/preload/api/jira-api.ts
index 06b1e2a8ac8..7498fc819a2 100644
--- a/src/preload/api/jira-api.ts
+++ b/src/preload/api/jira-api.ts
@@ -76,6 +76,11 @@ export type JiraApi = {
     query?: string
     siteId?: string
   }) => Promise<JiraUser[]>
+  listAssignableUsersForProject: (args: {
+    projectIdOrKey: string
+    query?: string
+    siteId?: string
+  }) => Promise<JiraUser[]>
   searchUsers: (args?: { query?: string; siteId?: string }) => Promise<JiraUser[]>
   listTransitions: (args: { key: string; siteId?: string }) => Promise<JiraTransition[]>
   getProjectStatusOrder: (args: {
diff --git a/src/preload/api/jira-bridge.ts b/src/preload/api/jira-bridge.ts
index 4b6b991095d..0aaf03521ff 100644
--- a/src/preload/api/jira-bridge.ts
+++ b/src/preload/api/jira-bridge.ts
@@ -46,6 +46,7 @@ export const jiraApi = {
     title: string
     description?: string
     customFields?: Record<string, unknown>
+    userFieldKeys?: string[]
   }): Promise<{ ok: true; id: string; key: string; url: string } | { ok: false; error: string }> =>
     ipcRenderer.invoke('jira:createIssue', args),
 
@@ -78,6 +79,11 @@ export const jiraApi = {
 
   listAssignableUsers: (args: { key: string; query?: string; siteId?: string }) =>
     ipcRenderer.invoke('jira:listAssignableUsers', args),
+  listAssignableUsersForProject: (args: {
+    projectIdOrKey: string
+    query?: string
+    siteId?: string
+  }) => ipcRenderer.invoke('jira:listAssignableUsersForProject', args),
   searchUsers: (args?: { query?: string; siteId?: string }) =>
     ipcRenderer.invoke('jira:searchUsers', args),
 
diff --git a/src/relay/fs-handler-list-files-cancel.test.ts b/src/relay/fs-handler-list-files-cancel.test.ts
index b6829921cb4..ca3bfed18e9 100644
--- a/src/relay/fs-handler-list-files-cancel.test.ts
+++ b/src/relay/fs-handler-list-files-cancel.test.ts
@@ -73,6 +73,28 @@ describe('relay list-files cancellation', () => {
     expect(spawnMock).not.toHaveBeenCalled()
   })
 
+  it('listFilesWithRg does not start the ignored pass after cancellation between passes', async () => {
+    vi.useFakeTimers()
+    const primaryProc = createMockProcess()
+    spawnMock.mockReturnValue(primaryProc)
+    const controller = new AbortController()
+    const promise = listFilesWithRg('/remote/root', [], {
+      signal: controller.signal,
+      maxResults: 10
+    })
+    const rejected = expect(promise).rejects.toSatisfy(isFileListingCancellation)
+
+    primaryProc.stdout?.emit('data', 'src/index.ts\0')
+    primaryProc.emit('close', 0, null)
+    // Abort before the completed pass's promise continuation admits the broader scan.
+    controller.abort()
+
+    await rejected
+    expect(spawnMock).toHaveBeenCalledTimes(1)
+    expect(primaryProc.kill).not.toHaveBeenCalled()
+    expect(vi.getTimerCount()).toBe(0)
+  })
+
   it('listFilesWithRg still resolves normally when a signal is provided but never aborted', async () => {
     const ignoredProc = createMockProcess()
     spawnMock.mockReturnValue(ignoredProc)
diff --git a/src/relay/fs-handler-list-files-diagnosis-cancel.test.ts b/src/relay/fs-handler-list-files-diagnosis-cancel.test.ts
new file mode 100644
index 00000000000..d5e515bfd12
--- /dev/null
+++ b/src/relay/fs-handler-list-files-diagnosis-cancel.test.ts
@@ -0,0 +1,142 @@
+import { ChildProcess } from 'node:child_process'
+import type * as ChildProcessModule from 'node:child_process'
+import type * as FsPromises from 'node:fs/promises'
+import { getEventListeners } from 'node:events'
+import { PassThrough } from 'node:stream'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+
+const { spawnMock, statMock, retryMock } = vi.hoisted(() => ({
+  spawnMock: vi.fn(),
+  statMock: vi.fn(),
+  retryMock: vi.fn()
+}))
+vi.mock('node:child_process', async (importOriginal) => ({
+  ...(await importOriginal<typeof ChildProcessModule>()),
+  spawn: spawnMock
+}))
+vi.mock('node:fs/promises', async (importOriginal) => ({
+  ...(await importOriginal<typeof FsPromises>()),
+  stat: statMock,
+  access: vi.fn(async () => undefined)
+}))
+vi.mock('./relay-bundled-ripgrep', () => ({
+  resolveRelayRipgrepCommand: () => '/tools/rg',
+  pathRipgrepCommand: () => '/fallback/rg',
+  retryRipgrepOnPathAfterLaunchFailure: retryMock
+}))
+import { listFilesWithRg } from './fs-handler-list-files'
+
+function child(spawned: boolean) {
+  const result = new ChildProcess()
+  result.stdout = new PassThrough()
+  result.stderr = new PassThrough()
+  Object.defineProperty(result, 'pid', { value: spawned ? 4321 : undefined })
+  result.kill = vi.fn(() => true)
+  return result
+}
+
+async function drainDiagnosis(): Promise<void> {
+  for (let tick = 0; tick < 20; tick += 1) {
+    await Promise.resolve()
+  }
+}
+
+beforeEach(() => {
+  vi.useFakeTimers()
+  spawnMock.mockReset()
+  statMock.mockReset().mockResolvedValue({ isDirectory: () => false })
+  retryMock.mockReset().mockResolvedValue(false)
+})
+afterEach(() => vi.useRealTimers())
+
+it('settles an unexpected diagnosis rejection without leaving a listing pending', async () => {
+  retryMock.mockRejectedValue('diagnosis failed')
+  const failed = child(false)
+  spawnMock.mockReturnValue(failed)
+  const controller = new AbortController()
+  const result = listFilesWithRg('/missing/root', [], { signal: controller.signal })
+  const rejected = expect(result).rejects.toThrow('diagnosis failed')
+  failed.emit('error', new Error('spawn ENOENT'))
+  await rejected
+  expect(spawnMock).toHaveBeenCalledOnce()
+  expect(getEventListeners(controller.signal, 'abort')).toHaveLength(0)
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+it('skips diagnosis when a canceled listing resumes its retry check', async () => {
+  let completeRetry: (value: boolean) => void = () => undefined
+  retryMock.mockReturnValue(
+    new Promise<boolean>((resolve) => {
+      completeRetry = resolve
+    })
+  )
+  const failed = child(false)
+  const probe = child(true)
+  spawnMock.mockReturnValueOnce(failed).mockReturnValue(probe)
+  const controller = new AbortController()
+  const result = listFilesWithRg('/missing/root', [], { signal: controller.signal })
+  const canceled = expect(result).rejects.toMatchObject({ name: 'FileListingCancelledError' })
+  failed.emit('error', new Error('spawn ENOENT'))
+  expect(retryMock).toHaveBeenCalledOnce()
+  controller.abort()
+  await canceled
+  completeRetry(false)
+  await drainDiagnosis()
+  const statCalls = statMock.mock.calls.length
+  probe.emit('close', 0)
+  await drainDiagnosis()
+  expect(statCalls).toBe(0)
+  expect(spawnMock).toHaveBeenCalledOnce()
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+it('skips version probes when cancellation wins a pending cwd check', async () => {
+  let completeStat: (value: { isDirectory: () => boolean }) => void = () => undefined
+  statMock.mockReturnValue(
+    new Promise((resolve) => {
+      completeStat = resolve
+    })
+  )
+  const failed = child(false)
+  const probe = child(true)
+  spawnMock.mockReturnValueOnce(failed).mockReturnValue(probe)
+  const controller = new AbortController()
+  const result = listFilesWithRg('/missing/root', [], { signal: controller.signal })
+  const canceled = expect(result).rejects.toMatchObject({ name: 'FileListingCancelledError' })
+  failed.emit('error', new Error('spawn ENOENT'))
+  await drainDiagnosis()
+  expect(statMock).toHaveBeenCalledOnce()
+  controller.abort()
+  await canceled
+  completeStat({ isDirectory: () => false })
+  await drainDiagnosis()
+  const spawnCalls = spawnMock.mock.calls.length
+  probe.emit('close', 0)
+  await drainDiagnosis()
+  expect(spawnCalls).toBe(1)
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+it('terminates a running diagnosis probe when its listing is canceled', async () => {
+  const failed = child(false)
+  const probe = child(true)
+  spawnMock.mockReturnValueOnce(failed).mockReturnValue(probe)
+  const controller = new AbortController()
+  const result = listFilesWithRg('/missing/root', [], { signal: controller.signal })
+  const canceled = expect(result).rejects.toMatchObject({ name: 'FileListingCancelledError' })
+  failed.emit('error', new Error('spawn ENOENT'))
+  await drainDiagnosis()
+  expect(spawnMock).toHaveBeenCalledTimes(2)
+  expect(spawnMock.mock.calls[1][1]).toEqual(['--version'])
+  controller.abort()
+  await canceled
+  const killCalls = vi.mocked(probe.kill).mock.calls.length
+  const closeListeners = probe.listenerCount('close')
+  probe.emit('close', 0)
+  await drainDiagnosis()
+  expect(killCalls).toBe(1)
+  expect(closeListeners).toBe(0)
+  expect(spawnMock).toHaveBeenCalledTimes(2)
+  expect(getEventListeners(controller.signal, 'abort')).toHaveLength(0)
+  expect(vi.getTimerCount()).toBe(0)
+})
diff --git a/src/relay/fs-handler-list-files.ts b/src/relay/fs-handler-list-files.ts
index ca25cd85e9e..93c325c301a 100644
--- a/src/relay/fs-handler-list-files.ts
+++ b/src/relay/fs-handler-list-files.ts
@@ -77,10 +77,8 @@ export function listFilesWithRg(
       }
       // Why: correctness backstop. The rg globs prune most blocklisted dirs,
       // but a glob edge case could still surface e.g. a .git/ or .npm/ hit.
-      if (!shouldIncludeQuickOpenPath(relPath)) {
-        return true
-      }
-      if (shouldExcludeQuickOpenRelPath(relPath, excludePathPrefixes)) {
+      const excluded = shouldExcludeQuickOpenRelPath(relPath, excludePathPrefixes)
+      if (!shouldIncludeQuickOpenPath(relPath) || excluded) {
         return true
       }
       if (attemptRanker) {
@@ -96,6 +94,10 @@ export function listFilesWithRg(
 
     const runPassOnce = (args: string[]): Promise<void> =>
       new Promise((passResolve, passReject) => {
+        // A completed pass may queue its continuation before cancellation settles the request.
+        if (done || signal?.aborted) {
+          return passResolve()
+        }
         const attemptRanker =
           searchQuery === undefined ? null : new QuickOpenPathRanker(searchQuery, maxResults ?? 16)
         const filenameDecoder = new RipgrepFilenameDecoder((error) => {
@@ -121,7 +123,7 @@ export function listFilesWithRg(
           child = spawn(command, ['--no-messages', ...args], {
             cwd: rootPath,
             env,
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ['ignore', 'pipe', 'ignore'],
             windowsHide: true
           })
         } catch (error) {
@@ -132,11 +134,8 @@ export function listFilesWithRg(
             : error
         }
         const cleanup = (): void => {
-          if (timer) {
-            clearTimeout(timer)
-          }
+          clearTimeout(timer)
           child.stdout?.off('data', handleStdoutData)
-          child.stderr?.off('data', handleStderrData)
           child.off('error', handleError)
           child.off('close', handleClose)
           absorbPendingRipgrepSpawnError(child, {
@@ -144,14 +143,14 @@ export function listFilesWithRg(
             unavailableExitObserved
           })
         }
-        const rejectPass = (error: Error): void => {
+        const rejectPass = (error: unknown): void => {
           if (passDone) {
             return
           }
           passDone = true
           passBuf = ''
           cleanup()
-          passReject(error)
+          passReject(error instanceof Error ? error : new Error(String(error)))
         }
         const resolvePass = (): void => {
           if (passDone) {
@@ -168,8 +167,11 @@ export function listFilesWithRg(
           if (launchFailureCheck) {
             return
           }
-          launchFailureCheck = retryRipgrepOnPathAfterLaunchFailure(command, rootPath, error).then(
-            async (retryOnPath) => {
+          launchFailureCheck = retryRipgrepOnPathAfterLaunchFailure(command, rootPath, error)
+            .then(async (retryOnPath) => {
+              if (passDone || done) {
+                return
+              }
               if (retryOnPath) {
                 // Why: runPass retries a launch failure once, and the retry resolves to PATH rg.
                 rejectPass(new RipgrepLaunchFailureError('bundled rg failed to start'))
@@ -181,13 +183,14 @@ export function listFilesWithRg(
                 (await classifyRipgrepLaunchFailure(
                   rootPath,
                   [command, pathRipgrepCommand()],
-                  env
+                  env,
+                  signal
                 )) === 'cwd-unreachable'
                   ? ripgrepMissingCwdError(rootPath)
                   : new RipgrepUnavailableError()
               )
-            }
-          )
+            })
+            .catch(rejectPass)
         }
         children.push({ child, isDone: () => passDone, reject: rejectPass })
 
@@ -218,9 +221,6 @@ export function listFilesWithRg(
           }
           passBuf = start < passBuf.length ? passBuf.substring(start) : ''
         }
-        function handleStderrData(): void {
-          /* drain to prevent backpressure stalls */
-        }
         function handleError(err: NodeJS.ErrnoException): void {
           processErrorObserved = true
           if (isTransientRipgrepSpawnError(err)) {
@@ -277,7 +277,6 @@ export function listFilesWithRg(
         }
 
         child.stdout?.on('data', handleStdoutData)
-        child.stderr?.on('data', handleStderrData)
         child.once('error', handleError)
         child.once('close', handleClose)
       })
diff --git a/src/relay/opencode-hook-selection.test.ts b/src/relay/opencode-hook-selection.test.ts
index 6e47c28bc36..0650662762c 100644
--- a/src/relay/opencode-hook-selection.test.ts
+++ b/src/relay/opencode-hook-selection.test.ts
@@ -27,6 +27,9 @@ vi.mock('node-pty', () => ({ spawn: mocks.mockPtySpawn }))
 vi.mock('../main/shell-prompt-readiness-probe', () => ({
   createShellPromptReadinessProbe: mocks.mockCreateShellPromptReadinessProbe
 }))
+vi.mock('../main/opencode/opencode-launch-capabilities', () => ({
+  probeOpenCodeLaunchCapabilities: async () => null
+}))
 vi.mock('../main/pty/posix-pty-process-groups', () => ({
   forceKillPosixPtyProcessGroups: vi.fn((_pid: number, fallback: () => void) => fallback())
 }))
@@ -94,6 +97,38 @@ async function spawn(params: Record<string, unknown> = {}): Promise<Record<strin
 }
 
 describe('relay OpenCode source selection on real fixture files', () => {
+  it.each(['home', 'xdg', 'shell'] as const)(
+    'consumer config root follows the remote %s environment',
+    async (kind) => {
+      await install('// remote plugin', '')
+      const home = join(root, 'remote-home')
+      const xdg = join(root, 'remote-xdg')
+      const consumer = kind === 'home' ? join(home, '.config', 'opencode') : join(xdg, 'opencode')
+      mkdirSync(home, { recursive: true })
+      mkdirSync(consumer, { recursive: true })
+      writeFileSync(join(consumer, 'opencode.json'), '{"model":"remote-model"}')
+      if (kind === 'shell') {
+        writeFileSync(join(home, '.zshrc'), `export XDG_CONFIG_HOME='${xdg}'\n`)
+      }
+      const env = await spawn({
+        cwd: home,
+        launchAgent: 'opencode',
+        env: {
+          HOME: home,
+          USERPROFILE: home,
+          XDG_CONFIG_HOME: kind === 'xdg' ? xdg : '',
+          SHELL: kind === 'shell' ? '/bin/zsh' : '/bin/sh'
+        }
+      })
+      expect(readFileSync(plugin(consumer, 'opencode'), 'utf8')).toBe('// remote plugin')
+      expect(existsSync(plugin(join(root, 'xdg', 'opencode'), 'opencode'))).toBe(false)
+      expect(readFileSync(join(consumer, 'opencode.json'), 'utf8')).toBe('{"model":"remote-model"}')
+      expect(env.OPENCODE_CONFIG_DIR).toBeUndefined()
+      expect(env.HOME).toBe(home)
+      expect(env.XDG_CONFIG_HOME).toBe(kind === 'xdg' ? xdg : '')
+    }
+  )
+
   it('leaves a standalone relay without supplied sources unconfigured', async () => {
     const env = await spawn()
     expect(env.ORCA_OPENCODE_AGENT).toBeUndefined()
diff --git a/src/relay/relay-agent-hook-runtime.ts b/src/relay/relay-agent-hook-runtime.ts
index 4ee9113919a..c991b3fde71 100644
--- a/src/relay/relay-agent-hook-runtime.ts
+++ b/src/relay/relay-agent-hook-runtime.ts
@@ -25,6 +25,7 @@ import { selectOpenCodeHookAgent } from '../shared/opencode-launch-command'
 import { relayLogLine } from './relay-diagnostic-log'
 import { restoreOrStripOverlayEnv } from '../shared/agent-overlay-env'
 import { registerManagedHookInstaller } from './managed-hook-installer'
+import { readSessionShellStartupEnvVar } from '../main/pty/shell-startup-env'
 
 export class RelayAgentHookRuntime {
   private readonly hookServer: RelayAgentHookServer
@@ -122,7 +123,12 @@ export class RelayAgentHookRuntime {
           env.ORCA_OPENCODE_SOURCE_CONFIG_DIR = sourceDir
         }
       } else {
-        this.pluginOverlay.installOpenCodePlugin(opencodeAgent, context.env)
+        this.pluginOverlay.installOpenCodePlugin(opencodeAgent, {
+          ...context.env,
+          XDG_CONFIG_HOME:
+            readSessionShellStartupEnvVar('XDG_CONFIG_HOME', context.env, context.shell) ??
+            context.env.XDG_CONFIG_HOME
+        })
       }
     }
     const explicitKind = isPiCompatibleAgentType(context.launchAgent)
diff --git a/src/renderer/src/components/LinearIssueTextEditor.tsx b/src/renderer/src/components/LinearIssueTextEditor.tsx
index 4301174ceb5..66806bf70f9 100644
--- a/src/renderer/src/components/LinearIssueTextEditor.tsx
+++ b/src/renderer/src/components/LinearIssueTextEditor.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import React, { useCallback, useRef, useState } from 'react'
 import { LoaderCircle } from 'lucide-react'
 import { toast } from 'sonner'
@@ -190,7 +191,7 @@ export function LinearIssueTextEditor({
     <div className="min-w-0">
       {fields !== 'description' ? (
         <div className="relative">
-          <textarea
+          <ImeTextarea
             value={titleDraft}
             onChange={(event) => updateTitleDraft(event.target.value)}
             onBlur={() => void saveField('title')}
diff --git a/src/renderer/src/components/TerminalSearch.tsx b/src/renderer/src/components/TerminalSearch.tsx
index 79051f5d84b..47db8092ef1 100644
--- a/src/renderer/src/components/TerminalSearch.tsx
+++ b/src/renderer/src/components/TerminalSearch.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import { useEffect, useState, useCallback } from 'react'
 import { ChevronUp, ChevronDown, X, CaseSensitive, Regex } from 'lucide-react'
 import type { SearchAddon } from '@xterm/addon-search'
@@ -152,7 +153,7 @@ export default function TerminalSearch({
       style={{ width: 340, maxWidth: 'calc(100% - 16px)' }}
       onKeyDown={handleKeyDown}
     >
-      <input
+      <ImeInput
         ref={handleInputRef}
         type="text"
         value={query}
diff --git a/src/renderer/src/components/activity/activity-thread-hover-card.test.tsx b/src/renderer/src/components/activity/activity-thread-hover-card.test.tsx
index ef1f109d50a..d64f60c11a1 100644
--- a/src/renderer/src/components/activity/activity-thread-hover-card.test.tsx
+++ b/src/renderer/src/components/activity/activity-thread-hover-card.test.tsx
@@ -262,4 +262,35 @@ describe('ActivityThreadHoverCard and ActivityThreadRow', () => {
 
     expect(onJump).toHaveBeenCalledWith(thread)
   })
+
+  it('flattens code blocks and tables in the reply preview so the line clamp cuts them', async () => {
+    const thread = createTestThread({
+      currentAgentState: null,
+      responsePreview:
+        'KK1-START\n\n```\n| metric | base median |\n| --- | --- |\n| p2 | 12 |\n```\n\n| a | b |\n| - | - |\n| 1 | 2 |'
+    })
+
+    await act(async () => {
+      root.render(<Harness thread={thread} />)
+    })
+
+    const pre = container.querySelector('pre')
+    const table = container.querySelector('table')
+    expect(pre).not.toBeNull()
+    expect(table).not.toBeNull()
+    const preview = pre?.closest<HTMLElement>('.line-clamp-3')
+    expect(preview).not.toBeNull()
+    expect(preview?.contains(table ?? null)).toBe(true)
+    // Why: the compact renderers draw both as scroll boxes; the row must undo that.
+    const previewClasses = preview?.className.split(/\s+/) ?? []
+    expect(previewClasses).toEqual(
+      expect.arrayContaining([
+        '[&_pre]:!max-h-none',
+        '[&_pre]:!overflow-visible',
+        '[&_pre]:!whitespace-normal',
+        '[&_div]:!overflow-visible',
+        '[&_:is(table,thead,tbody,tr,th,td)]:!inline'
+      ])
+    )
+  })
 })
diff --git a/src/renderer/src/components/activity/activity-thread-row.tsx b/src/renderer/src/components/activity/activity-thread-row.tsx
index fef63bda46e..207ba0d6021 100644
--- a/src/renderer/src/components/activity/activity-thread-row.tsx
+++ b/src/renderer/src/components/activity/activity-thread-row.tsx
@@ -133,7 +133,10 @@ export const ActivityThreadRow = React.memo(function ActivityThreadRow({
                   className={cn(
                     'min-w-0 break-words text-[13px] leading-5 text-foreground/80',
                     compactMode ? 'line-clamp-2' : 'line-clamp-3',
-                    '[&_*]:!m-0 [&_*]:!p-0 [&_br]:hidden [&_ol]:list-none [&_ul]:list-none'
+                    '[&_*]:!m-0 [&_*]:!p-0 [&_br]:hidden [&_ol]:list-none [&_ul]:list-none',
+                    // Why: code blocks and tables otherwise render as scroll boxes the line clamp cannot cut.
+                    '[&_pre]:!max-h-none [&_pre]:!overflow-visible [&_pre]:!whitespace-normal [&_pre]:!rounded-none [&_pre]:!bg-transparent [&_pre]:![font:inherit] [&_pre_code]:![font:inherit]',
+                    '[&_div]:!overflow-visible [&_:is(table,thead,tbody,tr,th,td)]:!inline [&_:is(table,thead,tbody,tr,th,td)]:!align-baseline [&_:is(th,td)]:!border-0 [&_:is(th,td)]:!pr-2 [&_table]:![font:inherit]'
                   )}
                 />
               ) : (
diff --git a/src/renderer/src/components/automations/AutomationEditorPromptSection.tsx b/src/renderer/src/components/automations/AutomationEditorPromptSection.tsx
index df988eb5039..d27394f98b8 100644
--- a/src/renderer/src/components/automations/AutomationEditorPromptSection.tsx
+++ b/src/renderer/src/components/automations/AutomationEditorPromptSection.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import React from 'react'
 import { Pencil } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -39,7 +40,7 @@ export function AutomationEditorPromptSection({
         </div>
       ) : null}
       <div className="group/title mb-5 flex max-w-full items-start gap-1">
-        <textarea
+        <ImeTextarea
           ref={titleRef}
           value={draft.name}
           rows={1}
diff --git a/src/renderer/src/components/automations/AutomationTimeField.tsx b/src/renderer/src/components/automations/AutomationTimeField.tsx
index 92a3639cff2..e13d1b911e6 100644
--- a/src/renderer/src/components/automations/AutomationTimeField.tsx
+++ b/src/renderer/src/components/automations/AutomationTimeField.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React from 'react'
 import { Clock } from 'lucide-react'
 import { cn } from '@/lib/utils'
@@ -125,7 +126,7 @@ function TimeDigitInput({
   }
 
   return (
-    <input
+    <ImeInput
       type="text"
       inputMode="numeric"
       autoComplete="off"
diff --git a/src/renderer/src/components/browser-pane/annotate/BrowserAnnotationSendMenuContent.tsx b/src/renderer/src/components/browser-pane/annotate/BrowserAnnotationSendMenuContent.tsx
index e19a0a2e2ec..faceaab0f0b 100644
--- a/src/renderer/src/components/browser-pane/annotate/BrowserAnnotationSendMenuContent.tsx
+++ b/src/renderer/src/components/browser-pane/annotate/BrowserAnnotationSendMenuContent.tsx
@@ -6,13 +6,15 @@ export type BrowserAnnotationSendMenuContentProps = {
   groupId: string
   prompt: string
   onPromptDelivered?: () => void
+  onPromptHandedOff?: (delivered: Promise<unknown>) => void
 }
 
 export function BrowserAnnotationSendMenuContent({
   worktreeId,
   groupId,
   prompt,
-  onPromptDelivered
+  onPromptDelivered,
+  onPromptHandedOff
 }: BrowserAnnotationSendMenuContentProps): React.JSX.Element {
   return (
     <ReviewNotesSendMenuContent
@@ -24,6 +26,7 @@ export function BrowserAnnotationSendMenuContent({
       promptDelivery="submit-after-ready"
       launchSource="notes_send"
       onPromptDelivered={onPromptDelivered}
+      onPromptHandedOff={onPromptHandedOff}
     />
   )
 }
diff --git a/src/renderer/src/components/browser-pane/annotate/MarkupOverlay.tsx b/src/renderer/src/components/browser-pane/annotate/MarkupOverlay.tsx
index 28b8c7ef167..4f8a02dbd91 100644
--- a/src/renderer/src/components/browser-pane/annotate/MarkupOverlay.tsx
+++ b/src/renderer/src/components/browser-pane/annotate/MarkupOverlay.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React, { useCallback, useRef, useState } from 'react'
 import { Check, X } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -69,7 +70,7 @@ export function MarkupOverlay({
       />
 
       {pendingText ? (
-        <input
+        <ImeInput
           ref={editor.textInputRef}
           // Why: key by position so each placement re-mounts a fresh input.
           key={`${pendingText.x},${pendingText.y}`}
diff --git a/src/renderer/src/components/browser-pane/annotate/browser-guest-annotate-overlays.tsx b/src/renderer/src/components/browser-pane/annotate/browser-guest-annotate-overlays.tsx
index 200670cd536..c8141bd0685 100644
--- a/src/renderer/src/components/browser-pane/annotate/browser-guest-annotate-overlays.tsx
+++ b/src/renderer/src/components/browser-pane/annotate/browser-guest-annotate-overlays.tsx
@@ -75,6 +75,7 @@ export function BrowserGuestAnnotateOverlays({
     activeGroupId,
     browserAnnotationsPrompt,
     handleBrowserAnnotationsSentToAgent,
+    handleBrowserAnnotationsHandedOff,
     handleCopyBrowserAnnotations,
     browserAnnotationsCopied,
     handleClearBrowserAnnotations,
@@ -119,6 +120,7 @@ export function BrowserGuestAnnotateOverlays({
           activeGroupId={activeGroupId}
           browserAnnotationsPrompt={browserAnnotationsPrompt}
           handleBrowserAnnotationsSentToAgent={handleBrowserAnnotationsSentToAgent}
+          handleBrowserAnnotationsHandedOff={handleBrowserAnnotationsHandedOff}
           handleCopyBrowserAnnotations={handleCopyBrowserAnnotations}
           browserAnnotationsCopied={browserAnnotationsCopied}
           handleClearBrowserAnnotations={handleClearBrowserAnnotations}
diff --git a/src/renderer/src/components/browser-pane/annotate/browser-page-annotation-tray.test.tsx b/src/renderer/src/components/browser-pane/annotate/browser-page-annotation-tray.test.tsx
index 1fe0b6bfd46..162e1c64bf0 100644
--- a/src/renderer/src/components/browser-pane/annotate/browser-page-annotation-tray.test.tsx
+++ b/src/renderer/src/components/browser-pane/annotate/browser-page-annotation-tray.test.tsx
@@ -87,6 +87,7 @@ function renderTray(currentUrl?: string): {
         activeGroupId={undefined}
         browserAnnotationsPrompt="prompt"
         handleBrowserAnnotationsSentToAgent={vi.fn()}
+        handleBrowserAnnotationsHandedOff={vi.fn()}
         handleCopyBrowserAnnotations={vi.fn()}
         browserAnnotationsCopied={false}
         handleClearBrowserAnnotations={vi.fn()}
diff --git a/src/renderer/src/components/browser-pane/annotate/browser-page-annotation-tray.tsx b/src/renderer/src/components/browser-pane/annotate/browser-page-annotation-tray.tsx
index a22f18b06d5..ca091dfd779 100644
--- a/src/renderer/src/components/browser-pane/annotate/browser-page-annotation-tray.tsx
+++ b/src/renderer/src/components/browser-pane/annotate/browser-page-annotation-tray.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import { useEffect, useState } from 'react'
 import { CircleCheck, Copy, MessageSquarePlus, Pencil, Send, Trash2 } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -29,6 +30,7 @@ export function BrowserPageAnnotationTray({
   activeGroupId,
   browserAnnotationsPrompt,
   handleBrowserAnnotationsSentToAgent,
+  handleBrowserAnnotationsHandedOff,
   handleCopyBrowserAnnotations,
   browserAnnotationsCopied,
   handleClearBrowserAnnotations,
@@ -43,6 +45,7 @@ export function BrowserPageAnnotationTray({
   activeGroupId: string | undefined
   browserAnnotationsPrompt: string
   handleBrowserAnnotationsSentToAgent: () => void
+  handleBrowserAnnotationsHandedOff: (delivered: Promise<unknown>) => void
   handleCopyBrowserAnnotations: () => void
   browserAnnotationsCopied: boolean
   handleClearBrowserAnnotations: () => void
@@ -111,7 +114,12 @@ export function BrowserPageAnnotationTray({
           <Tooltip>
             <TooltipTrigger asChild>
               <DropdownMenuTrigger asChild>
-                <Button size="xs" variant="outline" className="gap-1.5">
+                <Button
+                  size="xs"
+                  variant="outline"
+                  className="gap-1.5"
+                  disabled={!browserAnnotationsPrompt}
+                >
                   <Send className="size-3" />
                   {translate('auto.components.browser.pane.BrowserPane.ac39b9366b', 'Send')}
                 </Button>
@@ -135,6 +143,7 @@ export function BrowserPageAnnotationTray({
               groupId={activeGroupId ?? worktreeId}
               prompt={browserAnnotationsPrompt}
               onPromptDelivered={handleBrowserAnnotationsSentToAgent}
+              onPromptHandedOff={handleBrowserAnnotationsHandedOff}
             />
           </DropdownMenuContent>
         </DropdownMenu>
@@ -197,7 +206,7 @@ export function BrowserPageAnnotationTray({
                     }
                   }}
                 >
-                  <textarea
+                  <ImeTextarea
                     value={editComment}
                     onChange={(event) => setEditComment(event.target.value)}
                     maxLength={GRAB_BUDGET.annotationCommentMaxLength}
diff --git a/src/renderer/src/components/browser-pane/annotate/pending-browser-annotation-card.tsx b/src/renderer/src/components/browser-pane/annotate/pending-browser-annotation-card.tsx
index a751ac2644b..47daea3b1dd 100644
--- a/src/renderer/src/components/browser-pane/annotate/pending-browser-annotation-card.tsx
+++ b/src/renderer/src/components/browser-pane/annotate/pending-browser-annotation-card.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import { useState } from 'react'
 import { CornerDownLeft, MessageSquarePlus } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -79,7 +80,7 @@ export function PendingBrowserAnnotationCard({
         <Label htmlFor="browser-annotation-comment" className="sr-only">
           {translate('auto.components.browser.pane.BrowserPane.d2a7092e6e', 'Annotation comment')}
         </Label>
-        <textarea
+        <ImeTextarea
           id="browser-annotation-comment"
           value={comment}
           onChange={(event) => setComment(event.target.value)}
diff --git a/src/renderer/src/components/browser-pane/annotate/use-browser-page-annotation-send.test.tsx b/src/renderer/src/components/browser-pane/annotate/use-browser-page-annotation-send.test.tsx
index 9c7ca72e954..8eb9934c5a8 100644
--- a/src/renderer/src/components/browser-pane/annotate/use-browser-page-annotation-send.test.tsx
+++ b/src/renderer/src/components/browser-pane/annotate/use-browser-page-annotation-send.test.tsx
@@ -8,6 +8,7 @@ import { createTestStore } from '@/store/slices/browser-slice-test-harness'
 import type { OpenAgentSendPopoverTargetModeArgs } from '@/store/slices/ui'
 import { BrowserPageAnnotationTray } from './browser-page-annotation-tray'
 import { useBrowserPageAnnotationSend } from './use-browser-page-annotation-send'
+import { resetNotesInFlightForTests } from '@/lib/notes-send-in-flight'
 
 const state = vi.hoisted((): { store?: ReturnType<typeof createTestStore> } => ({}))
 vi.mock('@/store', () => ({
@@ -93,6 +94,7 @@ beforeEach(() => {
   store = createTestStore()
   state.store = store
   mode = undefined
+  resetNotesInFlightForTests()
   store.setState({
     activeGroupIdByWorktree: {},
     openAgentSendPopoverTargetMode: (next) => {
@@ -214,3 +216,65 @@ describe('website annotation delivery', () => {
     expect(notes()).toEqual([])
   })
 })
+
+describe('website annotations handed to a send', () => {
+  const second = (): BrowserPageAnnotation => ({
+    ...makeAnnotation('page-1', 'second'),
+    comment: 'Second note'
+  })
+
+  it('sends only an annotation added while an earlier send is still on its way', async () => {
+    const view = mount()
+    const firstDelivered = view.result.current.handleBrowserAnnotationsSentToAgent
+    let deliverFirst!: (result: { delivered: boolean }) => void
+    act(() =>
+      view.result.current.handleBrowserAnnotationsHandedOff(
+        new Promise((resolve) => (deliverFirst = resolve))
+      )
+    )
+    expect(view.result.current.browserAnnotationsPrompt).toBe('')
+
+    act(() => store.getState().addBrowserPageAnnotation(second()))
+    expect(view.result.current.browserAnnotationsPrompt).toContain('Second note')
+    expect(view.result.current.browserAnnotationsPrompt).not.toContain('Fix this button')
+    const secondDelivered = view.result.current.handleBrowserAnnotationsSentToAgent
+
+    act(firstDelivered)
+    await act(async () => deliverFirst({ delivered: true }))
+    expect(notes().map((note) => note.id)).toEqual(['second'])
+    act(secondDelivered)
+    expect(notes()).toEqual([])
+  })
+
+  it('puts annotations back for the next send when their delivery fails', async () => {
+    const view = mount()
+    const delivered = Promise.resolve({ delivered: false, failureNotified: true })
+    act(() => view.result.current.handleBrowserAnnotationsHandedOff(delivered))
+    expect(view.result.current.browserAnnotationsPrompt).toBe('')
+
+    await act(async () => {
+      await delivered
+    })
+
+    expect(view.result.current.browserAnnotationsPrompt).toContain('Fix this button')
+    expect(notes()).toHaveLength(1)
+  })
+
+  it('holds what a running-agent send carries too', () => {
+    const view = mount()
+    act(() => view.result.current.handleAnnotationTraySendOpenChange(true))
+    act(() => mode?.onPromptHandedOff?.(new Promise(() => undefined)))
+    expect(view.result.current.browserAnnotationsPrompt).toBe('')
+  })
+
+  it('offers no send while every annotation is already on its way', () => {
+    const view = mount()
+    act(() => view.result.current.handleBrowserAnnotationsHandedOff(new Promise(() => undefined)))
+
+    act(() => view.result.current.handleAnnotationTraySendOpenChange(true))
+    expect(mode).toBeUndefined()
+
+    render(<AnnotationTrayHarness />)
+    expect(screen.getByRole('button', { name: 'Send' })).toBeDisabled()
+  })
+})
diff --git a/src/renderer/src/components/browser-pane/annotate/use-browser-page-annotation-send.ts b/src/renderer/src/components/browser-pane/annotate/use-browser-page-annotation-send.ts
index b770302715f..700094fe874 100644
--- a/src/renderer/src/components/browser-pane/annotate/use-browser-page-annotation-send.ts
+++ b/src/renderer/src/components/browser-pane/annotate/use-browser-page-annotation-send.ts
@@ -16,6 +16,11 @@ import type {
 } from '../../../../../shared/browser-grab-types'
 import { formatBrowserAnnotationsAsMarkdown } from './browser-annotation-output'
 import { EMPTY_BROWSER_ANNOTATIONS } from '../describe-page/browser-annotation-geometry'
+import {
+  holdNotesForSend,
+  isNoteInFlight,
+  useNotesInFlightVersion
+} from '@/lib/notes-send-in-flight'
 
 export function useBrowserPageAnnotationSend({
   browserTabId,
@@ -42,6 +47,7 @@ export function useBrowserPageAnnotationSend({
     intent: BrowserAnnotationIntent
   ) => void
   handleBrowserAnnotationsSentToAgent: () => void
+  handleBrowserAnnotationsHandedOff: (delivered: Promise<unknown>) => void
   activeGroupId: string | undefined
 } {
   const browserAnnotations = useAppStore(
@@ -52,10 +58,20 @@ export function useBrowserPageAnnotationSend({
   const [browserAnnotationTrayOpen, setBrowserAnnotationTrayOpen] = useState(true)
   const [browserAnnotationsCopied, setBrowserAnnotationsCopied] = useState(false)
   const annotationCopyTimerRef = useRef<ReturnType<typeof setTimeout>>(undefined)
-  const browserAnnotationsPrompt = useMemo(
+  const copyPrompt = useMemo(
     () => formatBrowserAnnotationsAsMarkdown(browserAnnotations),
     [browserAnnotations]
   )
+  // Annotations another send holds are left out of the next one.
+  const inFlightVersion = useNotesInFlightVersion()
+  const sendableAnnotations = useMemo(() => {
+    void inFlightVersion
+    return browserAnnotations.filter((annotation) => !isNoteInFlight(annotation))
+  }, [browserAnnotations, inFlightVersion])
+  const browserAnnotationsPrompt = useMemo(
+    () => formatBrowserAnnotationsAsMarkdown(sendableAnnotations),
+    [sendableAnnotations]
+  )
   const openAgentSendPopoverTargetMode = useAppStore((s) => s.openAgentSendPopoverTargetMode)
   const closeAgentSendPopoverTargetMode = useAppStore((s) => s.closeAgentSendPopoverTargetMode)
   const activeAgentSendTargetModeId = useAppStore((s) => s.agentSendPopoverTargetMode?.id ?? null)
@@ -82,26 +98,32 @@ export function useBrowserPageAnnotationSend({
   }, [])
 
   const handleCopyBrowserAnnotations = useCallback((): void => {
-    if (!browserAnnotationsPrompt) {
+    if (!copyPrompt) {
       return
     }
-    void window.api.ui.writeClipboardText(browserAnnotationsPrompt)
+    void window.api.ui.writeClipboardText(copyPrompt)
     recordFeatureInteraction('browser-annotations')
     clearTimeout(annotationCopyTimerRef.current)
     setBrowserAnnotationsCopied(true)
     annotationCopyTimerRef.current = setTimeout(() => setBrowserAnnotationsCopied(false), 1400)
-  }, [browserAnnotationsPrompt, recordFeatureInteraction])
+  }, [copyPrompt, recordFeatureInteraction])
 
   const handleBrowserAnnotationsSentToAgent = useCallback((): void => {
     recordFeatureInteraction('browser-annotations-sent-to-agent')
-    removeDeliveredBrowserPageAnnotations(browserTabId, browserAnnotations)
+    removeDeliveredBrowserPageAnnotations(browserTabId, sendableAnnotations)
   }, [
-    browserAnnotations,
+    sendableAnnotations,
     browserTabId,
     recordFeatureInteraction,
     removeDeliveredBrowserPageAnnotations
   ])
 
+  const handleBrowserAnnotationsHandedOff = useCallback(
+    (delivered: Promise<unknown>): void =>
+      holdNotesForSend(sendableAnnotations, delivered, handleBrowserAnnotationsSentToAgent),
+    [handleBrowserAnnotationsSentToAgent, sendableAnnotations]
+  )
+
   const handleClearBrowserAnnotations = useCallback((): void => {
     if (browserAnnotationsRef.current.length === 0) {
       return
@@ -115,6 +137,10 @@ export function useBrowserPageAnnotationSend({
   const handleAnnotationSendOpenChange = useCallback(
     (modeId: string, open: boolean): void => {
       if (open) {
+        // Every annotation may already be on its way: there is nothing to send.
+        if (!browserAnnotationsPrompt) {
+          return
+        }
         openAgentSendPopoverTargetMode({
           id: modeId,
           worktreeId,
@@ -125,7 +151,8 @@ export function useBrowserPageAnnotationSend({
             'Browser annotations'
           ),
           launchSource: 'notes_send',
-          onPromptDelivered: handleBrowserAnnotationsSentToAgent
+          onPromptDelivered: handleBrowserAnnotationsSentToAgent,
+          onPromptHandedOff: handleBrowserAnnotationsHandedOff
         })
       } else {
         closeAgentSendPopoverTargetMode(modeId)
@@ -134,6 +161,7 @@ export function useBrowserPageAnnotationSend({
     [
       browserAnnotationsPrompt,
       handleBrowserAnnotationsSentToAgent,
+      handleBrowserAnnotationsHandedOff,
       closeAgentSendPopoverTargetMode,
       openAgentSendPopoverTargetMode,
       worktreeId
@@ -199,6 +227,7 @@ export function useBrowserPageAnnotationSend({
     handleDeleteBrowserAnnotation,
     handleUpdateBrowserAnnotation,
     handleBrowserAnnotationsSentToAgent,
+    handleBrowserAnnotationsHandedOff,
     activeGroupId
   }
 }
diff --git a/src/renderer/src/components/browser-pane/assemble-chrome/BrowserFind.tsx b/src/renderer/src/components/browser-pane/assemble-chrome/BrowserFind.tsx
index ed7814f159e..088b21463b3 100644
--- a/src/renderer/src/components/browser-pane/assemble-chrome/BrowserFind.tsx
+++ b/src/renderer/src/components/browser-pane/assemble-chrome/BrowserFind.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { ChevronUp, ChevronDown, X } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -168,7 +169,7 @@ export default function BrowserFind({
       style={{ width: 300 }}
       onKeyDown={handleKeyDown}
     >
-      <input
+      <ImeInput
         ref={inputRef}
         type="text"
         value={query}
diff --git a/src/renderer/src/components/browser-pane/assemble-chrome/browser-page-chrome-banners.tsx b/src/renderer/src/components/browser-pane/assemble-chrome/browser-page-chrome-banners.tsx
index 48dc0a6afe0..5bced58139a 100644
--- a/src/renderer/src/components/browser-pane/assemble-chrome/browser-page-chrome-banners.tsx
+++ b/src/renderer/src/components/browser-pane/assemble-chrome/browser-page-chrome-banners.tsx
@@ -28,6 +28,7 @@ export function BrowserPageChromeBanners({
   activeGroupId,
   browserAnnotationsPrompt,
   handleBrowserAnnotationsSentToAgent,
+  handleBrowserAnnotationsHandedOff,
   handleCopyBrowserAnnotations,
   browserAnnotationsCopied,
   handleClearBrowserAnnotations,
@@ -45,6 +46,7 @@ export function BrowserPageChromeBanners({
   activeGroupId: string | undefined
   browserAnnotationsPrompt: string
   handleBrowserAnnotationsSentToAgent: () => void
+  handleBrowserAnnotationsHandedOff: (delivered: Promise<unknown>) => void
   handleCopyBrowserAnnotations: () => void
   browserAnnotationsCopied: boolean
   handleClearBrowserAnnotations: () => void
@@ -131,7 +133,12 @@ export function BrowserPageChromeBanners({
                 <Tooltip>
                   <TooltipTrigger asChild>
                     <DropdownMenuTrigger asChild>
-                      <Button size="xs" variant="outline" className="h-6 gap-1.5">
+                      <Button
+                        size="xs"
+                        variant="outline"
+                        className="h-6 gap-1.5"
+                        disabled={!browserAnnotationsPrompt}
+                      >
                         <Send className="size-3" />
                         {translate('auto.components.browser.pane.BrowserPane.ac39b9366b', 'Send')}
                       </Button>
@@ -155,6 +162,7 @@ export function BrowserPageChromeBanners({
                     groupId={activeGroupId ?? worktreeId}
                     prompt={browserAnnotationsPrompt}
                     onPromptDelivered={handleBrowserAnnotationsSentToAgent}
+                    onPromptHandedOff={handleBrowserAnnotationsHandedOff}
                   />
                 </DropdownMenuContent>
               </DropdownMenu>
diff --git a/src/renderer/src/components/browser-pane/assemble-chrome/browser-page-chrome-header.tsx b/src/renderer/src/components/browser-pane/assemble-chrome/browser-page-chrome-header.tsx
index 8d5b5b68ade..b162a2ba34b 100644
--- a/src/renderer/src/components/browser-pane/assemble-chrome/browser-page-chrome-header.tsx
+++ b/src/renderer/src/components/browser-pane/assemble-chrome/browser-page-chrome-header.tsx
@@ -121,6 +121,7 @@ export function BrowserPageChromeHeader({
         activeGroupId={annotationSend.activeGroupId}
         browserAnnotationsPrompt={annotationSend.browserAnnotationsPrompt}
         handleBrowserAnnotationsSentToAgent={annotationSend.handleBrowserAnnotationsSentToAgent}
+        handleBrowserAnnotationsHandedOff={annotationSend.handleBrowserAnnotationsHandedOff}
         handleCopyBrowserAnnotations={annotationSend.handleCopyBrowserAnnotations}
         browserAnnotationsCopied={annotationSend.browserAnnotationsCopied}
         handleClearBrowserAnnotations={annotationSend.handleClearBrowserAnnotations}
diff --git a/src/renderer/src/components/browser-pane/describe-page/browser-artifact-upload.test.ts b/src/renderer/src/components/browser-pane/describe-page/browser-artifact-upload.test.ts
index 5490e8de27a..c525d22a755 100644
--- a/src/renderer/src/components/browser-pane/describe-page/browser-artifact-upload.test.ts
+++ b/src/renderer/src/components/browser-pane/describe-page/browser-artifact-upload.test.ts
@@ -43,8 +43,15 @@ describe('browser artifact upload', () => {
       contentType: 'text/html',
       fileName: 'report.html'
     })
-    expect(stat).toHaveBeenCalledWith({ filePath: '/tmp/report.html' })
-    expect(readFile).toHaveBeenCalledWith({ filePath: '/tmp/report.html' })
+    // Why user-file: the user opened this page by URL, so it is shared from where it is.
+    expect(stat).toHaveBeenCalledWith({
+      filePath: '/tmp/report.html',
+      access: { kind: 'user-file' }
+    })
+    expect(readFile).toHaveBeenCalledWith({
+      filePath: '/tmp/report.html',
+      access: { kind: 'user-file' }
+    })
   })
 
   it('rejects oversized and unreadable files before upload', async () => {
diff --git a/src/renderer/src/components/browser-pane/describe-page/browser-artifact-upload.ts b/src/renderer/src/components/browser-pane/describe-page/browser-artifact-upload.ts
index 8288e2d306a..85a6ca22b0f 100644
--- a/src/renderer/src/components/browser-pane/describe-page/browser-artifact-upload.ts
+++ b/src/renderer/src/components/browser-pane/describe-page/browser-artifact-upload.ts
@@ -2,6 +2,7 @@ import type { ArtifactWriteRequest } from '../../../../../shared/artifacts'
 import { ARTIFACT_MAX_CONTENT_BYTES } from '../../../../../shared/artifacts'
 import { getRuntimePathBasename } from '../../../../../shared/cross-platform-path'
 import { ArtifactPublishPreparationError } from '@/components/artifacts/artifact-publish-flow'
+import { userNamedFileAccess } from '@/lib/local-file-access'
 
 export type ShareableBrowserArtifactFile = {
   fileName: string
@@ -44,14 +45,20 @@ export async function readBrowserHtmlArtifactRequest(url: string): Promise<Artif
     throw new ArtifactPublishPreparationError('unsupported')
   }
   try {
-    const stat = await window.api.fs.stat({ filePath: file.filePath })
+    const stat = await window.api.fs.stat({
+      filePath: file.filePath,
+      access: userNamedFileAccess()
+    })
     if (stat.isDirectory) {
       throw new ArtifactPublishPreparationError('unsupported')
     }
     if (stat.size > ARTIFACT_MAX_CONTENT_BYTES) {
       throw new ArtifactPublishPreparationError('too-large')
     }
-    const result = await window.api.fs.readFile({ filePath: file.filePath })
+    const result = await window.api.fs.readFile({
+      filePath: file.filePath,
+      access: userNamedFileAccess()
+    })
     if (result.isBinary) {
       throw new ArtifactPublishPreparationError('binary')
     }
diff --git a/src/renderer/src/components/browser-pane/navigate/navigate-browser-page-notebook-link.test.ts b/src/renderer/src/components/browser-pane/navigate/navigate-browser-page-notebook-link.test.ts
new file mode 100644
index 00000000000..38a0326840d
--- /dev/null
+++ b/src/renderer/src/components/browser-pane/navigate/navigate-browser-page-notebook-link.test.ts
@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({ statUserOpenedPath: vi.fn(), openFile: vi.fn() }))
+
+vi.mock('@/lib/connection-context', () => ({ getConnectionId: () => null }))
+vi.mock('@/lib/user-opened-local-path', () => ({ statUserOpenedPath: mocks.statUserOpenedPath }))
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({
+      settings: {},
+      allWorktrees: () => [{ id: 'wt-1', path: '/repo' }],
+      setActiveTabType: vi.fn(),
+      ensureWorktreeRootGroup: () => 'group-1',
+      openFile: mocks.openFile
+    })
+  }
+}))
+
+import { navigateBrowserPageToUrl } from './navigate-browser-page-url'
+
+function ref<T>(current: T): { current: T } {
+  return { current }
+}
+
+function openNotebookUrl(url: string): void {
+  navigateBrowserPageToUrl({
+    url,
+    browserTabId: 'tab-1',
+    worktreeId: 'wt-1',
+    activeLoadFailureRef: ref(null),
+    lastKnownWebviewUrlRef: ref(null),
+    trackNextLoadingEventRef: ref(false),
+    recoveryNavigationValidationRef: ref(null),
+    webviewRef: ref(null),
+    onSetUrlRef: ref(vi.fn()),
+    onUpdatePageStateRef: ref(vi.fn()),
+    setAddressBarValue: vi.fn(),
+    setResourceNotice: vi.fn(),
+    focusWebviewNow: () => true
+  })
+}
+
+describe('opening a file:// notebook from the browser', () => {
+  beforeEach(() => {
+    mocks.statUserOpenedPath.mockReset()
+    mocks.openFile.mockReset()
+  })
+
+  it('opens a project link that leads out of the project by its absolute path', async () => {
+    mocks.statUserOpenedPath.mockResolvedValue({ isDirectory: false, escapesWorktree: true })
+
+    openNotebookUrl('file:///repo/notebooks-link/analysis.ipynb')
+    await vi.waitFor(() => expect(mocks.openFile).toHaveBeenCalledTimes(1))
+
+    expect(mocks.openFile).toHaveBeenCalledWith(
+      expect.objectContaining({
+        filePath: '/repo/notebooks-link/analysis.ipynb',
+        relativePath: '/repo/notebooks-link/analysis.ipynb'
+      }),
+      expect.anything()
+    )
+  })
+
+  it('keeps an ordinary project notebook project-relative', async () => {
+    mocks.statUserOpenedPath.mockResolvedValue({ isDirectory: false, escapesWorktree: false })
+
+    openNotebookUrl('file:///repo/analysis.ipynb')
+    await vi.waitFor(() => expect(mocks.openFile).toHaveBeenCalledTimes(1))
+
+    expect(mocks.openFile).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: '/repo/analysis.ipynb', relativePath: 'analysis.ipynb' }),
+      expect.anything()
+    )
+  })
+})
diff --git a/src/renderer/src/components/browser-pane/navigate/navigate-browser-page-url.ts b/src/renderer/src/components/browser-pane/navigate/navigate-browser-page-url.ts
index 9627437b256..2f33e434982 100644
--- a/src/renderer/src/components/browser-pane/navigate/navigate-browser-page-url.ts
+++ b/src/renderer/src/components/browser-pane/navigate/navigate-browser-page-url.ts
@@ -2,11 +2,7 @@ import { detectLanguage } from '@/lib/language-detect'
 import { getConnectionId } from '@/lib/connection-context'
 import { isPathInsideWorktree, toWorktreeRelativePath } from '@/lib/terminal-links'
 import { useAppStore } from '@/store'
-import {
-  isRemoteRuntimeFileOperation,
-  statRuntimePath,
-  type RuntimeFileOperationArgs
-} from '@/runtime/runtime-file-client'
+import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
 import {
   normalizeBrowserNavigationUrl,
   redactKagiSessionToken
@@ -25,6 +21,7 @@ import type {
   BrowserTabPageState
 } from '../describe-page/browser-page-types'
 import type { MutableRefObject } from 'react'
+import { statUserOpenedPath } from '@/lib/user-opened-local-path'
 
 export type NavigateBrowserPageToUrlArgs = {
   url: string
@@ -107,17 +104,19 @@ export function navigateBrowserPageToUrl({
           worktreePath: activeWorktree?.path,
           connectionId: undefined
         }
-        if (!isRemoteRuntimeFileOperation(fileContext, notebookPath)) {
-          await window.api.fs.authorizeExternalPath({ targetPath: notebookPath })
-        }
-        const stat = await statRuntimePath(fileContext, notebookPath)
+        const stat = await statUserOpenedPath(fileContext, notebookPath)
         if (stat.isDirectory) {
           navigateBrowserUrl(url)
           return
         }
 
         let relativePath = notebookPath
-        if (activeWorktree?.path && isPathInsideWorktree(notebookPath, activeWorktree.path)) {
+        // Why: a project link out of the project keeps its absolute path, so it reads as user-named.
+        if (
+          activeWorktree?.path &&
+          !stat.escapesWorktree &&
+          isPathInsideWorktree(notebookPath, activeWorktree.path)
+        ) {
           relativePath = toWorktreeRelativePath(notebookPath, activeWorktree.path) ?? notebookPath
         }
 
diff --git a/src/renderer/src/components/cmd-j/PaletteFilterFieldOptions.tsx b/src/renderer/src/components/cmd-j/PaletteFilterFieldOptions.tsx
index 95372319a33..58557f0e8a4 100644
--- a/src/renderer/src/components/cmd-j/PaletteFilterFieldOptions.tsx
+++ b/src/renderer/src/components/cmd-j/PaletteFilterFieldOptions.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useVirtualizer } from '@tanstack/react-virtual'
 import { Check, ChevronLeft, SearchIcon } from 'lucide-react'
@@ -237,7 +238,7 @@ export function PaletteFilterFieldOptions({
           className="mr-2 size-3.5 shrink-0 text-muted-foreground/60"
           aria-hidden="true"
         />
-        <input
+        <ImeInput
           ref={inputRef}
           value={optionQuery}
           onChange={(event) => onOptionQueryChange(event.target.value)}
diff --git a/src/renderer/src/components/dashboard/launch-dashboard-agent.test.ts b/src/renderer/src/components/dashboard/launch-dashboard-agent.test.ts
index a86e9901835..f72a249b9c7 100644
--- a/src/renderer/src/components/dashboard/launch-dashboard-agent.test.ts
+++ b/src/renderer/src/components/dashboard/launch-dashboard-agent.test.ts
@@ -40,6 +40,7 @@ describe('launchDashboardAgent', () => {
     expect(mocks.getKnownWorktreeById).toHaveBeenCalledWith('folder:docs', 'ssh:docs')
     expect(mocks.setActiveWorktree).toHaveBeenCalledWith('folder:docs', 'ssh:docs')
     expect(mocks.launchAgentInNewTab).toHaveBeenCalledWith({
+      requestId: expect.any(String),
       agent: 'codex',
       worktreeId: 'folder:docs',
       launchSource: 'unknown'
diff --git a/src/renderer/src/components/dashboard/launch-dashboard-agent.ts b/src/renderer/src/components/dashboard/launch-dashboard-agent.ts
index be3b644e5a6..43ff278bd7c 100644
--- a/src/renderer/src/components/dashboard/launch-dashboard-agent.ts
+++ b/src/renderer/src/components/dashboard/launch-dashboard-agent.ts
@@ -1,4 +1,5 @@
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { useAppStore } from '@/store'
 import { getExecutionHostIdForWorktree } from '@/lib/worktree-runtime-owner'
 import type { DashboardSpawnAgentArgs } from '../../../../shared/dashboard-snapshot'
@@ -15,6 +16,7 @@ export function launchDashboardAgent({ worktreeId, agent }: DashboardSpawnAgentA
   state.setActiveWorktree(worktreeId, executionHostId)
   return (
     launchAgentInNewTab({
+      requestId: newAgentLaunchRequestId(),
       agent,
       worktreeId,
       launchSource: 'unknown'
diff --git a/src/renderer/src/components/diff-comments/DiffCommentCard.tsx b/src/renderer/src/components/diff-comments/DiffCommentCard.tsx
index 6becfe1fb34..7ccb561379e 100644
--- a/src/renderer/src/components/diff-comments/DiffCommentCard.tsx
+++ b/src/renderer/src/components/diff-comments/DiffCommentCard.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import { CornerDownLeft, Pencil, Trash } from 'lucide-react'
 import { useLayoutEffect, useRef, useState, type ReactNode } from 'react'
 import { Button } from '@/components/ui/button'
@@ -281,7 +282,7 @@ export function DiffCommentCard({
         {/* Body or Edit Mode */}
         {editing ? (
           <div className="flex flex-col gap-2 mt-1">
-            <textarea
+            <ImeTextarea
               ref={textareaRef}
               className="orca-diff-comment-popover-textarea"
               value={draft}
diff --git a/src/renderer/src/components/diff-comments/DiffCommentDraftCard.tsx b/src/renderer/src/components/diff-comments/DiffCommentDraftCard.tsx
index f81444106af..68d78c2a616 100644
--- a/src/renderer/src/components/diff-comments/DiffCommentDraftCard.tsx
+++ b/src/renderer/src/components/diff-comments/DiffCommentDraftCard.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from 'react'
 import { CornerDownLeft } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -211,7 +212,7 @@ export function DiffCommentDraftCard({
         </div>
 
         {/* Textarea */}
-        <textarea
+        <ImeTextarea
           ref={focusTextareaRef}
           className="orca-diff-comment-popover-textarea"
           placeholder={
diff --git a/src/renderer/src/components/diff-comments/DiffCommentPopover.tsx b/src/renderer/src/components/diff-comments/DiffCommentPopover.tsx
index 235c572216f..b03d95cf82f 100644
--- a/src/renderer/src/components/diff-comments/DiffCommentPopover.tsx
+++ b/src/renderer/src/components/diff-comments/DiffCommentPopover.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from 'react'
 import { CornerDownLeft } from 'lucide-react'
 import { toast } from 'sonner'
@@ -198,7 +199,7 @@ export function DiffCommentPopover({
                   { value0: lineNumber }
                 ))}
         </div>
-        <textarea
+        <ImeTextarea
           ref={focusTextareaRef}
           className="orca-diff-comment-popover-textarea"
           placeholder={placeholder}
diff --git a/src/renderer/src/components/diff-comments/diff-comment-zone-card.tsx b/src/renderer/src/components/diff-comments/diff-comment-zone-card.tsx
index d34de51a2bc..5eb6d312971 100644
--- a/src/renderer/src/components/diff-comments/diff-comment-zone-card.tsx
+++ b/src/renderer/src/components/diff-comments/diff-comment-zone-card.tsx
@@ -39,7 +39,8 @@ function getSingleCommentSendScopes(
         'This note'
       ),
       notes: comment.sentAt ? [] : [comment],
-      prompt: formatCommentPrompt ? formatCommentPrompt(comment) : formatDiffComments([comment])
+      formatPrompt: () =>
+        formatCommentPrompt ? formatCommentPrompt(comment) : formatDiffComments([comment])
     }
   ]
 }
diff --git a/src/renderer/src/components/diff-comments/useDiffCommentDecorator.commentable-lines.test.tsx b/src/renderer/src/components/diff-comments/useDiffCommentDecorator.commentable-lines.test.tsx
index 6e2c7bbac32..14ea929b86f 100644
--- a/src/renderer/src/components/diff-comments/useDiffCommentDecorator.commentable-lines.test.tsx
+++ b/src/renderer/src/components/diff-comments/useDiffCommentDecorator.commentable-lines.test.tsx
@@ -4,6 +4,16 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { DecoratedDiffComment } from './decorated-diff-comment'
 import type * as ReactDomClientModule from 'react-dom/client'
 import type * as DiffCommentZoneCardModule from './diff-comment-zone-card'
+import type { NotesSendMenu } from '../editor/NotesSendMenu'
+
+const notesMenuFixture = vi.hoisted(() => ({
+  NotesSendMenu: vi.fn<typeof NotesSendMenu>(() => {
+    throw new Error('Commentable-line lifecycle must not render the agent notes menu')
+  })
+}))
+
+// Remote review-note lifecycle does not exercise saved-note delivery.
+vi.mock('../editor/NotesSendMenu', () => ({ NotesSendMenu: notesMenuFixture.NotesSendMenu }))
 
 const storeFixture = vi.hoisted(() => ({
   activeGroupIdByWorktree: {},
@@ -121,7 +131,11 @@ beforeEach(() => {
 
 afterEach(() => {
   document.body.replaceChildren()
-  vi.clearAllMocks()
+  try {
+    expect(notesMenuFixture.NotesSendMenu).not.toHaveBeenCalled()
+  } finally {
+    vi.clearAllMocks()
+  }
 })
 
 function countingCommentableLines(length: number): {
diff --git a/src/renderer/src/components/editor/CsvViewer.tsx b/src/renderer/src/components/editor/CsvViewer.tsx
deleted file mode 100644
index 49d3a2ba51e..00000000000
--- a/src/renderer/src/components/editor/CsvViewer.tsx
+++ /dev/null
@@ -1,208 +0,0 @@
-import React, { useMemo, useRef, useState } from 'react'
-import { useVirtualizer } from '@tanstack/react-virtual'
-import { detectCsvDelimiter, parseCsv } from './csv-parse'
-import { CsvDelimiterPicker, type CsvDelimiterChoice } from './csv-delimiter-picker'
-import { translate } from '@/i18n/i18n'
-
-type CsvViewerProps = {
-  content: string
-  filePath: string
-}
-
-const ROW_HEIGHT = 28
-const OVERSCAN = 12
-const MIN_COL_PX = 80
-const MAX_COL_PX = 320
-const ROW_NUMBER_COL_PX = 48
-const CHAR_PX = 7
-
-// Why: CsvViewer is the table counterpart to source-mode Monaco for .csv/.tsv
-// files. Row virtualization via @tanstack/react-virtual keeps large files
-// (100k+ rows) responsive. We use CSS grid with a shared grid-template-columns
-// rather than a <table>, because absolutely-positioned virtualized rows break
-// a table's column-width synchronization — the header would size itself
-// independently of the body, leaving values squashed together.
-export default function CsvViewer({ content, filePath }: CsvViewerProps): React.JSX.Element {
-  const scrollRef = useRef<HTMLDivElement>(null)
-  const [delimiterChoice, setDelimiterChoice] = useState<CsvDelimiterChoice>('auto')
-  const detectedDelimiter = useMemo(
-    () => detectCsvDelimiter(filePath, content),
-    [filePath, content]
-  )
-  const delimiter =
-    delimiterChoice === 'auto'
-      ? detectedDelimiter
-      : delimiterChoice === 'comma'
-        ? ','
-        : delimiterChoice === 'semicolon'
-          ? ';'
-          : '\t'
-
-  const parsed = useMemo(() => parseCsv(content, delimiter), [content, delimiter])
-
-  // Why: memoize header/body split so their references stay stable across
-  // renders that don't change content. A top-level rest-destructure would
-  // slice the full rows array (100k+ on large files) on every render and
-  // produce a new `bodyRows` reference, invalidating the downstream
-  // `columnWidths`/`gridTemplate` memos below.
-  const { headerRow, bodyRows } = useMemo(() => {
-    if (parsed.rows.length === 0) {
-      return { headerRow: [] as string[], bodyRows: [] as string[][] }
-    }
-    const [head, ...rest] = parsed.rows
-    return { headerRow: head ?? [], bodyRows: rest }
-  }, [parsed])
-  const columnCount = parsed.maxColumns
-  const header = useMemo(() => {
-    const out = [...(headerRow ?? [])]
-    while (out.length < columnCount) {
-      out.push('')
-    }
-    return out
-  }, [headerRow, columnCount])
-
-  // Why: size each column to its widest-seen value (sampled) so headers and
-  // body cells stay aligned. We cap sampling to the first 200 rows to avoid
-  // scanning huge files; uncommon long values clip with ellipsis rather than
-  // blowing out the viewport width.
-  const columnWidths = useMemo(() => {
-    const widths = Array.from<number>({ length: columnCount }).fill(MIN_COL_PX)
-    const consider = (cell: string | undefined, idx: number): void => {
-      if (!cell) {
-        return
-      }
-      const w = Math.min(MAX_COL_PX, Math.max(MIN_COL_PX, cell.length * CHAR_PX + 24))
-      if (w > widths[idx]!) {
-        widths[idx] = w
-      }
-    }
-    header.forEach(consider)
-    const sampleLimit = Math.min(bodyRows.length, 200)
-    for (let i = 0; i < sampleLimit; i += 1) {
-      const row = bodyRows[i]!
-      for (let c = 0; c < columnCount; c += 1) {
-        consider(row[c], c)
-      }
-    }
-    return widths
-  }, [header, bodyRows, columnCount])
-
-  const gridTemplate = useMemo(
-    () => `${ROW_NUMBER_COL_PX}px ${columnWidths.map((w) => `${w}px`).join(' ')}`,
-    [columnWidths]
-  )
-
-  const virtualizer = useVirtualizer({
-    count: bodyRows.length,
-    getScrollElement: () => scrollRef.current,
-    estimateSize: () => ROW_HEIGHT,
-    overscan: OVERSCAN,
-    getItemKey: (index) => index
-  })
-
-  if (parsed.rows.length === 0) {
-    return (
-      <div className="flex h-full items-center justify-center text-sm text-muted-foreground">
-        {translate('auto.components.editor.CsvViewer.a233d55b77', 'Empty file')}
-      </div>
-    )
-  }
-
-  const virtualRows = virtualizer.getVirtualItems()
-  const totalHeight = virtualizer.getTotalSize()
-
-  return (
-    <div className="flex h-full min-h-0 flex-col">
-      <div
-        ref={scrollRef}
-        className="relative min-h-0 flex-1 overflow-auto scrollbar-editor font-mono text-xs"
-      >
-        <div
-          role="table"
-          aria-rowcount={parsed.rows.length}
-          aria-colcount={columnCount + 1}
-          className="inline-block min-w-full"
-          style={{ width: 'max-content' }}
-        >
-          <div
-            role="row"
-            aria-rowindex={1}
-            className="sticky top-0 z-10 grid bg-muted/90 backdrop-blur"
-            style={{ gridTemplateColumns: gridTemplate, height: ROW_HEIGHT }}
-          >
-            <div
-              role="columnheader"
-              className="sticky left-0 z-20 flex items-center justify-end border-b border-r border-border/60 bg-muted/90 px-2 text-[10px] font-normal text-muted-foreground"
-            >
-              #
-            </div>
-            {header.map((cell, idx) => (
-              <div
-                role="columnheader"
-                key={idx}
-                className="flex items-center overflow-hidden border-b border-r border-border/60 px-2 font-medium text-foreground"
-              >
-                <span className="truncate" title={cell}>
-                  {cell}
-                </span>
-              </div>
-            ))}
-          </div>
-          <div style={{ height: totalHeight, position: 'relative' }}>
-            {virtualRows.map((vr) => {
-              const row = bodyRows[vr.index] ?? []
-              return (
-                <div
-                  role="row"
-                  aria-rowindex={vr.index + 2}
-                  key={vr.key}
-                  data-index={vr.index}
-                  className="group grid hover:bg-accent/40"
-                  style={{
-                    gridTemplateColumns: gridTemplate,
-                    position: 'absolute',
-                    top: 0,
-                    left: 0,
-                    height: ROW_HEIGHT,
-                    transform: `translateY(${vr.start}px)`
-                  }}
-                >
-                  <div
-                    role="rowheader"
-                    className="sticky left-0 z-[5] flex items-center justify-end border-b border-r border-border/40 bg-background/95 px-2 text-[10px] text-muted-foreground group-hover:bg-accent/40"
-                  >
-                    {vr.index + 1}
-                  </div>
-                  {Array.from({ length: columnCount }).map((_, colIdx) => (
-                    <div
-                      role="cell"
-                      key={colIdx}
-                      className="flex items-center overflow-hidden border-b border-r border-border/40 px-2 text-foreground"
-                      title={row[colIdx] ?? ''}
-                    >
-                      <span className="truncate">{row[colIdx] ?? ''}</span>
-                    </div>
-                  ))}
-                </div>
-              )
-            })}
-          </div>
-        </div>
-      </div>
-      <div className="flex flex-wrap items-center gap-4 border-t border-border/60 px-3 py-1 text-xs text-muted-foreground">
-        <span>
-          {bodyRows.length.toLocaleString()}{' '}
-          {translate('auto.components.editor.CsvViewer.ac31d2cd60', 'rows')}
-        </span>
-        <span>
-          {columnCount} {translate('auto.components.editor.CsvViewer.eedd0d37a7', 'columns')}
-        </span>
-        <CsvDelimiterPicker
-          value={delimiterChoice}
-          detectedDelimiter={detectedDelimiter}
-          onChange={setDelimiterChoice}
-        />
-      </div>
-    </div>
-  )
-}
diff --git a/src/renderer/src/components/editor/DiffNotesSendMenu.tsx b/src/renderer/src/components/editor/DiffNotesSendMenu.tsx
index d5ce2434449..08a0e07440a 100644
--- a/src/renderer/src/components/editor/DiffNotesSendMenu.tsx
+++ b/src/renderer/src/components/editor/DiffNotesSendMenu.tsx
@@ -54,20 +54,18 @@ export function DiffNotesSendMenu({
     [consumeOpenRequest, worktreeId]
   )
   const unsentNotes = useMemo(() => comments.filter((comment) => !comment.sentAt), [comments])
-  const unsentPrompt = useMemo(() => formatDiffComments(unsentNotes), [unsentNotes])
   const fileNotes = useMemo(
     () => (filePath ? comments.filter((comment) => comment.filePath === filePath) : []),
     [comments, filePath]
   )
   const unsentFileNotes = useMemo(() => fileNotes.filter((comment) => !comment.sentAt), [fileNotes])
-  const unsentFilePrompt = useMemo(() => formatDiffComments(unsentFileNotes), [unsentFileNotes])
   const canSendFileScope = showFileScope && Boolean(filePath)
   const scopes = useMemo<NotesSendMenuScope<DiffComment>[]>(() => {
     const allNotesScope = {
       id: 'all',
       label: translate('auto.components.editor.DiffNotesSendMenu.8b87612461', 'All unsent notes'),
       notes: unsentNotes,
-      prompt: unsentPrompt
+      formatPrompt: formatDiffComments
     }
     if (!canSendFileScope) {
       return [allNotesScope]
@@ -77,11 +75,11 @@ export function DiffNotesSendMenu({
         id: 'file',
         label: translate('auto.components.editor.DiffNotesSendMenu.f1aa04b5cf', 'This file'),
         notes: unsentFileNotes,
-        prompt: unsentFilePrompt
+        formatPrompt: formatDiffComments
       },
       allNotesScope
     ]
-  }, [canSendFileScope, unsentFileNotes, unsentFilePrompt, unsentNotes, unsentPrompt])
+  }, [canSendFileScope, unsentFileNotes, unsentNotes])
 
   return (
     <NotesSendMenu
diff --git a/src/renderer/src/components/editor/EditorEditFileSurface.tsx b/src/renderer/src/components/editor/EditorEditFileSurface.tsx
index 899460fb3e2..19630186727 100644
--- a/src/renderer/src/components/editor/EditorEditFileSurface.tsx
+++ b/src/renderer/src/components/editor/EditorEditFileSurface.tsx
@@ -6,6 +6,7 @@ import { ChangesModeView } from './ChangesModeView'
 import { ConflictBanner, ConflictPlaceholderView } from './ConflictComponents'
 import {
   CsvViewer,
+  CsvPagedViewer,
   ImageViewer,
   IpynbViewer,
   MermaidViewer,
@@ -100,6 +101,17 @@ export function EditorEditFileSurface({
       </div>
     )
   }
+  if (fileContent.csvPreview) {
+    return (
+      <CsvPagedViewer
+        key={activeFile.id}
+        file={fileContent.csvPreview}
+        preferenceKey={pdfPreferenceKey}
+        filePath={activeFile.filePath}
+        onReload={() => reloadContent(activeFile)}
+      />
+    )
+  }
   if (fileContent.loadError) {
     return (
       <EditorFileLoadErrorView
@@ -243,7 +255,19 @@ export function EditorEditFileSurface({
   ) : isMermaid && mdViewMode === 'rich' ? (
     <MermaidViewer key={activeFile.id} content={currentContent} filePath={activeFile.filePath} />
   ) : isCsv && mdViewMode === 'rich' ? (
-    <CsvViewer key={activeFile.id} content={currentContent} filePath={activeFile.filePath} />
+    <CsvViewer
+      key={activeFile.id}
+      content={currentContent}
+      filePath={activeFile.filePath}
+      worktreeId={activeFile.worktreeId}
+      runtimeEnvironmentId={activeFile.runtimeEnvironmentId}
+      preferenceKey={pdfPreferenceKey}
+      fileId={activeFile.id}
+      isDirty={activeFile.isDirty}
+      onDirtyStateHint={activeFile.readOnly ? undefined : handleDirtyStateHint}
+      onContentChange={activeFile.readOnly ? undefined : handleContentChange}
+      onSave={activeFile.readOnly ? undefined : handleSave}
+    />
   ) : isNotebook && mdViewMode === 'rich' ? (
     <IpynbViewer
       key={activeFile.id}
diff --git a/src/renderer/src/components/editor/EditorPanelHeader.tsx b/src/renderer/src/components/editor/EditorPanelHeader.tsx
index 5a211d08520..b16ea92587b 100644
--- a/src/renderer/src/components/editor/EditorPanelHeader.tsx
+++ b/src/renderer/src/components/editor/EditorPanelHeader.tsx
@@ -269,7 +269,7 @@ export function EditorPanelHeader({
           </Tooltip>
         </TooltipProvider>
       )}
-      {hasEditorToggle && (
+      {hasEditorToggle && !activeFile.csvPreviewOnly && (
         <EditorViewToggle
           value={effectiveToggleValue}
           modes={availableEditorToggleModes}
diff --git a/src/renderer/src/components/editor/EditorPanelHeaderPath.test.tsx b/src/renderer/src/components/editor/EditorPanelHeaderPath.test.tsx
index 14fd66b266d..0ffd1ac3cda 100644
--- a/src/renderer/src/components/editor/EditorPanelHeaderPath.test.tsx
+++ b/src/renderer/src/components/editor/EditorPanelHeaderPath.test.tsx
@@ -134,7 +134,8 @@ describe('EditorPanelHeaderPath inline rename', () => {
       oldPath: '/repo/notes.md',
       newName: 'renamed.mdx',
       worktreeId: 'wt-1',
-      worktreePath: '/repo'
+      worktreePath: '/repo',
+      documentScoped: false
     })
   })
 
@@ -160,19 +161,39 @@ describe('EditorPanelHeaderPath inline rename', () => {
     expect(renameFileOnDiskMock).not.toHaveBeenCalled()
   })
 
-  it('ignores an Enter that only confirms an IME candidate', () => {
+  it('ignores IME confirmation and its redispatch before accepting deliberate Enter', () => {
     renderPath(baseFile())
     openRenameInput()
 
     const input = getRenameInput('Rename file notes.md')
-    fireEvent.change(input, { target: { value: 'renamed.md' } })
-    fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
-    expect(renameFileOnDiskMock).not.toHaveBeenCalled()
+    const frames: FrameRequestCallback[] = []
+    const raf = vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
+      frames.push(callback)
+      return frames.length
+    })
+    try {
+      fireEvent.compositionStart(input)
+      fireEvent.change(input, { target: { value: 'renamed.md' } })
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
+      fireEvent.compositionEnd(input)
+      fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+      expect(renameFileOnDiskMock).not.toHaveBeenCalled()
 
-    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
-    expect(renameFileOnDiskMock).toHaveBeenCalledWith(
-      expect.objectContaining({ newName: 'renamed.md' })
-    )
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+      expect(renameFileOnDiskMock).not.toHaveBeenCalled()
+      expect(getRenameInput('Rename file notes.md')).toBe(input)
+
+      fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+      for (const frame of frames) {
+        frame(0)
+      }
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+      expect(renameFileOnDiskMock).toHaveBeenCalledExactlyOnceWith(
+        expect.objectContaining({ newName: 'renamed.md' })
+      )
+    } finally {
+      raf.mockRestore()
+    }
   })
 
   it('cancels on Escape without a trailing blur-commit, and ignores empty renames', () => {
diff --git a/src/renderer/src/components/editor/EditorPanelHeaderPath.tsx b/src/renderer/src/components/editor/EditorPanelHeaderPath.tsx
index 3ecd1e6e3d5..4b063019a78 100644
--- a/src/renderer/src/components/editor/EditorPanelHeaderPath.tsx
+++ b/src/renderer/src/components/editor/EditorPanelHeaderPath.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import { useEffect, useRef, useState } from 'react'
 import { Copy, ExternalLink, Eye, Pencil } from 'lucide-react'
 import {
@@ -88,7 +89,7 @@ export function EditorPanelHeaderPath({
         }}
       >
         {isRenaming ? (
-          <input
+          <ImeInput
             ref={renameInputRef}
             data-editor-header-rename-input="true"
             aria-label={translate(
diff --git a/src/renderer/src/components/editor/EditorViewToggle.tsx b/src/renderer/src/components/editor/EditorViewToggle.tsx
index 2a097af088a..ef8ebd95610 100644
--- a/src/renderer/src/components/editor/EditorViewToggle.tsx
+++ b/src/renderer/src/components/editor/EditorViewToggle.tsx
@@ -66,9 +66,7 @@ const DEFAULT_VIEW_MODE_METADATA: Record<EditorToggleValue, ViewModeMetadata> =
   }
 }
 
-// Why: CSV/TSV files reuse the 'rich' view mode slot but the rendered surface
-// is a read-only table, not an editor. The Pencil icon implies editability,
-// which we don't offer, so callers can override the per-mode presentation.
+// CSV/TSV uses a table icon for both editable tables and read-only previews.
 export const CSV_VIEW_MODE_METADATA: Partial<Record<MarkdownViewMode, ViewModeMetadata>> = {
   rich: {
     get label() {
diff --git a/src/renderer/src/components/editor/ExternalFileChangeBanner.test.tsx b/src/renderer/src/components/editor/ExternalFileChangeBanner.test.tsx
index eae2909bef5..a4c6598b307 100644
--- a/src/renderer/src/components/editor/ExternalFileChangeBanner.test.tsx
+++ b/src/renderer/src/components/editor/ExternalFileChangeBanner.test.tsx
@@ -19,7 +19,9 @@ vi.mock('@/runtime/runtime-rpc-client', () => ({
   settingsForRuntimeOwner: () => null
 }))
 vi.mock('@/lib/connection-context', () => ({
-  getConnectionIdForFile: () => undefined
+  // Why: the floating workspace is always client-local; other owners are still loading.
+  getConnectionIdForFile: (worktreeId: string) =>
+    worktreeId === 'global-floating-terminal' ? null : undefined
 }))
 
 import {
@@ -228,4 +230,21 @@ describe('ExternalFileChangeBanner', () => {
 
     expect(setLastKnownDiskSignature).not.toHaveBeenCalled()
   })
+
+  it.each([
+    [
+      'a floating-workspace tab, as the file the user named',
+      'global-floating-terminal',
+      'user-file'
+    ],
+    ['a project tab, inside its root', 'wt-1', undefined]
+  ])('keep-my-edits reads %s', async (_label, worktreeId, kind) => {
+    const tab: OpenFile = { ...file, worktreeId }
+    mockStoreState({}, [tab])
+
+    keepTabEditsOverExternalChange(tab)
+    await Promise.resolve()
+
+    expect(readRuntimeFileContentMock.mock.calls[0]?.[0]?.access?.kind).toBe(kind)
+  })
 })
diff --git a/src/renderer/src/components/editor/ExternalFileChangeBanner.tsx b/src/renderer/src/components/editor/ExternalFileChangeBanner.tsx
index dda2fd2d547..71a11eaa775 100644
--- a/src/renderer/src/components/editor/ExternalFileChangeBanner.tsx
+++ b/src/renderer/src/components/editor/ExternalFileChangeBanner.tsx
@@ -3,6 +3,7 @@ import { TriangleAlert } from 'lucide-react'
 import { toast } from 'sonner'
 import { Button } from '@/components/ui/button'
 import { getConnectionIdForFile } from '@/lib/connection-context'
+import { editorTabFileAccess } from '@/lib/local-file-access'
 import { readRuntimeFileContent } from '@/runtime/runtime-file-client'
 import { settingsForRuntimeOwner } from '@/runtime/runtime-rpc-client'
 import { useAppStore } from '@/store'
@@ -92,7 +93,8 @@ export function keepTabEditsOverExternalChange(file: OpenFile): void {
     relativePath: file.relativePath,
     worktreeId: file.worktreeId,
     connectionId: getConnectionIdForFile(file.worktreeId, file.filePath) ?? undefined,
-    expectedExternalSshTargetId: file.externalSshTargetId
+    expectedExternalSshTargetId: file.externalSshTargetId,
+    access: editorTabFileAccess(state, file)
   })
     .then((result) => {
       if (result.isBinary) {
diff --git a/src/renderer/src/components/editor/ExternalFileChangeCompareDialog.test.tsx b/src/renderer/src/components/editor/ExternalFileChangeCompareDialog.test.tsx
index 2a906005555..799cf3d7285 100644
--- a/src/renderer/src/components/editor/ExternalFileChangeCompareDialog.test.tsx
+++ b/src/renderer/src/components/editor/ExternalFileChangeCompareDialog.test.tsx
@@ -139,4 +139,30 @@ describe('ExternalFileChangeCompareDialog', () => {
     })
     expect(onKeepEdits).toHaveBeenCalledTimes(1)
   })
+
+  it.each([
+    [
+      'a floating-workspace tab as the file the user named',
+      'global-floating-terminal',
+      null,
+      'user-file'
+    ],
+    ['a project tab inside its root', 'wt-1', null, undefined]
+  ])('reads %s', async (_label, worktreeId, connectionId, kind) => {
+    mocks.getConnectionIdForFile.mockReturnValue(connectionId)
+    mocks.readRuntimeFileContent.mockResolvedValue({ content: 'disk version', isBinary: false })
+
+    await render(
+      <ExternalFileChangeCompareDialog
+        file={{ ...file, worktreeId }}
+        currentContent="buffer version"
+        open
+        onOpenChange={vi.fn()}
+        onReload={vi.fn()}
+        onKeepEdits={vi.fn()}
+      />
+    )
+
+    expect(mocks.readRuntimeFileContent.mock.calls[0]?.[0]?.access?.kind).toBe(kind)
+  })
 })
diff --git a/src/renderer/src/components/editor/ExternalFileChangeCompareDialog.tsx b/src/renderer/src/components/editor/ExternalFileChangeCompareDialog.tsx
index cb8230c3344..26cd9fbe95f 100644
--- a/src/renderer/src/components/editor/ExternalFileChangeCompareDialog.tsx
+++ b/src/renderer/src/components/editor/ExternalFileChangeCompareDialog.tsx
@@ -11,6 +11,7 @@ import {
 } from '@/components/ui/dialog'
 import { lazyWithRetry as lazy } from '@/lib/lazy-with-retry'
 import { getConnectionIdForFile } from '@/lib/connection-context'
+import { editorTabFileAccess } from '@/lib/local-file-access'
 import { detectLanguage } from '@/lib/language-detect'
 import { readRuntimeFileContent } from '@/runtime/runtime-file-client'
 import { settingsForRuntimeOwner } from '@/runtime/runtime-rpc-client'
@@ -46,6 +47,7 @@ export function ExternalFileChangeCompareDialog({
   onKeepEdits: () => void
 }): React.JSX.Element {
   const [diskState, setDiskState] = useState<DiskReadState>({ kind: 'loading' })
+  const access = editorTabFileAccess(useAppStore.getState(), file)
 
   useEffect(() => {
     if (!open) {
@@ -61,7 +63,8 @@ export function ExternalFileChangeCompareDialog({
       relativePath: file.relativePath,
       worktreeId: file.worktreeId,
       connectionId: getConnectionIdForFile(file.worktreeId, file.filePath) ?? undefined,
-      expectedExternalSshTargetId: file.externalSshTargetId
+      expectedExternalSshTargetId: file.externalSshTargetId,
+      access
     })
       .then((result) => {
         if (cancelled) {
@@ -89,7 +92,8 @@ export function ExternalFileChangeCompareDialog({
     file.relativePath,
     file.worktreeId,
     file.runtimeEnvironmentId,
-    file.externalSshTargetId
+    file.externalSshTargetId,
+    access
   ])
 
   const language = detectLanguage(file.relativePath)
diff --git a/src/renderer/src/components/editor/IpynbViewer.tsx b/src/renderer/src/components/editor/IpynbViewer.tsx
index 7b33d98952c..c3f5aaf2efa 100644
--- a/src/renderer/src/components/editor/IpynbViewer.tsx
+++ b/src/renderer/src/components/editor/IpynbViewer.tsx
@@ -1,3 +1,4 @@
+import { isImeOwnedKeyboardEvent } from '@/lib/ime-composition-keyboard-event'
 import { useCallback, useMemo, useState } from 'react'
 import { AlertCircle, Save } from 'lucide-react'
 import { computeEditorFontSize } from '@/lib/editor-font-zoom'
@@ -119,7 +120,12 @@ export default function IpynbViewer({
   ): void => {
     const mod = getShortcutPlatform() === 'darwin' ? event.metaKey : event.ctrlKey
     // Exactly one of Shift or Cmd/Ctrl.
-    if (event.key !== 'Enter' || event.altKey || event.shiftKey === mod) {
+    if (
+      isImeOwnedKeyboardEvent(event) ||
+      event.key !== 'Enter' ||
+      event.altKey ||
+      event.shiftKey === mod
+    ) {
       return
     }
     event.preventDefault()
diff --git a/src/renderer/src/components/editor/MarkdownPreview.image-access.test.tsx b/src/renderer/src/components/editor/MarkdownPreview.image-access.test.tsx
new file mode 100644
index 00000000000..7e815d20f43
--- /dev/null
+++ b/src/renderer/src/components/editor/MarkdownPreview.image-access.test.tsx
@@ -0,0 +1,111 @@
+// @vitest-environment happy-dom
+//
+// Renders the real MarkdownPreview and pins the file access its images are read with: a resource of the
+// document showing them, so main limits them to that document's roots or folder.
+
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const useLocalImageSrcSpy = vi.hoisted(() => vi.fn((src?: string, ..._context: unknown[]) => src))
+
+const storeState = {
+  openFile: vi.fn(),
+  activateMarkdownLink: vi.fn(),
+  openMarkdownPreview: vi.fn(),
+  setMarkdownViewMode: vi.fn(),
+  markdownFrontmatterVisible: {},
+  setPendingEditorReveal: vi.fn(),
+  addDiffComment: vi.fn(),
+  deleteDiffComment: vi.fn(),
+  updateDiffComment: vi.fn(),
+  clearDeliveredDiffComments: vi.fn(),
+  keybindings: {},
+  worktreesByRepo: {},
+  repos: [],
+  folderWorkspaces: [],
+  projectGroups: [],
+  openFiles: [],
+  activeFileIdByWorktree: {},
+  settings: { openLinksInApp: true },
+  editorFontZoomLevel: 0
+}
+
+vi.mock('@/store', () => {
+  const useAppStore = Object.assign(
+    (selector: (s: typeof storeState) => unknown) => selector(storeState),
+    { getState: () => storeState }
+  )
+  return { useAppStore }
+})
+vi.mock('@/store/slices/worktree-helpers', () => ({ findWorktreeById: () => null }))
+vi.mock('@/runtime/runtime-rpc-client', () => ({
+  settingsForRuntimeOwner: (settings: unknown) => settings
+}))
+vi.mock('@/runtime/runtime-file-client', () => ({
+  statRuntimePath: vi.fn(async () => ({ isDirectory: false }))
+}))
+vi.mock('@/lib/connection-context', () => ({ getConnectionIdForFile: () => null }))
+vi.mock('@/lib/connection-owner-resolution', () => ({
+  createConnectionIdForFileSelector: () => () => null
+}))
+vi.mock('@/i18n/i18n', () => ({
+  i18n: { language: 'en' },
+  translate: (_key: string, fallback: string) => fallback
+}))
+vi.mock('./useLocalImageSrc', () => ({ useLocalImageSrc: useLocalImageSrcSpy }))
+vi.mock('./markdown-preview-local-images', () => ({
+  prewarmMarkdownPreviewLocalImages: () => ({ cancel: () => {}, done: Promise.resolve() })
+}))
+vi.mock('./MermaidBlock', () => ({ default: () => null }))
+vi.mock('./CodeBlockCopyButton', () => ({
+  default: ({ children }: { children: React.ReactNode }) => children
+}))
+vi.mock('../diff-comments/DiffCommentCard', () => ({ DiffCommentCard: () => null }))
+vi.mock('./NotesSendMenu', () => ({ NotesSendMenu: () => null }))
+vi.mock('./MarkdownTableOfContentsPanel', () => ({ MarkdownTableOfContentsPanel: () => null }))
+
+import MarkdownPreview from './MarkdownPreview'
+
+describe('MarkdownPreview images', () => {
+  let container: HTMLDivElement
+  let root: Root
+
+  beforeEach(() => {
+    vi.stubGlobal('api', {
+      shell: { openUrl: vi.fn(), openFileUri: vi.fn(), pathExists: vi.fn(async () => true) },
+      ui: { writeClipboardText: vi.fn(async () => true) }
+    })
+    useLocalImageSrcSpy.mockClear()
+    container = document.createElement('div')
+    document.body.appendChild(container)
+    root = createRoot(container)
+  })
+
+  afterEach(() => {
+    act(() => {
+      root.unmount()
+    })
+    container.remove()
+    vi.unstubAllGlobals()
+  })
+
+  it('reads each image as a resource of the document showing it', () => {
+    act(() => {
+      root.render(
+        <MarkdownPreview
+          content="![Logo](./logo.png)"
+          filePath="/notes/readme.md"
+          sourceWorktreeId="wt-1"
+          scrollCacheKey="test-key"
+        />
+      )
+    })
+
+    expect(useLocalImageSrcSpy.mock.calls[0]?.[0]).toBe('./logo.png')
+    expect(useLocalImageSrcSpy.mock.calls[0]?.[4]).toEqual({
+      kind: 'document-resource',
+      documentPath: '/notes/readme.md'
+    })
+  })
+})
diff --git a/src/renderer/src/components/editor/MarkdownPreviewAnnotationComposer.tsx b/src/renderer/src/components/editor/MarkdownPreviewAnnotationComposer.tsx
index d13d8e9b066..7bb8a832b17 100644
--- a/src/renderer/src/components/editor/MarkdownPreviewAnnotationComposer.tsx
+++ b/src/renderer/src/components/editor/MarkdownPreviewAnnotationComposer.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { CornerDownLeft } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -32,7 +33,7 @@ export function MarkdownPreviewSingleNoteSendMenu({
           id: 'note',
           label: translate('auto.components.editor.MarkdownPreview.f37b98999e', 'This note'),
           notes: note.sentAt ? [] : [note],
-          prompt: formatMarkdownReviewNotes([note], content)
+          formatPrompt: (notes) => formatMarkdownReviewNotes(notes, content)
         }
       ]}
       targetModeLabel="This note"
@@ -101,7 +102,7 @@ export function MarkdownPreviewAnnotationComposer({
       <div className="orca-diff-comment-popover-label">
         {translate('auto.components.editor.MarkdownPreview.b1bfc04034', 'Selected text')}
       </div>
-      <textarea
+      <ImeTextarea
         ref={focusTextareaRef}
         className="orca-diff-comment-popover-textarea"
         placeholder={translate(
diff --git a/src/renderer/src/components/editor/MonacoEditor.content-owner.test.tsx b/src/renderer/src/components/editor/MonacoEditor.content-owner.test.tsx
index 790752921e2..68c8740eda6 100644
--- a/src/renderer/src/components/editor/MonacoEditor.content-owner.test.tsx
+++ b/src/renderer/src/components/editor/MonacoEditor.content-owner.test.tsx
@@ -1,12 +1,39 @@
 // @vitest-environment happy-dom
 import { cleanup, render } from '@testing-library/react'
+import { useEffect } from 'react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
+import { buildOwnedEditorFileId } from '@/store/slices/editor/file-ids/editor-file-ids'
+import type { OpenFile } from '@/store/slices/editor'
+import type { WorktreeOperationRouteState } from '@/lib/worktree-operation-route'
 
-const editorProps = vi.hoisted(() => ({ current: null as Record<string, unknown> | null }))
+const editorProps = vi.hoisted(() => {
+  const state: {
+    current: Record<string, unknown> | null
+    files: OpenFile[]
+    ownerCatalog: WorktreeOperationRouteState
+    mounts: unknown[]
+    unmounts: unknown[]
+  } = {
+    current: null,
+    files: [],
+    ownerCatalog: {
+      worktreesByRepo: { local: [{ id: 'local-worktree', repoId: 'local', hostId: 'local' }] }
+    },
+    mounts: [],
+    unmounts: []
+  }
+  return state
+})
 
 vi.mock('@monaco-editor/react', () => ({
-  default: (props: Record<string, unknown>) => {
+  default: function MockEditor(props: Record<string, unknown>) {
     editorProps.current = props
+    useEffect(() => {
+      editorProps.mounts.push(props.path)
+      return () => {
+        editorProps.unmounts.push(props.path)
+      }
+    }, [props.path])
     return null
   },
   loader: { config: vi.fn() }
@@ -16,6 +43,8 @@ vi.mock('@/store', () => ({
     selector({
       settings: { theme: 'dark', terminalFontSize: 13, terminalFontFamily: 'monospace' },
       editorFontZoomLevel: 0,
+      openFiles: editorProps.files,
+      ...editorProps.ownerCatalog,
       setPendingEditorReveal: vi.fn(),
       setEditorCursorLine: vi.fn(),
       addDiffComment: vi.fn(),
@@ -38,6 +67,12 @@ import MonacoEditor from './MonacoEditor'
 afterEach(() => {
   cleanup()
   editorProps.current = null
+  editorProps.files = []
+  editorProps.ownerCatalog = {
+    worktreesByRepo: { local: [{ id: 'local-worktree', repoId: 'local', hostId: 'local' }] }
+  }
+  editorProps.mounts = []
+  editorProps.unmounts = []
 })
 
 describe('MonacoEditor content ownership', () => {
@@ -59,4 +94,91 @@ describe('MonacoEditor content ownership', () => {
     expect(editorProps.current?.defaultValue).toBe('initial content')
     expect(editorProps.current).not.toHaveProperty('value')
   })
+
+  it('isolates same-path files on different hosts while sharing split panes', () => {
+    const filePath = '/srv/repo/file.ts'
+    const ownedId = buildOwnedEditorFileId(filePath, 'ssh-worktree', 'remote-runtime')
+    editorProps.files = [
+      {
+        id: filePath,
+        filePath,
+        relativePath: 'file.ts',
+        worktreeId: 'local-worktree',
+        mode: 'edit',
+        language: 'typescript',
+        isDirty: false
+      },
+      {
+        id: ownedId,
+        filePath,
+        relativePath: 'file.ts',
+        worktreeId: 'ssh-worktree',
+        runtimeEnvironmentId: 'remote-runtime',
+        mode: 'edit',
+        language: 'typescript',
+        isDirty: false
+      }
+    ]
+    const props = {
+      filePath,
+      relativePath: 'file.ts',
+      language: 'typescript',
+      onContentChange: vi.fn(),
+      onSave: vi.fn()
+    }
+    const local = render(
+      <MonacoEditor {...props} fileId={filePath} viewStateKey="local-pane" content="local" />
+    )
+    const localModel = editorProps.current?.path
+    local.unmount()
+    const remote = render(
+      <MonacoEditor {...props} fileId={ownedId} viewStateKey="remote-pane" content="remote" />
+    )
+    const remoteModel = editorProps.current?.path
+    expect(remoteModel).not.toBe(localModel)
+    remote.unmount()
+    render(<MonacoEditor {...props} fileId={ownedId} viewStateKey="split-pane" content="remote" />)
+    expect(editorProps.current?.path).toBe(remoteModel)
+  })
+
+  it('keeps the current draft when restored ownership resolves and remounts the widget', () => {
+    const file: OpenFile = {
+      id: 'restored-file',
+      filePath: '/repo/restored.ts',
+      relativePath: 'restored.ts',
+      worktreeId: 'restored-worktree',
+      mode: 'edit',
+      language: 'typescript',
+      isDirty: true
+    }
+    editorProps.files = [file]
+    editorProps.ownerCatalog = {}
+    const onContentChange = vi.fn()
+    const props = {
+      fileId: file.id,
+      filePath: file.filePath,
+      viewStateKey: 'pane:restored-file',
+      relativePath: file.relativePath,
+      language: file.language,
+      onContentChange,
+      onSave: vi.fn()
+    }
+    const rendered = render(<MonacoEditor {...props} content="restored draft" />)
+    const unresolvedModel = editorProps.current?.path
+    rendered.rerender(<MonacoEditor {...props} content="latest dirty draft" />)
+    expect(editorProps.mounts).toEqual([unresolvedModel])
+
+    editorProps.ownerCatalog = {
+      worktreesByRepo: {
+        repo: [{ id: file.worktreeId, repoId: 'repo', hostId: 'local' }]
+      }
+    }
+    rendered.rerender(<MonacoEditor {...props} content="latest dirty draft" />)
+
+    const resolvedModel = editorProps.current?.path
+    expect(resolvedModel).not.toBe(unresolvedModel)
+    expect(editorProps.current?.defaultValue).toBe('latest dirty draft')
+    expect(editorProps.mounts).toEqual([unresolvedModel, resolvedModel])
+    expect(editorProps.unmounts).toEqual([unresolvedModel])
+  })
 })
diff --git a/src/renderer/src/components/editor/MonacoEditor.owner-view-state.test.tsx b/src/renderer/src/components/editor/MonacoEditor.owner-view-state.test.tsx
new file mode 100644
index 00000000000..f8e3605ab78
--- /dev/null
+++ b/src/renderer/src/components/editor/MonacoEditor.owner-view-state.test.tsx
@@ -0,0 +1,161 @@
+// @vitest-environment happy-dom
+import { act, cleanup, render, waitFor } from '@testing-library/react'
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js'
+import { afterEach, expect, it, vi } from 'vitest'
+import type { AppState } from '@/store/types'
+import { createTestStore, makeWorktree } from '@/store/slices/store-test-helpers'
+import type { OpenFile } from '@/store/slices/editor'
+import { editorSelectionCache, scrollTopCache } from '@/lib/scroll-cache'
+import { getDefaultSettings } from '../../../../shared/constants'
+
+const testState = vi.hoisted(() => {
+  const state: { store: ReturnType<typeof createTestStore> | null } = { store: null }
+  return state
+})
+
+vi.mock('@/store', () => {
+  const getStore = () => {
+    if (!testState.store) {
+      throw new Error('Missing test store')
+    }
+    return testState.store
+  }
+  return {
+    useAppStore: Object.assign((selector: (state: AppState) => unknown) => getStore()(selector), {
+      getState: () => getStore().getState()
+    })
+  }
+})
+vi.mock('@/lib/monaco-setup', async () => {
+  const { loader } = await import('@monaco-editor/react')
+  loader.config({ monaco })
+  return {}
+})
+vi.mock('./useContextualCopySetup', () => ({
+  useContextualCopySetup: () => ({ setupCopy: vi.fn(), toastNode: null })
+}))
+vi.mock('../diff-comments/useDiffCommentDecorator', () => ({
+  useDiffCommentDecorator: vi.fn()
+}))
+vi.mock('sonner', () => ({
+  toast: { info: vi.fn(), error: vi.fn(), success: vi.fn() }
+}))
+
+import MonacoEditor from './MonacoEditor'
+
+const originalGetContext = HTMLCanvasElement.prototype.getContext
+let creationListener: monaco.IDisposable | null = null
+
+afterEach(() => {
+  cleanup()
+  creationListener?.dispose()
+  creationListener = null
+  for (const model of monaco.editor.getModels()) {
+    model.dispose()
+  }
+  editorSelectionCache.clear()
+  scrollTopCache.clear()
+  Reflect.set(HTMLCanvasElement.prototype, 'getContext', originalGetContext)
+  testState.store = null
+})
+
+it('preserves a draft, selected range and scroll when the same tab gains a known owner', async () => {
+  // Only text metrics are needed; this test does not inspect canvas painting.
+  Reflect.set(HTMLCanvasElement.prototype, 'getContext', () => ({
+    webkitBackingStorePixelRatio: 1,
+    measureText: (value: string) => ({ width: value.length * 8 }),
+    fillRect: () => {},
+    clearRect: () => {},
+    fillText: () => {},
+    setTransform: () => {},
+    save: () => {},
+    restore: () => {},
+    beginPath: () => {},
+    moveTo: () => {},
+    lineTo: () => {},
+    stroke: () => {},
+    createImageData: (width: number, height: number) => ({
+      data: new Uint8ClampedArray(width * height * 4)
+    }),
+    getImageData: (width: number, height: number) => ({
+      data: new Uint8ClampedArray(width * height * 4)
+    }),
+    putImageData: () => {}
+  }))
+  const store = createTestStore()
+  testState.store = store
+  const file: OpenFile = {
+    id: 'restored-file',
+    worktreeId: 'pending-workspace',
+    filePath: '/repo/restored.txt',
+    relativePath: 'restored.txt',
+    mode: 'edit',
+    language: 'plaintext',
+    isDirty: true
+  }
+  store.setState({
+    openFiles: [file],
+    repos: [],
+    worktreesByRepo: {},
+    detectedWorktreesByRepo: {},
+    settings: { ...getDefaultSettings('/fixture'), theme: 'dark', editorWordWrap: false }
+  })
+  const widgets: monaco.editor.ICodeEditor[] = []
+  creationListener = monaco.editor.onDidCreateEditor((instance) => widgets.push(instance))
+  const props = {
+    fileId: file.id,
+    filePath: file.filePath,
+    viewStateKey: 'pane:restored-file',
+    relativePath: file.relativePath,
+    language: file.language,
+    content: Array.from({ length: 300 }, (_, index) => `line ${index + 1}`).join('\n'),
+    onContentChange: vi.fn(),
+    onSave: vi.fn()
+  }
+  const rendered = render(<MonacoEditor {...props} />)
+  await waitFor(() => expect(widgets).toHaveLength(1))
+  const before = widgets[0]
+  if (!before) {
+    throw new Error('Missing initial editor')
+  }
+  const originalModel = before.getModel()
+  if (!originalModel) {
+    throw new Error('Missing original model')
+  }
+  const draft = `${props.content}\nunsaved draft`
+  rendered.rerender(<MonacoEditor {...props} content={draft} />)
+  expect(originalModel.getValue()).toBe(draft)
+  expect(originalModel.canUndo()).toBe(true)
+  before.layout({ width: 600, height: 300 })
+  const selection = new monaco.Selection(80, 2, 82, 5)
+  before.setSelection(selection)
+  before.setScrollTop(1500)
+  expect(before.getScrollTop()).toBe(1500)
+
+  const openFiles = store.getState().openFiles
+  act(() => {
+    store.setState({
+      worktreesByRepo: {
+        repo: [
+          makeWorktree({ id: file.worktreeId, repoId: 'repo', path: '/repo', hostId: 'local' })
+        ]
+      }
+    })
+  })
+  expect(store.getState().openFiles).toBe(openFiles)
+  await waitFor(() => expect(widgets).toHaveLength(2))
+  const after = widgets[1]
+  if (!after) {
+    throw new Error('Missing resolved editor')
+  }
+  expect(after.getModel()).not.toBe(originalModel)
+  expect(after.getModel()?.getValue()).toBe(draft)
+  expect(after.getModel()?.canUndo()).toBe(false)
+  await waitFor(() => expect(after.getSelection()?.toString()).toBe(selection.toString()))
+  expect(after.getScrollTop()).toBe(1500)
+  expect(props.onContentChange).not.toHaveBeenCalled()
+  act(() => {
+    after.executeEdits('user-edit', [{ range: new monaco.Range(301, 14, 301, 14), text: '!' }])
+  })
+  expect(props.onContentChange).toHaveBeenCalledExactlyOnceWith(`${draft}!`)
+})
diff --git a/src/renderer/src/components/editor/MonacoEditor.tsx b/src/renderer/src/components/editor/MonacoEditor.tsx
index 17f659607a3..3f1f27423cd 100644
--- a/src/renderer/src/components/editor/MonacoEditor.tsx
+++ b/src/renderer/src/components/editor/MonacoEditor.tsx
@@ -13,6 +13,7 @@ import { isLinuxUserAgent } from '../terminal-pane/pane-helpers'
 import { MAX_TOKENIZATION_LINE_LENGTH } from '@/lib/monaco-languages/monarch-embed-entry-budget'
 import { buildFileEditorWordWrapOptions } from './file-editor-word-wrap-options'
 import { toEditorModelUri } from './editor-model-uri'
+import { getEditorModelOwnerKey } from './editor-model-owner'
 import { getMonacoAutoHeightForContent, isMonacoAutoHeightCapped } from './monaco-auto-height'
 import { monacoFindOptions } from './monaco-find-options'
 import { useMonacoRevealScheduler } from './use-monaco-reveal-scheduler'
@@ -97,7 +98,16 @@ export default function MonacoEditor({
   )
   const editorFontFamily = resolveEditorFontFamily(settings)
   const editorWordWrap = settings?.editorWordWrap
-  const modelUri = useMemo(() => toEditorModelUri(filePath), [filePath])
+  const modelOwnerKey = useAppStore((state) => {
+    const file = state.openFiles?.find((entry) => entry.id === fileId)
+    return file
+      ? getEditorModelOwnerKey(file, state)
+      : JSON.stringify([null, `unresolved:${fileId}`])
+  })
+  const modelUri = useMemo(
+    () => toEditorModelUri(filePath, modelOwnerKey),
+    [filePath, modelOwnerKey]
+  )
   const estimatedAutoHeight = useMemo(() => {
     if (!autoHeight) {
       return null
@@ -127,7 +137,7 @@ export default function MonacoEditor({
     content,
     contentRef,
     contentSyncModeRef,
-    filePath,
+    modelKey: modelUri,
     onContentChange
   })
   const annotations = useMonacoMarkdownAnnotations({
@@ -154,7 +164,7 @@ export default function MonacoEditor({
       unregisterFileSearchSelectionRef.current?.()
       unregisterFileSearchSelectionRef.current = null
     }
-  }, [cancelScheduledReveal, clearTransientRevealHighlight, viewStateKey])
+  }, [cancelScheduledReveal, clearTransientRevealHighlight, modelUri, viewStateKey])
 
   // Update editor options when settings change
   useEffect(() => {
@@ -183,6 +193,7 @@ export default function MonacoEditor({
   const handleMount = useMonacoEditorMount({
     fileId,
     filePath,
+    modelOwnerKey,
     viewStateKey,
     viewStateId,
     worktreeId,
@@ -232,6 +243,7 @@ export default function MonacoEditor({
         onSubmitMarkdownComment={annotations.handleSubmitMarkdownComment}
       />
       <Editor
+        key={modelUri}
         height={renderedEditorHeight === null ? '100%' : `${renderedEditorHeight}px`}
         language={language}
         // Why: defaultValue, not controlled value — Orca owns post-mount content sync; a controlled path would double setValue.
diff --git a/src/renderer/src/components/editor/NotesSendMenu.test.tsx b/src/renderer/src/components/editor/NotesSendMenu.test.tsx
index 64556e6b83d..b8758850895 100644
--- a/src/renderer/src/components/editor/NotesSendMenu.test.tsx
+++ b/src/renderer/src/components/editor/NotesSendMenu.test.tsx
@@ -1,14 +1,18 @@
 import React from 'react'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { buildNotesSendTargetModeId, NotesSendMenu } from './NotesSendMenu'
+import type { DiffCommentDeliverySnapshot } from '@/store/slices/diffComments'
+import { resetNotesInFlightForTests } from '@/lib/notes-send-in-flight'
 
 type ReactElementLike = {
   type: unknown
   props: Record<string, unknown>
 }
 
-type TestNote = {
-  id: string
+type TestNote = DiffCommentDeliverySnapshot
+
+function note(id: string): TestNote {
+  return { id, body: `body of ${id}`, filePath: 'README.md', lineNumber: 1 }
 }
 
 const hookRuntime = vi.hoisted(() => ({
@@ -41,6 +45,9 @@ vi.mock('react', async () => {
     useMemo<T>(factory: () => T): T {
       return factory()
     },
+    useSyncExternalStore<T>(_subscribe: unknown, getSnapshot: () => T): T {
+      return getSnapshot()
+    },
     useState<T>(initial: T | (() => T)) {
       const stateIndex = hookRuntime.index++
       if (!(stateIndex in hookRuntime.states)) {
@@ -233,8 +240,8 @@ function renderMenu(
         {
           id: 'all',
           label: 'All unsent notes',
-          notes: [{ id: 'note-1' }],
-          prompt: 'prompt-all'
+          notes: [note('note-1')],
+          formatPrompt: () => 'prompt-all'
         }
       ]}
       onDelivered={vi.fn()}
@@ -274,11 +281,12 @@ describe('NotesSendMenu', () => {
     storeMocks.openAgentSendPopoverTargetMode.mockReset()
     storeMocks.closeAgentSendPopoverTargetMode.mockReset()
     storeMocks.state.agentSendPopoverTargetMode = null
+    resetNotesInFlightForTests()
   })
 
   it('disables the trigger when no scope has deliverable notes', () => {
     const tree = renderMenu({
-      scopes: [{ id: 'all', label: 'All unsent notes', notes: [], prompt: '' }]
+      scopes: [{ id: 'all', label: 'All unsent notes', notes: [], formatPrompt: () => '' }]
     })
 
     expect(findByType(tree, 'button').props.disabled).toBe(true)
@@ -288,7 +296,7 @@ describe('NotesSendMenu', () => {
 
   it('uses caller-provided disabled tooltip copy for disabled note actions', () => {
     const tree = renderMenu({
-      scopes: [{ id: 'note', label: 'This note', notes: [], prompt: '' }],
+      scopes: [{ id: 'note', label: 'This note', notes: [], formatPrompt: () => '' }],
       disabledTooltip: 'Note already sent'
     })
 
@@ -317,7 +325,7 @@ describe('NotesSendMenu', () => {
     const delivered = storeMocks.openAgentSendPopoverTargetMode.mock.calls[0][0]
       .onPromptDelivered as () => void
     delivered()
-    expect(onDelivered).toHaveBeenCalledWith([{ id: 'note-1' }])
+    expect(onDelivered).toHaveBeenCalledWith([note('note-1')])
 
     ;(dropdown.props.onOpenChange as (open: boolean) => void)(false)
     expect(storeMocks.closeAgentSendPopoverTargetMode).toHaveBeenCalledWith(
@@ -341,8 +349,18 @@ describe('NotesSendMenu', () => {
     const tree = renderMenu({
       defaultScopeId: 'file',
       scopes: [
-        { id: 'file', label: 'This file', notes: [{ id: 'file-note' }], prompt: 'prompt-file' },
-        { id: 'all', label: 'All unsent notes', notes: [{ id: 'all-note' }], prompt: 'prompt-all' }
+        {
+          id: 'file',
+          label: 'This file',
+          notes: [note('file-note')],
+          formatPrompt: () => 'prompt-file'
+        },
+        {
+          id: 'all',
+          label: 'All unsent notes',
+          notes: [note('all-note')],
+          formatPrompt: () => 'prompt-all'
+        }
       ]
     })
     const [fileTrigger, allTrigger] = findAllByType(tree, 'DropdownMenuSubTrigger')
@@ -375,7 +393,7 @@ describe('NotesSendMenu', () => {
     renderMenu({
       openRequestNonce: 1,
       onOpenRequestHandled,
-      scopes: [{ id: 'all', label: 'All unsent notes', notes: [], prompt: '' }]
+      scopes: [{ id: 'all', label: 'All unsent notes', notes: [], formatPrompt: () => '' }]
     })
 
     expect(storeMocks.openAgentSendPopoverTargetMode).not.toHaveBeenCalled()
@@ -437,3 +455,121 @@ describe('NotesSendMenu', () => {
     )
   })
 })
+
+describe('NotesSendMenu notes in flight', () => {
+  const noteA = note('note-a')
+  const noteB = note('note-b')
+  const scopeOf = (notes: TestNote[]) => [
+    {
+      id: 'all',
+      label: 'All unsent notes',
+      notes,
+      formatPrompt: (sent: readonly TestNote[]) => sent.map((entry) => entry.id).join('+')
+    }
+  ]
+  /** Calls a rendered callback prop, failing the test if it is missing. */
+  const invoke = (props: Record<string, unknown>, name: string, ...args: unknown[]): unknown => {
+    const callback = props[name]
+    if (typeof callback !== 'function') {
+      throw new Error(`${name} is not a function`)
+    }
+    return callback(...args)
+  }
+  const contentProps = (tree: unknown) => {
+    const props = findByType(tree, 'ReviewNotesSendMenuContent').props
+    return {
+      prompt: props.prompt,
+      onPromptDelivered: () => invoke(props, 'onPromptDelivered'),
+      onPromptHandedOff: (delivered: Promise<unknown>) =>
+        invoke(props, 'onPromptHandedOff', delivered)
+    }
+  }
+
+  beforeEach(() => {
+    resetHookRuntime()
+    storeMocks.openAgentSendPopoverTargetMode.mockReset()
+    storeMocks.state.agentSendPopoverTargetMode = null
+    resetNotesInFlightForTests()
+  })
+
+  it('sends only a note added while an earlier send to a new agent is still on its way', async () => {
+    const onDelivered = vi.fn()
+    let deliverA!: (result: { delivered: boolean }) => void
+    const first = contentProps(renderMenu({ scopes: scopeOf([noteA]), onDelivered }))
+    first.onPromptHandedOff(new Promise((resolve) => (deliverA = resolve)))
+
+    const second = contentProps(renderMenu({ scopes: scopeOf([noteA, noteB]), onDelivered }))
+    expect(second.prompt).toBe('note-b')
+    second.onPromptHandedOff(new Promise(() => undefined))
+
+    first.onPromptDelivered()
+    deliverA({ delivered: true })
+    second.onPromptDelivered()
+    await Promise.resolve()
+
+    // Each send clears only its own note; a repeated clear of A is a no-op for its owner.
+    expect(onDelivered).not.toHaveBeenCalledWith([noteA, noteB])
+    expect(onDelivered).toHaveBeenCalledWith([noteA])
+    expect(onDelivered).toHaveBeenCalledWith([noteB])
+  })
+
+  it('leaves the notes out of the running-agent target mode too', () => {
+    contentProps(renderMenu({ scopes: scopeOf([noteA]) })).onPromptHandedOff(
+      new Promise(() => undefined)
+    )
+
+    const tree = renderMenu({ scopes: scopeOf([noteA, noteB]) })
+    invoke(findByType(tree, 'DropdownMenu').props, 'onOpenChange', true)
+
+    expect(storeMocks.openAgentSendPopoverTargetMode).toHaveBeenCalledWith(
+      expect.objectContaining({ prompt: 'note-b', onPromptHandedOff: expect.any(Function) })
+    )
+  })
+
+  it.each([
+    ['an undelivered result', () => Promise.resolve({ delivered: false, failureNotified: true })],
+    ['a failed start', () => Promise.reject(new Error('refused'))]
+  ])('puts the notes back for the next send after %s', async (_name, deliver) => {
+    const delivered = deliver()
+    contentProps(renderMenu({ scopes: scopeOf([noteA]) })).onPromptHandedOff(delivered)
+    expect(contentProps(renderMenu({ scopes: scopeOf([noteA]) })).prompt).toBe('')
+
+    await delivered.catch(() => undefined)
+    await Promise.resolve()
+
+    expect(contentProps(renderMenu({ scopes: scopeOf([noteA]) })).prompt).toBe('note-a')
+  })
+
+  it('offers no send once every note is on its way', () => {
+    contentProps(renderMenu({ scopes: scopeOf([noteA]) })).onPromptHandedOff(
+      new Promise(() => undefined)
+    )
+
+    const tree = renderMenu({ scopes: scopeOf([noteA]) })
+    expect(findByType(tree, 'button').props.disabled).toBe(true)
+    invoke(findByType(tree, 'DropdownMenu').props, 'onOpenChange', true)
+    expect(storeMocks.openAgentSendPopoverTargetMode).not.toHaveBeenCalled()
+  })
+
+  it('says the notes are on their way, not sent, while every note is held', () => {
+    contentProps(
+      renderMenu({ scopes: scopeOf([noteA]), disabledTooltip: 'Note already sent' })
+    ).onPromptHandedOff(new Promise(() => undefined))
+
+    const tree = renderMenu({ scopes: scopeOf([noteA]), disabledTooltip: 'Note already sent' })
+
+    expect(findByType(tree, 'button').props.title).toBe('Sending…')
+  })
+
+  // A failed new chat's Retry delivers them after the send's own callback is gone.
+  it('clears notes whose send reports delivery later', async () => {
+    const onDelivered = vi.fn()
+    const delivered = Promise.resolve({ delivered: true })
+    contentProps(renderMenu({ scopes: scopeOf([noteA]), onDelivered })).onPromptHandedOff(delivered)
+
+    await delivered
+    await Promise.resolve()
+
+    expect(onDelivered).toHaveBeenCalledWith([noteA])
+  })
+})
diff --git a/src/renderer/src/components/editor/NotesSendMenu.tsx b/src/renderer/src/components/editor/NotesSendMenu.tsx
index 8315d4512df..bb8cac0511a 100644
--- a/src/renderer/src/components/editor/NotesSendMenu.tsx
+++ b/src/renderer/src/components/editor/NotesSendMenu.tsx
@@ -14,6 +14,13 @@ import {
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
 import { cn } from '@/lib/utils'
 import { ReviewNotesSendMenuContent } from './ReviewNotesSendMenuContent'
+import type { DiffCommentDeliverySnapshot } from '@/store/slices/diffComments'
+import {
+  diffCommentSendKey,
+  holdNotesForSend,
+  isNoteInFlight,
+  useNotesInFlightVersion
+} from '@/lib/notes-send-in-flight'
 import { translate } from '@/i18n/i18n'
 
 const ENABLED_SEND_TOOLTIP = 'Send notes to an agent'
@@ -22,6 +29,11 @@ export type NotesSendMenuScope<TNote> = {
   id: string
   label: string
   notes: readonly TNote[]
+  /** The prompt for the notes this send carries: notes another send holds are left out. */
+  formatPrompt: (notes: readonly TNote[]) => string
+}
+
+type SendableNotesScope<TNote> = Omit<NotesSendMenuScope<TNote>, 'formatPrompt'> & {
   prompt: string
 }
 
@@ -57,7 +69,7 @@ export function buildNotesSendTargetModeId(modeIdParts: readonly string[]): stri
   return `note-send:${modeIdParts.map((part) => `${part.length}:${part}`).join('|')}`
 }
 
-export function NotesSendMenu<TNote>({
+export function NotesSendMenu<TNote extends DiffCommentDeliverySnapshot>({
   worktreeId,
   groupId,
   modeIdParts,
@@ -82,12 +94,27 @@ export function NotesSendMenu<TNote>({
   const activeTargetModeId = useAppStore((s) => s.agentSendPopoverTargetMode?.id ?? null)
   const [sendMenuOpen, setSendMenuOpen] = useState(false)
   const targetModeId = useMemo(() => buildNotesSendTargetModeId(modeIdParts), [modeIdParts])
-  const enabledScopes = useMemo(() => scopes.filter((scope) => scope.notes.length > 0), [scopes])
+  const inFlightVersion = useNotesInFlightVersion()
+  const sendableScopes = useMemo<SendableNotesScope<TNote>[]>(() => {
+    void inFlightVersion
+    return scopes.map(({ formatPrompt, ...scope }) => {
+      const notes = scope.notes.filter((note) => !isNoteInFlight(diffCommentSendKey(note)))
+      return { ...scope, notes, prompt: notes.length > 0 ? formatPrompt(notes) : '' }
+    })
+  }, [inFlightVersion, scopes])
+  const enabledScopes = useMemo(
+    () => sendableScopes.filter((scope) => scope.notes.length > 0),
+    [sendableScopes]
+  )
   const defaultScope = useMemo(() => {
     const requested = enabledScopes.find((scope) => scope.id === defaultScopeId)
     return requested ?? enabledScopes[0] ?? null
   }, [defaultScopeId, enabledScopes])
   const hasDeliverableNotes = enabledScopes.length > 0
+  // Notes only on their way to an agent are not sent yet.
+  const disabledTitle = scopes.some((scope) => scope.notes.length > 0)
+    ? translate('components.native-chat.question.sending', 'Sending…')
+    : disabledTooltip
 
   const markDelivered = useCallback(
     (notes: readonly TNote[]) => {
@@ -95,9 +122,14 @@ export function NotesSendMenu<TNote>({
     },
     [onDelivered]
   )
+  const holdInFlight = useCallback(
+    (notes: readonly TNote[]) => (delivered: Promise<unknown>) =>
+      holdNotesForSend(notes.map(diffCommentSendKey), delivered, () => markDelivered(notes)),
+    [markDelivered]
+  )
 
   const openTargetMode = useCallback(
-    (scope: NotesSendMenuScope<TNote>) => {
+    (scope: SendableNotesScope<TNote>) => {
       if (scope.notes.length === 0) {
         return
       }
@@ -108,10 +140,12 @@ export function NotesSendMenu<TNote>({
         prompt: scope.prompt,
         label: targetModeLabel ?? scope.label,
         launchSource: 'notes_send',
-        onPromptDelivered: () => markDelivered(scope.notes)
+        onPromptDelivered: () => markDelivered(scope.notes),
+        onPromptHandedOff: holdInFlight(scope.notes)
       })
     },
     [
+      holdInFlight,
       markDelivered,
       openAgentSendPopoverTargetMode,
       source,
@@ -181,7 +215,7 @@ export function NotesSendMenu<TNote>({
                 triggerClassName
               )}
               disabled={!hasDeliverableNotes}
-              title={hasDeliverableNotes ? ENABLED_SEND_TOOLTIP : disabledTooltip}
+              title={hasDeliverableNotes ? ENABLED_SEND_TOOLTIP : disabledTitle}
               aria-label={
                 triggerLabel
                   ? translate(
@@ -212,7 +246,7 @@ export function NotesSendMenu<TNote>({
           </DropdownMenuTrigger>
         </TooltipTrigger>
         <TooltipContent side="bottom" sideOffset={6}>
-          {hasDeliverableNotes ? ENABLED_SEND_TOOLTIP : disabledTooltip}
+          {hasDeliverableNotes ? ENABLED_SEND_TOOLTIP : disabledTitle}
         </TooltipContent>
       </Tooltip>
       <DropdownMenuContent
@@ -226,7 +260,7 @@ export function NotesSendMenu<TNote>({
             <DropdownMenuLabel>
               {translate('auto.components.editor.NotesSendMenu.44dc5e60a6', 'Send notes')}
             </DropdownMenuLabel>
-            {scopes.map((scope) => (
+            {sendableScopes.map((scope) => (
               <DropdownMenuSub key={scope.id}>
                 <DropdownMenuSubTrigger
                   disabled={scope.notes.length === 0}
@@ -244,6 +278,7 @@ export function NotesSendMenu<TNote>({
                     promptDelivery="submit-after-ready"
                     launchSource="notes_send"
                     onPromptDelivered={() => markDelivered(scope.notes)}
+                    onPromptHandedOff={holdInFlight(scope.notes)}
                   />
                 </DropdownMenuSubContent>
               </DropdownMenuSub>
@@ -261,6 +296,7 @@ export function NotesSendMenu<TNote>({
                 markDelivered(defaultScope.notes)
               }
             }}
+            onPromptHandedOff={holdInFlight(defaultScope?.notes ?? [])}
           />
         )}
       </DropdownMenuContent>
diff --git a/src/renderer/src/components/editor/PdfFind.tsx b/src/renderer/src/components/editor/PdfFind.tsx
index a186123bcfa..e05ef09e670 100644
--- a/src/renderer/src/components/editor/PdfFind.tsx
+++ b/src/renderer/src/components/editor/PdfFind.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import { useCallback, useEffect, useState } from 'react'
 import { ChevronUp, ChevronDown, X } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -126,7 +127,7 @@ export default function PdfFind({
       style={{ width: 300 }}
       onKeyDown={handleKeyDown}
     >
-      <input
+      <ImeInput
         ref={handleInputRef}
         type="text"
         value={query}
diff --git a/src/renderer/src/components/editor/ReviewNotesSendMenuContent.test.tsx b/src/renderer/src/components/editor/ReviewNotesSendMenuContent.test.tsx
index 7c1961f7d7c..af4c1e98445 100644
--- a/src/renderer/src/components/editor/ReviewNotesSendMenuContent.test.tsx
+++ b/src/renderer/src/components/editor/ReviewNotesSendMenuContent.test.tsx
@@ -650,6 +650,7 @@ describe('ReviewNotesSendMenuContent', () => {
   it('sends notes to the chosen agent and tracks the send once it succeeds', async () => {
     const statusPaneKey = makePaneKey(TAB_A, LEAF_A)
     const onPromptDelivered = vi.fn()
+    const onPromptHandedOff = vi.fn()
     setStore({
       tabsByWorktree: { 'wt-1': [tab(TAB_A, { title: 'Terminal 1' })] },
       terminalLayoutsByTabId: { [TAB_A]: leafLayout(LEAF_A, 'pty-a') }
@@ -665,7 +666,7 @@ describe('ReviewNotesSendMenuContent', () => {
       }
     ]
 
-    const tree = render({ onPromptDelivered })
+    const tree = render({ onPromptDelivered, onPromptHandedOff })
     ;(findByType(tree, 'DropdownMenuItem').props.onSelect as () => void)()
     await flushMicrotasks()
 
@@ -680,6 +681,10 @@ describe('ReviewNotesSendMenuContent', () => {
       launch_source: 'notes_send',
       request_kind: 'followup'
     })
+    // The notes are held from the hand-off until this send's own outcome, after its delivery.
+    expect(onPromptHandedOff).toHaveBeenCalledOnce()
+    await onPromptHandedOff.mock.calls[0][0]
+    expect(onPromptDelivered).toHaveBeenCalledTimes(1)
   })
 
   it('keeps selected-target note failures undelivered and uses selected wording', async () => {
@@ -854,13 +859,23 @@ describe('ReviewNotesSendMenuContent', () => {
   })
 
   it('always offers the new-agent launcher', () => {
-    const tree = render()
+    const onPromptHandedOff = vi.fn()
+    const tree = render({ onPromptHandedOff })
 
     expect(findByType(tree, 'QuickLaunchAgentMenuItems').props).toMatchObject({
       worktreeId: 'wt-1',
       groupId: 'group-1',
       prompt: 'my notes',
-      launchSource: 'notes_send'
+      launchSource: 'notes_send',
+      onPromptHandedOff
     })
   })
+
+  // Every note already on its way leaves an empty prompt: no agent may start with no text.
+  it('disables the new-agent launcher when there is nothing left to send', () => {
+    expect(findByType(render({ prompt: '' }), 'QuickLaunchAgentMenuItems').props.disabled).toBe(
+      true
+    )
+    expect(findByType(render(), 'QuickLaunchAgentMenuItems').props.disabled).toBe(false)
+  })
 })
diff --git a/src/renderer/src/components/editor/ReviewNotesSendMenuContent.tsx b/src/renderer/src/components/editor/ReviewNotesSendMenuContent.tsx
index 688113e7a01..935d98dd986 100644
--- a/src/renderer/src/components/editor/ReviewNotesSendMenuContent.tsx
+++ b/src/renderer/src/components/editor/ReviewNotesSendMenuContent.tsx
@@ -46,7 +46,8 @@ export function ReviewNotesSendMenuContent({
   prompt,
   promptDelivery = 'submit-after-ready',
   launchSource = 'notes_send',
-  onPromptDelivered
+  onPromptDelivered,
+  onPromptHandedOff
 }: {
   worktreeId: string
   groupId: string
@@ -54,6 +55,8 @@ export function ReviewNotesSendMenuContent({
   promptDelivery?: 'auto-submit' | 'draft' | 'submit-after-ready'
   launchSource?: LaunchSource
   onPromptDelivered?: () => void
+  /** Given each send's own result the moment its prompt is handed to an agent. */
+  onPromptHandedOff?: (delivered: Promise<unknown>) => void
 }): React.JSX.Element {
   const hasPrompt = prompt.trim().length > 0
 
@@ -114,7 +117,7 @@ export function ReviewNotesSendMenuContent({
         )
       )
 
-      void send()
+      const sending = send()
         .then((result) => {
           if (result.status === 'sent') {
             onSent()
@@ -147,8 +150,9 @@ export function ReviewNotesSendMenuContent({
             { id: pending }
           )
         })
+      onPromptHandedOff?.(sending)
     },
-    []
+    [onPromptHandedOff]
   )
 
   const sendToAgentTarget = useCallback(
@@ -208,6 +212,8 @@ export function ReviewNotesSendMenuContent({
         promptDelivery={promptDelivery}
         launchSource={launchSource}
         onPromptDelivered={onPromptDelivered}
+        onPromptHandedOff={onPromptHandedOff}
+        disabled={!hasPrompt}
       />
     </>
   )
diff --git a/src/renderer/src/components/editor/RichMarkdownLinkBubble.tsx b/src/renderer/src/components/editor/RichMarkdownLinkBubble.tsx
index 0751d7216e5..5110ce7a34c 100644
--- a/src/renderer/src/components/editor/RichMarkdownLinkBubble.tsx
+++ b/src/renderer/src/components/editor/RichMarkdownLinkBubble.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React, { useCallback, useEffect, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
 import type { Editor } from '@tiptap/react'
@@ -129,7 +130,7 @@ function LinkEditInput({
   }, [])
 
   return (
-    <input
+    <ImeInput
       ref={setInputElement}
       value={value}
       onChange={(e) => setValue(e.target.value)}
diff --git a/src/renderer/src/components/editor/RichMarkdownReviewNoteLayer.tsx b/src/renderer/src/components/editor/RichMarkdownReviewNoteLayer.tsx
index 0aa90569f98..2caa79b5a8d 100644
--- a/src/renderer/src/components/editor/RichMarkdownReviewNoteLayer.tsx
+++ b/src/renderer/src/components/editor/RichMarkdownReviewNoteLayer.tsx
@@ -134,10 +134,8 @@ export function RichMarkdownReviewNoteLayer({
                         'This note'
                       ),
                       notes: comment.sentAt ? [] : [comment as MarkdownReviewNote],
-                      prompt: formatMarkdownReviewNotes(
-                        [comment as MarkdownReviewNote],
-                        markdownReviewContent
-                      )
+                      formatPrompt: (notes) =>
+                        formatMarkdownReviewNotes(notes, markdownReviewContent)
                     }
                   ]}
                   targetModeLabel="This note"
diff --git a/src/renderer/src/components/editor/closed-editor-tab-controller.ts b/src/renderer/src/components/editor/closed-editor-tab-controller.ts
index dcf0c89be9c..161c85deab8 100644
--- a/src/renderer/src/components/editor/closed-editor-tab-controller.ts
+++ b/src/renderer/src/components/editor/closed-editor-tab-controller.ts
@@ -5,8 +5,13 @@ import { editorModelRegistry } from '@/lib/editor-model-registry'
 import { disposeClosedEditorModels, type ClosedEditorTab } from './closed-editor-tab-disposal'
 import type { MonacoModelRegistry, DisposableMonacoModel } from './diff-monaco-model-disposal'
 import { toEditorModelUri } from './editor-model-uri'
+import { getEditorModelOwnerKey } from './editor-model-owner'
+import type { WorktreeOperationRouteState } from '@/lib/worktree-operation-route'
 
-type EditorStore = Pick<StoreApi<{ openFiles: OpenFile[] }>, 'getState' | 'subscribe'>
+type EditorStore = Pick<
+  StoreApi<WorktreeOperationRouteState & { openFiles: OpenFile[] }>,
+  'getState' | 'subscribe'
+>
 type RetainedModel = {
   files: Map<string, ClosedEditorTab>
   detach: { dispose(): void }
@@ -14,7 +19,7 @@ type RetainedModel = {
 }
 
 function ownerKey(file: ClosedEditorTab): string {
-  return JSON.stringify([file.id, file.mode, file.filePath])
+  return JSON.stringify([file.id, file.mode, file.filePath, file.modelOwnerKey])
 }
 
 export function attachClosedEditorTabCleanup(
@@ -22,7 +27,8 @@ export function attachClosedEditorTabCleanup(
   bridge = editorModelRegistry
 ): () => void {
   let registry = bridge.get()
-  let previousFiles = store.getState().openFiles
+  let previousState = store.getState()
+  let previousFiles = previousState.openFiles
   const pendingFiles = new Map<string, ClosedEditorTab>()
   const candidateModels = new Set<editor.ITextModel>()
   const retainedModels = new Map<editor.ITextModel, RetainedModel>()
@@ -96,24 +102,26 @@ export function attachClosedEditorTabCleanup(
       return
     }
     const flushGeneration = generation
-    let checkedOpenFiles: OpenFile[] | null = null
+    let checkedState: ReturnType<EditorStore['getState']> | null = null
     let openIds = new Set<string>()
     let openEditUris = new Set<string>()
     const stillOwned = (file: ClosedEditorTab): boolean => {
-      const openFiles = store.getState().openFiles
-      if (openFiles !== checkedOpenFiles) {
-        checkedOpenFiles = openFiles
+      const currentState = store.getState()
+      const openFiles = currentState.openFiles
+      if (currentState !== checkedState) {
+        checkedState = currentState
         openIds = new Set(openFiles.map((openFile) => openFile.id))
         openEditUris = new Set(
           openFiles
             .filter((openFile) => openFile.mode === 'edit')
-            .map((openFile) => toEditorModelUri(openFile.filePath))
+            .map((openFile) =>
+              toEditorModelUri(openFile.filePath, getEditorModelOwnerKey(openFile, currentState))
+            )
         )
       }
-      return (
-        openIds.has(file.id) ||
-        (file.mode === 'edit' && openEditUris.has(toEditorModelUri(file.filePath)))
-      )
+      return file.mode === 'edit'
+        ? openEditUris.has(toEditorModelUri(file.filePath, file.modelOwnerKey))
+        : openIds.has(file.id)
     }
     const disposeCaptured = (
       files: ClosedEditorTab[],
@@ -181,23 +189,52 @@ export function attachClosedEditorTabCleanup(
   }
 
   const unsubscribe = store.subscribe(() => {
-    const openFiles = store.getState().openFiles
-    if (openFiles === previousFiles) {
+    const currentState = store.getState()
+    const openFiles = currentState.openFiles
+    const previous = previousFiles
+    const closedState = previousState
+    previousFiles = openFiles
+    previousState = currentState
+    if (
+      openFiles === previous &&
+      currentState.repos === closedState.repos &&
+      currentState.worktreesByRepo === closedState.worktreesByRepo &&
+      currentState.detectedWorktreesByRepo === closedState.detectedWorktreesByRepo &&
+      currentState.folderWorkspaces === closedState.folderWorkspaces &&
+      currentState.projectGroups === closedState.projectGroups &&
+      currentState.restoredRuntimeHostIdByWorkspaceSessionKey ===
+        closedState.restoredRuntimeHostIdByWorkspaceSessionKey &&
+      currentState.runtimeEnvironmentCatalogHydrated ===
+        closedState.runtimeEnvironmentCatalogHydrated &&
+      currentState.removedRuntimeEnvironmentIds === closedState.removedRuntimeEnvironmentIds &&
+      currentState.runtimeEnvironments === closedState.runtimeEnvironments &&
+      currentState.settings === closedState.settings
+    ) {
       return
     }
-    const previous = previousFiles
-    previousFiles = openFiles
-    const liveIds = new Set(openFiles.map((file) => file.id))
+    const liveFiles = new Map(openFiles.map((file) => [file.id, file]))
     let removed = false
     let removedDiff = false
     for (const file of previous) {
-      if (!liveIds.has(file.id)) {
-        const descriptor = { id: file.id, mode: file.mode, filePath: file.filePath }
+      const priorOwner = getEditorModelOwnerKey(file, closedState)
+      const liveFile = liveFiles.get(file.id)
+      if (
+        !liveFile ||
+        liveFile.mode !== file.mode ||
+        liveFile.filePath !== file.filePath ||
+        (file.mode === 'edit' && getEditorModelOwnerKey(liveFile, currentState) !== priorOwner)
+      ) {
+        const descriptor = {
+          id: file.id,
+          mode: file.mode,
+          filePath: file.filePath,
+          modelOwnerKey: priorOwner
+        }
         pendingFiles.set(ownerKey(descriptor), descriptor)
         removed = true
         if (file.mode === 'edit' && registry) {
           const model = registry.editor.getModel(
-            registry.Uri.parse(toEditorModelUri(file.filePath))
+            registry.Uri.parse(toEditorModelUri(file.filePath, descriptor.modelOwnerKey))
           )
           if (model) {
             candidateModels.add(model)
diff --git a/src/renderer/src/components/editor/closed-editor-tab-disposal.ts b/src/renderer/src/components/editor/closed-editor-tab-disposal.ts
index 750c5e4317e..cd961c898b5 100644
--- a/src/renderer/src/components/editor/closed-editor-tab-disposal.ts
+++ b/src/renderer/src/components/editor/closed-editor-tab-disposal.ts
@@ -17,7 +17,9 @@ import {
 } from './closed-editor-tab-cache-sweep'
 import { toEditorModelUri } from './editor-model-uri'
 
-export type ClosedEditorTab = Pick<OpenFile, 'id' | 'mode' | 'filePath'>
+export type ClosedEditorTab = Pick<OpenFile, 'id' | 'mode' | 'filePath'> & {
+  modelOwnerKey?: string
+}
 
 // One registry sweep avoids quadratic close-all work.
 export function disposeClosedEditorModels(
@@ -37,7 +39,7 @@ export function disposeClosedEditorModels(
     }
     if (closedFile.mode === 'edit') {
       const model = monacoRegistry.editor.getModel(
-        monacoRegistry.Uri.parse(toEditorModelUri(closedFile.filePath))
+        monacoRegistry.Uri.parse(toEditorModelUri(closedFile.filePath, closedFile.modelOwnerKey))
       )
       if (model?.isAttachedToEditor()) {
         onAttachedModel?.(model, closedFile)
diff --git a/src/renderer/src/components/editor/closed-editor-view-state-retention.test.ts b/src/renderer/src/components/editor/closed-editor-view-state-retention.test.ts
index 1b88f0ccbb6..206ff5fdf77 100644
--- a/src/renderer/src/components/editor/closed-editor-view-state-retention.test.ts
+++ b/src/renderer/src/components/editor/closed-editor-view-state-retention.test.ts
@@ -42,7 +42,10 @@ function open(path: string, text = 'original') {
     'plaintext',
     monaco.Uri.parse(toEditorModelUri(path))
   )
-  const store = createStore(() => ({ openFiles: [file] }))
+  const store = createStore(() => ({
+    openFiles: [file],
+    worktreesByRepo: { fixture: [{ id: 'fixture', repoId: 'fixture', hostId: 'local' as const }] }
+  }))
   const bridge = createEditorModelRegistry()
   disposeOwners.push(bridge.register(monaco), attachClosedEditorTabCleanup(store, bridge))
   return {
diff --git a/src/renderer/src/components/editor/csv/CsvCellValue.tsx b/src/renderer/src/components/editor/csv/CsvCellValue.tsx
new file mode 100644
index 00000000000..91613e30cb8
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvCellValue.tsx
@@ -0,0 +1,39 @@
+import type { MouseEvent } from 'react'
+
+export function CsvCellValue({
+  value,
+  onOpenUrl
+}: {
+  value: string
+  onOpenUrl?: (url: string, event: MouseEvent<HTMLAnchorElement>) => void
+}): React.JSX.Element {
+  const candidate = value.trim()
+  let href: string | undefined
+  if (onOpenUrl && /^https?:\/\/\S+$/i.test(candidate)) {
+    try {
+      href = new URL(candidate).href
+    } catch {
+      // Malformed URLs stay selectable text.
+    }
+  }
+  return href ? (
+    <a
+      href={href}
+      className="truncate rounded text-primary underline underline-offset-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+      onClick={(event) => {
+        event.preventDefault()
+        onOpenUrl?.(href, event)
+      }}
+      onAuxClick={(event) => {
+        if (event.button === 1) {
+          event.preventDefault()
+          onOpenUrl?.(href, event)
+        }
+      }}
+    >
+      {value}
+    </a>
+  ) : (
+    <span className="truncate">{value}</span>
+  )
+}
diff --git a/src/renderer/src/components/editor/csv/CsvColumnResizeHandle.tsx b/src/renderer/src/components/editor/csv/CsvColumnResizeHandle.tsx
new file mode 100644
index 00000000000..0efdb568c70
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvColumnResizeHandle.tsx
@@ -0,0 +1,88 @@
+import { useEffect, useRef } from 'react'
+import { translate } from '@/i18n/i18n'
+import { CSV_MIN_COLUMN_WIDTH, CSV_MAX_COLUMN_WIDTH } from './csv-column-width-limits'
+export { CSV_MIN_COLUMN_WIDTH, CSV_MAX_COLUMN_WIDTH } from './csv-column-width-limits'
+
+export function CsvColumnResizeHandle({
+  index,
+  width,
+  onResize,
+  onReset
+}: {
+  index: number
+  width: number
+  onResize: (index: number, width: number) => void
+  onReset: (index: number) => void
+}): React.JSX.Element {
+  const drag = useRef<{ x: number; width: number } | null>(null)
+  const frame = useRef<number | null>(null)
+  const pendingWidth = useRef(width)
+  const resize = (next: number): void =>
+    onResize(index, Math.max(CSV_MIN_COLUMN_WIDTH, Math.min(CSV_MAX_COLUMN_WIDTH, next)))
+  useEffect(
+    () => () => {
+      if (frame.current !== null) {
+        cancelAnimationFrame(frame.current)
+      }
+    },
+    []
+  )
+  const finish = (): void => {
+    if (!drag.current) {
+      return
+    }
+    drag.current = null
+    if (frame.current !== null) {
+      cancelAnimationFrame(frame.current)
+      frame.current = null
+      resize(pendingWidth.current)
+    }
+  }
+  return (
+    <div
+      role="separator"
+      tabIndex={0}
+      aria-orientation="vertical"
+      aria-label={translate('csv.resizeColumn', 'Resize column {{column}}', { column: index + 1 })}
+      aria-valuemin={CSV_MIN_COLUMN_WIDTH}
+      aria-valuemax={CSV_MAX_COLUMN_WIDTH}
+      aria-valuenow={width}
+      className="absolute inset-y-0 right-0 w-2 cursor-col-resize touch-none select-none hover:bg-accent focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+      onPointerDown={(event) => {
+        if (event.button !== 0) {
+          return
+        }
+        event.preventDefault()
+        event.currentTarget.setPointerCapture(event.pointerId)
+        drag.current = { x: event.clientX, width }
+        pendingWidth.current = width
+      }}
+      onPointerMove={(event) => {
+        if (!drag.current) {
+          return
+        }
+        pendingWidth.current = drag.current.width + event.clientX - drag.current.x
+        if (frame.current === null) {
+          frame.current = requestAnimationFrame(() => {
+            frame.current = null
+            resize(pendingWidth.current)
+          })
+        }
+      }}
+      onPointerUp={finish}
+      onPointerCancel={finish}
+      onLostPointerCapture={finish}
+      onBlur={finish}
+      onDoubleClick={() => onReset(index)}
+      onKeyDown={(event) => {
+        if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {
+          event.preventDefault()
+          resize(width + (event.key === 'ArrowLeft' ? -1 : 1) * (event.shiftKey ? 40 : 8))
+        } else if (event.key === 'Home') {
+          event.preventDefault()
+          onReset(index)
+        }
+      }}
+    />
+  )
+}
diff --git a/src/renderer/src/components/editor/csv/CsvGrid.test.tsx b/src/renderer/src/components/editor/csv/CsvGrid.test.tsx
new file mode 100644
index 00000000000..09855cd0998
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvGrid.test.tsx
@@ -0,0 +1,150 @@
+// @vitest-environment happy-dom
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, expect, it, vi } from 'vitest'
+import { CsvGrid } from './CsvGrid'
+import type * as VirtualLibrary from '@tanstack/react-virtual'
+
+vi.mock('@tanstack/react-virtual', async (importOriginal) => {
+  const original = await importOriginal<typeof VirtualLibrary>()
+  return {
+    ...original,
+    useVirtualizer: (options: Parameters<typeof original.useVirtualizer>[0]) =>
+      original.useVirtualizer({
+        ...options,
+        initialRect: { width: 500, height: 300 },
+        observeElementRect: (_instance, callback) => {
+          callback({ width: 500, height: 300 })
+          return () => {}
+        },
+        observeElementOffset: (instance, callback) => {
+          const element = instance.scrollElement
+          const onScroll = (): void =>
+            callback(
+              (instance.options.horizontal ? element?.scrollLeft : element?.scrollTop) ?? 0,
+              false
+            )
+          element?.addEventListener('scroll', onScroll)
+          onScroll()
+          return () => element?.removeEventListener('scroll', onScroll)
+        }
+      })
+  }
+})
+afterEach(cleanup)
+
+it('returns to existing rows when a refresh shrinks the file below its selected row window', async () => {
+  const grid = (rowCount: number) => (
+    <CsvGrid
+      header={['id']}
+      rowCount={rowCount}
+      columnCount={1}
+      sampleRows={[]}
+      getRow={(index) => [`r${index}`]}
+    />
+  )
+  const { rerender } = render(grid(1_500_100))
+  fireEvent.click(screen.getByRole('button', { name: 'Next rows' }))
+  await waitFor(() => expect(screen.getByRole('cell', { name: 'r500000' })).toBeTruthy())
+  rerender(grid(3))
+  await waitFor(() => expect(screen.getByRole('cell', { name: 'r0' })).toBeTruthy())
+  expect(screen.getAllByRole('row')).toHaveLength(4)
+})
+
+it('virtualizes both axes with the real TanStack implementation', async () => {
+  const onVisibleRows = vi.fn()
+  render(
+    <CsvGrid
+      header={Array.from({ length: 2000 }, (_, i) => `column-${i}`)}
+      rowCount={200_000}
+      columnCount={2000}
+      sampleRows={[]}
+      getRow={(index) => [String(index)]}
+      onVisibleRows={onVisibleRows}
+    />
+  )
+  const scroll = screen.getByTestId('csv-scroll')
+  expect(screen.getAllByRole('columnheader').length).toBeLessThan(15)
+  expect(screen.getAllByRole('row').length).toBeLessThan(40)
+  expect(screen.getAllByRole('cell').length).toBeLessThan(400)
+  scroll.scrollTop = 28 * 190_000
+  scroll.scrollLeft = 80 * 1500
+  fireEvent.scroll(scroll)
+  await waitFor(() =>
+    expect(Number(screen.getAllByRole('row')[1]?.getAttribute('aria-rowindex'))).toBeGreaterThan(
+      180000
+    )
+  )
+  expect(screen.queryByRole('columnheader', { name: 'column-0' })).toBeNull()
+  expect(screen.getAllByRole('columnheader')[1]?.getAttribute('aria-colindex')).not.toBe('2')
+  expect(screen.getAllByRole('cell').length).toBeLessThan(600)
+  expect(onVisibleRows).toHaveBeenLastCalledWith(expect.any(Number), expect.any(Number))
+})
+
+it('resizes with the keyboard and aligns body columns, then resets', async () => {
+  render(
+    <CsvGrid
+      header={['name', 'value']}
+      rowCount={2}
+      columnCount={2}
+      sampleRows={[]}
+      getRow={() => ['a', 'b']}
+    />
+  )
+  const handle = screen.getByRole('separator', { name: 'Resize column 1' })
+  fireEvent.keyDown(handle, { key: 'ArrowRight', shiftKey: true })
+  await waitFor(() => expect(handle.getAttribute('aria-valuenow')).toBe('120'))
+  const template = screen.getAllByRole('row')[0]?.style.gridTemplateColumns
+  expect(
+    screen.getAllByRole('row').every((row) => row.style.gridTemplateColumns === template)
+  ).toBe(true)
+  fireEvent.keyDown(handle, { key: 'Home' })
+  await waitFor(() => expect(handle.getAttribute('aria-valuenow')).toBe('80'))
+  for (let i = 0; i < 10; i += 1) {
+    fireEvent.keyDown(handle, { key: 'ArrowLeft', shiftKey: true })
+  }
+  expect(handle.getAttribute('aria-valuenow')).toBe('48')
+})
+
+it('retains user widths when refreshed data changes the size estimates', async () => {
+  const grid = (header: string[]) => (
+    <CsvGrid
+      header={header}
+      rowCount={2}
+      columnCount={2}
+      sampleRows={[]}
+      getRow={() => ['a', 'b']}
+    />
+  )
+  const { rerender } = render(grid(['name', 'value']))
+  const handle = screen.getByRole('separator', { name: 'Resize column 1' })
+  fireEvent.keyDown(handle, { key: 'ArrowRight', shiftKey: true })
+  rerender(grid(['a much longer header changes the width estimate', 'value']))
+  await waitFor(() => expect(handle.getAttribute('aria-valuenow')).toBe('120'))
+  const template = screen.getAllByRole('row')[0]?.style.gridTemplateColumns
+  expect(
+    screen.getAllByRole('row').every((row) => row.style.gridTemplateColumns === template)
+  ).toBe(true)
+  fireEvent.keyDown(handle, { key: 'Home' })
+  await waitFor(() => expect(handle.getAttribute('aria-valuenow')).toBe('320'))
+})
+
+it('makes rows beyond the browser layout limit reachable', async () => {
+  render(
+    <CsvGrid
+      header={['id']}
+      rowCount={1_500_100}
+      columnCount={1}
+      sampleRows={[]}
+      getRow={(index) => [String(index)]}
+    />
+  )
+  const next = screen.getByRole('button', { name: 'Next rows' })
+  fireEvent.click(next)
+  await waitFor(() =>
+    expect(screen.getAllByRole('row')[1]?.getAttribute('aria-rowindex')).toBe('500002')
+  )
+  fireEvent.click(next)
+  fireEvent.click(next)
+  expect(next.getAttribute('disabled')).not.toBeNull()
+  expect(screen.getByText('Rows 1,500,001–1,500,100')).toBeTruthy()
+})
diff --git a/src/renderer/src/components/editor/csv/CsvGrid.tsx b/src/renderer/src/components/editor/csv/CsvGrid.tsx
new file mode 100644
index 00000000000..9afe01942ad
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvGrid.tsx
@@ -0,0 +1,355 @@
+import { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from 'react'
+import { useVirtualizer } from '@tanstack/react-virtual'
+import { Button } from '@/components/ui/button'
+import { translate } from '@/i18n/i18n'
+import { CsvColumnResizeHandle } from './CsvColumnResizeHandle'
+import { CsvGridCell } from './CsvGridCell'
+import type { CsvGridInteraction } from './csv-grid-interaction'
+import type { CsvColumnWidths } from './csv-column-width-preferences'
+
+const ROW_HEIGHT = 28
+// Keep the scroll surface below Chromium's layout extent limit.
+const SCROLL_WINDOW_ROWS = 500_000
+
+export function CsvGrid({
+  header,
+  rowCount,
+  columnCount,
+  sampleRows,
+  getRow,
+  onVisibleRows,
+  onOpenUrl,
+  interaction,
+  columnWidths,
+  onColumnWidthsChange
+}: {
+  header: string[]
+  rowCount: number
+  columnCount: number
+  sampleRows: string[][]
+  getRow: (index: number) => string[] | undefined
+  onVisibleRows?: (first: number, last: number) => void
+  onOpenUrl?: (url: string, event: React.MouseEvent<HTMLAnchorElement>) => void
+  interaction?: CsvGridInteraction
+  columnWidths?: CsvColumnWidths
+  onColumnWidthsChange?: (widths: CsvColumnWidths) => void
+}): React.JSX.Element {
+  const scrollRef = useRef<HTMLDivElement>(null)
+  const gridRef = useRef<HTMLDivElement>(null)
+  const gridId = useId()
+  const dragging = useRef(false)
+  const scrolledFocusVersion = useRef(-1)
+  const focusGrid = (): void => gridRef.current?.focus({ preventScroll: true })
+  const [requestedWindowStart, setWindowStart] = useState(0)
+  const windowStart = Math.min(
+    requestedWindowStart,
+    Math.floor(Math.max(0, rowCount - 1) / SCROLL_WINDOW_ROWS) * SCROLL_WINDOW_ROWS
+  )
+  const [localWidths, setLocalWidths] = useState<CsvColumnWidths>({})
+  const widthOverrides = columnWidths ?? localWidths
+  const rowNumberWidth = Math.max(48, String(rowCount).length * 8 + 16)
+  const widths = useMemo(() => {
+    const result = Array.from({ length: columnCount }, () => 80)
+    for (const row of [header, ...sampleRows.slice(0, 200)]) {
+      row.forEach((cell, index) => {
+        if (index < columnCount) {
+          result[index] = Math.max(result[index]!, Math.min(320, cell.length * 7 + 24))
+        }
+      })
+    }
+    return result
+  }, [header, sampleRows, columnCount])
+  const rows = useVirtualizer({
+    count: Math.min(SCROLL_WINDOW_ROWS, Math.max(0, rowCount - windowStart)),
+    getScrollElement: () => scrollRef.current,
+    estimateSize: () => ROW_HEIGHT,
+    overscan: 12,
+    paddingStart: ROW_HEIGHT
+  })
+  const columns = useVirtualizer({
+    horizontal: true,
+    count: columnCount,
+    getScrollElement: () => scrollRef.current,
+    estimateSize: (index) => widthOverrides[index] ?? widths[index] ?? 80,
+    paddingStart: rowNumberWidth,
+    overscan: 2
+  })
+  useLayoutEffect(() => columns.measure(), [columns, widths, columnWidths])
+  const virtualRows = rows.getVirtualItems()
+  const virtualColumns = columns.getVirtualItems()
+  const first = virtualRows[0]?.index
+  const last = virtualRows.at(-1)?.index
+  useEffect(() => {
+    if (first !== undefined && last !== undefined) {
+      onVisibleRows?.(first + windowStart, last + windowStart)
+    }
+  }, [first, last, windowStart, onVisibleRows])
+  const resize = useCallback(
+    (index: number, width: number) => {
+      const next = { ...widthOverrides, [index]: width }
+      if (onColumnWidthsChange) {
+        onColumnWidthsChange(next)
+      } else {
+        setLocalWidths(next)
+      }
+      columns.resizeItem(index, width)
+    },
+    [columns, onColumnWidthsChange, widthOverrides]
+  )
+  const reset = (index: number): void => {
+    const next = { ...widthOverrides }
+    delete next[index]
+    if (onColumnWidthsChange) {
+      onColumnWidthsChange(next)
+    } else {
+      setLocalWidths(next)
+    }
+    columns.resizeItem(index, widths[index] ?? 80)
+  }
+  const active = interaction?.selection?.focus
+  useLayoutEffect(() => {
+    if (!active || scrolledFocusVersion.current === interaction?.focusVersion) {
+      return
+    }
+    if (interaction?.editing) {
+      scrolledFocusVersion.current = interaction.focusVersion
+      return
+    }
+    const targetWindow =
+      Math.floor(Math.max(0, active.row - 1) / SCROLL_WINDOW_ROWS) * SCROLL_WINDOW_ROWS
+    if (targetWindow !== windowStart) {
+      setWindowStart(targetWindow)
+      return
+    }
+    if (active.row > 0) {
+      rows.scrollToIndex(active.row - 1 - windowStart, { align: 'auto' })
+    } else {
+      scrollRef.current?.scrollTo({ top: 0 })
+    }
+    columns.scrollToIndex(active.column, { align: 'auto' })
+    scrolledFocusVersion.current = interaction?.focusVersion ?? -1
+  }, [active, interaction?.editing, interaction?.focusVersion, rows, columns, windowStart])
+  useEffect(() => {
+    const finish = (): void => {
+      dragging.current = false
+    }
+    window.addEventListener('pointerup', finish)
+    window.addEventListener('pointercancel', finish)
+    window.addEventListener('blur', finish)
+    return () => {
+      window.removeEventListener('pointerup', finish)
+      window.removeEventListener('pointercancel', finish)
+      window.removeEventListener('blur', finish)
+    }
+  }, [])
+  const pointerCell = (event: React.PointerEvent): { row: number; column: number } | null => {
+    if (
+      !(event.target instanceof Element) ||
+      event.target.closest('a,textarea,[role="separator"]')
+    ) {
+      return null
+    }
+    const cell = event.target.closest('[data-csv-row]')
+    if (!cell) {
+      return null
+    }
+    const row = Number(cell.getAttribute('data-csv-row'))
+    const column = Number(cell.getAttribute('data-csv-column'))
+    return Number.isInteger(row) && Number.isInteger(column) ? { row, column } : null
+  }
+  const activeMounted =
+    active &&
+    virtualColumns.some((column) => column.index === active.column) &&
+    (active.row === 0 || virtualRows.some((row) => row.index + windowStart + 1 === active.row))
+
+  const totalWidth = columns.getTotalSize()
+  const gridTemplate = `${rowNumberWidth}px ${Math.max(0, (virtualColumns[0]?.start ?? rowNumberWidth) - rowNumberWidth)}px ${virtualColumns.map((column) => `${column.size}px`).join(' ')} ${Math.max(0, totalWidth - (virtualColumns.at(-1)?.end ?? rowNumberWidth))}px`
+  const moveWindow = (start: number): void => {
+    setWindowStart(start)
+    scrollRef.current?.scrollTo({ top: 0 })
+  }
+  return (
+    <>
+      <div
+        ref={scrollRef}
+        data-testid="csv-scroll"
+        className="relative min-h-0 flex-1 overflow-auto scrollbar-editor font-mono text-xs"
+        onScroll={(event) => {
+          if (!interaction?.editing) {
+            return
+          }
+          const position = interaction.editing.position
+          const cell = gridRef.current
+            ?.querySelector(
+              `[data-csv-row="${position.row}"][data-csv-column="${position.column}"]`
+            )
+            ?.getBoundingClientRect()
+          const viewport = event.currentTarget.getBoundingClientRect()
+          // Caret visibility can scroll a clipped input while the user is still typing.
+          if (
+            cell &&
+            cell.bottom > viewport.top + (position.row ? ROW_HEIGHT : 0) &&
+            cell.top < viewport.bottom &&
+            cell.right > viewport.left &&
+            cell.left < viewport.right
+          ) {
+            return
+          }
+          if (!interaction.commit()) {
+            if (position.row > 0) {
+              rows.scrollToIndex(position.row - 1 - windowStart, { align: 'auto' })
+            }
+            columns.scrollToIndex(position.column, { align: 'auto' })
+          }
+        }}
+      >
+        <div
+          ref={gridRef}
+          role={interaction ? 'grid' : 'table'}
+          data-testid="csv-grid"
+          data-csv-owner={interaction?.ownerId}
+          tabIndex={interaction ? 0 : undefined}
+          aria-label={interaction ? translate('csv.editor', 'CSV editor') : undefined}
+          aria-activedescendant={
+            activeMounted ? `${gridId}-${active.row}-${active.column}` : undefined
+          }
+          onKeyDown={interaction?.keyDown}
+          onCopy={interaction?.copy}
+          onPaste={interaction?.paste}
+          onPointerDown={(event) => {
+            const cell = pointerCell(event)
+            if (!interaction || !cell || event.button !== 0) {
+              return
+            }
+            event.preventDefault()
+            if (interaction.select(cell.row, cell.column, event.shiftKey)) {
+              dragging.current = true
+              focusGrid()
+            }
+          }}
+          onPointerMove={(event) => {
+            const cell = pointerCell(event)
+            if (interaction && dragging.current && cell) {
+              interaction.select(cell.row, cell.column, true)
+            }
+          }}
+          aria-rowcount={rowCount + 1}
+          aria-colcount={columnCount + 1}
+          className="relative min-w-full"
+          style={{ width: totalWidth }}
+        >
+          <div
+            role="row"
+            aria-rowindex={1}
+            className="sticky top-0 z-10 grid bg-muted/90 backdrop-blur"
+            style={{ gridTemplateColumns: gridTemplate, height: ROW_HEIGHT }}
+          >
+            <div
+              role="columnheader"
+              aria-colindex={1}
+              className="sticky left-0 z-20 flex items-center justify-end border-b border-r border-border/60 bg-muted px-2 font-normal text-muted-foreground"
+            >
+              #
+            </div>
+            <div aria-hidden="true" />
+            {virtualColumns.map((column) => (
+              <CsvGridCell
+                key={column.key}
+                id={`${gridId}-0-${column.index}`}
+                header
+                value={header[column.index] ?? ''}
+                row={0}
+                column={column.index}
+                interaction={interaction}
+                focusGrid={focusGrid}
+              >
+                <CsvColumnResizeHandle
+                  index={column.index}
+                  width={column.size}
+                  onResize={resize}
+                  onReset={reset}
+                />
+              </CsvGridCell>
+            ))}
+            <div aria-hidden="true" />
+          </div>
+          <div
+            className="relative"
+            style={{ height: Math.max(0, rows.getTotalSize() - ROW_HEIGHT) }}
+          >
+            {virtualRows.map((virtualRow) => {
+              const index = virtualRow.index + windowStart
+              const row = getRow(index)
+              return (
+                <div
+                  role="row"
+                  aria-rowindex={index + 2}
+                  aria-busy={row === undefined}
+                  key={virtualRow.key}
+                  data-index={index}
+                  className="group absolute left-0 top-0 grid hover:bg-accent/40"
+                  style={{
+                    gridTemplateColumns: gridTemplate,
+                    height: ROW_HEIGHT,
+                    width: totalWidth,
+                    transform: `translateY(${virtualRow.start - ROW_HEIGHT}px)`
+                  }}
+                >
+                  <div
+                    role="rowheader"
+                    aria-colindex={1}
+                    className="sticky left-0 z-10 flex items-center justify-end border-b border-r border-border/40 bg-background px-2 text-muted-foreground group-hover:bg-accent"
+                  >
+                    {index + 1}
+                  </div>
+                  <div aria-hidden="true" />
+                  {virtualColumns.map((column) => (
+                    <CsvGridCell
+                      key={column.key}
+                      id={`${gridId}-${index + 1}-${column.index}`}
+                      value={
+                        row ? (row[column.index] ?? '') : translate('csv.loadingCell', 'Loading…')
+                      }
+                      row={index + 1}
+                      column={column.index}
+                      interaction={interaction}
+                      focusGrid={focusGrid}
+                      onOpenUrl={onOpenUrl}
+                    />
+                  ))}
+                  <div aria-hidden="true" />
+                </div>
+              )
+            })}
+          </div>
+        </div>
+      </div>
+      {rowCount > SCROLL_WINDOW_ROWS && (
+        <div className="flex items-center gap-2 border-t border-border px-3 py-1 text-xs text-muted-foreground">
+          <Button
+            variant="ghost"
+            size="xs"
+            disabled={windowStart === 0}
+            onClick={() => moveWindow(Math.max(0, windowStart - SCROLL_WINDOW_ROWS))}
+          >
+            {translate('csv.previousRows', 'Previous rows')}
+          </Button>
+          <span>
+            {translate('csv.rowWindow', 'Rows {{first}}–{{last}}', {
+              first: (windowStart + 1).toLocaleString(),
+              last: Math.min(rowCount, windowStart + SCROLL_WINDOW_ROWS).toLocaleString()
+            })}
+          </span>
+          <Button
+            variant="ghost"
+            size="xs"
+            disabled={windowStart + SCROLL_WINDOW_ROWS >= rowCount}
+            onClick={() => moveWindow(windowStart + SCROLL_WINDOW_ROWS)}
+          >
+            {translate('csv.nextRows', 'Next rows')}
+          </Button>
+        </div>
+      )}
+    </>
+  )
+}
diff --git a/src/renderer/src/components/editor/csv/CsvGridCell.tsx b/src/renderer/src/components/editor/csv/CsvGridCell.tsx
new file mode 100644
index 00000000000..ddd441087c3
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvGridCell.tsx
@@ -0,0 +1,106 @@
+import { Textarea } from '@/components/ui/textarea'
+import { CsvCellValue } from './CsvCellValue'
+import { csvCellIsSelected } from './csv-cell-selection'
+import type { CsvGridInteraction } from './csv-grid-interaction'
+import { translate } from '@/i18n/i18n'
+
+function focusCellInput(node: HTMLTextAreaElement | null): void {
+  node?.focus({ preventScroll: true })
+}
+
+export function CsvGridCell({
+  value,
+  row,
+  column,
+  id,
+  header = false,
+  interaction,
+  onOpenUrl,
+  focusGrid,
+  children
+}: {
+  value: string
+  row: number
+  column: number
+  id: string
+  header?: boolean
+  interaction?: CsvGridInteraction
+  onOpenUrl?: (url: string, event: React.MouseEvent<HTMLAnchorElement>) => void
+  focusGrid: () => void
+  children?: React.ReactNode
+}): React.JSX.Element {
+  const editing = interaction?.editing
+  const active = editing?.position.row === row && editing.position.column === column
+  return (
+    <div
+      id={id}
+      role={header ? 'columnheader' : interaction ? 'gridcell' : 'cell'}
+      aria-colindex={column + 2}
+      aria-label={header ? value : undefined}
+      aria-selected={
+        interaction ? csvCellIsSelected(interaction.selection, row, column) : undefined
+      }
+      data-active={
+        interaction?.selection?.focus.row === row && interaction.selection.focus.column === column
+      }
+      data-csv-row={row}
+      data-csv-column={column}
+      className={
+        header
+          ? 'relative flex min-w-0 items-center border-b border-r border-border/60 font-medium text-foreground aria-selected:bg-accent data-[active=true]:ring-1 data-[active=true]:ring-inset data-[active=true]:ring-ring'
+          : 'flex min-w-0 items-center overflow-hidden border-b border-r border-border/40 text-foreground aria-selected:bg-accent data-[active=true]:ring-1 data-[active=true]:ring-inset data-[active=true]:ring-ring'
+      }
+      title={value}
+      onDoubleClick={(event) => {
+        if (event.target instanceof Element && event.target.closest('a,[role="separator"]')) {
+          return
+        }
+        interaction?.edit(row, column)
+      }}
+    >
+      {active && editing ? (
+        <Textarea
+          ref={focusCellInput}
+          variant="cell"
+          rows={1}
+          aria-label={translate('csv.editCell', 'Edit row {{row}}, column {{column}}', {
+            row: row + 1,
+            column: column + 1
+          })}
+          value={editing.value}
+          onChange={(event) => interaction?.change(event.target.value)}
+          onBlur={() => interaction?.commit()}
+          onKeyDown={(event) => {
+            event.stopPropagation()
+            if (event.nativeEvent.isComposing) {
+              return
+            }
+            const modifier = navigator.userAgent.includes('Mac') ? event.metaKey : event.ctrlKey
+            if (modifier && event.key.toLowerCase() === 's') {
+              event.preventDefault()
+              interaction?.save()
+            } else if (event.key === 'Escape') {
+              event.preventDefault()
+              interaction?.cancel()
+              focusGrid()
+            } else if ((event.key === 'Enter' && !event.shiftKey) || event.key === 'Tab') {
+              event.preventDefault()
+              if (interaction?.commit()) {
+                focusGrid()
+              }
+            }
+          }}
+        />
+      ) : (
+        <div className="flex min-w-0 flex-1 items-center px-2">
+          {header ? (
+            <span className="truncate">{value}</span>
+          ) : (
+            <CsvCellValue value={value} onOpenUrl={onOpenUrl} />
+          )}
+        </div>
+      )}
+      {children}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/editor/csv/CsvPagedViewer.tsx b/src/renderer/src/components/editor/csv/CsvPagedViewer.tsx
new file mode 100644
index 00000000000..968a2420e28
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvPagedViewer.tsx
@@ -0,0 +1,151 @@
+import { useEffect, useState } from 'react'
+import { readRuntimeFileRange } from '@/runtime/runtime-file-range-client'
+import { translate } from '@/i18n/i18n'
+import { detectCsvDelimiter } from './csv-parse'
+import { CsvFooter, csvChosenDelimiter } from './CsvViewer'
+import { CsvGrid } from './CsvGrid'
+import type { CsvFilePreview } from './csv-file-content'
+import type { CsvDelimiterChoice } from './csv-delimiter-picker'
+import { useCsvPagedPreview } from './useCsvPagedPreview'
+import { EditorFileLoadErrorView } from '../EditorFileLoadErrorView'
+import { useCsvColumnWidths } from './useCsvColumnWidths'
+import { buildFileViewPreferenceKey } from '../file-view-preference-storage'
+import { openCsvHttpLink } from './csv-link-routing'
+
+export default function CsvPagedViewer({
+  file,
+  filePath,
+  preferenceKey,
+  onReload
+}: {
+  file: CsvFilePreview
+  filePath: string
+  preferenceKey?: string
+  onReload: () => void
+}): React.JSX.Element {
+  const [sniff, setSniff] = useState<{ delimiter: string; error: string | null } | null>(null)
+  const [choice, setChoice] = useState<CsvDelimiterChoice>('auto')
+  useEffect(() => {
+    let canceled = false
+    setSniff(null)
+    void readRuntimeFileRange(file.readArgs, 0, Math.min(file.snapshot.size, 64 * 1024))
+      .then((bytes) => {
+        if (!canceled) {
+          setSniff({
+            delimiter: detectCsvDelimiter(filePath, new TextDecoder().decode(bytes)),
+            error: null
+          })
+        }
+      })
+      .catch((error: unknown) => {
+        if (!canceled) {
+          setSniff({
+            delimiter: ',',
+            error: error instanceof Error ? error.message : String(error)
+          })
+        }
+      })
+    return () => {
+      canceled = true
+    }
+  }, [file, filePath])
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="border-b border-border px-3 py-1 text-xs text-muted-foreground">
+        {translate('csv.readOnlyPreview', 'Large file preview · Read-only')}
+      </div>
+      {sniff?.error ? (
+        <EditorFileLoadErrorView message={sniff.error} onRetry={onReload} />
+      ) : sniff ? (
+        <CsvPagedTable
+          key={csvChosenDelimiter(choice, sniff.delimiter)}
+          file={file}
+          preferenceKey={preferenceKey}
+          delimiter={csvChosenDelimiter(choice, sniff.delimiter)}
+          choice={choice}
+          detected={sniff.delimiter}
+          onChange={setChoice}
+          onReload={onReload}
+        />
+      ) : (
+        <div role="status" className="p-4 text-sm text-muted-foreground">
+          {translate('csv.detectingDelimiter', 'Detecting delimiter…')}
+        </div>
+      )}
+    </div>
+  )
+}
+
+function CsvPagedTable({
+  file,
+  preferenceKey,
+  delimiter,
+  choice,
+  detected,
+  onChange,
+  onReload
+}: {
+  file: CsvFilePreview
+  preferenceKey?: string
+  delimiter: string
+  choice: CsvDelimiterChoice
+  detected: string
+  onChange: (choice: CsvDelimiterChoice) => void
+  onReload: () => void
+}): React.JSX.Element {
+  const storedKey = JSON.stringify([
+    preferenceKey ??
+      buildFileViewPreferenceKey({
+        worktreeId: file.readArgs.worktreeId ?? '',
+        runtimeEnvironmentId: file.readArgs.settings?.activeRuntimeEnvironmentId,
+        externalSshTargetId: file.readArgs.connectionId,
+        filePath: file.readArgs.filePath
+      }),
+    delimiter
+  ])
+  const { widths, changeWidths } = useCsvColumnWidths(storedKey)
+  const preview = useCsvPagedPreview(file, delimiter)
+  const rowCount = Math.max(0, (preview.index?.rowCount ?? 0) - 1)
+  return (
+    <>
+      {preview.error ? (
+        <EditorFileLoadErrorView message={preview.error} onRetry={onReload} />
+      ) : preview.index ? (
+        <CsvGrid
+          header={preview.header}
+          columnWidths={widths}
+          onColumnWidthsChange={changeWidths}
+          rowCount={rowCount}
+          columnCount={preview.index.columnCount}
+          sampleRows={preview.sample}
+          getRow={preview.getRow}
+          onVisibleRows={preview.onVisibleRows}
+          onOpenUrl={(url, event) =>
+            openCsvHttpLink(url, event, {
+              filePath: file.readArgs.filePath,
+              worktreeId: file.readArgs.worktreeId,
+              runtimeEnvironmentId: file.readArgs.settings?.activeRuntimeEnvironmentId,
+              connectionId: file.readArgs.connectionId ?? null
+            })
+          }
+        />
+      ) : (
+        <div
+          role="status"
+          className="flex flex-1 items-center justify-center text-sm text-muted-foreground"
+        >
+          {translate('csv.indexProgress', 'Indexing CSV… {{percent}}%', {
+            percent: Math.floor((preview.progress / file.snapshot.size) * 100)
+          })}
+        </div>
+      )}
+      <CsvFooter
+        rowCount={rowCount}
+        columnCount={preview.index?.columnCount ?? 0}
+        delimiterChoice={choice}
+        detectedDelimiter={detected}
+        onDelimiterChange={onChange}
+      />
+    </>
+  )
+}
diff --git a/src/renderer/src/components/editor/csv/CsvTableToolbar.tsx b/src/renderer/src/components/editor/csv/CsvTableToolbar.tsx
new file mode 100644
index 00000000000..478f6579ac3
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvTableToolbar.tsx
@@ -0,0 +1,193 @@
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger
+} from '@/components/ui/dropdown-menu'
+import { translate } from '@/i18n/i18n'
+import { csvSelectionBounds, type CsvCellSelection } from './csv-cell-selection'
+import type { CsvTableMutation } from './csv-text-document'
+import type { CsvInspectionSort } from './csv-inspection'
+
+export function CsvTableToolbar({
+  selection,
+  getSelectedRows,
+  sourceRow,
+  sourceRowCount,
+  columnCount,
+  filter,
+  sort,
+  saving,
+  canEdit,
+  canSave,
+  onFilter,
+  onSort,
+  onApply,
+  onEdit,
+  onSave,
+  onCopy,
+  onPaste
+}: {
+  selection: CsvCellSelection | null
+  getSelectedRows: () => number[]
+  sourceRow: number
+  sourceRowCount: number
+  columnCount: number
+  filter: string
+  sort: CsvInspectionSort | null
+  saving: boolean
+  canEdit: boolean
+  canSave: boolean
+  onFilter: (value: string) => void
+  onSort: (value: CsvInspectionSort | null) => void
+  onApply: (mutation: CsvTableMutation) => boolean
+  onEdit: () => void
+  onSave: () => void
+  onCopy: () => void
+  onPaste: () => void
+}): React.JSX.Element {
+  const column = selection?.focus.column ?? 0
+  const row = Math.max(1, sourceRow)
+  const blankRow = () => Array.from({ length: columnCount }, () => '')
+  const selectedColumns = selection ? csvSelectionBounds(selection) : null
+  const deleteColumns = () =>
+    selectedColumns
+      ? Array.from(
+          { length: selectedColumns.lastColumn - selectedColumns.firstColumn + 1 },
+          (_, offset) => selectedColumns.firstColumn + offset
+        )
+      : []
+  return (
+    <div className="flex flex-wrap items-center gap-2 border-b border-border px-3 py-2">
+      <div className="min-w-0 flex-1 max-w-xs">
+        <Input
+          aria-label={translate('csv.filterRows', 'Filter rows')}
+          placeholder={translate('csv.filterRows', 'Filter rows')}
+          value={filter}
+          onChange={(event) => onFilter(event.target.value)}
+        />
+      </div>
+      <Button variant="ghost" size="xs" disabled={!selection || !canEdit} onClick={onEdit}>
+        {translate('csv.edit', 'Edit cell')}
+      </Button>
+      <Button variant="ghost" size="xs" disabled={!selection} onClick={onCopy}>
+        {translate('csv.copy', 'Copy')}
+      </Button>
+      <Button variant="ghost" size="xs" disabled={!selection || !canEdit} onClick={onPaste}>
+        {translate('csv.paste', 'Paste')}
+      </Button>
+      <DropdownMenu>
+        <DropdownMenuTrigger asChild>
+          <Button variant="ghost" size="xs" disabled={!canEdit || !columnCount}>
+            {translate('csv.rows', 'Rows')}
+          </Button>
+        </DropdownMenuTrigger>
+        <DropdownMenuContent>
+          <DropdownMenuItem
+            onSelect={() => onApply({ kind: 'insert-rows', at: row, rows: [blankRow()] })}
+          >
+            {translate('csv.insertRowAbove', 'Insert row above')}
+          </DropdownMenuItem>
+          <DropdownMenuItem
+            onSelect={() =>
+              onApply({
+                kind: 'insert-rows',
+                at: sourceRow === 0 ? 1 : Math.min(row + 1, sourceRowCount),
+                rows: [blankRow()]
+              })
+            }
+          >
+            {translate('csv.insertRowBelow', 'Insert row below')}
+          </DropdownMenuItem>
+          <DropdownMenuItem
+            disabled={!selection || csvSelectionBounds(selection).lastRow === 0}
+            onSelect={() =>
+              onApply({ kind: 'delete-rows', rows: getSelectedRows().filter((row) => row > 0) })
+            }
+          >
+            {translate('csv.deleteRows', 'Delete selected rows')}
+          </DropdownMenuItem>
+        </DropdownMenuContent>
+      </DropdownMenu>
+      <DropdownMenu>
+        <DropdownMenuTrigger asChild>
+          <Button variant="ghost" size="xs" disabled={!canEdit}>
+            {translate('csv.columns', 'Columns')}
+          </Button>
+        </DropdownMenuTrigger>
+        <DropdownMenuContent>
+          <DropdownMenuItem
+            onSelect={() =>
+              onApply({
+                kind: 'insert-column',
+                at: column,
+                label: translate('csv.newColumn', 'Column {{column}}', { column: columnCount + 1 })
+              })
+            }
+          >
+            {translate('csv.insertColumnBefore', 'Insert column before')}
+          </DropdownMenuItem>
+          <DropdownMenuItem
+            onSelect={() =>
+              onApply({
+                kind: 'insert-column',
+                at: Math.min(columnCount, column + 1),
+                label: translate('csv.newColumn', 'Column {{column}}', { column: columnCount + 1 })
+              })
+            }
+          >
+            {translate('csv.insertColumnAfter', 'Insert column after')}
+          </DropdownMenuItem>
+          <DropdownMenuItem
+            disabled={!selection || column === 0}
+            onSelect={() => onApply({ kind: 'move-column', from: column, to: column - 1 })}
+          >
+            {translate('csv.moveColumnLeft', 'Move column left')}
+          </DropdownMenuItem>
+          <DropdownMenuItem
+            disabled={!selection || column >= columnCount - 1}
+            onSelect={() => onApply({ kind: 'move-column', from: column, to: column + 1 })}
+          >
+            {translate('csv.moveColumnRight', 'Move column right')}
+          </DropdownMenuItem>
+          <DropdownMenuItem
+            disabled={!selection}
+            onSelect={() => onApply({ kind: 'delete-columns', columns: deleteColumns() })}
+          >
+            {translate('csv.deleteColumns', 'Delete selected columns')}
+          </DropdownMenuItem>
+        </DropdownMenuContent>
+      </DropdownMenu>
+      <DropdownMenu>
+        <DropdownMenuTrigger asChild>
+          <Button variant="ghost" size="xs" disabled={!columnCount}>
+            {translate('csv.sort', 'Sort')}
+          </Button>
+        </DropdownMenuTrigger>
+        <DropdownMenuContent>
+          <DropdownMenuItem onSelect={() => onSort({ column, direction: 'ascending' })}>
+            {translate('csv.sortAscending', 'Sort selected column ascending')}
+          </DropdownMenuItem>
+          <DropdownMenuItem onSelect={() => onSort({ column, direction: 'descending' })}>
+            {translate('csv.sortDescending', 'Sort selected column descending')}
+          </DropdownMenuItem>
+          <DropdownMenuItem disabled={!sort} onSelect={() => onSort(null)}>
+            {translate('csv.originalOrder', 'Original row order')}
+          </DropdownMenuItem>
+        </DropdownMenuContent>
+      </DropdownMenu>
+      {canSave && (
+        <Button variant="outline" size="xs" disabled={saving} aria-busy={saving} onClick={onSave}>
+          {translate('csv.save', 'Save')}
+        </Button>
+      )}
+      {(filter || sort) && (
+        <span className="text-xs text-muted-foreground">
+          {translate('csv.inspectionOnly', 'Inspection only · File row order unchanged')}
+        </span>
+      )}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/editor/CsvViewer.delimiter.test.tsx b/src/renderer/src/components/editor/csv/CsvViewer.delimiter.test.tsx
similarity index 77%
rename from src/renderer/src/components/editor/CsvViewer.delimiter.test.tsx
rename to src/renderer/src/components/editor/csv/CsvViewer.delimiter.test.tsx
index 73f4091df0a..4abdfd2e9d6 100644
--- a/src/renderer/src/components/editor/CsvViewer.delimiter.test.tsx
+++ b/src/renderer/src/components/editor/csv/CsvViewer.delimiter.test.tsx
@@ -4,14 +4,26 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import CsvViewer from './CsvViewer'
 
 vi.mock('@tanstack/react-virtual', () => ({
-  useVirtualizer: ({ count }: { count: number }) => ({
+  useVirtualizer: ({
+    count,
+    estimateSize,
+    paddingStart = 0
+  }: {
+    count: number
+    estimateSize: (index: number) => number
+    paddingStart?: number
+  }) => ({
     getVirtualItems: () =>
       Array.from({ length: Math.min(count, 3) }, (_, index) => ({
         index,
         key: index,
-        start: index * 28
+        start: paddingStart + index * estimateSize(index),
+        size: estimateSize(index),
+        end: paddingStart + (index + 1) * estimateSize(index)
       })),
-    getTotalSize: () => count * 28
+    getTotalSize: () => paddingStart + count * estimateSize(0),
+    resizeItem: vi.fn(),
+    measure: vi.fn()
   })
 }))
 
@@ -23,6 +35,14 @@ async function chooseDelimiter(label: string): Promise<void> {
 }
 
 describe('CSV delimiter selection', () => {
+  it('previews a dense file below the paged byte threshold', () => {
+    const header = Array.from({ length: 100 }, (_, i) => `column-${i}`).join(',')
+    const content = `${header}\n${`${Array.from({ length: 100 }, () => '1').join(',')}\n`.repeat(4000)}`
+    expect(new TextEncoder().encode(content).length).toBeLessThan(1024 * 1024)
+    render(<CsvViewer content={content} filePath="dense.csv" />)
+    expect(screen.queryByRole('alert')).toBeNull()
+    expect(screen.getByRole('table').getAttribute('aria-rowcount')).toBe('4001')
+  })
   it('lets the reader resolve ambiguous headerless decimal data', async () => {
     render(<CsvViewer content={'1,50;coffee\n2,75;tea'} filePath="prices.csv" />)
     expect(screen.getByRole('combobox', { name: 'Delimiter' }).textContent).toBe('Auto (Comma)')
diff --git a/src/renderer/src/components/editor/csv/CsvViewer.editing.test.tsx b/src/renderer/src/components/editor/csv/CsvViewer.editing.test.tsx
new file mode 100644
index 00000000000..01e37f89155
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvViewer.editing.test.tsx
@@ -0,0 +1,365 @@
+// @vitest-environment happy-dom
+import { useState } from 'react'
+import { renderHook, cleanup, fireEvent, render, screen, act } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import CsvViewer from './CsvViewer'
+import { useCsvTableEditor } from './useCsvTableEditor'
+import { parseCsvTextDocument } from './csv-text-document'
+import { flushPendingEditorChange, hasPendingEditorChange } from '../editor-pending-flush'
+import { APP_MENU_PASTE_EVENT } from '@/lib/app-menu-paste'
+import { ORCA_EDITOR_FILE_SAVED_EVENT } from '../editor-autosave'
+
+vi.mock('@tanstack/react-virtual', () => ({
+  useVirtualizer: ({
+    count,
+    estimateSize,
+    paddingStart = 0
+  }: {
+    count: number
+    estimateSize: (index: number) => number
+    paddingStart?: number
+  }) => ({
+    getVirtualItems: () =>
+      Array.from({ length: Math.min(count, 20) }, (_, index) => ({
+        index,
+        key: index,
+        start: paddingStart + index * estimateSize(index),
+        size: estimateSize(index),
+        end: paddingStart + (index + 1) * estimateSize(index)
+      })),
+    getTotalSize: () => paddingStart + count * estimateSize(0),
+    resizeItem: vi.fn(),
+    measure: vi.fn(),
+    scrollToIndex: vi.fn()
+  })
+}))
+
+afterEach(() => {
+  cleanup()
+  vi.unstubAllGlobals()
+  localStorage.clear()
+  Reflect.deleteProperty(window, 'api')
+})
+
+function setup(source = '\ufeffname,value\r\nB,2\r\nA,1') {
+  const changes = vi.fn()
+  const save = vi.fn().mockResolvedValue(true)
+  function Editor() {
+    const [content, setContent] = useState(source)
+    const [dirty, setDirty] = useState(false)
+    return (
+      <>
+        <CsvViewer
+          content={content}
+          filePath="test.csv"
+          fileId="csv-edit-test"
+          isDirty={dirty}
+          onDirtyStateHint={setDirty}
+          onContentChange={(next) => {
+            changes(next)
+            setContent(next)
+            setDirty(next !== source)
+          }}
+          onSave={save}
+        />
+        <output data-testid="source">{content}</output>
+        <output data-testid="dirty">{String(dirty)}</output>
+      </>
+    )
+  }
+  return { ...render(<Editor />), changes, save }
+}
+
+function edit(value: string, next: string): HTMLElement {
+  fireEvent.doubleClick(screen.getByRole('gridcell', { name: value }))
+  const input = screen.getByRole('textbox', { name: /Edit row/ })
+  fireEvent.change(input, { target: { value: next } })
+  return input
+}
+
+describe('editable CSV table', () => {
+  it('commits escaped multiline values while preserving BOM, endings and source order', () => {
+    const { changes } = setup()
+    const input = edit('B', 'x,"quoted"\nnext')
+    expect(screen.getByTestId('dirty').textContent).toBe('true')
+    fireEvent.keyDown(input, { key: 'Enter' })
+    expect(changes).toHaveBeenCalledTimes(1)
+    expect(screen.getByTestId('source').textContent).toBe(
+      '\ufeffname,value\r\n"x,""quoted""\nnext",2\r\nA,1'
+    )
+  })
+
+  it('Escape cancels before the following blur can commit, preserving earlier dirty state', () => {
+    const { changes } = setup()
+    fireEvent.keyDown(edit('B', 'discarded'), { key: 'Escape' })
+    expect(changes).not.toHaveBeenCalled()
+    expect(screen.getByTestId('dirty').textContent).toBe('false')
+    fireEvent.keyDown(edit('B', 'kept'), { key: 'Enter' })
+    fireEvent.keyDown(edit('A', 'discarded too'), { key: 'Escape' })
+    expect(changes).toHaveBeenCalledTimes(1)
+    expect(screen.getByTestId('dirty').textContent).toBe('true')
+  })
+
+  it('flushes the active input into the draft for global Save and hot exit', () => {
+    const { changes } = setup()
+    edit('B', 'pending')
+    act(() => flushPendingEditorChange('csv-edit-test'))
+    expect(changes).toHaveBeenCalledWith('\ufeffname,value\r\npending,2\r\nA,1')
+  })
+
+  it('retains pending input when switching away from the table', () => {
+    const { changes, unmount } = setup()
+    edit('B', 'switching')
+    unmount()
+    expect(changes).toHaveBeenCalledWith('\ufeffname,value\r\nswitching,2\r\nA,1')
+  })
+
+  it('saves the current cell value and reports a failed write without dropping the draft', async () => {
+    const { save } = setup()
+    save.mockResolvedValue(false)
+    fireEvent.keyDown(edit('B', 'saved value'), { key: 's', ctrlKey: true, metaKey: true })
+    expect(save).toHaveBeenCalledWith('\ufeffname,value\r\nsaved value,2\r\nA,1')
+    expect((await screen.findByRole('alert')).textContent).toContain(
+      'Your edits remain in the draft'
+    )
+    expect(screen.getByTestId('source').textContent).toContain('saved value')
+  })
+
+  it('pastes atomically into selected cells and does not partially apply an oversized rectangle', () => {
+    const { changes } = setup()
+    const cell = screen.getByRole('gridcell', { name: 'B' })
+    fireEvent.pointerDown(cell, { button: 0 })
+    const grid = screen.getByRole('grid')
+    fireEvent.paste(grid, { clipboardData: { getData: () => 'new\t3\nother\t4' } })
+    expect(screen.getByTestId('source').textContent).toBe('\ufeffname,value\r\nnew,3\r\nother,4')
+    fireEvent.paste(grid, { clipboardData: { getData: () => 'one\ttwo\tthree' } })
+    expect(changes).toHaveBeenCalledTimes(1)
+    expect(screen.getByRole('alert').textContent).toContain('Paste exceeds the table')
+  })
+
+  it('edits a filtered row in its original source position', () => {
+    setup()
+    fireEvent.change(screen.getByRole('textbox', { name: 'Filter rows' }), {
+      target: { value: 'A' }
+    })
+    fireEvent.keyDown(edit('1', 'updated'), { key: 'Enter' })
+    expect(screen.getByTestId('source').textContent).toBe('\ufeffname,value\r\nB,2\r\nA,updated')
+  })
+
+  it('keeps the chosen table delimiter when an edit would change the Auto guess', () => {
+    setup('first;second\nvalue;two')
+    fireEvent.doubleClick(screen.getByRole('columnheader', { name: 'first' }))
+    const input = screen.getByRole('textbox', { name: /Edit row/ })
+    fireEvent.change(input, { target: { value: 'tabs\there\ttoo' } })
+    fireEvent.keyDown(input, { key: 'Enter' })
+    expect(screen.getByRole('grid').getAttribute('aria-colcount')).toBe('3')
+    expect(screen.getByRole('columnheader', { name: 'tabs\there\ttoo' })).toBeTruthy()
+    expect(screen.getByRole('combobox', { name: 'Delimiter' }).textContent).toBe('Semicolon (;)')
+  })
+
+  it('cancels only the new cell after an earlier save completes', () => {
+    setup()
+    fireEvent.keyDown(edit('B', 'saved base'), { key: 'Enter' })
+    const source = screen.getByTestId('source').textContent
+    const input = edit('A', 'new pending cell')
+    expect(hasPendingEditorChange('csv-edit-test')).toBe(true)
+    act(() =>
+      window.dispatchEvent(
+        new CustomEvent(ORCA_EDITOR_FILE_SAVED_EVENT, {
+          detail: { fileId: 'csv-edit-test', content: source }
+        })
+      )
+    )
+    fireEvent.keyDown(input, { key: 'Escape' })
+    expect(hasPendingEditorChange('csv-edit-test')).toBe(false)
+    expect(screen.getByTestId('dirty').textContent).toBe('false')
+    expect(screen.getByTestId('source').textContent).toBe(source)
+  })
+
+  it('keeps a rejected over-limit edit visible and recoverable on view detachment', () => {
+    const { changes, unmount } = setup()
+    const value = 'x'.repeat(1024 * 1024 + 1)
+    fireEvent.keyDown(edit('B', value), { key: 'Enter' })
+    expect(screen.getByRole('alert').textContent).toContain('record is too large')
+    expect(changes).not.toHaveBeenCalled()
+    const retained = screen.getByRole('textbox', { name: /Edit row/ })
+    expect(retained instanceof HTMLTextAreaElement && retained.value).toBe(value)
+    unmount()
+    expect(changes).toHaveBeenCalledWith(`\ufeffname,value\r\n${value},2\r\nA,1`)
+  })
+
+  it('blocks table mutations after a rejected pending edit and preserves its recovery draft', () => {
+    const { changes, unmount } = setup()
+    const value = 'x'.repeat(1024 * 1024 + 1)
+    fireEvent.keyDown(edit('B', value), { key: 'Enter' })
+    fireEvent.keyDown(screen.getByRole('button', { name: 'Rows' }), {
+      key: 'ArrowDown'
+    })
+    fireEvent.click(screen.getByRole('menuitem', { name: 'Insert row below' }))
+    expect(changes).not.toHaveBeenCalled()
+    expect(screen.getByTestId('source').textContent).toBe('\ufeffname,value\r\nB,2\r\nA,1')
+    unmount()
+    expect(changes).toHaveBeenCalledWith(`\ufeffname,value\r\n${value},2\r\nA,1`)
+  })
+
+  it('applies a pending cell and a subsequent structural mutation atomically', () => {
+    const changes = vi.fn()
+    const { result } = renderHook(() =>
+      useCsvTableEditor({
+        document: parseCsvTextDocument('name,value\nB,2', ','),
+        inspectionRows: null,
+        onContentChange: changes,
+        onStructureChange: vi.fn()
+      })
+    )
+    act(() => result.current.edit(1, 0))
+    act(() => result.current.interaction?.change('pending'))
+    act(() =>
+      expect(result.current.apply({ kind: 'insert-column', at: 1, label: 'new' })).toBe(true)
+    )
+    expect(changes).toHaveBeenCalledExactlyOnceWith('name,new,value\npending,,2')
+    expect(result.current.interaction?.editing).toBeNull()
+  })
+
+  it('leaves a read-only table without mutation controls or an input', () => {
+    render(<CsvViewer content={'a,b\nx,y'} filePath="readonly.csv" />)
+    fireEvent.doubleClick(screen.getByRole('cell', { name: 'x' }))
+    expect(screen.queryByRole('grid')).toBeNull()
+    expect(screen.queryByRole('textbox', { name: /Edit row/ })).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Save' })).toBeNull()
+  })
+
+  it('rejects an asynchronous paste when the selection changes while reading', async () => {
+    let resolveRead: (value: string) => void = () => {
+      throw new Error('read not initialized')
+    }
+    const pending = new Promise<string>((resolve) => {
+      resolveRead = resolve
+    })
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: { ui: { readClipboardText: () => pending } }
+    })
+    const { changes } = setup()
+    fireEvent.pointerDown(screen.getByRole('gridcell', { name: 'B' }), { button: 0 })
+    fireEvent.click(screen.getByRole('button', { name: 'Paste' }))
+    fireEvent.pointerDown(screen.getByRole('gridcell', { name: 'A' }), { button: 0 })
+    await act(async () => {
+      resolveRead('stale paste')
+      await pending
+    })
+    expect(changes).not.toHaveBeenCalled()
+    expect(screen.getByRole('alert').textContent).toContain('CSV changed before paste completed')
+  })
+
+  it('rejects a delayed paste if typing starts before the clipboard read completes', async () => {
+    let resolveRead: (value: string) => void = () => {}
+    const pending = new Promise<string>((resolve) => {
+      resolveRead = resolve
+    })
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: { ui: { readClipboardText: () => pending } }
+    })
+    const { changes } = setup()
+    fireEvent.pointerDown(screen.getByRole('gridcell', { name: 'B' }), { button: 0 })
+    fireEvent.click(screen.getByRole('button', { name: 'Paste' }))
+    edit('B', 'new pending input')
+    await act(async () => {
+      resolveRead('old clipboard')
+      await pending
+    })
+    expect(changes).not.toHaveBeenCalled()
+    expect(screen.getByRole('alert').textContent).toContain('CSV changed before paste completed')
+    const retained = screen.getByRole('textbox', { name: /Edit row/ })
+    expect(retained instanceof HTMLTextAreaElement && retained.value).toBe('new pending input')
+  })
+
+  it('routes menu paste only to the focused grid when two file panes are mounted', async () => {
+    const first = vi.fn()
+    const second = vi.fn()
+    const read = vi.fn().mockResolvedValue('pasted')
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: { ui: { readClipboardText: read } }
+    })
+    render(
+      <>
+        <CsvViewer content={'header\nfirst'} filePath="first.csv" onContentChange={first} />
+        <CsvViewer content={'header\nsecond'} filePath="second.csv" onContentChange={second} />
+      </>
+    )
+    fireEvent.pointerDown(screen.getByRole('gridcell', { name: 'first' }), { button: 0 })
+    fireEvent.pointerDown(screen.getByRole('gridcell', { name: 'second' }), { button: 0 })
+    await act(async () => {
+      window.dispatchEvent(new Event(APP_MENU_PASTE_EVENT, { cancelable: true }))
+      await Promise.resolve()
+    })
+    expect(read).toHaveBeenCalledTimes(1)
+    expect(first).not.toHaveBeenCalled()
+    expect(second).toHaveBeenCalledWith('header\npasted')
+  })
+
+  it('cancels delayed app-menu paste when focus moves to another file pane', async () => {
+    const first = vi.fn()
+    const second = vi.fn()
+    let resolveRead: (value: string) => void = () => {}
+    const pending = new Promise<string>((resolve) => {
+      resolveRead = resolve
+    })
+    const read = vi.fn(() => pending)
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: { ui: { readClipboardText: read } }
+    })
+    render(
+      <>
+        <CsvViewer content={'header\nfirst'} filePath="first.csv" onContentChange={first} />
+        <CsvViewer content={'header\nsecond'} filePath="second.csv" onContentChange={second} />
+      </>
+    )
+    fireEvent.pointerDown(screen.getByRole('gridcell', { name: 'first' }), { button: 0 })
+    act(() => {
+      window.dispatchEvent(new Event(APP_MENU_PASTE_EVENT, { cancelable: true }))
+    })
+    expect(read).toHaveBeenCalledTimes(1)
+    act(() => {
+      screen.getAllByRole('grid')[1]?.focus()
+    })
+    await act(async () => {
+      resolveRead('stale paste')
+      await pending
+    })
+    expect(first).not.toHaveBeenCalled()
+    expect(second).not.toHaveBeenCalled()
+  })
+
+  it('flushes an edited pane even when another pane of the same file registered later', () => {
+    const first = vi.fn()
+    const second = vi.fn()
+    render(
+      <>
+        <CsvViewer
+          content={'header\nfirst'}
+          filePath="same.csv"
+          fileId="same-file"
+          onContentChange={first}
+        />
+        <CsvViewer
+          content={'header\nfirst'}
+          filePath="same.csv"
+          fileId="same-file"
+          onContentChange={second}
+        />
+      </>
+    )
+    fireEvent.doubleClick(screen.getAllByRole('gridcell', { name: 'first' })[0]!)
+    fireEvent.change(screen.getByRole('textbox', { name: /Edit row/ }), {
+      target: { value: 'pending first pane' }
+    })
+    expect(hasPendingEditorChange('same-file')).toBe(true)
+    act(() => flushPendingEditorChange('same-file'))
+    expect(first).toHaveBeenCalledWith('header\npending first pane')
+    expect(second).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/components/editor/csv/CsvViewer.tsx b/src/renderer/src/components/editor/csv/CsvViewer.tsx
new file mode 100644
index 00000000000..c6264f1c3d3
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/CsvViewer.tsx
@@ -0,0 +1,224 @@
+import { useCallback, useMemo, useState } from 'react'
+import { detectCsvDelimiter } from './csv-parse'
+import { CsvDelimiterPicker, type CsvDelimiterChoice } from './csv-delimiter-picker'
+import { CsvGrid } from './CsvGrid'
+import { translate } from '@/i18n/i18n'
+import { openCsvHttpLink } from './csv-link-routing'
+import { parseCsvTextDocument } from './csv-text-document'
+import { csvInspectionRows, csvSourceRow, type CsvInspectionSort } from './csv-inspection'
+import { useCsvTableEditor } from './useCsvTableEditor'
+import { CsvTableToolbar } from './CsvTableToolbar'
+import { remapCsvColumnWidths } from './csv-column-width-preferences'
+import { useCsvColumnWidths } from './useCsvColumnWidths'
+import { buildFileViewPreferenceKey } from '../file-view-preference-storage'
+
+export default function CsvViewer({
+  content,
+  filePath,
+  worktreeId,
+  runtimeEnvironmentId,
+  preferenceKey,
+  onContentChange,
+  onSave,
+  fileId,
+  isDirty,
+  onDirtyStateHint
+}: {
+  content: string
+  filePath: string
+  worktreeId?: string
+  runtimeEnvironmentId?: string | null
+  preferenceKey?: string
+  fileId?: string
+  isDirty?: boolean
+  onDirtyStateHint?: (dirty: boolean) => void
+  onContentChange?: (content: string) => void
+  onSave?: (content: string) => Promise<boolean>
+}): React.JSX.Element {
+  const [delimiterChoice, setDelimiterChoice] = useState<CsvDelimiterChoice>('auto')
+  const detectedDelimiter = useMemo(
+    () => detectCsvDelimiter(filePath, content),
+    [filePath, content]
+  )
+  const delimiter = csvChosenDelimiter(delimiterChoice, detectedDelimiter)
+  const result = useMemo(() => {
+    try {
+      return {
+        parsed: parseCsvTextDocument(content, delimiter),
+        error: null
+      }
+    } catch (error) {
+      return { parsed: null, error: error instanceof Error ? error.message : String(error) }
+    }
+  }, [content, delimiter])
+  const [filter, setFilter] = useState('')
+  const [sort, setSort] = useState<CsvInspectionSort | null>(null)
+  const storedKey = JSON.stringify([
+    preferenceKey ??
+      buildFileViewPreferenceKey({
+        worktreeId: worktreeId ?? '',
+        runtimeEnvironmentId,
+        filePath
+      }),
+    delimiter
+  ])
+  const { widths: columnWidths, changeWidths } = useCsvColumnWidths(storedKey)
+  const document = result.parsed
+  const effectiveSort = sort && sort.column < (document?.columnCount ?? 0) ? sort : null
+  const inspectionRows = useMemo(
+    () => (document ? csvInspectionRows(document.rows, filter, effectiveSort) : null),
+    [document, filter, effectiveSort]
+  )
+  const editor = useCsvTableEditor({
+    document,
+    fileId,
+    isDirty,
+    onDirtyStateHint,
+    inspectionRows,
+    onContentChange,
+    onSave,
+    onStructureChange: (mutation) => {
+      if (delimiterChoice === 'auto') {
+        setDelimiterChoice(delimiter === ',' ? 'comma' : delimiter === ';' ? 'semicolon' : 'tab')
+      }
+      const widths = remapCsvColumnWidths(columnWidths, document?.columnCount ?? 0, mutation)
+      if (widths !== columnWidths) {
+        changeWidths(widths)
+      }
+      if (
+        mutation.kind === 'delete-columns' ||
+        mutation.kind === 'insert-column' ||
+        mutation.kind === 'move-column'
+      ) {
+        setSort(null)
+      }
+    }
+  })
+  const header = document?.rows[0] ?? []
+  const rowCount = inspectionRows?.length ?? Math.max(0, (document?.rows.length ?? 0) - 1)
+  const sample = useMemo(() => document?.rows.slice(1, 201) ?? [], [document])
+  const getRow = useCallback(
+    (index: number) => document?.rows[csvSourceRow(index + 1, inspectionRows)],
+    [document, inspectionRows]
+  )
+  return (
+    <div ref={editor.setRootRef} className="flex h-full min-h-0 flex-col">
+      {onContentChange && (
+        <CsvTableToolbar
+          selection={editor.selection}
+          getSelectedRows={editor.selectedRows}
+          sourceRow={csvSourceRow(editor.selection?.focus.row ?? 0, inspectionRows)}
+          sourceRowCount={document?.rows.length ?? 0}
+          columnCount={document?.columnCount ?? 0}
+          filter={filter}
+          sort={effectiveSort}
+          saving={editor.saving}
+          canEdit={!result.error}
+          canSave={Boolean(onSave)}
+          onFilter={(next) => {
+            if (editor.interaction?.commit() !== false) {
+              setFilter(next)
+            }
+          }}
+          onSort={(next) => {
+            if (editor.interaction?.commit() !== false) {
+              setSort(next)
+            }
+          }}
+          onApply={editor.apply}
+          onEdit={() =>
+            editor.edit(editor.selection?.focus.row ?? 0, editor.selection?.focus.column ?? 0)
+          }
+          onSave={() => void editor.save()}
+          onCopy={() => void editor.copy()}
+          onPaste={() => void editor.paste()}
+        />
+      )}
+      {editor.error && (
+        <div role="alert" className="border-b border-border px-3 py-2 text-sm text-destructive">
+          {editor.error}
+        </div>
+      )}
+      {result.error ? (
+        <div
+          role="alert"
+          className="flex flex-1 items-center justify-center px-4 text-sm text-muted-foreground"
+        >
+          {result.error}
+        </div>
+      ) : result.parsed?.rows.length ? (
+        <CsvGrid
+          key={delimiter}
+          header={header}
+          rowCount={rowCount}
+          columnCount={result.parsed.columnCount}
+          interaction={editor.interaction}
+          columnWidths={columnWidths}
+          onColumnWidthsChange={changeWidths}
+          sampleRows={sample}
+          getRow={getRow}
+          onOpenUrl={(url, event) =>
+            openCsvHttpLink(url, event, { filePath, worktreeId, runtimeEnvironmentId })
+          }
+        />
+      ) : (
+        <div className="flex flex-1 items-center justify-center text-sm text-muted-foreground">
+          {translate('auto.components.editor.CsvViewer.a233d55b77', 'Empty file')}
+        </div>
+      )}
+      <CsvFooter
+        rowCount={rowCount}
+        columnCount={result.parsed?.columnCount ?? 0}
+        delimiterChoice={delimiterChoice}
+        detectedDelimiter={detectedDelimiter}
+        onDelimiterChange={(next) => {
+          if (editor.interaction?.commit() !== false) {
+            setDelimiterChoice(next)
+          }
+        }}
+      />
+    </div>
+  )
+}
+
+export function csvChosenDelimiter(choice: CsvDelimiterChoice, detected: string): string {
+  return choice === 'auto'
+    ? detected
+    : choice === 'comma'
+      ? ','
+      : choice === 'semicolon'
+        ? ';'
+        : '\t'
+}
+
+export function CsvFooter({
+  rowCount,
+  columnCount,
+  delimiterChoice,
+  detectedDelimiter,
+  onDelimiterChange
+}: {
+  rowCount: number
+  columnCount: number
+  delimiterChoice: CsvDelimiterChoice
+  detectedDelimiter: string
+  onDelimiterChange: (choice: CsvDelimiterChoice) => void
+}): React.JSX.Element {
+  return (
+    <div className="flex flex-wrap items-center gap-4 border-t border-border/60 px-3 py-1 text-xs text-muted-foreground">
+      <span>
+        {rowCount.toLocaleString()}{' '}
+        {translate('auto.components.editor.CsvViewer.ac31d2cd60', 'rows')}
+      </span>
+      <span>
+        {columnCount.toLocaleString()}{' '}
+        {translate('auto.components.editor.CsvViewer.eedd0d37a7', 'columns')}
+      </span>
+      <CsvDelimiterPicker
+        value={delimiterChoice}
+        detectedDelimiter={detectedDelimiter}
+        onChange={onDelimiterChange}
+      />
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/editor/csv/csv-byte-index.test.ts b/src/renderer/src/components/editor/csv/csv-byte-index.test.ts
new file mode 100644
index 00000000000..2a792f7a915
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-byte-index.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest'
+import {
+  CsvByteIndex,
+  CSV_MAX_COLUMNS,
+  CSV_MAX_PAGE_BYTES,
+  CSV_RECORD_BYTES,
+  csvPageForRow
+} from './csv-byte-index'
+import { parseCsv } from './csv-parse'
+
+function indexCsv(source: string, delimiter: string, chunkSize: number) {
+  const bytes = new TextEncoder().encode(source)
+  const index = new CsvByteIndex(delimiter.charCodeAt(0))
+  for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+    index.feed(bytes.subarray(offset, offset + chunkSize))
+  }
+  return { bytes, result: index.finish() }
+}
+
+describe('CSV byte index', () => {
+  const samples = [
+    '',
+    '\ufeff',
+    '""',
+    '\n',
+    'a,b\r\n1,2\r\n',
+    'a\rb\nc\r\nd',
+    'a,b,',
+    '"a\r\nb","x""y"\n"",z',
+    '"""";日本語\r\n"line\nline";😀',
+    '""""""\n""""""',
+    '""""x,1\n""""x,2',
+    '"""";"unclosed\nfield',
+    '""""\n\ufeffvalue'
+  ]
+  for (const delimiter of [',', ';', '\t']) {
+    for (const chunkSize of [1, 2, 3, 7, 256 * 1024]) {
+      it(`matches the parser for ${JSON.stringify(delimiter)} with ${chunkSize}-byte chunks`, () => {
+        for (const source of samples) {
+          const { bytes, result } = indexCsv(source, delimiter, chunkSize)
+          const expected = parseCsv(source, delimiter)
+          expect(result.rowCount, source).toBe(expected.rows.length)
+          expect(result.columnCount, source).toBe(expected.maxColumns)
+          const decoded = result.pages.flatMap(
+            (page) =>
+              parseCsv(
+                new TextDecoder('utf-8', { ignoreBOM: true }).decode(
+                  bytes.subarray(page.start, page.end)
+                ),
+                delimiter,
+                { stripBom: page.start === 0 }
+              ).rows
+          )
+          expect(decoded, source).toEqual(expected.rows)
+        }
+      })
+    }
+  }
+  it('round-trips many pages with Unicode, escaped quotes, mixed line endings and ragged rows', () => {
+    const rows = Array.from({ length: 1800 }, (_, i) => [
+      String(i),
+      `😀;${i}\r\n"quoted"`,
+      ...(i % 3 ? [] : [''])
+    ])
+    const source = `\ufeff${rows.map((row, i) => row.map((cell) => `"${cell.replaceAll('"', '""')}"`).join(';') + ['\n', '\r\n', '\r'][i % 3]).join('')}`
+    const { bytes, result } = indexCsv(source, ';', 7)
+    expect(result.pages.length).toBeGreaterThan(4)
+    expect(
+      result.pages.flatMap(
+        (page) => parseCsv(new TextDecoder().decode(bytes.subarray(page.start, page.end)), ';').rows
+      )
+    ).toEqual(rows)
+    for (let row = 0; row < rows.length; row += 1) {
+      const page = result.pages[csvPageForRow(result.pages, row)]!
+      expect(row).toBeGreaterThanOrEqual(page.firstRow)
+      expect(row).toBeLessThan(page.firstRow + page.rowCount)
+    }
+  })
+  it('limits raw record bytes and empty columns before allocating any cells', () => {
+    expect(() => indexCsv(`"${'x'.repeat(CSV_RECORD_BYTES)}`, ',', 1000)).toThrow('record')
+    expect(() => indexCsv(','.repeat(CSV_MAX_COLUMNS), ',', 1000)).toThrow('column')
+    expect(() => indexCsv('a\0b', ',', 1)).toThrow('binary')
+  })
+  it('matches parser limits at record boundaries with BOMs and every line ending', () => {
+    const records = [
+      'x'.repeat(CSV_RECORD_BYTES),
+      `"${'x'.repeat(CSV_RECORD_BYTES - 2)}"`,
+      `"${'x'.repeat(CSV_RECORD_BYTES - 3)}\n"`
+    ]
+    for (const bom of ['', '\ufeff']) {
+      for (const ending of ['', '\n', '\r', '\r\n']) {
+        for (const record of records) {
+          const source = `${bom}${record}${ending}`
+          const { bytes, result } = indexCsv(source, ',', 256 * 1024)
+          expect(result.rowCount).toBe(1)
+          expect(result.pages[0]!.end - result.pages[0]!.start).toBeLessThanOrEqual(
+            CSV_MAX_PAGE_BYTES
+          )
+          const decoded = new TextDecoder('utf-8', { ignoreBOM: true }).decode(bytes)
+          expect(parseCsv(decoded, ',', { maxRecordLength: CSV_RECORD_BYTES })).toEqual(
+            parseCsv(source)
+          )
+          expect(() => indexCsv(`${bom}${record}x${ending}`, ',', 256 * 1024)).toThrow('record')
+        }
+      }
+    }
+  })
+  it('preserves a real BOM character at a later page boundary', () => {
+    const source = `${'value\n'.repeat(256)}\ufefflast\n`
+    const { bytes, result } = indexCsv(source, ',', 7)
+    const page = result.pages[1]!
+    const text = new TextDecoder('utf-8', { ignoreBOM: true }).decode(
+      bytes.subarray(page.start, page.end)
+    )
+    expect(parseCsv(text, ',', { stripBom: false }).rows).toEqual([['\ufefflast']])
+  })
+  it('splits dense records by cell budget instead of only row count', () => {
+    const source = `${','.repeat(CSV_MAX_COLUMNS - 1)}\n`.repeat(30)
+    const { result } = indexCsv(source, ',', 256 * 1024)
+    expect(result.rowCount).toBe(30)
+    expect(result.pages.every((page) => page.rowCount <= 4)).toBe(true)
+  })
+})
diff --git a/src/renderer/src/components/editor/csv/csv-byte-index.ts b/src/renderer/src/components/editor/csv/csv-byte-index.ts
new file mode 100644
index 00000000000..3f74ea132c6
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-byte-index.ts
@@ -0,0 +1,173 @@
+export const CSV_RECORD_BYTES = 1024 * 1024
+// A first page can also contain a UTF-8 BOM and a trailing CRLF.
+export const CSV_MAX_PAGE_BYTES = CSV_RECORD_BYTES + 5
+export const CSV_MAX_COLUMNS = 4096
+const PAGE_ROWS = 256
+const PAGE_BYTES = 64 * 1024
+export const CSV_PAGE_CELLS = 16 * 1024
+const MAX_PAGES = 100_000
+
+export type CsvPageRange = { start: number; end: number; firstRow: number; rowCount: number }
+export type CsvIndex = { pages: CsvPageRange[]; rowCount: number; columnCount: number }
+
+/** Record boundaries use ASCII bytes, so multibyte text never needs decoding during the scan. */
+export class CsvByteIndex {
+  private position = 0
+  private rowStart = 0
+  private pageStart = 0
+  private pageFirstRow = 0
+  private pageCells = 0
+  private rowCount = 0
+  private columns = 1
+  private columnCount = 0
+  private fieldEmpty = true
+  private hasContent = false
+  private inQuotes = false
+  private pendingQuote = false
+  private pendingCR = false
+  private prefix: number[] = []
+  private pages: CsvPageRange[] = []
+
+  constructor(private readonly delimiter: number) {}
+
+  feed(bytes: Uint8Array): void {
+    for (const byte of bytes) {
+      const at = this.position++
+      if (at < 3) {
+        this.prefix.push(byte)
+        if (at === 2) {
+          this.consumePrefix()
+        }
+      } else {
+        this.consume(byte, at)
+      }
+    }
+  }
+
+  finish(): CsvIndex {
+    if (this.position < 3) {
+      this.consumePrefix()
+    }
+    if (this.pendingCR || this.hasContent || this.columns > 1) {
+      this.emitRow(this.position, this.position - (this.pendingCR ? 1 : 0))
+    }
+    this.checkpoint(this.position)
+    return { pages: this.pages, rowCount: this.rowCount, columnCount: this.columnCount }
+  }
+
+  private consumePrefix(): void {
+    if (this.prefix[0] === 239 && this.prefix[1] === 187 && this.prefix[2] === 191) {
+      this.rowStart = 3
+    } else {
+      this.prefix.forEach((byte, at) => this.consume(byte, at))
+    }
+    this.prefix = []
+  }
+
+  private checkpoint(end: number): void {
+    if (this.rowCount === this.pageFirstRow) {
+      return
+    }
+    if (this.pages.length >= MAX_PAGES) {
+      throw new Error('CSV has too many pages to preview safely.')
+    }
+    this.pages.push({
+      start: this.pageStart,
+      end,
+      firstRow: this.pageFirstRow,
+      rowCount: this.rowCount - this.pageFirstRow
+    })
+    this.pageStart = end
+    this.pageFirstRow = this.rowCount
+    this.pageCells = 0
+  }
+
+  private emitRow(end: number, contentEnd = end): void {
+    if (contentEnd - this.rowStart > CSV_RECORD_BYTES) {
+      throw new Error('CSV record exceeds the 1 MB preview limit.')
+    }
+    if (end - this.pageStart > PAGE_BYTES || this.pageCells + this.columns > CSV_PAGE_CELLS) {
+      this.checkpoint(this.rowStart)
+    }
+    this.rowCount += 1
+    this.columnCount = Math.max(this.columnCount, this.columns)
+    this.pageCells += this.columns
+    if (
+      this.rowCount - this.pageFirstRow >= PAGE_ROWS ||
+      end - this.pageStart >= PAGE_BYTES ||
+      this.pageCells >= CSV_PAGE_CELLS
+    ) {
+      this.checkpoint(end)
+    }
+    this.rowStart = end
+    this.columns = 1
+    this.fieldEmpty = true
+    this.hasContent = false
+  }
+
+  private consume(byte: number, at: number): void {
+    if (this.pendingCR) {
+      this.pendingCR = false
+      this.emitRow(byte === 10 ? at + 1 : at, at - 1)
+      if (byte === 10) {
+        return
+      }
+    }
+    const endsRecord = (byte === 13 || byte === 10) && (!this.inQuotes || this.pendingQuote)
+    if (at + (endsRecord ? 0 : 1) - this.rowStart > CSV_RECORD_BYTES) {
+      throw new Error('CSV record exceeds the 1 MB preview limit.')
+    }
+    if (byte === 0) {
+      throw new Error('This file contains binary data.')
+    }
+    if (this.inQuotes && this.pendingQuote) {
+      this.pendingQuote = false
+      if (byte === 34) {
+        this.fieldEmpty = false
+        return
+      }
+      this.inQuotes = false
+    }
+    if (this.inQuotes) {
+      if (byte === 34) {
+        this.pendingQuote = true
+      } else {
+        this.fieldEmpty = false
+      }
+      return
+    }
+    if (byte === 34 && this.fieldEmpty) {
+      this.inQuotes = true
+      this.hasContent = true
+      return
+    }
+    if (byte === this.delimiter) {
+      if (++this.columns > CSV_MAX_COLUMNS) {
+        throw new Error('CSV exceeds the 4,096 column preview limit.')
+      }
+      this.fieldEmpty = true
+      this.hasContent = true
+    } else if (byte === 13) {
+      this.pendingCR = true
+    } else if (byte === 10) {
+      this.emitRow(at + 1, at)
+    } else {
+      this.fieldEmpty = false
+      this.hasContent = true
+    }
+  }
+}
+
+export function csvPageForRow(pages: CsvPageRange[], row: number): number {
+  let low = 0
+  let high = pages.length - 1
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2)
+    if (pages[mid]!.firstRow <= row) {
+      low = mid
+    } else {
+      high = mid - 1
+    }
+  }
+  return low
+}
diff --git a/src/renderer/src/components/editor/csv/csv-cell-clipboard.ts b/src/renderer/src/components/editor/csv/csv-cell-clipboard.ts
new file mode 100644
index 00000000000..48334b252cf
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-cell-clipboard.ts
@@ -0,0 +1,90 @@
+import {
+  CLIPBOARD_TEXT_WRITE_MAX_BYTES,
+  assertClipboardTextWithinLimit,
+  assertClipboardTextWriteWithinLimit
+} from '../../../../../shared/clipboard-text'
+import { CSV_MAX_COLUMNS, CSV_RECORD_BYTES } from './csv-byte-index'
+import { measureUtf8ByteLength } from '../../../../../shared/utf8-byte-limits'
+import { parseCsv } from './csv-parse'
+import { serializeCsvRecord } from './csv-serialization'
+import { csvSelectionBounds, type CsvCellSelection } from './csv-cell-selection'
+import { csvSourceRow } from './csv-inspection'
+import type { CsvCellEdit } from './csv-text-document'
+
+const CLIPBOARD_CELLS = 1024 * 1024
+
+export function copyCsvSelection(
+  selection: CsvCellSelection,
+  rows: readonly string[][],
+  inspectionRows: readonly number[] | null
+): string {
+  const bounds = csvSelectionBounds(selection)
+  const records: string[] = []
+  let cells = 0
+  let bytes = 0
+  for (let row = bounds.firstRow; row <= bounds.lastRow; row += 1) {
+    const source = rows[csvSourceRow(row, inspectionRows)]
+    if (!source) {
+      throw new Error('The selected CSV row no longer exists.')
+    }
+    const values: string[] = []
+    for (let column = bounds.firstColumn; column <= bounds.lastColumn; column += 1) {
+      if (++cells > CLIPBOARD_CELLS) {
+        throw new Error('Select fewer cells to copy at once.')
+      }
+      values.push(source[column] ?? '')
+    }
+    const record = serializeCsvRecord(values, '\t')
+    bytes +=
+      measureUtf8ByteLength(record, { stopAfterBytes: CLIPBOARD_TEXT_WRITE_MAX_BYTES }).byteLength +
+      (records.length ? 1 : 0)
+    if (bytes > CLIPBOARD_TEXT_WRITE_MAX_BYTES) {
+      throw new Error('Selected cells are too large to copy safely.')
+    }
+    records.push(record)
+  }
+  return assertClipboardTextWriteWithinLimit(records.join('\n'))
+}
+
+export function pasteCsvSelection(
+  text: string,
+  selection: CsvCellSelection,
+  rows: readonly string[][],
+  columnCount: number,
+  inspectionRows: readonly number[] | null
+): CsvCellEdit[] {
+  assertClipboardTextWithinLimit(text)
+  const pasted =
+    text === ''
+      ? [['']]
+      : parseCsv(text, '\t', {
+          maxCells: CLIPBOARD_CELLS,
+          maxColumns: CSV_MAX_COLUMNS,
+          maxRecordLength: CSV_RECORD_BYTES,
+          stripBom: false
+        }).rows
+  const bounds = csvSelectionBounds(selection)
+  const fill = pasted.length === 1 && pasted[0]?.length === 1
+  const height = fill ? bounds.lastRow - bounds.firstRow + 1 : pasted.length
+  const width = fill
+    ? bounds.lastColumn - bounds.firstColumn + 1
+    : pasted.reduce((maximum, row) => Math.max(maximum, row.length), 0)
+  const viewRowCount = inspectionRows ? inspectionRows.length + 1 : rows.length
+  if (bounds.firstRow + height > viewRowCount || bounds.firstColumn + width > columnCount) {
+    throw new Error('Paste exceeds the table. Add rows or columns first.')
+  }
+  if (height * width > CLIPBOARD_CELLS) {
+    throw new Error('Select fewer cells to paste at once.')
+  }
+  const edits: CsvCellEdit[] = []
+  for (let row = 0; row < height; row += 1) {
+    for (let column = 0; column < width; column += 1) {
+      edits.push({
+        row: csvSourceRow(bounds.firstRow + row, inspectionRows),
+        column: bounds.firstColumn + column,
+        value: fill ? pasted[0]![0]! : (pasted[row]?.[column] ?? '')
+      })
+    }
+  }
+  return edits
+}
diff --git a/src/renderer/src/components/editor/csv/csv-cell-links.test.tsx b/src/renderer/src/components/editor/csv/csv-cell-links.test.tsx
new file mode 100644
index 00000000000..5e07824495d
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-cell-links.test.tsx
@@ -0,0 +1,100 @@
+// @vitest-environment happy-dom
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, expect, it, vi } from 'vitest'
+import { CsvCellValue } from './CsvCellValue'
+import { openCsvHttpLink } from './csv-link-routing'
+
+const { openHttpLink, getConnectionIdForFile } = vi.hoisted(() => ({
+  openHttpLink: vi.fn(),
+  getConnectionIdForFile: vi.fn((): string | null | undefined => null)
+}))
+vi.mock('@/lib/http-link-routing', () => ({ openHttpLink }))
+vi.mock('@/lib/connection-context', () => ({ getConnectionIdForFile }))
+afterEach(() => {
+  cleanup()
+  vi.clearAllMocks()
+})
+
+it('opens a whole-cell URL without navigating the renderer or changing its displayed text', () => {
+  const onOpenUrl = vi.fn()
+  render(<CsvCellValue value=" https://example.com/a?q=b#section " onOpenUrl={onOpenUrl} />)
+  const link = screen.getByRole('link')
+  expect(link.textContent).toBe(' https://example.com/a?q=b#section ')
+  expect(link.getAttribute('href')).toBe('https://example.com/a?q=b#section')
+  expect(fireEvent.click(link)).toBe(false)
+  expect(onOpenUrl).toHaveBeenCalledWith('https://example.com/a?q=b#section', expect.anything())
+  fireEvent(link, new MouseEvent('auxclick', { button: 1, bubbles: true, cancelable: true }))
+  expect(onOpenUrl).toHaveBeenCalledTimes(2)
+})
+
+it.each([
+  'javascript:alert(1)',
+  'data:text/html,<script>alert(1)</script>',
+  'file:///tmp/example.csv',
+  'https://',
+  'https://[broken',
+  'See https://example.com for details',
+  '<a href="https://example.com">click</a>'
+])('keeps non-URLs and executable content as literal text: %s', (value) => {
+  render(<CsvCellValue value={value} onOpenUrl={vi.fn()} />)
+  expect(screen.queryByRole('link')).toBeNull()
+  expect(screen.getByText(value)).toBeTruthy()
+})
+
+it('keeps HTTP and localhost URLs clickable', () => {
+  render(<CsvCellValue value="HTTP://localhost:3000/demo" onOpenUrl={vi.fn()} />)
+  expect(screen.getByRole('link').getAttribute('href')).toBe('http://localhost:3000/demo')
+})
+
+it('routes with the file owner and the platform-specific escape modifier', () => {
+  const isMac = navigator.userAgent.includes('Mac')
+  openCsvHttpLink(
+    'https://example.com/',
+    { metaKey: isMac, ctrlKey: !isMac, shiftKey: true },
+    { filePath: '/demo.csv', worktreeId: 'folder:demo' }
+  )
+  expect(openHttpLink).toHaveBeenCalledWith('https://example.com/', {
+    worktreeId: 'folder:demo',
+    sourceOwner: { kind: 'local' },
+    modifierHeld: true
+  })
+})
+
+it('uses the pinned SSH and runtime owners without consulting the active workspace', () => {
+  const event = { metaKey: false, ctrlKey: false, shiftKey: false }
+  openCsvHttpLink('http://localhost:3000/', event, {
+    filePath: '/demo.csv',
+    worktreeId: 'folder:ssh',
+    connectionId: 'ssh-owner'
+  })
+  expect(openHttpLink).toHaveBeenLastCalledWith('http://localhost:3000/', {
+    worktreeId: 'folder:ssh',
+    sourceOwner: { kind: 'ssh', connectionId: 'ssh-owner' }
+  })
+  openCsvHttpLink('https://example.com/', event, {
+    filePath: '/demo.csv',
+    worktreeId: 'folder:paired',
+    runtimeEnvironmentId: 'paired-owner'
+  })
+  expect(openHttpLink).toHaveBeenLastCalledWith('https://example.com/', {
+    worktreeId: 'folder:paired',
+    sourceOwner: { kind: 'runtime', runtimeEnvironmentId: 'paired-owner' }
+  })
+  expect(getConnectionIdForFile).not.toHaveBeenCalled()
+})
+
+it('leaves unresolved ownership to the existing routing guard', () => {
+  getConnectionIdForFile.mockReturnValueOnce(undefined)
+  openCsvHttpLink(
+    'https://example.com/',
+    { metaKey: false, ctrlKey: false, shiftKey: false },
+    {
+      filePath: '/demo.csv',
+      worktreeId: 'missing-workspace'
+    }
+  )
+  expect(openHttpLink).toHaveBeenCalledWith('https://example.com/', {
+    worktreeId: 'missing-workspace',
+    sourceOwner: { kind: 'unknown' }
+  })
+})
diff --git a/src/renderer/src/components/editor/csv/csv-cell-selection.ts b/src/renderer/src/components/editor/csv/csv-cell-selection.ts
new file mode 100644
index 00000000000..1ee87c6ae9f
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-cell-selection.ts
@@ -0,0 +1,64 @@
+export type CsvCellPosition = { row: number; column: number }
+export type CsvCellSelection = { anchor: CsvCellPosition; focus: CsvCellPosition }
+
+export function remapCsvSelectionAfterColumnMove(
+  selection: CsvCellSelection | null,
+  from: number,
+  to: number
+): CsvCellSelection | null {
+  if (!selection) {
+    return null
+  }
+  const moved = (column: number): number => {
+    if (column === from) {
+      return to
+    }
+    if (from < to && column > from && column <= to) {
+      return column - 1
+    }
+    if (from > to && column >= to && column < from) {
+      return column + 1
+    }
+    return column
+  }
+  return {
+    anchor: { ...selection.anchor, column: moved(selection.anchor.column) },
+    focus: { ...selection.focus, column: moved(selection.focus.column) }
+  }
+}
+
+export function csvSelectionBounds(selection: CsvCellSelection) {
+  return {
+    firstRow: Math.min(selection.anchor.row, selection.focus.row),
+    lastRow: Math.max(selection.anchor.row, selection.focus.row),
+    firstColumn: Math.min(selection.anchor.column, selection.focus.column),
+    lastColumn: Math.max(selection.anchor.column, selection.focus.column)
+  }
+}
+
+export function csvCellIsSelected(
+  selection: CsvCellSelection | null,
+  row: number,
+  column: number
+): boolean {
+  if (!selection) {
+    return false
+  }
+  const bounds = csvSelectionBounds(selection)
+  return (
+    row >= bounds.firstRow &&
+    row <= bounds.lastRow &&
+    column >= bounds.firstColumn &&
+    column <= bounds.lastColumn
+  )
+}
+
+export function moveCsvSelection(
+  selection: CsvCellSelection | null,
+  row: number,
+  column: number,
+  extend: boolean
+): CsvCellSelection {
+  const focus = { row, column }
+  return { anchor: extend && selection ? selection.anchor : focus, focus }
+}
diff --git a/src/renderer/src/components/editor/csv/csv-column-width-limits.ts b/src/renderer/src/components/editor/csv/csv-column-width-limits.ts
new file mode 100644
index 00000000000..25a76c6f4d5
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-column-width-limits.ts
@@ -0,0 +1,2 @@
+export const CSV_MIN_COLUMN_WIDTH = 48
+export const CSV_MAX_COLUMN_WIDTH = 1200
diff --git a/src/renderer/src/components/editor/csv/csv-column-width-preferences.test.ts b/src/renderer/src/components/editor/csv/csv-column-width-preferences.test.ts
new file mode 100644
index 00000000000..2acb92c4ac4
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-column-width-preferences.test.ts
@@ -0,0 +1,77 @@
+// @vitest-environment happy-dom
+import { afterEach, expect, it, vi } from 'vitest'
+import {
+  CSV_COLUMN_WIDTHS_STORAGE_KEY,
+  readCsvColumnWidths,
+  writeCsvColumnWidths,
+  remapCsvColumnWidths
+} from './csv-column-width-preferences'
+import { buildFileViewPreferenceKey } from '../file-view-preference-storage'
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  localStorage.clear()
+})
+
+it('persists widths through remounts and isolates the same path by owner', () => {
+  const owner = { worktreeId: 'folder:a', filePath: '/repo/a.csv' }
+  const local = buildFileViewPreferenceKey(owner)
+  const paired = buildFileViewPreferenceKey({ ...owner, runtimeEnvironmentId: 'paired' })
+  const ssh = buildFileViewPreferenceKey({ ...owner, externalSshTargetId: 'ssh' })
+  writeCsvColumnWidths(local, { 0: 180, 2: 300 })
+  expect(readCsvColumnWidths(local)).toEqual({ 0: 180, 2: 300 })
+  expect(readCsvColumnWidths(paired)).toEqual({})
+  expect(readCsvColumnWidths(ssh)).toEqual({})
+  writeCsvColumnWidths(local, {})
+  expect(readCsvColumnWidths(local)).toEqual({})
+})
+
+it('ignores corrupted indexes, malformed values and unsupported widths', () => {
+  localStorage.setItem(
+    CSV_COLUMN_WIDTHS_STORAGE_KEY,
+    JSON.stringify({
+      file: {
+        '0': 160,
+        '1': '80',
+        '-1': 160,
+        '02': 160,
+        '2.5': 160,
+        '4096': 160,
+        '3': 20,
+        '4': 1300,
+        '5': null
+      }
+    })
+  )
+  expect(readCsvColumnWidths('file')).toEqual({ 0: 160 })
+  localStorage.setItem(CSV_COLUMN_WIDTHS_STORAGE_KEY, 'invalid json')
+  expect(readCsvColumnWidths('file')).toEqual({})
+})
+
+it('bounds retained file preferences and tolerates storage failure', () => {
+  for (let index = 0; index <= 100; index += 1) {
+    writeCsvColumnWidths(`file-${index}`, { 0: 160 })
+  }
+  expect(readCsvColumnWidths('file-0')).toEqual({})
+  expect(readCsvColumnWidths('file-100')).toEqual({ 0: 160 })
+  vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+    throw new Error('quota')
+  })
+  expect(() => writeCsvColumnWidths('file', { 0: 180 })).not.toThrow()
+})
+
+it('moves widths with column identity through insertion, deletion and reordering', () => {
+  const widths = { 0: 180, 2: 300 }
+  expect(remapCsvColumnWidths(widths, 3, { kind: 'insert-column', at: 1, label: '' })).toEqual({
+    0: 180,
+    3: 300
+  })
+  expect(remapCsvColumnWidths(widths, 3, { kind: 'delete-columns', columns: [1] })).toEqual({
+    0: 180,
+    1: 300
+  })
+  expect(remapCsvColumnWidths(widths, 3, { kind: 'move-column', from: 2, to: 0 })).toEqual({
+    0: 300,
+    1: 180
+  })
+})
diff --git a/src/renderer/src/components/editor/csv/csv-column-width-preferences.ts b/src/renderer/src/components/editor/csv/csv-column-width-preferences.ts
new file mode 100644
index 00000000000..38a99ed61fd
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-column-width-preferences.ts
@@ -0,0 +1,62 @@
+import { CSV_MAX_COLUMNS } from './csv-byte-index'
+import { CSV_MAX_COLUMN_WIDTH, CSV_MIN_COLUMN_WIDTH } from './csv-column-width-limits'
+import { readFileViewPreference, writeFileViewPreference } from '../file-view-preference-storage'
+import type { CsvTableMutation } from './csv-text-document'
+
+export const CSV_COLUMN_WIDTHS_STORAGE_KEY = 'orca.csv.column-widths.v1'
+export type CsvColumnWidths = Record<number, number>
+
+export function readCsvColumnWidths(fileKey: string): CsvColumnWidths {
+  const stored = readFileViewPreference(CSV_COLUMN_WIDTHS_STORAGE_KEY, fileKey)
+  const result: CsvColumnWidths = {}
+  if (typeof stored !== 'object' || stored === null || Array.isArray(stored)) {
+    return result
+  }
+  for (const [key, width] of Object.entries(stored)) {
+    const index = Number(key)
+    if (
+      Number.isInteger(index) &&
+      String(index) === key &&
+      index >= 0 &&
+      index < CSV_MAX_COLUMNS &&
+      typeof width === 'number' &&
+      Number.isFinite(width) &&
+      width >= CSV_MIN_COLUMN_WIDTH &&
+      width <= CSV_MAX_COLUMN_WIDTH
+    ) {
+      result[index] = width
+    }
+  }
+  return result
+}
+
+export function writeCsvColumnWidths(fileKey: string, widths: CsvColumnWidths): void {
+  writeFileViewPreference(CSV_COLUMN_WIDTHS_STORAGE_KEY, fileKey, widths)
+}
+
+export function remapCsvColumnWidths(
+  widths: CsvColumnWidths,
+  count: number,
+  mutation: CsvTableMutation
+): CsvColumnWidths {
+  const columns = Array.from({ length: count }, (_, index) => index)
+  if (mutation.kind === 'insert-column') {
+    columns.splice(mutation.at, 0, -1)
+  } else if (mutation.kind === 'delete-columns') {
+    const deleted = new Set(mutation.columns)
+    return Object.fromEntries(
+      columns
+        .filter((column) => !deleted.has(column))
+        .flatMap((column, index) => (widths[column] === undefined ? [] : [[index, widths[column]]]))
+    )
+  } else if (mutation.kind === 'move-column') {
+    columns.splice(mutation.to, 0, columns.splice(mutation.from, 1)[0]!)
+  } else {
+    return widths
+  }
+  return Object.fromEntries(
+    columns.flatMap((column, index) =>
+      widths[column] === undefined ? [] : [[index, widths[column]]]
+    )
+  )
+}
diff --git a/src/renderer/src/components/editor/csv-parse.ts b/src/renderer/src/components/editor/csv/csv-delimiter-detection.ts
similarity index 62%
rename from src/renderer/src/components/editor/csv-parse.ts
rename to src/renderer/src/components/editor/csv/csv-delimiter-detection.ts
index 6f52edbf5b7..c7c68dc0fa1 100644
--- a/src/renderer/src/components/editor/csv-parse.ts
+++ b/src/renderer/src/components/editor/csv/csv-delimiter-detection.ts
@@ -1,108 +1,8 @@
-export type CsvParseResult = {
-  rows: string[][]
-  maxColumns: number
-}
-
 export const CSV_DELIMITER_SNIFF_SCAN_CODE_UNITS = 64 * 1024
 
 const LINE_FEED_CODE_UNIT = 10
 const CARRIAGE_RETURN_CODE_UNIT = 13
 
-// Why: RFC 4180-compatible CSV parsing with quote handling and CRLF support.
-// A hand-rolled parser avoids pulling a new dependency (papaparse) for what is
-// a small, well-specified grammar. Inline state machine keeps the hot path
-// allocation-light for large files.
-export function parseCsv(source: string, delimiter: string = ','): CsvParseResult {
-  // Why: strip a leading UTF-8 BOM (U+FEFF). Excel and other spreadsheet tools
-  // prepend a BOM to exported CSVs; without this, the BOM contaminates the
-  // first header cell and breaks column-name lookups for downstream consumers.
-  if (source.charCodeAt(0) === 0xfeff) {
-    source = source.slice(1)
-  }
-
-  const rows: string[][] = []
-  let row: string[] = []
-  let field = ''
-  let inQuotes = false
-  let maxColumns = 0
-  // Why: track whether the current record has produced any content — including
-  // a quoted-but-empty field like `""`. Without this flag, the EOF flush
-  // condition `field.length > 0 || row.length > 0` would drop a record whose
-  // only field was a quoted empty string, since the field is empty and no
-  // delimiter/newline ever pushed it onto the row.
-  let recordHasContent = false
-
-  const pushField = (): void => {
-    row.push(field)
-    field = ''
-  }
-  const pushRow = (): void => {
-    pushField()
-    if (row.length > maxColumns) {
-      maxColumns = row.length
-    }
-    rows.push(row)
-    row = []
-    recordHasContent = false
-  }
-
-  for (let i = 0; i < source.length; i += 1) {
-    const ch = source[i]
-
-    if (inQuotes) {
-      if (ch === '"') {
-        if (source[i + 1] === '"') {
-          field += '"'
-          i += 1
-        } else {
-          inQuotes = false
-        }
-      } else {
-        field += ch
-      }
-      continue
-    }
-
-    if (ch === '"' && field === '') {
-      inQuotes = true
-      // Why: entering quote mode means this record has real content even if
-      // the quoted field ends up empty (e.g. the whole file is `""`).
-      recordHasContent = true
-      continue
-    }
-    if (ch === delimiter) {
-      pushField()
-      recordHasContent = true
-      continue
-    }
-    if (ch === '\r') {
-      if (source[i + 1] === '\n') {
-        i += 1
-      }
-      pushRow()
-      continue
-    }
-    if (ch === '\n') {
-      pushRow()
-      continue
-    }
-    field += ch
-    recordHasContent = true
-  }
-
-  // Why: don't emit a trailing empty row for files that end with a newline —
-  // that's just whitespace, not a record. But preserve an in-progress final
-  // row that lacks a newline. `recordHasContent` covers the edge case where
-  // the final record is a single quoted empty field (`""`) — the field is
-  // empty and nothing has been pushed to `row`, but the record is real and
-  // must not be dropped.
-  if (field.length > 0 || row.length > 0 || recordHasContent) {
-    pushRow()
-  }
-
-  return { rows, maxColumns }
-}
-
 export function detectCsvDelimiter(filePath: string, content: string): string {
   if (filePath.toLowerCase().endsWith('.tsv')) {
     return '\t'
diff --git a/src/renderer/src/components/editor/csv-delimiter-picker.tsx b/src/renderer/src/components/editor/csv/csv-delimiter-picker.tsx
similarity index 100%
rename from src/renderer/src/components/editor/csv-delimiter-picker.tsx
rename to src/renderer/src/components/editor/csv/csv-delimiter-picker.tsx
diff --git a/src/renderer/src/components/editor/csv/csv-file-content.ts b/src/renderer/src/components/editor/csv/csv-file-content.ts
new file mode 100644
index 00000000000..c78b0214414
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-file-content.ts
@@ -0,0 +1,25 @@
+import type { RuntimeFileReadArgs } from '@/runtime/runtime-file-client-types'
+import { readRuntimeFileContent } from '@/runtime/runtime-file-client'
+import {
+  statRuntimeReadTarget,
+  type RuntimeFileSnapshot
+} from '@/runtime/runtime-file-range-client'
+import type { FileContent } from '../editor-panel-content-types'
+
+import { CSV_PAGED_PREVIEW_BYTES } from './csv-file-limits'
+export { CSV_PAGED_PREVIEW_BYTES } from './csv-file-limits'
+
+export type CsvFilePreview = { readArgs: RuntimeFileReadArgs; snapshot: RuntimeFileSnapshot }
+
+export async function readEditorCsvFileContent(
+  args: RuntimeFileReadArgs,
+  allowPagedPreview = true
+): Promise<FileContent> {
+  if (allowPagedPreview && /\.(csv|tsv)$/i.test(args.filePath)) {
+    const snapshot = await statRuntimeReadTarget(args)
+    if (!snapshot.isDirectory && snapshot.size >= CSV_PAGED_PREVIEW_BYTES) {
+      return { content: '', isBinary: false, csvPreview: { readArgs: args, snapshot } }
+    }
+  }
+  return readRuntimeFileContent(args)
+}
diff --git a/src/renderer/src/components/editor/csv/csv-file-limits.ts b/src/renderer/src/components/editor/csv/csv-file-limits.ts
new file mode 100644
index 00000000000..7772f36bb83
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-file-limits.ts
@@ -0,0 +1 @@
+export const CSV_PAGED_PREVIEW_BYTES = 1024 * 1024
diff --git a/src/renderer/src/components/editor/csv/csv-grid-interaction.ts b/src/renderer/src/components/editor/csv/csv-grid-interaction.ts
new file mode 100644
index 00000000000..8d57cb7cd7f
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-grid-interaction.ts
@@ -0,0 +1,26 @@
+import type { ClipboardEvent, KeyboardEvent } from 'react'
+import type { CsvCellPosition, CsvCellSelection } from './csv-cell-selection'
+
+export type CsvCellEditSession = {
+  position: CsvCellPosition
+  value: string
+  sourceRow: number
+  source: string
+  wasDirty: boolean
+}
+
+export type CsvGridInteraction = {
+  selection: CsvCellSelection | null
+  focusVersion: number
+  ownerId: string
+  editing: { position: CsvCellPosition; value: string } | null
+  select: (row: number, column: number, extend: boolean) => boolean
+  edit: (row: number, column: number) => void
+  change: (value: string) => void
+  commit: () => boolean
+  cancel: () => void
+  save: () => void
+  keyDown: (event: KeyboardEvent<HTMLDivElement>) => void
+  copy: (event: ClipboardEvent<HTMLDivElement>) => void
+  paste: (event: ClipboardEvent<HTMLDivElement>) => void
+}
diff --git a/src/renderer/src/components/editor/csv/csv-grid-keyboard.ts b/src/renderer/src/components/editor/csv/csv-grid-keyboard.ts
new file mode 100644
index 00000000000..dae85a626aa
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-grid-keyboard.ts
@@ -0,0 +1,115 @@
+import type { KeyboardEvent } from 'react'
+import type { CsvCellSelection } from './csv-cell-selection'
+
+export function csvGridKeyDown(
+  event: KeyboardEvent<HTMLDivElement>,
+  {
+    selection,
+    columns,
+    count,
+    copy,
+    paste,
+    save,
+    edit,
+    clear,
+    cancel,
+    select,
+    selectAll
+  }: {
+    selection: CsvCellSelection | null
+    columns: number
+    count: number
+    copy: () => Promise<void>
+    paste: () => Promise<void>
+    save: () => Promise<void>
+    edit: (row: number, column: number) => void
+    clear: () => void
+    cancel: () => void
+    select: (row: number, column: number, extend: boolean) => boolean
+    selectAll: (selection: CsvCellSelection) => void
+  }
+): void {
+  if (
+    event.target !== event.currentTarget ||
+    event.nativeEvent.isComposing ||
+    event.defaultPrevented
+  ) {
+    return
+  }
+  const modifier = navigator.userAgent.includes('Mac') ? event.metaKey : event.ctrlKey
+  if (modifier && ['c', 'v', 's', 'a'].includes(event.key.toLowerCase())) {
+    event.preventDefault()
+    if (event.key.toLowerCase() === 'c') {
+      void copy()
+    }
+    if (event.key.toLowerCase() === 'v') {
+      void paste()
+    }
+    if (event.key.toLowerCase() === 's') {
+      void save()
+    }
+    if (event.key.toLowerCase() === 'a' && columns) {
+      selectAll({
+        anchor: { row: 0, column: 0 },
+        focus: { row: count, column: columns - 1 }
+      })
+    }
+    return
+  }
+  const active = selection?.focus ?? { row: 0, column: 0 }
+  if (event.key === 'Enter' || event.key === 'F2') {
+    event.preventDefault()
+    edit(active.row, active.column)
+  } else if (event.key === 'Delete' || event.key === 'Backspace') {
+    event.preventDefault()
+    clear()
+  } else if (event.key === 'Escape') {
+    cancel()
+  } else if (
+    ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', 'Home', 'End', 'Tab'].includes(event.key)
+  ) {
+    event.preventDefault()
+    let row = active.row
+    let column = active.column
+    if (event.key === 'ArrowUp') {
+      row -= 1
+    }
+    if (event.key === 'ArrowDown') {
+      row += 1
+    }
+    if (event.key === 'ArrowLeft') {
+      column -= 1
+    }
+    if (event.key === 'ArrowRight') {
+      column += 1
+    }
+    if (event.key === 'Home') {
+      column = 0
+      if (modifier) {
+        row = 0
+      }
+    }
+    if (event.key === 'End') {
+      column = columns - 1
+      if (modifier) {
+        row = count
+      }
+    }
+    if (event.key === 'Tab') {
+      column += event.shiftKey ? -1 : 1
+      if (column >= columns) {
+        column = 0
+        row += 1
+      }
+      if (column < 0) {
+        column = columns - 1
+        row -= 1
+      }
+    }
+    select(
+      Math.max(0, Math.min(count, row)),
+      Math.max(0, Math.min(columns - 1, column)),
+      event.shiftKey && event.key !== 'Tab'
+    )
+  }
+}
diff --git a/src/renderer/src/components/editor/csv/csv-inspection.ts b/src/renderer/src/components/editor/csv/csv-inspection.ts
new file mode 100644
index 00000000000..1634ce308cf
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-inspection.ts
@@ -0,0 +1,32 @@
+export type CsvInspectionSort = { column: number; direction: 'ascending' | 'descending' }
+
+export function csvInspectionRows(
+  rows: readonly string[][],
+  filter: string,
+  sort: CsvInspectionSort | null
+): number[] | null {
+  if (!filter && !sort) {
+    return null
+  }
+  const query = filter.toLocaleLowerCase()
+  const result: number[] = []
+  for (let row = 1; row < rows.length; row += 1) {
+    if (!query || rows[row]!.some((cell) => cell.toLocaleLowerCase().includes(query))) {
+      result.push(row)
+    }
+  }
+  if (sort) {
+    const collator = new Intl.Collator(undefined, { numeric: true })
+    const direction = sort.direction === 'ascending' ? 1 : -1
+    result.sort(
+      (a, b) =>
+        direction * collator.compare(rows[a]?.[sort.column] ?? '', rows[b]?.[sort.column] ?? '') ||
+        a - b
+    )
+  }
+  return result
+}
+
+export function csvSourceRow(viewRow: number, inspectionRows: readonly number[] | null): number {
+  return viewRow === 0 ? 0 : inspectionRows ? (inspectionRows[viewRow - 1] ?? -1) : viewRow
+}
diff --git a/src/renderer/src/components/editor/csv/csv-link-routing.ts b/src/renderer/src/components/editor/csv/csv-link-routing.ts
new file mode 100644
index 00000000000..239f6435a3c
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-link-routing.ts
@@ -0,0 +1,37 @@
+import { getConnectionIdForFile } from '@/lib/connection-context'
+import { openHttpLink, type HttpLinkSourceOwner } from '@/lib/http-link-routing'
+import { resolveMarkdownPreviewHttpOpenOptions } from '../markdown-preview-links'
+
+export function openCsvHttpLink(
+  url: string,
+  event: Pick<MouseEvent, 'metaKey' | 'ctrlKey' | 'shiftKey'>,
+  file: {
+    filePath: string
+    worktreeId?: string
+    runtimeEnvironmentId?: string | null
+    connectionId?: string | null
+  }
+): void {
+  const runtimeId = file.runtimeEnvironmentId?.trim()
+  const connectionId = runtimeId
+    ? undefined
+    : file.connectionId !== undefined
+      ? file.connectionId
+      : getConnectionIdForFile(file.worktreeId ?? null, file.filePath)
+  const sourceOwner: HttpLinkSourceOwner = runtimeId
+    ? { kind: 'runtime', runtimeEnvironmentId: runtimeId }
+    : connectionId === undefined
+      ? { kind: 'unknown' }
+      : connectionId === null
+        ? { kind: 'local' }
+        : { kind: 'ssh', connectionId }
+  openHttpLink(
+    url,
+    resolveMarkdownPreviewHttpOpenOptions(
+      event,
+      navigator.userAgent.includes('Mac'),
+      file.worktreeId ?? null,
+      sourceOwner
+    )
+  )
+}
diff --git a/src/renderer/src/components/editor/csv/csv-paged-preview.test.ts b/src/renderer/src/components/editor/csv/csv-paged-preview.test.ts
new file mode 100644
index 00000000000..8e873a8a79a
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-paged-preview.test.ts
@@ -0,0 +1,205 @@
+import { beforeEach, expect, it, vi } from 'vitest'
+import { CSV_MAX_PAGE_BYTES } from './csv-byte-index'
+import { CsvPagedPreview } from './csv-paged-preview'
+
+const mocks = vi.hoisted(() => ({ stat: vi.fn(), read: vi.fn(), request: vi.fn(), close: vi.fn() }))
+vi.mock('@/runtime/runtime-file-range-client', () => ({
+  statRuntimeReadTarget: mocks.stat,
+  readRuntimeFileRange: mocks.read
+}))
+vi.mock('./csv-preview-worker-client', () => ({
+  CsvPreviewWorkerClient: class {
+    request = mocks.request
+    close = mocks.close
+  }
+}))
+
+const snapshot = { size: 1024 * 1024, mtime: 1, isDirectory: false }
+const file = { readArgs: { settings: null, filePath: '/repo/a.csv' }, snapshot }
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.stat.mockResolvedValue(snapshot)
+  mocks.read.mockImplementation(async (_args, _offset, length: number) => new Uint8Array(length))
+  mocks.request.mockResolvedValue({ kind: 'rows', rows: [['value']] })
+})
+
+it('caps the page count and evicts the least recently used one', async () => {
+  const preview = new CsvPagedPreview(file)
+  const range = (index: number) => ({
+    start: index * 10,
+    end: index * 10 + 10,
+    firstRow: index,
+    rowCount: 1
+  })
+  for (let index = 0; index < 64; index += 1) {
+    await preview.page(index, range(index))
+  }
+  await preview.page(0, range(0))
+  await preview.page(64, range(64))
+  await preview.page(1, range(1))
+  expect(mocks.read).toHaveBeenCalledTimes(66)
+  preview.close()
+})
+
+it('detects changes even when a page is already cached', async () => {
+  const preview = new CsvPagedPreview(file)
+  const range = { start: 0, end: 10, firstRow: 0, rowCount: 1 }
+  await preview.page(0, range)
+  mocks.stat.mockResolvedValue({ ...snapshot, mtime: 2 })
+  await expect(preview.page(0, range)).rejects.toThrow('changed on disk')
+  expect(mocks.read).toHaveBeenCalledTimes(1)
+  preview.close()
+})
+
+it('keeps a dense viewport cached when scrolling by one page', async () => {
+  const preview = new CsvPagedPreview(file)
+  mocks.request.mockResolvedValue({
+    kind: 'rows',
+    rows: Array.from({ length: 4 }, () => Array.from({ length: 4096 }, () => 'x'))
+  })
+  const range = (index: number) => ({
+    start: index * 32768,
+    end: (index + 1) * 32768,
+    firstRow: index * 4,
+    rowCount: 4
+  })
+  for (let index = 0; index < 16; index += 1) {
+    await preview.page(index, range(index))
+  }
+  for (let index = 1; index <= 16; index += 1) {
+    await preview.page(index, range(index))
+  }
+  expect(mocks.read).toHaveBeenCalledTimes(17)
+  preview.close()
+})
+
+it('bounds cached cells independently of raw bytes and page count', async () => {
+  const largeSnapshot = { ...snapshot, size: 2 * 1024 * 1024 }
+  mocks.stat.mockResolvedValue(largeSnapshot)
+  const preview = new CsvPagedPreview({ ...file, snapshot: largeSnapshot })
+  mocks.request.mockResolvedValue({
+    kind: 'rows',
+    rows: Array.from({ length: 4 }, () => Array.from({ length: 4096 }, () => 'x'))
+  })
+  const range = (index: number) => ({
+    start: index * 32768,
+    end: (index + 1) * 32768,
+    firstRow: index * 4,
+    rowCount: 4
+  })
+  for (let index = 0; index < 33; index += 1) {
+    await preview.page(index, range(index))
+  }
+  await preview.page(32, range(32))
+  expect(mocks.read).toHaveBeenCalledTimes(33)
+  await preview.page(0, range(0))
+  expect(mocks.read).toHaveBeenCalledTimes(34)
+  preview.close()
+})
+
+it('bounds cached raw bytes independently of cell count', async () => {
+  const largeSnapshot = { ...snapshot, size: 10 * 1024 * 1024 }
+  mocks.stat.mockResolvedValue(largeSnapshot)
+  const preview = new CsvPagedPreview({ ...file, snapshot: largeSnapshot })
+  const range = (index: number) => ({
+    start: index * 1024 * 1024,
+    end: (index + 1) * 1024 * 1024,
+    firstRow: index,
+    rowCount: 1
+  })
+  for (let index = 0; index < 9; index += 1) {
+    await preview.page(index, range(index))
+  }
+  await preview.page(8, range(8))
+  expect(mocks.request).toHaveBeenCalledTimes(9)
+  await preview.page(0, range(0))
+  expect(mocks.request).toHaveBeenCalledTimes(10)
+  preview.close()
+})
+
+it('validates one viewport once before and after loading its pages, including cache hits', async () => {
+  const preview = new CsvPagedPreview(file)
+  const index = {
+    pages: Array.from({ length: 16 }, (_, i) => ({
+      start: i * 10,
+      end: (i + 1) * 10,
+      firstRow: i,
+      rowCount: 1
+    })),
+    rowCount: 16,
+    columnCount: 1
+  }
+  const rows = await preview.rows(index, 0, 14, () => false)
+  expect(rows?.size).toBe(15)
+  expect(mocks.stat).toHaveBeenCalledTimes(2)
+  expect(mocks.read).toHaveBeenCalledTimes(15)
+  mocks.stat.mockClear()
+  await preview.rows(index, 0, 14, () => false)
+  expect(mocks.stat).toHaveBeenCalledTimes(2)
+  expect(mocks.read).toHaveBeenCalledTimes(15)
+  mocks.stat.mockResolvedValueOnce(snapshot).mockResolvedValueOnce({ ...snapshot, mtime: 2 })
+  await expect(preview.rows(index, 0, 14, () => false)).rejects.toThrow('changed on disk')
+  preview.close()
+})
+
+it('drops an abandoned viewport after its current page without starting more reads', async () => {
+  const preview = new CsvPagedPreview(file)
+  const index = {
+    pages: Array.from({ length: 16 }, (_, i) => ({
+      start: i * 10,
+      end: (i + 1) * 10,
+      firstRow: i,
+      rowCount: 1
+    })),
+    rowCount: 16,
+    columnCount: 1
+  }
+  let stale = false
+  mocks.request.mockImplementation(async () => {
+    stale = true
+    return { kind: 'rows', rows: [['value']] }
+  })
+  await expect(preview.rows(index, 0, 14, () => stale)).resolves.toBeNull()
+  expect(mocks.read).toHaveBeenCalledTimes(1)
+  preview.close()
+})
+
+it('bounds reads, stops after cancellation, and rejects mismatched pages', async () => {
+  const preview = new CsvPagedPreview(file)
+  await preview.read(0, 1024 * 1024)
+  expect(mocks.read.mock.calls.map((call) => call[2])).toEqual(
+    Array.from({ length: 4 }, () => 256 * 1024)
+  )
+  await expect(preview.read(-1, 1)).rejects.toThrow('Invalid CSV page range')
+  await expect(preview.page(0, { start: 0, end: 10, firstRow: 0, rowCount: 2 })).rejects.toThrow(
+    'boundary mismatch'
+  )
+  preview.close()
+  await expect(preview.read(0, 10)).rejects.toThrow('canceled')
+  expect(mocks.close).toHaveBeenCalledTimes(1)
+})
+
+it('detects a mutation during the full scan before publishing an index', async () => {
+  const preview = new CsvPagedPreview(file)
+  mocks.request.mockResolvedValue({ kind: 'ack' })
+  mocks.stat.mockResolvedValueOnce(snapshot).mockResolvedValue({ ...snapshot, size: 20 })
+  await expect(preview.buildIndex(',', () => {})).rejects.toThrow('changed on disk')
+  expect(mocks.request.mock.calls.some(([command]) => command.kind === 'finish')).toBe(false)
+  preview.close()
+})
+
+it('reads a maximum-size first record including its BOM and CRLF in bounded chunks', async () => {
+  const largeSnapshot = { ...snapshot, size: CSV_MAX_PAGE_BYTES }
+  mocks.stat.mockResolvedValue(largeSnapshot)
+  const preview = new CsvPagedPreview({ ...file, snapshot: largeSnapshot })
+  await preview.page(0, { start: 0, end: CSV_MAX_PAGE_BYTES, firstRow: 0, rowCount: 1 })
+  expect(mocks.read.mock.calls.map((call) => call[2])).toEqual([
+    256 * 1024,
+    256 * 1024,
+    256 * 1024,
+    256 * 1024,
+    5
+  ])
+  await expect(preview.read(0, CSV_MAX_PAGE_BYTES + 1)).rejects.toThrow('Invalid CSV page range')
+  preview.close()
+})
diff --git a/src/renderer/src/components/editor/csv/csv-paged-preview.ts b/src/renderer/src/components/editor/csv/csv-paged-preview.ts
new file mode 100644
index 00000000000..87c7be35c48
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-paged-preview.ts
@@ -0,0 +1,187 @@
+import { MAX_FILE_RANGE_READ_BYTES } from '../../../../../shared/file-range-read'
+import { readRuntimeFileRange, statRuntimeReadTarget } from '@/runtime/runtime-file-range-client'
+import type { CsvFilePreview } from './csv-file-content'
+import {
+  CSV_MAX_PAGE_BYTES,
+  csvPageForRow,
+  type CsvIndex,
+  type CsvPageRange
+} from './csv-byte-index'
+import { CsvPreviewWorkerClient } from './csv-preview-worker-client'
+
+const CACHE_CELLS = 512 * 1024
+const CACHE_BYTES = 8 * 1024 * 1024
+const CACHE_PAGES = 64
+type CachedPage = { rows: string[][]; cells: number; bytes: number }
+
+export class CsvPagedPreview {
+  private worker = new CsvPreviewWorkerClient()
+  private cache = new Map<number, CachedPage>()
+  private cacheCells = 0
+  private cacheBytes = 0
+  private canceled = false
+
+  constructor(private readonly file: CsvFilePreview) {}
+
+  async validateSnapshot(): Promise<void> {
+    this.checkCanceled()
+    const current = await statRuntimeReadTarget(this.file.readArgs)
+    if (
+      current.size !== this.file.snapshot.size ||
+      current.mtime !== this.file.snapshot.mtime ||
+      current.isDirectory
+    ) {
+      this.clearCache()
+      throw new Error('CSV changed on disk. Reload the file to refresh the preview.')
+    }
+    this.checkCanceled()
+  }
+
+  async read(start: number, end: number): Promise<Uint8Array<ArrayBuffer>> {
+    this.checkCanceled()
+    if (
+      !Number.isSafeInteger(start) ||
+      !Number.isSafeInteger(end) ||
+      start < 0 ||
+      end <= start ||
+      end > this.file.snapshot.size ||
+      end - start > CSV_MAX_PAGE_BYTES
+    ) {
+      throw new Error('Invalid CSV page range')
+    }
+    const bytes = new Uint8Array(end - start)
+    let received = 0
+    while (received < bytes.length) {
+      this.checkCanceled()
+      const chunk = await readRuntimeFileRange(
+        this.file.readArgs,
+        start + received,
+        Math.min(MAX_FILE_RANGE_READ_BYTES, bytes.length - received)
+      )
+      this.checkCanceled()
+      bytes.set(chunk, received)
+      received += chunk.length
+    }
+    return bytes
+  }
+
+  async buildIndex(delimiter: string, onProgress: (bytes: number) => void): Promise<CsvIndex> {
+    await this.validateSnapshot()
+    await this.worker.request({ kind: 'init', delimiter })
+    for (let offset = 0; offset < this.file.snapshot.size;) {
+      const end = Math.min(this.file.snapshot.size, offset + MAX_FILE_RANGE_READ_BYTES)
+      const bytes = await this.read(offset, end)
+      await this.worker.request({ kind: 'feed', bytes })
+      offset = end
+      onProgress(offset)
+    }
+    await this.validateSnapshot()
+    const value = await this.worker.request({ kind: 'finish' })
+    if (value.kind !== 'index') {
+      throw new Error('CSV worker did not return an index')
+    }
+    return value.index
+  }
+
+  async page(pageIndex: number, range: CsvPageRange): Promise<string[][]> {
+    await this.validateSnapshot()
+    const rows = await this.loadPage(pageIndex, range)
+    await this.validateSnapshot()
+    return rows
+  }
+
+  async rows(
+    index: CsvIndex,
+    first: number,
+    last: number,
+    isStale: () => boolean
+  ): Promise<Map<number, string[]> | null> {
+    await this.validateSnapshot()
+    const rows = new Map<number, string[]>()
+    const firstPage = csvPageForRow(index.pages, first + 1)
+    const lastPage = csvPageForRow(index.pages, last + 1)
+    for (let pageIndex = firstPage; pageIndex <= lastPage; pageIndex += 1) {
+      this.checkCanceled()
+      if (isStale()) {
+        return null
+      }
+      const range = index.pages[pageIndex]
+      if (!range) {
+        continue
+      }
+      const page = await this.loadPage(pageIndex, range)
+      page.forEach((row, offset) => {
+        const bodyIndex = range.firstRow + offset - 1
+        if (bodyIndex >= first && bodyIndex <= last) {
+          rows.set(bodyIndex, row)
+        }
+      })
+    }
+    if (isStale()) {
+      return null
+    }
+    await this.validateSnapshot()
+    return rows
+  }
+
+  private async loadPage(pageIndex: number, range: CsvPageRange): Promise<string[][]> {
+    this.checkCanceled()
+    const cached = this.cache.get(pageIndex)
+    if (cached) {
+      this.cache.delete(pageIndex)
+      this.cache.set(pageIndex, cached)
+      return cached.rows
+    }
+    const bytes = await this.read(range.start, range.end)
+    const value = await this.worker.request({ kind: 'parse', bytes, stripBom: range.start === 0 })
+    if (value.kind !== 'rows' || value.rows.length !== range.rowCount) {
+      throw new Error('CSV page boundary mismatch. Reload the preview.')
+    }
+    this.checkCanceled()
+    const previous = this.cache.get(pageIndex)
+    this.cacheCells -= previous?.cells ?? 0
+    this.cacheBytes -= previous?.bytes ?? 0
+    const entry = {
+      rows: value.rows,
+      cells: value.rows.reduce((sum, row) => sum + row.length, 0),
+      bytes: range.end - range.start
+    }
+    this.cache.delete(pageIndex)
+    this.cache.set(pageIndex, entry)
+    this.cacheCells += entry.cells
+    this.cacheBytes += entry.bytes
+    while (
+      this.cache.size > CACHE_PAGES ||
+      this.cacheCells > CACHE_CELLS ||
+      this.cacheBytes > CACHE_BYTES
+    ) {
+      const first = this.cache.keys().next().value
+      if (first === undefined) {
+        break
+      }
+      const evicted = this.cache.get(first)
+      this.cacheCells -= evicted?.cells ?? 0
+      this.cacheBytes -= evicted?.bytes ?? 0
+      this.cache.delete(first)
+    }
+    return value.rows
+  }
+
+  close(): void {
+    this.canceled = true
+    this.clearCache()
+    this.worker.close()
+  }
+
+  private clearCache(): void {
+    this.cache.clear()
+    this.cacheCells = 0
+    this.cacheBytes = 0
+  }
+
+  private checkCanceled(): void {
+    if (this.canceled) {
+      throw new Error('CSV preview was canceled')
+    }
+  }
+}
diff --git a/src/renderer/src/components/editor/csv/csv-parse-budget.test.ts b/src/renderer/src/components/editor/csv/csv-parse-budget.test.ts
new file mode 100644
index 00000000000..a98d3a8fc92
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-parse-budget.test.ts
@@ -0,0 +1,34 @@
+import { expect, it } from 'vitest'
+import { parseCsv } from './csv-parse'
+
+it('parses large quoted spans and escaped quotes without character strings', () => {
+  const large = 'a'.repeat(4 * 1024 * 1024)
+  expect(parseCsv(`"${large}""b",tail`).rows).toEqual([[`${large}"b`, 'tail']])
+})
+it('keeps permissive empty quote reopening and text after quotes', () => {
+  expect(parseCsv('""""x,"""a"b\n""""""')).toEqual({ rows: [['"x', '"ab'], ['""']], maxColumns: 2 })
+})
+it('bounds columns, cells and a single record', () => {
+  expect(() => parseCsv(','.repeat(100_000), ',', { maxColumns: 4096 })).toThrow('cells')
+  expect(() => parseCsv('a,b\nc,d', ',', { maxCells: 3 })).toThrow('cells')
+  expect(() => parseCsv('abcd', ',', { maxRecordLength: 3 })).toThrow('record')
+  expect(() => parseCsv('"a""', ',', { maxRecordLength: 3 })).toThrow('record')
+})
+it('retains a real BOM in a later page', () => {
+  expect(parseCsv('\ufeffvalue', ',', { stripBom: false }).rows).toEqual([['\ufeffvalue']])
+})
+
+it('excludes BOMs and record terminators while counting quoted newlines toward the limit', () => {
+  for (const bom of ['', '\ufeff']) {
+    for (const ending of ['', '\n', '\r', '\r\n']) {
+      for (const record of ['abcd', '"ab"', '"a\n"', '""""']) {
+        expect(parseCsv(`${bom}${record}${ending}`, ',', { maxRecordLength: 4 })).toEqual(
+          parseCsv(`${bom}${record}${ending}`)
+        )
+        expect(() => parseCsv(`${bom}${record}x${ending}`, ',', { maxRecordLength: 4 })).toThrow(
+          'record'
+        )
+      }
+    }
+  }
+})
diff --git a/src/renderer/src/components/editor/csv-parse.test.ts b/src/renderer/src/components/editor/csv/csv-parse.test.ts
similarity index 100%
rename from src/renderer/src/components/editor/csv-parse.test.ts
rename to src/renderer/src/components/editor/csv/csv-parse.test.ts
diff --git a/src/renderer/src/components/editor/csv/csv-parse.ts b/src/renderer/src/components/editor/csv/csv-parse.ts
new file mode 100644
index 00000000000..243c9e3ee34
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-parse.ts
@@ -0,0 +1,112 @@
+export { detectCsvDelimiter, CSV_DELIMITER_SNIFF_SCAN_CODE_UNITS } from './csv-delimiter-detection'
+
+export type CsvParseResult = { rows: string[][]; maxColumns: number }
+export type CsvParseLimits = {
+  maxCells?: number
+  maxColumns?: number
+  maxRecordLength?: number
+  stripBom?: boolean
+  retainRows?: boolean
+  onField?: (start: number, end: number) => void
+  onRecord?: (start: number, contentEnd: number, end: number) => void
+}
+
+export function parseCsv(
+  source: string,
+  delimiter = ',',
+  limits: CsvParseLimits = {}
+): CsvParseResult {
+  const rows: string[][] = []
+  let row: string[] = []
+  let start = limits.stripBom !== false && source.charCodeAt(0) === 0xfeff ? 1 : 0
+  let recordStart = start
+  let fieldStart = start
+  let parts: string[] = []
+  let fieldLength = 0
+  let inQuotes = false
+  let hasContent = false
+  let maxColumns = 0
+  let cells = 0
+  const appendSpan = (end: number): void => {
+    if (end > start) {
+      parts.push(source.slice(start, end))
+      fieldLength += end - start
+    }
+  }
+  const pushField = (end: number): void => {
+    if (row.length >= (limits.maxColumns ?? Infinity) || ++cells > (limits.maxCells ?? Infinity)) {
+      throw new Error('CSV contains too many cells to preview safely.')
+    }
+    // Slice ordinary fields once; only escaped or interleaved quotes need a join.
+    if (parts.length) {
+      appendSpan(end)
+      row.push(parts.join(''))
+    } else {
+      row.push(source.slice(start, end))
+    }
+    limits.onField?.(fieldStart, end)
+    parts = []
+    fieldLength = 0
+    start = end + 1
+    fieldStart = start
+  }
+  const pushRow = (end: number, next: number): void => {
+    if (end - recordStart > (limits.maxRecordLength ?? Infinity)) {
+      throw new Error('CSV record is too large to preview safely.')
+    }
+    pushField(end)
+    maxColumns = Math.max(maxColumns, row.length)
+    if (limits.retainRows !== false) {
+      rows.push(row)
+    }
+    limits.onRecord?.(recordStart, end, next)
+    row = []
+    hasContent = false
+    start = next
+    recordStart = next
+    fieldStart = next
+  }
+  for (let i = start; i < source.length; i += 1) {
+    const ch = source[i]
+    if (
+      i - recordStart >= (limits.maxRecordLength ?? Infinity) &&
+      (inQuotes || (ch !== '\r' && ch !== '\n'))
+    ) {
+      throw new Error('CSV record is too large to preview safely.')
+    }
+    if (inQuotes) {
+      if (ch === '"') {
+        appendSpan(i)
+        if (source[i + 1] === '"') {
+          parts.push('"')
+          fieldLength += 1
+          i += 1
+        } else {
+          inQuotes = false
+        }
+        start = i + 1
+      }
+      continue
+    }
+    if (ch === '"' && fieldLength + i - start === 0) {
+      inQuotes = true
+      hasContent = true
+      start = i + 1
+    } else if (ch === delimiter) {
+      pushField(i)
+      hasContent = true
+    } else if (ch === '\r' || ch === '\n') {
+      const end = i
+      if (ch === '\r' && source[i + 1] === '\n') {
+        i += 1
+      }
+      pushRow(end, i + 1)
+    } else {
+      hasContent = true
+    }
+  }
+  if (hasContent || row.length) {
+    pushRow(source.length, source.length)
+  }
+  return { rows, maxColumns }
+}
diff --git a/src/renderer/src/components/editor/csv/csv-pending-save.test.ts b/src/renderer/src/components/editor/csv/csv-pending-save.test.ts
new file mode 100644
index 00000000000..59f1139c1c8
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-pending-save.test.ts
@@ -0,0 +1,127 @@
+import { afterEach, expect, it, vi } from 'vitest'
+import { createEditorSaveQueue } from '../editor-save-queue'
+import { registerPendingEditorFlush } from '../editor-pending-flush'
+import {
+  createEditorStore,
+  stubEditorWindowWithDisk
+} from '../editor-autosave-controller-test-fixture'
+
+afterEach(() => vi.unstubAllGlobals())
+
+function setup() {
+  const disk = stubEditorWindowWithDisk()
+  const store = createEditorStore()
+  store.getState().openFile({
+    filePath: '/repo/data.csv',
+    relativePath: 'data.csv',
+    worktreeId: 'wt-1',
+    mode: 'edit',
+    language: 'plaintext'
+  })
+  const file = store.getState().openFiles[0]!
+  store.getState().setEditorDraft(file.id, 'header\nprevious')
+  store.getState().markFileDirty(file.id, true)
+  const queue = createEditorSaveQueue(store)
+  return { disk, store, file, queue }
+}
+
+it('autosave flushes a legacy editor and reads its updated draft before writing', async () => {
+  const { disk, store, file, queue } = setup()
+  const unregister = registerPendingEditorFlush(file.id, () =>
+    store.getState().setEditorDraft(file.id, 'header\nlatest')
+  )
+  try {
+    await queue.queueSave(file, 'header\nstale', 'autosave')
+    expect(disk.files.get(file.filePath)).toBe('header\nlatest')
+    expect(store.getState().openFiles[0]?.isDirty).toBe(false)
+  } finally {
+    unregister()
+    queue.dispose()
+  }
+})
+
+it('a failed pending edit prevents the write and keeps the existing dirty draft', async () => {
+  const { disk, store, file, queue } = setup()
+  const unregister = registerPendingEditorFlush(file.id, () => {
+    throw new Error('invalid pending cell')
+  })
+  try {
+    await expect(queue.queueSave(file, 'fallback')).rejects.toThrow('invalid pending cell')
+    expect(disk.fs.writeFile).not.toHaveBeenCalled()
+    expect(store.getState().editorDrafts[file.id]).toBe('header\nprevious')
+    expect(store.getState().openFiles[0]?.isDirty).toBe(true)
+  } finally {
+    unregister()
+    queue.dispose()
+  }
+})
+
+it('a suspended autosave does not flush a pending cell or write the file', async () => {
+  const { disk, store, file, queue } = setup()
+  store.getState().setExternalMutation(file.id, 'changed')
+  const flush = vi.fn()
+  const unregister = registerPendingEditorFlush(file.id, flush)
+  try {
+    await queue.queueSave(file, 'fallback', 'autosave')
+    expect(flush).not.toHaveBeenCalled()
+    expect(disk.fs.writeFile).not.toHaveBeenCalled()
+  } finally {
+    unregister()
+    queue.dispose()
+  }
+})
+
+it('keeps a newer pending cell dirty when an earlier remote save completes', async () => {
+  const { disk, store, file, queue } = setup()
+  let releaseWrite: () => void = () => {
+    throw new Error('write not started')
+  }
+  disk.fs.writeFile.mockImplementationOnce(
+    () =>
+      new Promise<void>((resolve) => {
+        releaseWrite = resolve
+      })
+  )
+  let pending = false
+  const unregister = registerPendingEditorFlush(
+    file.id,
+    () => {},
+    () => pending
+  )
+  try {
+    const saving = queue.queueSave(file, 'fallback')
+    await vi.waitFor(() => expect(disk.fs.writeFile).toHaveBeenCalledTimes(1))
+    pending = true
+    releaseWrite()
+    await saving
+    expect(store.getState().openFiles[0]?.isDirty).toBe(true)
+    expect(store.getState().editorDrafts[file.id]).toBe('header\nprevious')
+  } finally {
+    unregister()
+    queue.dispose()
+  }
+})
+
+it.each([false, true])(
+  'autosave leaves an active CSV input alone (changed: %s)',
+  async (changed) => {
+    const { disk, store, file, queue } = setup()
+    const flush = vi.fn(() => {
+      throw new Error('rejected cell')
+    })
+    const unregister = registerPendingEditorFlush(file.id, flush, () => changed)
+    try {
+      await queue.queueSave(file, 'fallback', 'autosave')
+      expect(flush).not.toHaveBeenCalled()
+      expect(disk.files.get(file.filePath)).toBe('header\nprevious')
+      expect(store.getState().openFiles[0]?.isDirty).toBe(changed)
+      if (changed) {
+        await queue.queueSave(file, 'fallback', 'autosave')
+        expect(disk.fs.writeFile).toHaveBeenCalledTimes(1)
+      }
+    } finally {
+      unregister()
+      queue.dispose()
+    }
+  }
+)
diff --git a/src/renderer/src/components/editor/csv/csv-preview-save-safety.test.ts b/src/renderer/src/components/editor/csv/csv-preview-save-safety.test.ts
new file mode 100644
index 00000000000..fe2e247c966
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-preview-save-safety.test.ts
@@ -0,0 +1,34 @@
+// @vitest-environment happy-dom
+import { expect, it, vi } from 'vitest'
+import { createEditorStore } from '@/store/slices/editor-slice-test-harness'
+import { createEditorSaveQueue } from '../editor-save-queue'
+import { canAutoSaveOpenFile } from '../editor-autosave'
+
+const { writeFile } = vi.hoisted(() => ({ writeFile: vi.fn() }))
+vi.mock('@/runtime/runtime-file-client', () => ({ writeRuntimeFile: writeFile }))
+
+it('blocks drafts, dirty state, autosave and explicit writes for paged previews', async () => {
+  const store = createEditorStore()
+  store.getState().openFile({
+    filePath: '/repo/large.csv',
+    relativePath: 'large.csv',
+    worktreeId: 'wt-1',
+    language: 'plaintext',
+    mode: 'edit'
+  })
+  const fileId = store.getState().openFiles[0]!.id
+  store.getState().setCsvPreviewOnly(fileId, true)
+  store.getState().setEditorDraft(fileId, 'partial CSV')
+  store.getState().markFileDirty(fileId, true)
+  const file = store.getState().openFiles[0]!
+  expect(store.getState().editorDrafts[fileId]).toBeUndefined()
+  expect(file.isDirty).toBe(false)
+  expect(canAutoSaveOpenFile(file)).toBe(false)
+  const queue = createEditorSaveQueue(store)
+  await expect(queue.queueSave(file, '')).rejects.toThrow('read-only')
+  expect(writeFile).not.toHaveBeenCalled()
+  queue.dispose()
+  store.getState().setCsvPreviewOnly(fileId, false)
+  store.getState().setEditorDraft(fileId, 'complete CSV')
+  expect(store.getState().editorDrafts[fileId]).toBe('complete CSV')
+})
diff --git a/src/renderer/src/components/editor/csv/csv-preview-worker-client.ts b/src/renderer/src/components/editor/csv/csv-preview-worker-client.ts
new file mode 100644
index 00000000000..50d32e2fcd6
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-preview-worker-client.ts
@@ -0,0 +1,59 @@
+import type {
+  CsvWorkerCommand,
+  CsvWorkerResponse,
+  CsvWorkerValue
+} from './csv-preview-worker-protocol'
+
+export class CsvPreviewWorkerClient {
+  private worker = new Worker(new URL('./csv-preview.worker.ts', import.meta.url), {
+    type: 'module'
+  })
+  private nextId = 0
+  private pending = new Map<
+    number,
+    { resolve: (value: CsvWorkerValue) => void; reject: (error: Error) => void }
+  >()
+  private closed = false
+
+  constructor() {
+    this.worker.onmessage = (event: MessageEvent<CsvWorkerResponse>) => {
+      const response = event.data
+      const request = this.pending.get(response.id)
+      this.pending.delete(response.id)
+      if (response.ok) {
+        request?.resolve(response.value)
+      } else {
+        request?.reject(new Error(response.error))
+      }
+    }
+    this.worker.onerror = () =>
+      this.close(new Error('CSV preview worker failed. Reload the file to retry.'))
+    this.worker.onmessageerror = () =>
+      this.close(new Error('CSV preview worker returned an unreadable response.'))
+  }
+
+  request(command: CsvWorkerCommand): Promise<CsvWorkerValue> {
+    if (this.closed) {
+      return Promise.reject(new Error('CSV preview was canceled'))
+    }
+    const id = ++this.nextId
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject })
+      try {
+        this.worker.postMessage({ id, command }, 'bytes' in command ? [command.bytes.buffer] : [])
+      } catch (error) {
+        this.pending.delete(id)
+        reject(error)
+      }
+    })
+  }
+
+  close(error = new Error('CSV preview was canceled')): void {
+    this.closed = true
+    this.worker.terminate()
+    for (const request of this.pending.values()) {
+      request.reject(error)
+    }
+    this.pending.clear()
+  }
+}
diff --git a/src/renderer/src/components/editor/csv/csv-preview-worker-protocol.ts b/src/renderer/src/components/editor/csv/csv-preview-worker-protocol.ts
new file mode 100644
index 00000000000..b4993323e15
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-preview-worker-protocol.ts
@@ -0,0 +1,17 @@
+import type { CsvIndex } from './csv-byte-index'
+
+export type CsvWorkerCommand =
+  | { kind: 'init'; delimiter: string }
+  | { kind: 'feed'; bytes: Uint8Array<ArrayBuffer> }
+  | { kind: 'finish' }
+  | { kind: 'parse'; bytes: Uint8Array<ArrayBuffer>; stripBom: boolean }
+
+export type CsvWorkerValue =
+  | { kind: 'ack' }
+  | { kind: 'index'; index: CsvIndex }
+  | { kind: 'rows'; rows: string[][] }
+export type CsvWorkerRequest = { id: number; command: CsvWorkerCommand }
+export type CsvWorkerResponse = { id: number } & (
+  | { ok: true; value: CsvWorkerValue }
+  | { ok: false; error: string }
+)
diff --git a/src/renderer/src/components/editor/csv/csv-preview.worker.ts b/src/renderer/src/components/editor/csv/csv-preview.worker.ts
new file mode 100644
index 00000000000..4d4171ebcdf
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-preview.worker.ts
@@ -0,0 +1,53 @@
+import { CsvByteIndex, CSV_MAX_COLUMNS, CSV_RECORD_BYTES, CSV_PAGE_CELLS } from './csv-byte-index'
+import { parseCsv } from './csv-parse'
+import type {
+  CsvWorkerRequest,
+  CsvWorkerResponse,
+  CsvWorkerValue
+} from './csv-preview-worker-protocol'
+
+let index: CsvByteIndex | null = null
+let delimiter = ','
+self.onmessage = (event: MessageEvent<CsvWorkerRequest>): void => {
+  const { id, command } = event.data
+  try {
+    let value: CsvWorkerValue = { kind: 'ack' }
+    if (command.kind === 'init') {
+      delimiter = command.delimiter
+      index = new CsvByteIndex(delimiter.charCodeAt(0))
+    } else if (command.kind === 'feed') {
+      if (!index) {
+        throw new Error('CSV index is not initialized')
+      }
+      index.feed(command.bytes)
+    } else if (command.kind === 'finish') {
+      if (!index) {
+        throw new Error('CSV index is not initialized')
+      }
+      value = { kind: 'index', index: index.finish() }
+      index = null
+    } else {
+      const source = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(
+        command.bytes
+      )
+      value = {
+        kind: 'rows',
+        rows: parseCsv(source, delimiter, {
+          maxCells: CSV_PAGE_CELLS,
+          maxColumns: CSV_MAX_COLUMNS,
+          maxRecordLength: CSV_RECORD_BYTES,
+          stripBom: command.stripBom
+        }).rows
+      }
+    }
+    const response: CsvWorkerResponse = { id, ok: true, value }
+    self.postMessage(response)
+  } catch (error) {
+    const response: CsvWorkerResponse = {
+      id,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    }
+    self.postMessage(response)
+  }
+}
diff --git a/src/renderer/src/components/editor/csv/csv-serialization.ts b/src/renderer/src/components/editor/csv/csv-serialization.ts
new file mode 100644
index 00000000000..059e970df41
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-serialization.ts
@@ -0,0 +1,30 @@
+export function serializeCsvCell(value: string, delimiter: string, quoted = false): string {
+  return quoted || /["\r\n]/.test(value) || value.includes(delimiter) || value.startsWith('\ufeff')
+    ? `"${value.replaceAll('"', '""')}"`
+    : value
+}
+
+export function serializeCsvRecord(
+  values: readonly string[],
+  delimiter: string,
+  originalValues: readonly string[] = [],
+  originalTokens: readonly string[] = []
+): string {
+  return values
+    .map((value, index) => {
+      const token = originalTokens[index]
+      const quoteSingleField = values.length === 1 && (value === '' || /[,;\t]/.test(value))
+      const validToken =
+        token !== undefined &&
+        (token.startsWith('"') ? /^"(?:[^"]|"")*"$/.test(token) : !/["\r\n]/.test(token))
+      if (
+        value === originalValues[index] &&
+        validToken &&
+        !(quoteSingleField && !token?.startsWith('"'))
+      ) {
+        return token
+      }
+      return serializeCsvCell(value, delimiter, token?.startsWith('"') || quoteSingleField)
+    })
+    .join(delimiter)
+}
diff --git a/src/renderer/src/components/editor/csv/csv-source-record.ts b/src/renderer/src/components/editor/csv/csv-source-record.ts
new file mode 100644
index 00000000000..c7d74a7858a
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-source-record.ts
@@ -0,0 +1,12 @@
+import { parseCsv } from './csv-parse'
+import type { CsvTextDocument } from './csv-text-document'
+
+export function csvRecordTokens(document: CsvTextDocument, row: number): string[] {
+  const source = document.source.slice(document.starts[row], document.contentEnds[row])
+  const tokens: string[] = []
+  parseCsv(source, document.delimiter, {
+    stripBom: false,
+    onField: (start, end) => tokens.push(source.slice(start, end))
+  })
+  return tokens
+}
diff --git a/src/renderer/src/components/editor/csv/csv-table-edit-budget.ts b/src/renderer/src/components/editor/csv/csv-table-edit-budget.ts
new file mode 100644
index 00000000000..38b0b2a07c8
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-table-edit-budget.ts
@@ -0,0 +1,7 @@
+import { CSV_PAGED_PREVIEW_BYTES } from './csv-file-limits'
+
+export function assertCsvTableEditBytes(bytes: number): void {
+  if (bytes >= CSV_PAGED_PREVIEW_BYTES) {
+    throw new Error('Table edits must stay below 1 MiB. Use Source for larger changes.')
+  }
+}
diff --git a/src/renderer/src/components/editor/csv/csv-table-interactions.test.ts b/src/renderer/src/components/editor/csv/csv-table-interactions.test.ts
new file mode 100644
index 00000000000..12047c9997d
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-table-interactions.test.ts
@@ -0,0 +1,70 @@
+import { expect, it } from 'vitest'
+import { csvCellIsSelected, csvSelectionBounds, moveCsvSelection } from './csv-cell-selection'
+import { csvInspectionRows, csvSourceRow } from './csv-inspection'
+import { copyCsvSelection, pasteCsvSelection } from './csv-cell-clipboard'
+import { mutateCsvTextDocument, parseCsvTextDocument } from './csv-text-document'
+
+it('retains the selection anchor when extending backwards and collapses on normal movement', () => {
+  const first = moveCsvSelection(null, 3, 2, false)
+  const extended = moveCsvSelection(first, 1, 0, true)
+  expect(extended.anchor).toEqual({ row: 3, column: 2 })
+  expect(csvSelectionBounds(extended)).toEqual({
+    firstRow: 1,
+    lastRow: 3,
+    firstColumn: 0,
+    lastColumn: 2
+  })
+  expect(csvCellIsSelected(extended, 2, 1)).toBe(true)
+  expect(csvCellIsSelected(extended, 0, 1)).toBe(false)
+  expect(moveCsvSelection(extended, 2, 1, false).anchor).toEqual({ row: 2, column: 1 })
+})
+
+it('sorts and filters for inspection without mutating source order and edits the original row', () => {
+  const document = parseCsvTextDocument('name,value\nb,10\na,2\na,1', ',')
+  const view = csvInspectionRows(document.rows, 'a', { column: 1, direction: 'ascending' })
+  expect(view).toEqual([3, 2])
+  expect(csvSourceRow(0, view)).toBe(0)
+  const result = mutateCsvTextDocument(document, {
+    kind: 'cells',
+    edits: [{ row: csvSourceRow(1, view), column: 1, value: 'changed' }]
+  })
+  expect(result).toBe('name,value\nb,10\na,2\na,changed')
+  expect(document.source).toBe('name,value\nb,10\na,2\na,1')
+})
+
+it('copies and pastes rectangular quoted TSV without losing embedded CRLF or trailing blanks', () => {
+  const rows = [
+    ['a', 'b', 'c'],
+    ['line\r\nline', 'quote"', ''],
+    ['last', 'x', '']
+  ]
+  const selection = moveCsvSelection(moveCsvSelection(null, 1, 0, false), 2, 2, true)
+  const copied = copyCsvSelection(selection, rows, null)
+  expect(copied).toBe('"line\r\nline"\t"quote"""\t\nlast\tx\t')
+  expect(pasteCsvSelection(copied, selection, rows, 3, null)).toEqual([
+    { row: 1, column: 0, value: 'line\r\nline' },
+    { row: 1, column: 1, value: 'quote"' },
+    { row: 1, column: 2, value: '' },
+    { row: 2, column: 0, value: 'last' },
+    { row: 2, column: 1, value: 'x' },
+    { row: 2, column: 2, value: '' }
+  ])
+})
+
+it('fills a selected range with one literal value and rejects partial or oversized pastes', () => {
+  const rows = [
+    ['a', 'b'],
+    ['x', 'y'],
+    ['z', 'w']
+  ]
+  const selection = moveCsvSelection(moveCsvSelection(null, 1, 0, false), 2, 1, true)
+  expect(pasteCsvSelection('=literal', selection, rows, 2, [2, 1])).toEqual([
+    { row: 2, column: 0, value: '=literal' },
+    { row: 2, column: 1, value: '=literal' },
+    { row: 1, column: 0, value: '=literal' },
+    { row: 1, column: 1, value: '=literal' }
+  ])
+  expect(() => pasteCsvSelection('1\t2\t3', selection, rows, 2, null)).toThrow('exceeds the table')
+  const huge = moveCsvSelection(moveCsvSelection(null, 0, 0, false), 100_000, 1, true)
+  expect(() => pasteCsvSelection('x', huge, rows, 2, null)).toThrow()
+})
diff --git a/src/renderer/src/components/editor/csv/csv-text-cell-edits.ts b/src/renderer/src/components/editor/csv/csv-text-cell-edits.ts
new file mode 100644
index 00000000000..a8f77bbce7a
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-text-cell-edits.ts
@@ -0,0 +1,81 @@
+import { measureUtf8ByteLength } from '../../../../../shared/utf8-byte-limits'
+import { assertCsvTableEditBytes } from './csv-table-edit-budget'
+import { CSV_RECORD_BYTES } from './csv-byte-index'
+import { csvRecordTokens } from './csv-source-record'
+import { serializeCsvRecord } from './csv-serialization'
+import type { CsvCellEdit, CsvTextDocument } from './csv-text-document'
+
+export function editCsvTextCells(
+  document: CsvTextDocument,
+  edits: CsvCellEdit[],
+  preservePendingDraft = false
+): string {
+  const changed = new Map<number, string[]>()
+  for (const edit of edits) {
+    if (
+      !Number.isInteger(edit.row) ||
+      edit.row < 0 ||
+      edit.row >= document.rows.length ||
+      !Number.isInteger(edit.column) ||
+      edit.column < 0 ||
+      edit.column >= document.columnCount
+    ) {
+      throw new Error('The selected CSV row or column no longer exists.')
+    }
+    if (!changed.has(edit.row)) {
+      changed.set(edit.row, [...document.rows[edit.row]!])
+    }
+    const row = changed.get(edit.row)!
+    while (row.length <= edit.column) {
+      row.push('')
+    }
+    row[edit.column] = edit.value
+  }
+  const entries = [...changed.entries()]
+    .filter(([index, values]) => {
+      const original = document.rows[index]!
+      return (
+        values.length !== original.length ||
+        values.some((value, column) => value !== original[column])
+      )
+    })
+    .sort(([a], [b]) => a - b)
+  let cells = document.cellCount
+  let bytes = entries.reduce(
+    (bytes, [index]) =>
+      bytes -
+      measureUtf8ByteLength(
+        document.source.slice(document.starts[index], document.contentEnds[index])
+      ).byteLength,
+    document.byteLength
+  )
+  let previousEnd = 0
+  const parts: string[] = []
+  for (const [index, values] of entries) {
+    const original = document.rows[index]!
+    const record = serializeCsvRecord(
+      values,
+      document.delimiter,
+      original,
+      csvRecordTokens(document, index)
+    )
+    cells += values.length - original.length
+    bytes += measureUtf8ByteLength(record).byteLength
+    if (!preservePendingDraft) {
+      if (cells > 1024 * 1024 + 1) {
+        throw new Error('CSV contains too many cells to preview safely.')
+      }
+      if (measureUtf8ByteLength(record, { stopAfterBytes: CSV_RECORD_BYTES }).exceededLimit) {
+        throw new Error('CSV record is too large to preview safely.')
+      }
+      assertCsvTableEditBytes(bytes)
+    }
+    parts.push(document.source.slice(previousEnd, document.starts[index]), record)
+    previousEnd = document.contentEnds[index]!
+  }
+  if (!parts.length) {
+    return document.source
+  }
+  parts.push(document.source.slice(previousEnd))
+  return parts.join('')
+}
diff --git a/src/renderer/src/components/editor/csv/csv-text-document.test.ts b/src/renderer/src/components/editor/csv/csv-text-document.test.ts
new file mode 100644
index 00000000000..aac6e4de871
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-text-document.test.ts
@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest'
+import { parseCsv } from './csv-parse'
+import { detectCsvDelimiter } from './csv-delimiter-detection'
+import { mutateCsvTextDocument, parseCsvTextDocument } from './csv-text-document'
+
+describe('CSV text mutations', () => {
+  it('rejects a range fill before repeated large values can exceed the editable file budget', () => {
+    const document = parseCsvTextDocument('header\nfirst\nsecond', ',')
+    expect(() =>
+      mutateCsvTextDocument(document, {
+        kind: 'cells',
+        edits: [
+          { row: 1, column: 0, value: 'x'.repeat(600_000) },
+          { row: 2, column: 0, value: 'x'.repeat(600_000) }
+        ]
+      })
+    ).toThrow('Table edits must stay below 1 MiB')
+    expect(document.source).toBe('header\nfirst\nsecond')
+  })
+  it('quotes a remaining ambiguous column so reopening Auto does not split its values', () => {
+    const document = parseCsvTextDocument('name;label,other\na;b,x', ',')
+    const result = mutateCsvTextDocument(document, { kind: 'delete-columns', columns: [1] })
+    expect(result).toBe('"name;label"\n"a;b"')
+    expect(parseCsv(result, detectCsvDelimiter('data.csv', result)).rows).toEqual([
+      ['name;label'],
+      ['a;b']
+    ])
+  })
+  it('retains other tokens, BOM, mixed record endings and absent final newline', () => {
+    const source = '\ufeff"name",note\r\n"Ada","a""b"\nBob,"two\r\nlines"\rEnd,last'
+    const document = parseCsvTextDocument(source, ',')
+    expect(mutateCsvTextDocument(document, { kind: 'cells', edits: [] })).toBe(source)
+    const result = mutateCsvTextDocument(document, {
+      kind: 'cells',
+      edits: [{ row: 2, column: 0, value: 'B,ob' }]
+    })
+    expect(result).toBe(source.replace('Bob,', '"B,ob",'))
+    expect(parseCsv(result).rows[2]).toEqual(['B,ob', 'two\r\nlines'])
+  })
+
+  it.each([',', ';', '\t'])('safely round-trips edited values with %s', (delimiter) => {
+    const values = [
+      'quotes "inside"',
+      'line\r\nbreak',
+      `has${delimiter}delimiter`,
+      '',
+      '\ufeffliteral',
+      '=literal'
+    ]
+    const document = parseCsvTextDocument(`header\nold`, delimiter)
+    for (const value of values) {
+      const result = mutateCsvTextDocument(document, {
+        kind: 'cells',
+        edits: [{ row: 1, column: 0, value }]
+      })
+      expect(parseCsv(result, delimiter).rows).toEqual([['header'], [value]])
+    }
+  })
+
+  it('extends ragged rows without padding unaffected rows', () => {
+    const document = parseCsvTextDocument('a,b,c\nshort\n1,2,3\n', ',')
+    expect(
+      mutateCsvTextDocument(document, {
+        kind: 'cells',
+        edits: [{ row: 1, column: 2, value: 'last' }]
+      })
+    ).toBe('a,b,c\nshort,,last\n1,2,3\n')
+  })
+
+  it('inserts and deletes rows while retaining the final-newline preference', () => {
+    for (const ending of ['', '\r\n']) {
+      const document = parseCsvTextDocument(`a\r\nfirst\r\nlast${ending}`, ',')
+      expect(
+        mutateCsvTextDocument(document, {
+          kind: 'delete-rows',
+          rows: [2]
+        })
+      ).toBe(`a\r\nfirst${ending}`)
+      const result = mutateCsvTextDocument(document, {
+        kind: 'insert-rows',
+        at: 3,
+        rows: [['']]
+      })
+      expect(result).toBe(`a\r\nfirst\r\nlast\r\n""${ending}`)
+      expect(parseCsv(result).rows).toEqual([['a'], ['first'], ['last'], ['']])
+    }
+  })
+
+  it('keeps an empty retained record when deleting the unterminated last row', () => {
+    const document = parseCsvTextDocument('\nbody', ',')
+    const result = mutateCsvTextDocument(document, { kind: 'delete-rows', rows: [1] })
+    expect(result).toBe('""')
+    expect(parseCsv(result).rows).toEqual([['']])
+  })
+
+  it('closes a permissive unterminated field before adding a following row', () => {
+    const result = mutateCsvTextDocument(parseCsvTextDocument('a\n"open', ','), {
+      kind: 'insert-rows',
+      at: 2,
+      rows: [['next']]
+    })
+    expect(parseCsv(result).rows).toEqual([['a'], ['open'], ['next']])
+  })
+
+  it('adds, deletes and reorders duplicate and blank columns using positions', () => {
+    const document = parseCsvTextDocument('same,,same\n"01",,"03"\n1\n', ',')
+    const moved = mutateCsvTextDocument(document, { kind: 'move-column', from: 2, to: 0 })
+    expect(moved).toBe('same,same,\n"03","01",\n,1,\n')
+    const inserted = mutateCsvTextDocument(document, {
+      kind: 'insert-column',
+      at: 1,
+      label: 'new,name'
+    })
+    expect(parseCsv(inserted).rows).toEqual([
+      ['same', 'new,name', '', 'same'],
+      ['01', '', '', '03'],
+      ['1', '', '', '']
+    ])
+    const deleted = mutateCsvTextDocument(document, { kind: 'delete-columns', columns: [0, 2] })
+    expect(parseCsv(deleted).rows).toEqual([[''], [''], ['']])
+    expect(mutateCsvTextDocument(document, { kind: 'delete-columns', columns: [0, 1, 2] })).toBe('')
+  })
+
+  it('creates a first column in an empty file and rejects stale or unsafe mutations', () => {
+    expect(
+      mutateCsvTextDocument(parseCsvTextDocument('\ufeff', ','), {
+        kind: 'insert-column',
+        at: 0,
+        label: 'name'
+      })
+    ).toBe('\ufeffname')
+    const document = parseCsvTextDocument('a\nx', ',')
+    expect(() =>
+      mutateCsvTextDocument(document, {
+        kind: 'cells',
+        edits: [{ row: 1, column: 1, value: 'wrong' }]
+      })
+    ).toThrow('no longer exists')
+    expect(() =>
+      mutateCsvTextDocument(document, {
+        kind: 'cells',
+        edits: [{ row: 1, column: 0, value: 'x'.repeat(1024 * 1024 + 1) }]
+      })
+    ).toThrow('record')
+    expect(document.rows).toEqual([['a'], ['x']])
+  })
+})
diff --git a/src/renderer/src/components/editor/csv/csv-text-document.ts b/src/renderer/src/components/editor/csv/csv-text-document.ts
new file mode 100644
index 00000000000..f02dcba33ae
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/csv-text-document.ts
@@ -0,0 +1,197 @@
+import { measureUtf8ByteLength } from '../../../../../shared/utf8-byte-limits'
+import { parseCsv } from './csv-parse'
+import { CSV_MAX_COLUMNS, CSV_RECORD_BYTES } from './csv-byte-index'
+import { assertCsvTableEditBytes } from './csv-table-edit-budget'
+import { editCsvTextCells } from './csv-text-cell-edits'
+import { csvRecordTokens } from './csv-source-record'
+import { serializeCsvRecord } from './csv-serialization'
+
+export type CsvTextDocument = {
+  source: string
+  delimiter: string
+  rows: string[][]
+  columnCount: number
+  byteLength: number
+  cellCount: number
+  starts: Uint32Array
+  contentEnds: Uint32Array
+  ends: Uint32Array
+  lineEnding: string
+  bom: string
+}
+
+export type CsvCellEdit = { row: number; column: number; value: string }
+export type CsvTableMutation =
+  | { kind: 'cells'; edits: CsvCellEdit[] }
+  | { kind: 'insert-rows'; at: number; rows: string[][] }
+  | { kind: 'delete-rows'; rows: number[] }
+  | { kind: 'insert-column'; at: number; label: string }
+  | { kind: 'delete-columns'; columns: number[] }
+  | { kind: 'move-column'; from: number; to: number }
+
+export function parseCsvTextDocument(source: string, delimiter: string): CsvTextDocument {
+  const starts: number[] = []
+  const contentEnds: number[] = []
+  const ends: number[] = []
+  const parsed = parseCsv(source, delimiter, {
+    maxCells: 1024 * 1024 + 1,
+    maxColumns: CSV_MAX_COLUMNS,
+    maxRecordLength: CSV_RECORD_BYTES,
+    onRecord: (start, contentEnd, end) => {
+      starts.push(start)
+      contentEnds.push(contentEnd)
+      ends.push(end)
+    }
+  })
+  const terminated = ends.findIndex((end, index) => end > contentEnds[index]!)
+  return {
+    source,
+    delimiter,
+    rows: parsed.rows,
+    columnCount: parsed.maxColumns,
+    byteLength: measureUtf8ByteLength(source).byteLength,
+    cellCount: parsed.rows.reduce((count, row) => count + row.length, 0),
+    starts: Uint32Array.from(starts),
+    contentEnds: Uint32Array.from(contentEnds),
+    ends: Uint32Array.from(ends),
+    lineEnding: terminated === -1 ? '\n' : source.slice(contentEnds[terminated], ends[terminated]),
+    bom: source.startsWith('\ufeff') ? '\ufeff' : ''
+  }
+}
+
+function checkedIndex(index: number, count: number, inserting = false): void {
+  if (!Number.isInteger(index) || index < 0 || index >= count + (inserting ? 1 : 0)) {
+    throw new Error('The selected CSV row or column no longer exists.')
+  }
+}
+
+export function mutateCsvTextDocument(
+  document: CsvTextDocument,
+  mutation: CsvTableMutation
+): string {
+  if (mutation.kind === 'cells') {
+    return editCsvTextCells(document, mutation.edits)
+  }
+  let rows = [...document.rows]
+  let sourceRows = rows.map((_, index) => index)
+  let columns = Array.from({ length: document.columnCount }, (_, index) => index)
+  if (mutation.kind === 'insert-rows') {
+    checkedIndex(mutation.at, rows.length, true)
+    if (mutation.rows.some((row) => row.length > CSV_MAX_COLUMNS)) {
+      throw new Error('CSV exceeds the 4,096 column limit.')
+    }
+    rows = [...rows.slice(0, mutation.at), ...mutation.rows, ...rows.slice(mutation.at)]
+    sourceRows = [
+      ...sourceRows.slice(0, mutation.at),
+      ...mutation.rows.map(() => -1),
+      ...sourceRows.slice(mutation.at)
+    ]
+  } else if (mutation.kind === 'delete-rows') {
+    for (const row of new Set(mutation.rows)) {
+      checkedIndex(row, rows.length)
+    }
+    const deleted = new Set(mutation.rows)
+    rows = rows.filter((_, index) => !deleted.has(index))
+    sourceRows = sourceRows.filter((index) => !deleted.has(index))
+  } else {
+    if (mutation.kind === 'insert-column') {
+      checkedIndex(mutation.at, columns.length, true)
+      if (columns.length >= CSV_MAX_COLUMNS) {
+        throw new Error('CSV exceeds the 4,096 column limit.')
+      }
+      columns.splice(mutation.at, 0, -1)
+    } else if (mutation.kind === 'delete-columns') {
+      for (const column of new Set(mutation.columns)) {
+        checkedIndex(column, columns.length)
+      }
+      const deleted = new Set(mutation.columns)
+      columns = columns.filter((column) => !deleted.has(column))
+    } else {
+      checkedIndex(mutation.from, columns.length)
+      checkedIndex(mutation.to, columns.length)
+      const column = columns.splice(mutation.from, 1)[0]!
+      columns.splice(mutation.to, 0, column)
+    }
+    for (let index = 0; index < rows.length; index += 1) {
+      const original = rows[index]!
+      rows[index] = columns.map((column) =>
+        column < 0
+          ? index === 0 && mutation.kind === 'insert-column'
+            ? mutation.label
+            : ''
+          : (original[column] ?? '')
+      )
+    }
+    if (!rows.length && mutation.kind === 'insert-column') {
+      rows.push([mutation.label])
+      sourceRows.push(-1)
+    }
+    if (!columns.length) {
+      return document.bom
+    }
+  }
+  const finalTerminated = Boolean(document.ends.at(-1)! > document.contentEnds.at(-1)!)
+  const parts = [document.bom]
+  let bytes = document.bom ? 3 : 0
+  for (let index = 0; index < rows.length; index += 1) {
+    const sourceRow = sourceRows[index]!
+    const hasFollowing = index < rows.length - 1
+    const originalEnding =
+      sourceRow < 0
+        ? ''
+        : document.source.slice(document.contentEnds[sourceRow], document.ends[sourceRow])
+    if (
+      sourceRow >= 0 &&
+      mutation.kind !== 'insert-column' &&
+      mutation.kind !== 'delete-columns' &&
+      mutation.kind !== 'move-column'
+    ) {
+      const original = document.source.slice(
+        document.starts[sourceRow],
+        document.contentEnds[sourceRow]
+      )
+      // A newly following row must not fall inside an unterminated quoted field.
+      parts.push(
+        (!originalEnding && hasFollowing) || (!hasFollowing && !finalTerminated && original === '')
+          ? serializeCsvRecord(
+              rows[index]!,
+              document.delimiter,
+              document.rows[sourceRow],
+              csvRecordTokens(document, sourceRow)
+            )
+          : original
+      )
+    } else {
+      const tokens = sourceRow < 0 ? [] : csvRecordTokens(document, sourceRow)
+      const values = sourceRow < 0 ? [] : document.rows[sourceRow]!
+      parts.push(
+        serializeCsvRecord(
+          rows[index]!,
+          document.delimiter,
+          columns.map((column) => values[column] ?? ''),
+          columns.map((column) => tokens[column] ?? '')
+        )
+      )
+    }
+    const ending = hasFollowing || finalTerminated ? originalEnding || document.lineEnding : ''
+    bytes += measureUtf8ByteLength(parts.at(-1)!).byteLength + ending.length
+    assertCsvTableEditBytes(bytes)
+    parts.push(ending)
+  }
+  const result = parts.join('')
+  parseCsv(result, document.delimiter, {
+    maxCells: 1024 * 1024 + 1,
+    maxColumns: CSV_MAX_COLUMNS,
+    maxRecordLength: CSV_RECORD_BYTES,
+    retainRows: false,
+    onRecord: (start, contentEnd) => {
+      if (
+        measureUtf8ByteLength(result.slice(start, contentEnd), { stopAfterBytes: CSV_RECORD_BYTES })
+          .exceededLimit
+      ) {
+        throw new Error('CSV record exceeds the 1 MB limit.')
+      }
+    }
+  })
+  return result
+}
diff --git a/src/renderer/src/components/editor/csv/useCsvClipboard.ts b/src/renderer/src/components/editor/csv/useCsvClipboard.ts
new file mode 100644
index 00000000000..89d6293069d
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/useCsvClipboard.ts
@@ -0,0 +1,124 @@
+import { useEffect, useLayoutEffect, useRef, type ClipboardEvent } from 'react'
+import { APP_MENU_PASTE_EVENT } from '@/lib/app-menu-paste'
+import { copyCsvSelection, pasteCsvSelection } from './csv-cell-clipboard'
+import type { CsvCellSelection } from './csv-cell-selection'
+import type { CsvCellEditSession } from './csv-grid-interaction'
+import type { CsvCellEdit, CsvTextDocument } from './csv-text-document'
+
+export function useCsvClipboard({
+  document,
+  selection,
+  editing,
+  columns,
+  inspectionRows,
+  ownerId,
+  apply,
+  fail
+}: {
+  document: CsvTextDocument | null
+  selection: CsvCellSelection | null
+  editing: CsvCellEditSession | null
+  columns: number
+  inspectionRows: number[] | null
+  ownerId: string
+  apply: (edits: CsvCellEdit[]) => boolean
+  fail: (reason: unknown) => void
+}) {
+  const mounted = useRef(true)
+  const revision = useRef(0)
+  useLayoutEffect(() => {
+    revision.current += 1
+  }, [
+    document,
+    inspectionRows,
+    editing,
+    selection?.anchor.row,
+    selection?.anchor.column,
+    selection?.focus.row,
+    selection?.focus.column
+  ])
+  useEffect(() => {
+    mounted.current = true
+    return () => {
+      mounted.current = false
+    }
+  }, [])
+  const pasteText = (text: string): void => {
+    if (!document || !selection) {
+      return
+    }
+    try {
+      apply(pasteCsvSelection(text, selection, document.rows, columns, inspectionRows))
+    } catch (reason) {
+      fail(reason)
+    }
+  }
+  const ownsFocus = (): boolean =>
+    globalThis.document.activeElement?.getAttribute('data-csv-owner') === ownerId
+  const paste = async (requireOwnerFocus = false): Promise<void> => {
+    if (!document || !selection) {
+      return
+    }
+    const initialRevision = revision.current
+    try {
+      const text = await window.api.ui.readClipboardText()
+      if (!mounted.current || (requireOwnerFocus && !ownsFocus())) {
+        return
+      }
+      if (initialRevision !== revision.current) {
+        throw new Error('CSV changed before paste completed. Try again.')
+      }
+      pasteText(text)
+    } catch (reason) {
+      if (mounted.current) {
+        fail(reason)
+      }
+    }
+  }
+  const copy = async (): Promise<void> => {
+    if (!document || !selection) {
+      return
+    }
+    try {
+      await window.api.ui.writeClipboardText(
+        copyCsvSelection(selection, document.rows, inspectionRows)
+      )
+    } catch (reason) {
+      if (mounted.current) {
+        fail(reason)
+      }
+    }
+  }
+  const copyEvent = (event: ClipboardEvent<HTMLDivElement>): void => {
+    if (!document || !selection || event.target !== event.currentTarget) {
+      return
+    }
+    event.preventDefault()
+    try {
+      event.clipboardData.setData(
+        'text/plain',
+        copyCsvSelection(selection, document.rows, inspectionRows)
+      )
+    } catch (reason) {
+      fail(reason)
+    }
+  }
+  const pasteEvent = (event: ClipboardEvent<HTMLDivElement>): void => {
+    if (event.target !== event.currentTarget) {
+      return
+    }
+    event.preventDefault()
+    pasteText(event.clipboardData.getData('text/plain'))
+  }
+  useEffect(() => {
+    const handle = (event: Event): void => {
+      if (document && selection && ownsFocus()) {
+        event.preventDefault()
+        void paste(true)
+      }
+    }
+    window.addEventListener(APP_MENU_PASTE_EVENT, handle)
+    return () => window.removeEventListener(APP_MENU_PASTE_EVENT, handle)
+  })
+  return { pasteText, paste, copy, copyEvent, pasteEvent }
+}
diff --git a/src/renderer/src/components/editor/csv/useCsvColumnWidths.ts b/src/renderer/src/components/editor/csv/useCsvColumnWidths.ts
new file mode 100644
index 00000000000..856a9970390
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/useCsvColumnWidths.ts
@@ -0,0 +1,39 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import {
+  readCsvColumnWidths,
+  writeCsvColumnWidths,
+  type CsvColumnWidths
+} from './csv-column-width-preferences'
+
+export function useCsvColumnWidths(key: string) {
+  const [state, setState] = useState(() => ({ key, widths: readCsvColumnWidths(key) }))
+  const pending = useRef<{ key: string; widths: CsvColumnWidths } | null>(null)
+  const timer = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const flush = useCallback((): void => {
+    if (timer.current !== null) {
+      clearTimeout(timer.current)
+    }
+    timer.current = null
+    if (pending.current) {
+      writeCsvColumnWidths(pending.current.key, pending.current.widths)
+    }
+    pending.current = null
+  }, [])
+  useEffect(() => flush, [flush])
+  const widths = useMemo(
+    () => (state.key === key ? state.widths : readCsvColumnWidths(key)),
+    [state, key]
+  )
+  const changeWidths = (next: CsvColumnWidths): void => {
+    if (pending.current && pending.current.key !== key) {
+      flush()
+    }
+    setState({ key, widths: next })
+    pending.current = { key, widths: next }
+    if (timer.current !== null) {
+      clearTimeout(timer.current)
+    }
+    timer.current = setTimeout(flush, 200)
+  }
+  return { widths, changeWidths }
+}
diff --git a/src/renderer/src/components/editor/csv/useCsvPagedPreview.test.tsx b/src/renderer/src/components/editor/csv/useCsvPagedPreview.test.tsx
new file mode 100644
index 00000000000..8f9cf3349ab
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/useCsvPagedPreview.test.tsx
@@ -0,0 +1,97 @@
+// @vitest-environment happy-dom
+import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
+import { afterEach, expect, it, vi } from 'vitest'
+import { useCsvPagedPreview } from './useCsvPagedPreview'
+
+const mocks = vi.hoisted(() => ({
+  buildIndex: vi.fn(),
+  page: vi.fn(),
+  rows: vi.fn(),
+  close: vi.fn()
+}))
+vi.mock('./csv-paged-preview', () => ({
+  CsvPagedPreview: class {
+    buildIndex = mocks.buildIndex
+    page = mocks.page
+    rows = mocks.rows
+    close = mocks.close
+  }
+}))
+afterEach(() => {
+  cleanup()
+  vi.clearAllMocks()
+})
+
+it('keeps the new viewport loader alive when a canceled delimiter scan rejects late', async () => {
+  let rejectOld!: (error: Error) => void
+  const oldScan = new Promise<never>((_resolve, reject) => {
+    rejectOld = reject
+  })
+  const pages = [{ start: 0, end: 20, firstRow: 0, rowCount: 4 }]
+  mocks.buildIndex
+    .mockReturnValueOnce(oldScan)
+    .mockResolvedValue({ pages, rowCount: 4, columnCount: 1 })
+  mocks.page.mockResolvedValue([['id'], ['first'], ['second'], ['third']])
+  mocks.rows.mockResolvedValue(
+    new Map([
+      [1, ['second']],
+      [2, ['third']]
+    ])
+  )
+  const file = {
+    readArgs: { settings: null, filePath: '/repo/a.csv' },
+    snapshot: { size: 20, mtime: 1, isDirectory: false }
+  }
+  const { result, rerender } = renderHook(({ delimiter }) => useCsvPagedPreview(file, delimiter), {
+    initialProps: { delimiter: ',' }
+  })
+  rerender({ delimiter: ';' })
+  await waitFor(() => expect(result.current.header).toEqual(['id']))
+  await act(async () => {
+    rejectOld(new Error('old scan canceled'))
+  })
+  expect(result.current.error).toBeNull()
+  act(() => result.current.onVisibleRows(1, 2))
+  await waitFor(() => expect(result.current.getRow(2)).toEqual(['third']))
+  expect(mocks.rows).toHaveBeenCalledTimes(1)
+  expect(mocks.page).toHaveBeenCalledTimes(1)
+  expect(mocks.close).toHaveBeenCalledTimes(1)
+})
+
+it('coalesces rapid scrolls and releases rows outside the latest viewport', async () => {
+  const pages = Array.from({ length: 4 }, (_, i) => ({
+    start: i * 20,
+    end: (i + 1) * 20,
+    firstRow: i * 4,
+    rowCount: 4
+  }))
+  mocks.buildIndex.mockResolvedValue({ pages, rowCount: 16, columnCount: 1 })
+  mocks.page.mockImplementation(async (index: number) =>
+    Array.from({ length: 4 }, (_, offset) => [String(index * 4 + offset)])
+  )
+  mocks.rows.mockImplementation(
+    async (_index, first: number, last: number) =>
+      new Map(
+        Array.from({ length: last - first + 1 }, (_, offset) => [
+          first + offset,
+          [String(first + offset + 1)]
+        ])
+      )
+  )
+  const file = {
+    readArgs: { settings: null, filePath: '/repo/a.csv' },
+    snapshot: { size: 80, mtime: 1, isDirectory: false }
+  }
+  const { result } = renderHook(() => useCsvPagedPreview(file, ','))
+  await waitFor(() => expect(result.current.index?.rowCount).toBe(16))
+  act(() => {
+    result.current.onVisibleRows(3, 5)
+    result.current.onVisibleRows(8, 9)
+    result.current.onVisibleRows(13, 14)
+  })
+  await waitFor(() => expect(result.current.getRow(14)).toEqual(['15']))
+  expect(result.current.getRow(0)).toBeUndefined()
+  expect(result.current.rows.size).toBe(2)
+  expect(mocks.rows).toHaveBeenCalledTimes(2)
+  expect(mocks.page).toHaveBeenCalledTimes(1)
+})
diff --git a/src/renderer/src/components/editor/csv/useCsvPagedPreview.ts b/src/renderer/src/components/editor/csv/useCsvPagedPreview.ts
new file mode 100644
index 00000000000..fceb2dc6c05
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/useCsvPagedPreview.ts
@@ -0,0 +1,101 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { CsvFilePreview } from './csv-file-content'
+import { CsvPagedPreview } from './csv-paged-preview'
+import type { CsvIndex } from './csv-byte-index'
+
+type PreviewState = {
+  index: CsvIndex | null
+  header: string[]
+  sample: string[][]
+  rows: Map<number, string[]>
+  progress: number
+  error: string | null
+}
+const initialState = (): PreviewState => ({
+  index: null,
+  header: [],
+  sample: [],
+  rows: new Map(),
+  progress: 0,
+  error: null
+})
+
+export function useCsvPagedPreview(file: CsvFilePreview, delimiter: string) {
+  const [state, setState] = useState(initialState)
+  const requestRows = useRef<(first: number, last: number) => void>(() => {})
+  useEffect(() => {
+    const preview = new CsvPagedPreview(file)
+    let canceled = false
+    let wanted: { first: number; last: number } | null = null
+    let loading = false
+    const fail = (error: unknown): void => {
+      if (canceled) {
+        return
+      }
+      preview.close()
+      requestRows.current = () => {}
+      setState((previous) => ({
+        ...previous,
+        error: error instanceof Error ? error.message : String(error)
+      }))
+    }
+    setState(initialState())
+    void (async () => {
+      const index = await preview.buildIndex(delimiter, (progress) => {
+        if (!canceled) {
+          setState((previous) => ({ ...previous, progress }))
+        }
+      })
+      const firstPage = index.pages[0] ? await preview.page(0, index.pages[0]) : []
+      if (canceled) {
+        return
+      }
+      setState({
+        index,
+        header: firstPage[0] ?? [],
+        sample: firstPage.slice(1, 201),
+        rows: new Map(firstPage.slice(1).map((row, i) => [i, row])),
+        progress: file.snapshot.size,
+        error: null
+      })
+      const loadLatest = async (): Promise<void> => {
+        if (loading) {
+          return
+        }
+        loading = true
+        try {
+          while (wanted && !canceled) {
+            const range = wanted
+            wanted = null
+            const rows = await preview.rows(
+              index,
+              range.first,
+              range.last,
+              () => canceled || wanted !== null
+            )
+            if (rows && !canceled && !wanted) {
+              setState((previous) => ({ ...previous, rows }))
+            }
+          }
+        } finally {
+          loading = false
+        }
+      }
+      requestRows.current = (first, last) => {
+        wanted = { first, last }
+        void loadLatest().catch(fail)
+      }
+    })().catch(fail)
+    return () => {
+      canceled = true
+      requestRows.current = () => {}
+      preview.close()
+    }
+  }, [file, delimiter])
+  const onVisibleRows = useCallback(
+    (first: number, last: number) => requestRows.current(first, last),
+    []
+  )
+  const getRow = useCallback((index: number) => state.rows.get(index), [state.rows])
+  return { ...state, onVisibleRows, getRow }
+}
diff --git a/src/renderer/src/components/editor/csv/useCsvPendingCell.ts b/src/renderer/src/components/editor/csv/useCsvPendingCell.ts
new file mode 100644
index 00000000000..c59dfc47888
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/useCsvPendingCell.ts
@@ -0,0 +1,93 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, type RefObject } from 'react'
+import { registerPendingEditorFlush } from '../editor-pending-flush'
+import { ORCA_EDITOR_FILE_SAVED_EVENT } from '../editor-autosave'
+import type { CsvTextDocument } from './csv-text-document'
+import { editCsvTextCells } from './csv-text-cell-edits'
+import type { CsvCellEditSession } from './csv-grid-interaction'
+
+export function useCsvPendingCell({
+  fileId,
+  commit,
+  document,
+  onContentChange,
+  editingRef,
+  onSessionChange
+}: {
+  fileId?: string
+  commit: () => boolean
+  document: CsvTextDocument | null
+  onContentChange?: (content: string) => void
+  editingRef: RefObject<CsvCellEditSession | null>
+  onSessionChange: (session: CsvCellEditSession) => void
+}) {
+  const latest = useRef({ commit, document, onContentChange, onSessionChange })
+  useLayoutEffect(() => {
+    latest.current = { commit, document, onContentChange, onSessionChange }
+  })
+  useEffect(() => {
+    if (!fileId) {
+      return
+    }
+    const unregister = registerPendingEditorFlush(
+      fileId,
+      () => {
+        if (!latest.current.commit()) {
+          throw new Error('Resolve the pending CSV cell edit before saving.')
+        }
+      },
+      () => {
+        const draft = editingRef.current
+        return Boolean(
+          draft &&
+          draft.value !==
+            (latest.current.document?.rows[draft.sourceRow]?.[draft.position.column] ?? '')
+        )
+      }
+    )
+    const saved = (event: Event): void => {
+      if (!(event instanceof CustomEvent)) {
+        return
+      }
+      const detail: unknown = event.detail
+      if (
+        typeof detail !== 'object' ||
+        detail === null ||
+        !('fileId' in detail) ||
+        detail.fileId !== fileId ||
+        !('content' in detail)
+      ) {
+        return
+      }
+      const draft = editingRef.current
+      if (draft && draft.source === detail.content) {
+        latest.current.onSessionChange({ ...draft, wasDirty: false })
+      }
+    }
+    window.addEventListener(ORCA_EDITOR_FILE_SAVED_EVENT, saved)
+    return () => {
+      unregister()
+      window.removeEventListener(ORCA_EDITOR_FILE_SAVED_EVENT, saved)
+    }
+  }, [fileId, editingRef])
+  return useCallback(
+    (node: HTMLDivElement | null): void => {
+      if (node) {
+        return
+      }
+      const draft = editingRef.current
+      const snapshot = latest.current
+      if (!draft || !snapshot.document || draft.source !== snapshot.document.source) {
+        return
+      }
+      snapshot.onContentChange?.(
+        editCsvTextCells(
+          snapshot.document,
+          [{ row: draft.sourceRow, column: draft.position.column, value: draft.value }],
+          true
+        )
+      )
+      editingRef.current = null
+    },
+    [editingRef]
+  )
+}
diff --git a/src/renderer/src/components/editor/csv/useCsvTableEditor.ts b/src/renderer/src/components/editor/csv/useCsvTableEditor.ts
new file mode 100644
index 00000000000..3cf69954548
--- /dev/null
+++ b/src/renderer/src/components/editor/csv/useCsvTableEditor.ts
@@ -0,0 +1,255 @@
+import { useEffect, useId, useLayoutEffect, useRef, useState } from 'react'
+import { csvGridKeyDown } from './csv-grid-keyboard'
+import type { CsvCellEditSession, CsvGridInteraction } from './csv-grid-interaction'
+import {
+  csvSelectionBounds,
+  moveCsvSelection,
+  remapCsvSelectionAfterColumnMove,
+  type CsvCellSelection
+} from './csv-cell-selection'
+import { useCsvClipboard } from './useCsvClipboard'
+import { csvSourceRow } from './csv-inspection'
+import {
+  mutateCsvTextDocument,
+  parseCsvTextDocument,
+  type CsvTextDocument,
+  type CsvTableMutation
+} from './csv-text-document'
+import { useCsvPendingCell } from './useCsvPendingCell'
+
+export function useCsvTableEditor({
+  document,
+  inspectionRows,
+  onContentChange,
+  onSave,
+  onStructureChange,
+  fileId,
+  isDirty,
+  onDirtyStateHint
+}: {
+  document: CsvTextDocument | null
+  fileId?: string
+  isDirty?: boolean
+  onDirtyStateHint?: (dirty: boolean) => void
+  inspectionRows: number[] | null
+  onContentChange?: (content: string) => void
+  onSave?: (content: string) => Promise<boolean>
+  onStructureChange: (mutation: CsvTableMutation) => void
+}) {
+  const ownerId = useId()
+  const [selected, setSelected] = useState<CsvCellSelection | null>(null)
+  const [editing, setEditing] = useState<CsvCellEditSession | null>(null)
+  const editingRef = useRef<CsvCellEditSession | null>(null)
+  const setCellEditing = (next: CsvCellEditSession | null): void => {
+    editingRef.current = next
+    setEditing(next)
+  }
+  const [focusVersion, setFocusVersion] = useState(0)
+  const [error, setError] = useState<string | null>(null)
+  const [saving, setSaving] = useState(false)
+  const mounted = useRef(true)
+  const current = useRef(document)
+  useLayoutEffect(() => {
+    current.current = document
+  }, [document])
+  useEffect(() => {
+    mounted.current = true
+    return () => {
+      mounted.current = false
+    }
+  }, [])
+  const count = inspectionRows?.length ?? Math.max(0, (document?.rows.length ?? 0) - 1)
+  const columns = document?.columnCount ?? 0
+  const clamp = (position: { row: number; column: number }) => ({
+    row: Math.min(position.row, count),
+    column: Math.min(position.column, Math.max(0, columns - 1))
+  })
+  const selection =
+    selected && columns ? { anchor: clamp(selected.anchor), focus: clamp(selected.focus) } : null
+  const fail = (reason: unknown): void => {
+    if (mounted.current) {
+      setError(reason instanceof Error ? reason.message : String(reason))
+    }
+  }
+  const update = (mutation?: CsvTableMutation): string | null => {
+    if (!document || !onContentChange || current.current?.source !== document.source) {
+      return null
+    }
+    const draft = editingRef.current
+    try {
+      if (draft && draft.source !== document.source) {
+        throw new Error('CSV changed while this cell was being edited. Cancel and try again.')
+      }
+      const cellMutation: CsvTableMutation = {
+        kind: 'cells',
+        edits: draft
+          ? [{ row: draft.sourceRow, column: draft.position.column, value: draft.value }]
+          : []
+      }
+      let source = draft ? mutateCsvTextDocument(document, cellMutation) : document.source
+      if (mutation) {
+        const next =
+          source === document.source ? document : parseCsvTextDocument(source, document.delimiter)
+        source = mutateCsvTextDocument(next, mutation)
+      }
+      if (source !== document.source) {
+        onContentChange(source)
+        onStructureChange(mutation ?? cellMutation)
+        if (mutation?.kind === 'move-column') {
+          setSelected((previous) =>
+            remapCsvSelectionAfterColumnMove(previous, mutation.from, mutation.to)
+          )
+        } else if (mutation && mutation.kind !== 'cells') {
+          setSelected(null)
+        }
+      } else if (draft) {
+        onDirtyStateHint?.(draft.wasDirty)
+      }
+      setCellEditing(null)
+      setError(null)
+      return source
+    } catch (reason) {
+      fail(reason)
+      return null
+    }
+  }
+  const apply = (mutation: CsvTableMutation): boolean => update(mutation) !== null
+  const commit = (): boolean => update() !== null
+  const setRootRef = useCsvPendingCell({
+    fileId,
+    commit,
+    document,
+    onContentChange,
+    editingRef,
+    onSessionChange: setCellEditing
+  })
+  const select = (row: number, column: number, extend: boolean): boolean => {
+    if (!commit()) {
+      return false
+    }
+    setSelected((previous) => moveCsvSelection(previous, row, column, extend))
+    setFocusVersion((previous) => previous + 1)
+    return true
+  }
+  const edit = (row: number, column: number): void => {
+    if (!document || !onContentChange || !commit()) {
+      return
+    }
+    const sourceRow = csvSourceRow(row, inspectionRows)
+    if (!document.rows[sourceRow]) {
+      return
+    }
+    setSelected(moveCsvSelection(null, row, column, false))
+    setCellEditing({
+      position: { row, column },
+      sourceRow,
+      source: document.source,
+      wasDirty: Boolean(isDirty),
+      value: document.rows[sourceRow]?.[column] ?? ''
+    })
+  }
+  const { pasteText, paste, copy, copyEvent, pasteEvent } = useCsvClipboard({
+    document,
+    selection,
+    editing,
+    columns,
+    inspectionRows,
+    ownerId,
+    fail,
+    apply: (edits) => apply({ kind: 'cells', edits })
+  })
+  const save = async (): Promise<void> => {
+    if (!onSave || saving) {
+      return
+    }
+    const source = update()
+    if (source === null) {
+      return
+    }
+    setSaving(true)
+    try {
+      if (!(await onSave(source))) {
+        throw new Error('CSV could not be saved. Your edits remain in the draft.')
+      }
+    } catch (reason) {
+      fail(reason)
+    } finally {
+      if (mounted.current) {
+        setSaving(false)
+      }
+    }
+  }
+  const clear = (): void => pasteText('')
+  const interaction: CsvGridInteraction | undefined = onContentChange
+    ? {
+        selection,
+        editing,
+        focusVersion,
+        ownerId,
+        select,
+        edit,
+        change: (value) => {
+          const previous = editingRef.current
+          if (!previous) {
+            return
+          }
+          setCellEditing({ ...previous, value })
+          onDirtyStateHint?.(
+            previous.wasDirty ||
+              value !== document?.rows[previous.sourceRow]?.[previous.position.column]
+          )
+        },
+        commit,
+        save: () => void save(),
+        cancel: () => {
+          const previous = editingRef.current
+          setCellEditing(null)
+          if (previous?.source === document?.source) {
+            onDirtyStateHint?.(previous?.wasDirty ?? false)
+          }
+          setError(null)
+        },
+        keyDown: (event) =>
+          csvGridKeyDown(event, {
+            selection,
+            columns,
+            count,
+            copy,
+            paste,
+            save,
+            edit,
+            clear,
+            select,
+            cancel: () => {
+              setSelected(null)
+              setCellEditing(null)
+            },
+            selectAll: setSelected
+          }),
+        copy: copyEvent,
+        paste: pasteEvent
+      }
+    : undefined
+  const selectedRows = (): number[] => {
+    if (!selection) {
+      return []
+    }
+    const bounds = csvSelectionBounds(selection)
+    return Array.from({ length: bounds.lastRow - bounds.firstRow + 1 }, (_, index) =>
+      csvSourceRow(bounds.firstRow + index, inspectionRows)
+    )
+  }
+  return {
+    interaction,
+    selection,
+    error,
+    saving,
+    apply,
+    save,
+    copy,
+    paste,
+    edit,
+    selectedRows,
+    setRootRef
+  }
+}
diff --git a/src/renderer/src/components/editor/editor-autosave.ts b/src/renderer/src/components/editor/editor-autosave.ts
index c647fbfb779..e2f7a304e4a 100644
--- a/src/renderer/src/components/editor/editor-autosave.ts
+++ b/src/renderer/src/components/editor/editor-autosave.ts
@@ -82,7 +82,7 @@ export function isWorkingTreeCombinedDiffTab(file: OpenFile): boolean {
 export function canAutoSaveOpenFile(file: OpenFile): boolean {
   // Why: read-only tabs (AI Vault View Log) must never autosave — writing an
   // agent-owned transcript can corrupt the provider's resume history.
-  if (file.readOnly === true) {
+  if (file.readOnly === true || file.csvPreviewOnly === true) {
     return false
   }
   // Why: single-file editors and one-file unstaged diffs have an unambiguous
diff --git a/src/renderer/src/components/editor/editor-header-file-rename.ts b/src/renderer/src/components/editor/editor-header-file-rename.ts
index 5dc67d80358..e5df74ac141 100644
--- a/src/renderer/src/components/editor/editor-header-file-rename.ts
+++ b/src/renderer/src/components/editor/editor-header-file-rename.ts
@@ -5,6 +5,8 @@ import { useWorktreeById } from '@/store/selectors'
 import { basename } from '@/lib/path'
 import { renameFileOnDisk } from '@/lib/rename-file'
 import { getUntitledFileRoot } from './untitled-file-rename-path'
+import { useAppStore } from '@/store'
+import { editorTabDocumentFolderAccess } from '@/lib/local-file-access'
 
 type EditorHeaderFileRenameState = {
   canRename: boolean
@@ -75,7 +77,9 @@ export function useEditorHeaderFileRename(activeFile: OpenFile): EditorHeaderFil
       oldPath: activeFile.filePath,
       newName,
       worktreeId: activeFile.worktreeId,
-      worktreePath
+      worktreePath,
+      documentScoped:
+        editorTabDocumentFolderAccess(useAppStore.getState(), activeFile) !== undefined
     })
   }
 
diff --git a/src/renderer/src/components/editor/editor-lazy-views.ts b/src/renderer/src/components/editor/editor-lazy-views.ts
index 093b06317b8..15673c6966e 100644
--- a/src/renderer/src/components/editor/editor-lazy-views.ts
+++ b/src/renderer/src/components/editor/editor-lazy-views.ts
@@ -12,5 +12,6 @@ export const MarkdownPreview = lazy(() => import('./MarkdownPreview'))
 export const ImageViewer = lazy(() => import('./ImageViewer'))
 export const ImageDiffViewer = lazy(() => import('./ImageDiffViewer'))
 export const MermaidViewer = lazy(() => import('./MermaidViewer'))
-export const CsvViewer = lazy(() => import('./CsvViewer'))
+export const CsvViewer = lazy(() => import('./csv/CsvViewer'))
+export const CsvPagedViewer = lazy(() => import('./csv/CsvPagedViewer'))
 export const IpynbViewer = lazy(() => import('./IpynbViewer'))
diff --git a/src/renderer/src/components/editor/editor-model-host-isolation.test.ts b/src/renderer/src/components/editor/editor-model-host-isolation.test.ts
new file mode 100644
index 00000000000..c37491b0836
--- /dev/null
+++ b/src/renderer/src/components/editor/editor-model-host-isolation.test.ts
@@ -0,0 +1,324 @@
+// @vitest-environment happy-dom
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { OpenFile } from '@/store/slices/editor'
+import type { WorktreeOperationRoute } from '@/lib/worktree-operation-route'
+import {
+  attachModelLifetimeView,
+  createModelLifetimeFixture,
+  modelLifetimeFile,
+  modelLifetimeTextModel,
+  resetModelLifetimeFixtures
+} from './editor-model-lifetime-fixture'
+import { getEditorModelOwnerKey } from './editor-model-owner'
+import { toEditorModelUri } from './editor-model-uri'
+import {
+  beginProgrammaticContentSync,
+  endProgrammaticContentSync,
+  resetProgrammaticContentSyncForTests,
+  shouldIgnoreMonacoContentChange
+} from './monaco-programmatic-sync'
+
+vi.mock('sonner', () => ({ toast: { info: vi.fn(), error: vi.fn(), success: vi.fn() } }))
+
+const FILE_PATH = '/fixture/workspace/same-path.txt'
+const HOSTS: readonly WorktreeOperationRoute[] = [
+  { executionHostId: 'local', runtimeEnvironmentId: null },
+  { executionHostId: 'ssh:target', runtimeEnvironmentId: null },
+  { executionHostId: 'runtime:hub-a', runtimeEnvironmentId: 'hub-a' },
+  { executionHostId: 'ssh:target', runtimeEnvironmentId: 'hub-a' },
+  { executionHostId: 'ssh:target', runtimeEnvironmentId: 'hub-b' }
+]
+
+function file(id: string, route: WorktreeOperationRoute, filePath = FILE_PATH): OpenFile {
+  return {
+    ...modelLifetimeFile(id),
+    filePath,
+    relativePath: 'same-path.txt',
+    operationProvenance: {
+      ownershipProjection: 'explicit',
+      generation: {
+        route,
+        runtimeConnectionGeneration: null,
+        runtimePairingRevision: undefined,
+        runtimeSshGeneration: null,
+        nestedSshGeneration: null,
+        directSshGeneration: null
+      }
+    }
+  }
+}
+
+function createHostModels(filePath = FILE_PATH) {
+  const fixture = createModelLifetimeFixture()
+  const owners = HOSTS.map((route, index) => {
+    const ownedFile = file(`host-${index}`, route, filePath)
+    const modelKey = toEditorModelUri(
+      ownedFile.filePath,
+      getEditorModelOwnerKey(ownedFile, fixture.store.getState())
+    )
+    const initial = `text owned by ${route.executionHostId} through ${route.runtimeEnvironmentId}`
+    const model = modelLifetimeTextModel(modelKey, initial)
+    return { file: ownedFile, model, modelKey, initial }
+  })
+  fixture.store.setState({ openFiles: owners.map((owner) => owner.file) })
+  return { ...fixture, owners }
+}
+
+function edit(model: monaco.editor.ITextModel, text: string) {
+  model.pushStackElement()
+  model.pushEditOperations([], [{ range: model.getFullModelRange(), text }], () => null)
+  model.pushStackElement()
+}
+
+afterEach(() => {
+  resetProgrammaticContentSyncForTests()
+  resetModelLifetimeFixtures()
+})
+
+describe('same-path models on different execution hosts', () => {
+  it.each([FILE_PATH, 'C:\\fixture\\workspace\\same-path.txt', '\\\\server\\share\\same-path.txt'])(
+    'keeps host text and undo histories independent for %s',
+    async (filePath) => {
+      const { owners } = createHostModels(filePath)
+      expect(new Set(owners.map((owner) => owner.modelKey)).size).toBe(HOSTS.length)
+      expect(new Set(owners.map((owner) => owner.model.uri.fsPath))).toEqual(
+        new Set([monaco.Uri.file(filePath).fsPath])
+      )
+      for (const [index, owner] of owners.entries()) {
+        expect(monaco.editor.getModel(monaco.Uri.parse(owner.modelKey))).toBe(owner.model)
+        edit(owner.model, `edited host ${index}`)
+        expect(owner.model.canUndo()).toBe(true)
+        expect(owners.map((candidate) => candidate.model.getValue())).toEqual(
+          owners.map((candidate, candidateIndex) =>
+            candidateIndex <= index ? `edited host ${candidateIndex}` : candidate.initial
+          )
+        )
+      }
+      for (const [index, owner] of owners.entries()) {
+        await owner.model.undo()
+        expect(owner.model.canRedo()).toBe(true)
+        expect(owners.map((candidate) => candidate.model.getValue())).toEqual(
+          owners.map((candidate, candidateIndex) =>
+            candidateIndex <= index ? candidate.initial : `edited host ${candidateIndex}`
+          )
+        )
+      }
+      await owners[1]!.model.redo()
+      expect(owners.map((owner) => owner.model.getValue())).toEqual(
+        owners.map((owner, index) => (index === 1 ? 'edited host 1' : owner.initial))
+      )
+    }
+  )
+
+  it('suppresses watcher echoes in shared local panes without hiding an SSH user edit', () => {
+    const { owners } = createHostModels()
+    const local = owners[0]!
+    const ssh = owners[1]!
+    const accepted: string[] = []
+    const listeners = [local, local, ssh].map((owner, index) =>
+      owner.model.onDidChangeContent(() => {
+        if (
+          !shouldIgnoreMonacoContentChange({
+            modelKey: owner.modelKey,
+            isApplyingProgrammaticContent: false
+          })
+        ) {
+          accepted.push(`pane-${index}:${owner.model.getValue()}`)
+        }
+      })
+    )
+    beginProgrammaticContentSync(local.modelKey)
+    try {
+      local.model.setValue('local watcher update')
+      expect(accepted).toEqual([])
+      edit(ssh.model, 'SSH user edit')
+      expect(accepted).toEqual(['pane-2:SSH user edit'])
+      expect(local.model.getValue()).toBe('local watcher update')
+      expect(owners.slice(2).map((owner) => owner.model.getValue())).toEqual(
+        owners.slice(2).map((owner) => owner.initial)
+      )
+    } finally {
+      endProgrammaticContentSync(local.modelKey)
+      listeners.forEach((listener) => listener.dispose())
+    }
+  })
+
+  it('closes only the selected host model while siblings retain their text and undo', async () => {
+    const { owners, store, attach } = createHostModels()
+    owners.forEach((owner, index) => edit(owner.model, `edited host ${index}`))
+    attach()
+    const enumeration = vi.spyOn(monaco.editor, 'getModels')
+    for (const [index, owner] of owners.entries()) {
+      store.getState().closeFile(owner.file.id)
+      await Promise.resolve()
+      expect(owner.model.isDisposed()).toBe(true)
+      for (const [siblingIndex, sibling] of owners.slice(index + 1).entries()) {
+        expect(sibling.model.isDisposed()).toBe(false)
+        expect(sibling.model.getValue()).toBe(`edited host ${index + siblingIndex + 1}`)
+        expect(sibling.model.canUndo()).toBe(true)
+      }
+    }
+    expect(enumeration).not.toHaveBeenCalled()
+    expect(store.getState().openFiles).toHaveLength(0)
+  })
+
+  it.each([FILE_PATH, 'C:\\fixture\\workspace\\same-path.txt', '\\\\server\\share\\same-path.txt'])(
+    'restores independent closed-tab undo for remote owners of %s',
+    async (filePath) => {
+      const { owners, store, attach } = createHostModels(filePath)
+      const remoteOwners = [owners[1], owners[4]]
+      attach()
+      const closed = remoteOwners.map((owner, index) => {
+        if (!owner) {
+          throw new Error('Missing remote owner')
+        }
+        edit(owner.model, `saved remote draft ${index}`)
+        return { ...owner, saved: owner.model.getValue() }
+      })
+      for (const owner of closed) {
+        store.getState().closeFile(owner.file.id)
+      }
+      await Promise.resolve()
+      expect(closed.every((owner) => owner.model.isDisposed())).toBe(true)
+      store.setState({
+        openFiles: [...store.getState().openFiles, ...closed.map((owner) => owner.file)]
+      })
+      const reopened = closed.map((owner) => modelLifetimeTextModel(owner.modelKey, owner.saved))
+      expect(reopened.every((model) => model.canUndo())).toBe(true)
+      for (const [index, model] of reopened.entries()) {
+        await model.undo()
+        expect(reopened.map((candidate) => candidate.getValue())).toEqual(
+          closed.map((owner, ownerIndex) => (ownerIndex <= index ? owner.initial : owner.saved))
+        )
+      }
+      for (const owner of owners.filter(
+        (candidate) => !closed.some((entry) => entry.file.id === candidate.file.id)
+      )) {
+        expect(owner.model.isDisposed()).toBe(false)
+        expect(owner.model.getValue()).toBe(owner.initial)
+      }
+    }
+  )
+
+  it('releases a closed SSH model after its view detaches without touching a live local model', async () => {
+    const { owners, store, attach } = createHostModels()
+    const local = owners[0]!
+    const ssh = owners[1]!
+    const detach = attachModelLifetimeView(ssh.model)
+    attach()
+    store.getState().closeFile(ssh.file.id)
+    await Promise.resolve()
+    expect(ssh.model.isDisposed()).toBe(false)
+    detach()
+    expect(ssh.model.isDisposed()).toBe(false)
+    await Promise.resolve()
+    expect(ssh.model.isDisposed()).toBe(true)
+    expect(local.model.isDisposed()).toBe(false)
+    edit(local.model, 'local still editable')
+    await local.model.undo()
+    expect(local.model.getValue()).toBe(local.initial)
+  })
+
+  it('preserves local same-path sharing until the final local tab closes', async () => {
+    const { owners, store, attach } = createHostModels()
+    const local = owners[0]!
+    const sharedLocal = {
+      ...local.file,
+      id: 'local-other-workspace',
+      worktreeId: 'another-workspace'
+    }
+    expect(toEditorModelUri(FILE_PATH, getEditorModelOwnerKey(sharedLocal, store.getState()))).toBe(
+      local.modelKey
+    )
+    store.setState({ openFiles: [...store.getState().openFiles, sharedLocal] })
+    attach()
+    edit(local.model, 'shared local edit')
+    store.getState().closeFile(local.file.id)
+    await Promise.resolve()
+    expect(local.model.isDisposed()).toBe(false)
+    await local.model.undo()
+    expect(local.model.getValue()).toBe(local.initial)
+    store.getState().closeFile(sharedLocal.id)
+    await Promise.resolve()
+    expect(local.model.isDisposed()).toBe(true)
+    expect(owners.slice(1).every((owner) => !owner.model.isDisposed())).toBe(true)
+  })
+
+  it('releases an attached old owner when the same tab moves to a live runtime model', async () => {
+    const { owners, store, attach } = createHostModels()
+    const local = owners[0]!
+    const runtime = owners[2]!
+    const detach = attachModelLifetimeView(local.model)
+    edit(runtime.model, 'runtime independent edit')
+    attach()
+    store.setState({
+      openFiles: store
+        .getState()
+        .openFiles.map((opened) =>
+          opened.id === local.file.id
+            ? { ...opened, operationProvenance: runtime.file.operationProvenance }
+            : opened
+        )
+    })
+    await Promise.resolve()
+    expect(local.model.isDisposed()).toBe(false)
+    detach()
+    await Promise.resolve()
+    expect(local.model.isDisposed()).toBe(true)
+    expect(runtime.model.isDisposed()).toBe(false)
+    expect(runtime.model.getValue()).toBe('runtime independent edit')
+    store.getState().closeFile(local.file.id)
+    await Promise.resolve()
+    expect(runtime.model.isDisposed()).toBe(false)
+    await runtime.model.undo()
+    expect(runtime.model.getValue()).toBe(runtime.initial)
+  })
+
+  it('releases the prior owner when an uncaptured tab changes host without changing the tab array', async () => {
+    const { owners, store, attach } = createHostModels()
+    const local = owners[0]!
+    const ssh = owners[1]!
+    const legacyFile = { ...local.file, operationProvenance: undefined }
+    store.setState({ openFiles: [legacyFile, ...owners.slice(1).map((owner) => owner.file)] })
+    expect(getEditorModelOwnerKey(legacyFile, store.getState())).toBe('')
+    const openFiles = store.getState().openFiles
+    const detach = attachModelLifetimeView(local.model)
+    attach()
+    store.setState({
+      worktreesByRepo: Object.fromEntries(
+        Object.entries(store.getState().worktreesByRepo).map(([repoId, worktrees]) => [
+          repoId,
+          worktrees.map((worktree) => ({ ...worktree, hostId: 'ssh:target' as const }))
+        ])
+      )
+    })
+    expect(store.getState().openFiles).toBe(openFiles)
+    expect(toEditorModelUri(FILE_PATH, getEditorModelOwnerKey(legacyFile, store.getState()))).toBe(
+      ssh.modelKey
+    )
+    await Promise.resolve()
+    expect(local.model.isDisposed()).toBe(false)
+    detach()
+    await Promise.resolve()
+    expect(local.model.isDisposed()).toBe(true)
+    expect(ssh.model.isDisposed()).toBe(false)
+    expect(ssh.model.getValue()).toBe(ssh.initial)
+  })
+
+  it('uses prior host ownership when a catalog and its uncaptured tab disappear together', async () => {
+    const { owners, store, attach } = createHostModels()
+    const local = owners[0]!
+    const legacyFile = { ...local.file, operationProvenance: undefined }
+    store.setState({ openFiles: [legacyFile, ...owners.slice(1).map((owner) => owner.file)] })
+    expect(getEditorModelOwnerKey(legacyFile, store.getState())).toBe('')
+    attach()
+    store.setState({ openFiles: owners.slice(1).map((owner) => owner.file), worktreesByRepo: {} })
+    await Promise.resolve()
+    expect(local.model.isDisposed()).toBe(true)
+    for (const owner of owners.slice(1)) {
+      expect(owner.model.isDisposed()).toBe(false)
+      expect(owner.model.getValue()).toBe(owner.initial)
+    }
+  })
+})
diff --git a/src/renderer/src/components/editor/editor-model-owner.test.ts b/src/renderer/src/components/editor/editor-model-owner.test.ts
new file mode 100644
index 00000000000..3106939277d
--- /dev/null
+++ b/src/renderer/src/components/editor/editor-model-owner.test.ts
@@ -0,0 +1,151 @@
+import { describe, expect, it } from 'vitest'
+import type { OpenFile } from '@/store/slices/editor'
+import type {
+  WorktreeOperationRoute,
+  WorktreeOperationRouteState
+} from '@/lib/worktree-operation-route'
+import { folderWorkspaceKey } from '../../../../shared/workspace-scope'
+import { getEditorModelOwnerKey } from './editor-model-owner'
+
+function file(overrides: Partial<OpenFile> = {}): OpenFile {
+  return {
+    id: 'file',
+    filePath: '/srv/repo/file.ts',
+    relativePath: 'file.ts',
+    worktreeId: 'repo::/srv/repo',
+    language: 'typescript',
+    mode: 'edit',
+    isDirty: false,
+    ...overrides
+  }
+}
+
+function captured(route: WorktreeOperationRoute): OpenFile['operationProvenance'] {
+  return {
+    ownershipProjection: 'explicit',
+    generation: {
+      route,
+      runtimeConnectionGeneration: null,
+      runtimePairingRevision: undefined,
+      runtimeSshGeneration: null,
+      nestedSshGeneration: null,
+      directSshGeneration: null
+    }
+  }
+}
+
+const localState: WorktreeOperationRouteState = {
+  worktreesByRepo: { repo: [{ id: 'repo::/srv/repo', repoId: 'repo', hostId: 'local' }] }
+}
+
+describe('editor model ownership', () => {
+  it('shares local physical files across workspace and tab identities', () => {
+    expect(getEditorModelOwnerKey(file(), localState)).toBe('')
+    expect(
+      getEditorModelOwnerKey(
+        file({
+          id: 'other',
+          worktreeId: 'other',
+          operationProvenance: captured({ executionHostId: 'local', runtimeEnvironmentId: null })
+        }),
+        {}
+      )
+    ).toBe('')
+  })
+
+  it('keeps captured ownership when the focused host changes', () => {
+    const opened = file({
+      operationProvenance: captured({
+        executionHostId: 'ssh:target',
+        runtimeEnvironmentId: 'hub-a'
+      })
+    })
+    const key = getEditorModelOwnerKey(opened, {})
+    expect(
+      getEditorModelOwnerKey(opened, {
+        ...localState,
+        activeWorktreeId: opened.worktreeId,
+        activeWorkspaceExecutionHostId: 'runtime:hub-b'
+      })
+    ).toBe(key)
+    expect(key).toBe('["hub-a","ssh:target"]')
+  })
+
+  it('keeps distinct paired transports to the same target separate', () => {
+    const keys = ['hub-a', 'hub-b'].map((runtimeEnvironmentId) =>
+      getEditorModelOwnerKey(
+        file({
+          operationProvenance: captured({ executionHostId: 'ssh:target', runtimeEnvironmentId })
+        }),
+        {}
+      )
+    )
+    expect(keys[0]).not.toBe(keys[1])
+    expect(keys).not.toContain(
+      getEditorModelOwnerKey(
+        file({ externalSshTargetId: 'target', runtimeEnvironmentId: null }),
+        {}
+      )
+    )
+  })
+
+  it('uses the tab runtime hint when no owner catalog is present', () => {
+    expect(getEditorModelOwnerKey(file({ runtimeEnvironmentId: 'hub-a' }), {})).toBe(
+      '["hub-a","runtime:hub-a"]'
+    )
+    expect(getEditorModelOwnerKey(file({ runtimeEnvironmentId: 'hub-b' }), {})).toBe(
+      '["hub-b","runtime:hub-b"]'
+    )
+  })
+
+  it('honors an explicit local transport hint instead of the focused runtime', () => {
+    const opened = file({ runtimeEnvironmentId: null, externalSshTargetId: 'target' })
+    const state: WorktreeOperationRouteState = {
+      worktreesByRepo: {
+        repo: [
+          {
+            id: opened.worktreeId,
+            repoId: 'repo',
+            hostId: 'ssh:target',
+            runtimeOwnerEnvironmentId: 'hub-a'
+          }
+        ]
+      }
+    }
+    expect(getEditorModelOwnerKey(opened, state)).toBe('[null,"ssh:target"]')
+  })
+
+  it('does not adopt a new active host for a legacy local tab', () => {
+    const opened = file()
+    expect(
+      getEditorModelOwnerKey(opened, {
+        ...localState,
+        activeWorktreeId: opened.worktreeId,
+        activeWorkspaceExecutionHostId: 'ssh:new-target'
+      })
+    ).toBe('')
+  })
+
+  it('keeps unresolved owners separate from local files', () => {
+    expect(getEditorModelOwnerKey(file(), {})).not.toBe('')
+    expect(getEditorModelOwnerKey(file(), {})).not.toBe(
+      getEditorModelOwnerKey(file({ worktreeId: 'another-owner' }), {})
+    )
+  })
+
+  it('supports local and remote folder workspaces', () => {
+    const opened = file({ worktreeId: folderWorkspaceKey('folder') })
+    expect(
+      getEditorModelOwnerKey(opened, {
+        folderWorkspaces: [{ id: 'folder', projectGroupId: 'group', executionHostId: 'local' }]
+      })
+    ).toBe('')
+    expect(
+      getEditorModelOwnerKey(opened, {
+        folderWorkspaces: [
+          { id: 'folder', projectGroupId: 'group', executionHostId: 'runtime:hub-a' }
+        ]
+      })
+    ).toBe('["hub-a","runtime:hub-a"]')
+  })
+})
diff --git a/src/renderer/src/components/editor/editor-model-owner.ts b/src/renderer/src/components/editor/editor-model-owner.ts
new file mode 100644
index 00000000000..b8764943ca1
--- /dev/null
+++ b/src/renderer/src/components/editor/editor-model-owner.ts
@@ -0,0 +1,39 @@
+import type { OpenFile } from '@/store/slices/editor'
+import {
+  resolveWorktreeOperationRoute,
+  type WorktreeOperationRouteState
+} from '@/lib/worktree-operation-route'
+import { toRuntimeExecutionHostId, toSshExecutionHostId } from '../../../../shared/execution-host'
+
+export function getEditorModelOwnerKey(file: OpenFile, state: WorktreeOperationRouteState): string {
+  const captured = file.operationProvenance?.generation.route
+  const route =
+    captured ??
+    resolveWorktreeOperationRoute(
+      state.activeWorktreeId === file.worktreeId ? { ...state, activeWorktreeId: null } : state,
+      file.worktreeId
+    )
+  const environmentId = captured
+    ? captured.runtimeEnvironmentId
+    : file.runtimeEnvironmentId !== undefined
+      ? file.runtimeEnvironmentId?.trim() || null
+      : (route?.runtimeEnvironmentId ?? null)
+  const hostId = captured
+    ? captured.executionHostId
+    : file.externalSshTargetId
+      ? toSshExecutionHostId(file.externalSshTargetId)
+      : route &&
+          (file.runtimeEnvironmentId === undefined ||
+            (file.runtimeEnvironmentId || null) === route.runtimeEnvironmentId)
+        ? route.executionHostId
+        : environmentId
+          ? toRuntimeExecutionHostId(environmentId)
+          : null
+  if (hostId === 'local' && !environmentId) {
+    return ''
+  }
+  // Unresolved owners must not borrow another host's retained text.
+  return JSON.stringify(
+    hostId ? [environmentId, hostId] : [environmentId, 'unresolved', file.worktreeId, file.id]
+  )
+}
diff --git a/src/renderer/src/components/editor/editor-model-uri.test.ts b/src/renderer/src/components/editor/editor-model-uri.test.ts
index ab36097ca20..4fc1828b791 100644
--- a/src/renderer/src/components/editor/editor-model-uri.test.ts
+++ b/src/renderer/src/components/editor/editor-model-uri.test.ts
@@ -37,4 +37,16 @@ describe('toEditorModelUri', () => {
   it('keeps distinct POSIX paths distinct', () => {
     expect(toEditorModelUri('/repo/a b.ts')).not.toBe(toEditorModelUri('/repo/a%20b.ts'))
   })
+
+  it.each(paths)('isolates owners while preserving the filesystem path for %s', (path) => {
+    const local = URI.parse(toEditorModelUri(path))
+    const remoteUri = toEditorModelUri(path, '["hub-a","ssh:target#1"]')
+    const remote = URI.parse(remoteUri)
+    expect(remote.scheme).toBe('file')
+    expect(remote.fsPath).toBe(local.fsPath)
+    expect(remote.toString()).not.toBe(local.toString())
+    expect(remote.toString()).toBe(remoteUri)
+    expect(toEditorModelUri(remoteUri)).toBe(remoteUri)
+    expect(toEditorModelUri(path, '["hub-b","ssh:target#1"]')).not.toBe(remoteUri)
+  })
 })
diff --git a/src/renderer/src/components/editor/editor-model-uri.ts b/src/renderer/src/components/editor/editor-model-uri.ts
index 1953a2ab757..6d467bd2549 100644
--- a/src/renderer/src/components/editor/editor-model-uri.ts
+++ b/src/renderer/src/components/editor/editor-model-uri.ts
@@ -12,6 +12,10 @@ const FILE_SCHEME = /^file:/i
  * re-parses to itself, so a consumer that can only take a string (the `path` prop of
  * `@monaco-editor/react`, which calls `Uri.parse` internally) lands on the same key.
  */
-export function toEditorModelUri(filePath: string): string {
-  return URI.file(FILE_SCHEME.test(filePath) ? URI.parse(filePath).fsPath : filePath).toString()
+export function toEditorModelUri(filePath: string, ownerKey = ''): string {
+  const parsed = FILE_SCHEME.test(filePath) ? URI.parse(filePath) : URI.file(filePath)
+  // Equal paths on different owners must not share text or undo history.
+  return URI.file(parsed.fsPath)
+    .with({ fragment: ownerKey || parsed.fragment })
+    .toString()
 }
diff --git a/src/renderer/src/components/editor/editor-panel-content-types.ts b/src/renderer/src/components/editor/editor-panel-content-types.ts
index e9d2b02916b..af621f509c7 100644
--- a/src/renderer/src/components/editor/editor-panel-content-types.ts
+++ b/src/renderer/src/components/editor/editor-panel-content-types.ts
@@ -1,4 +1,5 @@
 import type { GitDiffResult } from '../../../../shared/git-diff-compare-types'
+import type { CsvFilePreview } from './csv/csv-file-content'
 
 /**
  * Thrown when a worktree's host owner is not yet known (the backing repo has
@@ -47,6 +48,7 @@ export const WORKTREE_HOST_UNRESOLVED_ERROR =
   "The host couldn't find this file's workspace. It may have been removed, or the host may not know about it yet. Retry, or close this tab from the tab strip."
 
 export type FileContent = {
+  csvPreview?: CsvFilePreview
   content: string
   isBinary: boolean
   isImage?: boolean
diff --git a/src/renderer/src/components/editor/editor-pending-flush.test.ts b/src/renderer/src/components/editor/editor-pending-flush.test.ts
new file mode 100644
index 00000000000..a5d88b62b9c
--- /dev/null
+++ b/src/renderer/src/components/editor/editor-pending-flush.test.ts
@@ -0,0 +1,44 @@
+import { expect, it, vi } from 'vitest'
+import {
+  flushPendingEditorChange,
+  hasPendingEditorChange,
+  registerPendingEditorFlush
+} from './editor-pending-flush'
+
+it('retains legacy replacement semantics and independently cleans up registrations', () => {
+  const earlier = vi.fn()
+  const later = vi.fn()
+  const removeEarlier = registerPendingEditorFlush('legacy', earlier)
+  const removeLater = registerPendingEditorFlush('legacy', later)
+  try {
+    flushPendingEditorChange('legacy')
+    expect(earlier).not.toHaveBeenCalled()
+    expect(later).toHaveBeenCalledTimes(1)
+    removeEarlier()
+    flushPendingEditorChange('legacy')
+    expect(later).toHaveBeenCalledTimes(2)
+  } finally {
+    removeEarlier()
+    removeLater()
+  }
+  flushPendingEditorChange('legacy')
+  expect(later).toHaveBeenCalledTimes(2)
+})
+
+it('checks pending changes across panes and retains the remaining registration on cleanup', () => {
+  const earlier = vi.fn()
+  const later = vi.fn()
+  const removeEarlier = registerPendingEditorFlush('panes', earlier, () => true)
+  const removeLater = registerPendingEditorFlush('panes', later, () => false)
+  try {
+    expect(hasPendingEditorChange('panes')).toBe(true)
+    removeLater()
+    flushPendingEditorChange('panes')
+    expect(earlier).toHaveBeenCalledTimes(1)
+    expect(later).not.toHaveBeenCalled()
+  } finally {
+    removeEarlier()
+    removeLater()
+  }
+  expect(hasPendingEditorChange('panes')).toBe(false)
+})
diff --git a/src/renderer/src/components/editor/editor-pending-flush.ts b/src/renderer/src/components/editor/editor-pending-flush.ts
index 5122457d663..28e5ba15e43 100644
--- a/src/renderer/src/components/editor/editor-pending-flush.ts
+++ b/src/renderer/src/components/editor/editor-pending-flush.ts
@@ -1,14 +1,34 @@
-const pendingEditorFlushes = new Map<string, () => void>()
+type PendingEditor = { flush: () => void; hasChange?: () => boolean }
+const pendingEditorFlushes = new Map<string, Set<PendingEditor>>()
 
-export function registerPendingEditorFlush(fileId: string, flush: () => void): () => void {
-  pendingEditorFlushes.set(fileId, flush)
+export function registerPendingEditorFlush(
+  fileId: string,
+  flush: () => void,
+  hasChange?: () => boolean
+): () => void {
+  const entry = { flush, hasChange }
+  const entries = pendingEditorFlushes.get(fileId) ?? new Set<PendingEditor>()
+  entries.add(entry)
+  pendingEditorFlushes.set(fileId, entries)
   return () => {
-    if (pendingEditorFlushes.get(fileId) === flush) {
+    entries.delete(entry)
+    if (!entries.size && pendingEditorFlushes.get(fileId) === entries) {
       pendingEditorFlushes.delete(fileId)
     }
   }
 }
 
-export function flushPendingEditorChange(fileId: string): void {
-  pendingEditorFlushes.get(fileId)?.()
+export function flushPendingEditorChange(fileId: string, autosave = false): void {
+  const entries = [...(pendingEditorFlushes.get(fileId) ?? [])]
+  // Keep legacy replacement semantics while retaining each CSV pane's pending input.
+  const legacy = entries.findLast((entry) => !entry.hasChange)
+  for (const entry of entries) {
+    if (entry.hasChange ? !autosave : entry === legacy) {
+      entry.flush()
+    }
+  }
+}
+
+export function hasPendingEditorChange(fileId: string): boolean {
+  return [...(pendingEditorFlushes.get(fileId) ?? [])].some((entry) => entry.hasChange?.())
 }
diff --git a/src/renderer/src/components/editor/editor-restored-tab-conflict-scan.test.ts b/src/renderer/src/components/editor/editor-restored-tab-conflict-scan.test.ts
index 8e25daabad7..1e6bbe22779 100644
--- a/src/renderer/src/components/editor/editor-restored-tab-conflict-scan.test.ts
+++ b/src/renderer/src/components/editor/editor-restored-tab-conflict-scan.test.ts
@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { createStore, type StoreApi } from 'zustand/vanilla'
 import { createEditorSlice } from '@/store/slices/editor'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../../shared/constants'
 import type { AppState } from '@/store'
 import { attachRestoredTabConflictScan } from './editor-restored-tab-conflict-scan'
 import { getDiskBaselineSignature } from './diff-content-signature'
@@ -32,12 +33,15 @@ function createEditorStore(): StoreApi<AppState> {
 function openRestoredDirtyTab(
   store: StoreApi<AppState>,
   filePath: string,
-  baselineContent: string
+  baselineContent: string,
+  owner: { relativePath: string; worktreeId: string } = {
+    relativePath: filePath.slice(1),
+    worktreeId: 'wt-1'
+  }
 ): void {
   store.getState().openFile({
     filePath,
-    relativePath: filePath.slice(1),
-    worktreeId: 'wt-1',
+    ...owner,
     language: 'typescript',
     mode: 'edit'
   })
@@ -250,6 +254,56 @@ describe('attachRestoredTabConflictScan', () => {
     }
   })
 
+  it('verifies a restored dirty floating-workspace tab as the file the user named', async () => {
+    mocks.readRuntimeFileContent.mockRejectedValueOnce(new Error('ENOENT'))
+    mocks.readRuntimeFileContent.mockResolvedValue({
+      content: 'original baseline',
+      isBinary: false
+    })
+    mocks.pathExists.mockResolvedValue(true)
+    mocks.getConnectionIdForFile.mockReturnValue(null)
+    const store = createEditorStore()
+    openRestoredDirtyTab(store, '/Users/me/notes.txt', 'original baseline', {
+      relativePath: 'notes.txt',
+      worktreeId: FLOATING_TERMINAL_WORKTREE_ID
+    })
+
+    const detach = attachRestoredTabConflictScan(store)
+    try {
+      await vi.advanceTimersByTimeAsync(10)
+      expect(mocks.pathExists).toHaveBeenCalledWith(
+        expect.objectContaining({ filePath: '/Users/me/notes.txt', access: { kind: 'user-file' } })
+      )
+      await vi.advanceTimersByTimeAsync(2_100)
+      expect(mocks.readRuntimeFileContent).toHaveBeenLastCalledWith(
+        expect.objectContaining({ filePath: '/Users/me/notes.txt', access: { kind: 'user-file' } })
+      )
+      expect(store.getState().openFiles[0]?.pendingDiskBaselineVerification).toBeUndefined()
+    } finally {
+      detach()
+    }
+  })
+
+  it('verifies a restored dirty project tab inside its root', async () => {
+    mocks.readRuntimeFileContent.mockResolvedValue({
+      content: 'original baseline',
+      isBinary: false
+    })
+    mocks.getConnectionIdForFile.mockReturnValue(null)
+    const store = createEditorStore()
+    openRestoredDirtyTab(store, '/repo/file.ts', 'original baseline')
+
+    const detach = attachRestoredTabConflictScan(store)
+    try {
+      await vi.advanceTimersByTimeAsync(10)
+      expect(mocks.readRuntimeFileContent).toHaveBeenCalledWith(
+        expect.objectContaining({ filePath: '/repo/file.ts', access: undefined })
+      )
+    } finally {
+      detach()
+    }
+  })
+
   it('does not verify an external SSH file through a replacement target', async () => {
     const store = createEditorStore()
     openRestoredDirtyTab(store, '/tmp/external.ts', 'original baseline')
diff --git a/src/renderer/src/components/editor/editor-restored-tab-conflict-scan.ts b/src/renderer/src/components/editor/editor-restored-tab-conflict-scan.ts
index 92fde37b51e..72d44520981 100644
--- a/src/renderer/src/components/editor/editor-restored-tab-conflict-scan.ts
+++ b/src/renderer/src/components/editor/editor-restored-tab-conflict-scan.ts
@@ -3,6 +3,7 @@ import type { StoreApi } from 'zustand'
 import type { AppState } from '@/store'
 import type { OpenFile } from '@/store/slices/editor'
 import { getConnectionIdForFile } from '@/lib/connection-context'
+import { editorTabFileAccess } from '@/lib/local-file-access'
 import { readRuntimeFileContent } from '@/runtime/runtime-file-client'
 import { settingsForRuntimeOwner } from '@/runtime/runtime-rpc-client'
 import { canAutoSaveOpenFile } from './editor-autosave'
@@ -44,9 +45,12 @@ export function attachRestoredTabConflictScan(store: AppStoreApi): () => void {
       return false
     }
     try {
+      const connectionId = getFileConnectionId(file)
+      const access = connectionId ? undefined : editorTabFileAccess(store.getState(), file)
       const exists = await globalThis.window?.api?.fs?.pathExists?.({
         filePath: file.filePath,
-        connectionId: getFileConnectionId(file)
+        connectionId,
+        ...(access ? { access } : {})
       })
       return exists === false
     } catch {
@@ -66,7 +70,8 @@ export function attachRestoredTabConflictScan(store: AppStoreApi): () => void {
         relativePath: file.relativePath,
         worktreeId: file.worktreeId,
         connectionId: getFileConnectionId(file),
-        expectedExternalSshTargetId: file.externalSshTargetId
+        expectedExternalSshTargetId: file.externalSshTargetId,
+        access: editorTabFileAccess(state, file)
       })
       if (disposed) {
         return
diff --git a/src/renderer/src/components/editor/editor-save-queue.ts b/src/renderer/src/components/editor/editor-save-queue.ts
index b5a0281470d..d3873c6b679 100644
--- a/src/renderer/src/components/editor/editor-save-queue.ts
+++ b/src/renderer/src/components/editor/editor-save-queue.ts
@@ -11,7 +11,7 @@ import {
   ORCA_EDITOR_FILE_SAVED_EVENT,
   type EditorFileSavedDetail
 } from './editor-autosave'
-import { flushPendingEditorChange } from './editor-pending-flush'
+import { flushPendingEditorChange, hasPendingEditorChange } from './editor-pending-flush'
 import {
   clearSelfWrite,
   recordSelfWrite,
@@ -19,6 +19,7 @@ import {
 } from './editor-self-write-registry'
 import { getDiskBaselineSignature } from './diff-content-signature'
 import { trackExternalChangeConflictAction } from './editor-external-change-telemetry'
+import { editorTabFileAccess } from '@/lib/local-file-access'
 
 export type AppStoreApi = Pick<StoreApi<AppState>, 'getState' | 'subscribe'>
 
@@ -76,6 +77,9 @@ export function createEditorSaveQueue(store: AppStoreApi): EditorSaveQueue {
         if (!liveFile) {
           return
         }
+        if (liveFile.csvPreviewOnly === true) {
+          throw new Error('Large CSV previews are read-only.')
+        }
 
         // Why: read-only tabs (AI Vault View Log) must never write the agent-owned artifact through editor paths.
         if (liveFile.readOnly === true) {
@@ -94,7 +98,15 @@ export function createEditorSaveQueue(store: AppStoreApi): EditorSaveQueue {
           return
         }
 
-        const contentToSave = state.editorDrafts[file.id] ?? fallbackContent
+        flushPendingEditorChange(file.id, trigger === 'autosave')
+        const contentToSave = store.getState().editorDrafts[file.id] ?? fallbackContent
+        if (
+          trigger === 'autosave' &&
+          hasPendingEditorChange(file.id) &&
+          liveFile.lastKnownDiskSignature === getDiskBaselineSignature(contentToSave)
+        ) {
+          return
+        }
         const worktree = liveFile.worktreeId
           ? findWorktreeById(state.worktreesByRepo ?? {}, liveFile.worktreeId)
           : null
@@ -110,7 +122,12 @@ export function createEditorSaveQueue(store: AppStoreApi): EditorSaveQueue {
             : undefined
         )
         try {
-          await writeRuntimeFile(fileContext, liveFile.filePath, contentToSave)
+          await writeRuntimeFile(
+            fileContext,
+            liveFile.filePath,
+            contentToSave,
+            editorTabFileAccess(state, liveFile)
+          )
         } catch (error) {
           // Why: the self-write stamp is only valid after a real write; clear on failure so it can't suppress a real update.
           clearSelfWrite(liveFile.filePath, liveFile.runtimeEnvironmentId)
@@ -123,7 +140,9 @@ export function createEditorSaveQueue(store: AppStoreApi): EditorSaveQueue {
 
         const nextState = store.getState()
         const currentDraft = nextState.editorDrafts[file.id]
-        const stillDirty = currentDraft !== undefined && currentDraft !== contentToSave
+        const stillDirty =
+          (currentDraft !== undefined && currentDraft !== contentToSave) ||
+          hasPendingEditorChange(file.id)
         nextState.markFileDirty(file.id, stillDirty)
         if (!stillDirty) {
           nextState.clearEditorDraft(file.id)
@@ -210,7 +229,9 @@ export function createEditorSaveQueue(store: AppStoreApi): EditorSaveQueue {
       const timerId = window.setTimeout(() => {
         autoSaveTimers.delete(file.id)
         autoSaveScheduledContent.delete(file.id)
-        void queueSave(file, draft, 'autosave')
+        void queueSave(file, draft, 'autosave').catch((error) => {
+          console.error('[editor] autosave failed', error)
+        })
       }, autoSaveDelayMs)
       autoSaveTimers.set(file.id, timerId)
     }
diff --git a/src/renderer/src/components/editor/editor-save-user-named-tab.test.ts b/src/renderer/src/components/editor/editor-save-user-named-tab.test.ts
new file mode 100644
index 00000000000..36818ef2d24
--- /dev/null
+++ b/src/renderer/src/components/editor/editor-save-user-named-tab.test.ts
@@ -0,0 +1,109 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createStore, type StoreApi } from 'zustand/vanilla'
+import { createEditorSlice } from '@/store/slices/editor'
+import type { AppState } from '@/store'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../../shared/constants'
+import { ORCA_EDITOR_SAVE_DIRTY_FILES_EVENT } from '../../../../shared/editor-save-events'
+import { attachEditorAutosaveController } from './editor-autosave-controller'
+import { __clearSelfWriteRegistryForTests } from './editor-self-write-registry'
+
+vi.mock('@/lib/connection-context', () => ({ getConnectionIdForFile: () => null }))
+
+function createEditorStore(): StoreApi<AppState> {
+  // oxlint-disable-next-line typescript/consistent-type-assertions, typescript/no-explicit-any -- SAFETY: the editor save path reads only the slice and fields built here.
+  return createStore<any>()((...args: any[]) => ({
+    settings: { editorAutoSave: false },
+    repos: [],
+    worktreesByRepo: {
+      'repo-1': [{ id: 'wt-1', repoId: 'repo-1', path: '/repo', hostId: 'local' }]
+    },
+    detectedWorktreesByRepo: {},
+    runtimeEnvironments: [],
+    runtimeEnvironmentCatalogHydrated: true,
+    removedRuntimeEnvironmentIds: new Set(),
+    sshConnectionStates: new Map(),
+    sshStateByEnvironment: new Map(),
+    ...createEditorSlice(...(args as Parameters<typeof createEditorSlice>))
+  })) as unknown as StoreApi<AppState>
+}
+
+async function saveDirtyFiles(): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    window.dispatchEvent(
+      new CustomEvent(ORCA_EDITOR_SAVE_DIRTY_FILES_EVENT, {
+        detail: {
+          claim: () => {},
+          resolve,
+          reject: (message: string) => reject(new Error(message))
+        }
+      })
+    )
+  })
+}
+
+describe('saving a restored tab', () => {
+  let writeFile: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    writeFile = vi.fn().mockResolvedValue(undefined)
+    const eventTarget = new EventTarget()
+    vi.stubGlobal('window', {
+      addEventListener: eventTarget.addEventListener.bind(eventTarget),
+      removeEventListener: eventTarget.removeEventListener.bind(eventTarget),
+      dispatchEvent: eventTarget.dispatchEvent.bind(eventTarget),
+      setTimeout: globalThis.setTimeout.bind(globalThis),
+      clearTimeout: globalThis.clearTimeout.bind(globalThis),
+      api: { fs: { writeFile } }
+    })
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    __clearSelfWriteRegistryForTests()
+  })
+
+  it.each([
+    ['a floating-workspace tab', 'notes.txt', FLOATING_TERMINAL_WORKTREE_ID, '/Users/me/notes.txt'],
+    ['a tab stored by absolute path', '/tmp/audit.md', 'wt-1', '/tmp/audit.md']
+  ])('saves %s as the file the user named', async (_label, relativePath, worktreeId, filePath) => {
+    const store = createEditorStore()
+    // Hydration restores the tab exactly as persisted; nothing is re-granted first.
+    store
+      .getState()
+      .openFile({ filePath, relativePath, worktreeId, language: 'markdown', mode: 'edit' })
+    store.getState().setEditorDraft(filePath, 'edited')
+    store.getState().markFileDirty(filePath, true)
+    const detach = attachEditorAutosaveController(store)
+    try {
+      await saveDirtyFiles()
+
+      expect(writeFile).toHaveBeenCalledWith(
+        expect.objectContaining({ filePath, content: 'edited', access: { kind: 'user-file' } })
+      )
+    } finally {
+      detach()
+    }
+  })
+
+  it('saves a project tab inside its root, with no declared access', async () => {
+    const store = createEditorStore()
+    store.getState().openFile({
+      filePath: '/repo/a.ts',
+      relativePath: 'a.ts',
+      worktreeId: 'wt-1',
+      language: 'typescript',
+      mode: 'edit'
+    })
+    store.getState().setEditorDraft('/repo/a.ts', 'edited')
+    store.getState().markFileDirty('/repo/a.ts', true)
+    const detach = attachEditorAutosaveController(store)
+    try {
+      await saveDirtyFiles()
+
+      expect(writeFile).toHaveBeenCalledTimes(1)
+      expect(writeFile.mock.calls[0]?.[0]).not.toHaveProperty('access')
+    } finally {
+      detach()
+    }
+  })
+})
diff --git a/src/renderer/src/components/editor/file-view-preference-storage.ts b/src/renderer/src/components/editor/file-view-preference-storage.ts
new file mode 100644
index 00000000000..77ec02c3a8e
--- /dev/null
+++ b/src/renderer/src/components/editor/file-view-preference-storage.ts
@@ -0,0 +1,69 @@
+const MAX_PREFERENCES = 100
+const MAX_STORAGE_LENGTH = 2 * 1024 * 1024
+
+export function buildFileViewPreferenceKey(input: {
+  worktreeId: string
+  runtimeEnvironmentId?: string | null
+  externalSshTargetId?: string | null
+  filePath: string
+}): string {
+  return JSON.stringify([
+    input.worktreeId,
+    input.runtimeEnvironmentId?.trim() || 'local',
+    input.externalSshTargetId?.trim() || null,
+    input.filePath
+  ])
+}
+
+function storage(): Storage | null {
+  try {
+    return globalThis.localStorage ?? null
+  } catch {
+    return null
+  }
+}
+
+function readPreferences(target: Storage, key: string): Record<string, unknown> {
+  try {
+    const raw = target.getItem(key)
+    if (!raw || raw.length > MAX_STORAGE_LENGTH) {
+      return {}
+    }
+    const value: unknown = JSON.parse(raw)
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+      ? Object.fromEntries(Object.entries(value).slice(-MAX_PREFERENCES))
+      : {}
+  } catch {
+    return {}
+  }
+}
+
+export function readFileViewPreference(storageKey: string, fileKey: string): unknown {
+  const target = storage()
+  return target ? readPreferences(target, storageKey)[fileKey] : undefined
+}
+
+export function writeFileViewPreference(storageKey: string, fileKey: string, value: unknown): void {
+  const target = storage()
+  if (!target) {
+    return
+  }
+  const preferences = readPreferences(target, storageKey)
+  delete preferences[fileKey]
+  preferences[fileKey] = value
+  const keys = Object.keys(preferences)
+  let serialized = JSON.stringify(preferences)
+  while (keys.length > MAX_PREFERENCES || serialized.length > MAX_STORAGE_LENGTH) {
+    const oldest = keys.shift()
+    if (oldest === undefined) {
+      return
+    }
+    delete preferences[oldest]
+    serialized = JSON.stringify(preferences)
+  }
+  try {
+    target.setItem(storageKey, serialized)
+  } catch {
+    // Preferences must not prevent using the viewer when storage is unavailable.
+  }
+}
diff --git a/src/renderer/src/components/editor/local-image-src-reader.ts b/src/renderer/src/components/editor/local-image-src-reader.ts
index 5e845031bd0..acef96fc54a 100644
--- a/src/renderer/src/components/editor/local-image-src-reader.ts
+++ b/src/renderer/src/components/editor/local-image-src-reader.ts
@@ -1,21 +1,27 @@
+import type { LocalFileAccess } from '../../../../shared/local-file-access'
 import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
 import { readRuntimeFilePreview } from '@/runtime/runtime-file-client'
 
 export function readLocalImagePreview(
   absolutePath: string,
   connectionId?: string | null,
-  runtimeContext?: Omit<RuntimeFileOperationArgs, 'connectionId'> & { connectionId?: string | null }
+  runtimeContext?: Omit<RuntimeFileOperationArgs, 'connectionId'> & {
+    connectionId?: string | null
+  },
+  access?: LocalFileAccess
 ) {
   try {
     if (!runtimeContext) {
       return window.api.fs.readFile({
         filePath: absolutePath,
-        connectionId: connectionId ?? undefined
+        connectionId: connectionId ?? undefined,
+        ...(access && !connectionId ? { access } : {})
       })
     }
     return readRuntimeFilePreview(
       { ...runtimeContext, connectionId: runtimeContext.connectionId ?? connectionId ?? undefined },
-      absolutePath
+      absolutePath,
+      access
     )
   } catch (error) {
     return Promise.reject(error)
diff --git a/src/renderer/src/components/editor/markdown-preview-local-images.test.ts b/src/renderer/src/components/editor/markdown-preview-local-images.test.ts
index f7d60703fb3..3f4b8f8f447 100644
--- a/src/renderer/src/components/editor/markdown-preview-local-images.test.ts
+++ b/src/renderer/src/components/editor/markdown-preview-local-images.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import {
   MARKDOWN_PREVIEW_LOCAL_IMAGE_PREWARM_CONCURRENCY,
   MARKDOWN_PREVIEW_LOCAL_IMAGE_PREWARM_LIMIT,
@@ -247,3 +247,21 @@ describe('prewarmMarkdownPreviewLocalImages', () => {
     expect(started).toHaveLength(2)
   })
 })
+
+describe('prewarming preview images', () => {
+  it('reads each image as a resource of the document that references it', async () => {
+    const readFile = vi.fn().mockResolvedValue({ content: '', isBinary: false })
+    vi.stubGlobal('window', { api: { fs: { readFile } } })
+    try {
+      await prewarmMarkdownPreviewLocalImages('![Logo](./logo.png)', '/notes/readme.md').done
+
+      expect(readFile).toHaveBeenCalledWith({
+        filePath: '/notes/logo.png',
+        connectionId: undefined,
+        access: { kind: 'document-resource', documentPath: '/notes/readme.md' }
+      })
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
+})
diff --git a/src/renderer/src/components/editor/markdown-preview-local-images.ts b/src/renderer/src/components/editor/markdown-preview-local-images.ts
index 57d37f09d9e..bd14a540f51 100644
--- a/src/renderer/src/components/editor/markdown-preview-local-images.ts
+++ b/src/renderer/src/components/editor/markdown-preview-local-images.ts
@@ -5,6 +5,7 @@ import { unified } from 'unified'
 import { resolveImageAbsolutePath } from './markdown-preview-links'
 import { getLocalImageCacheKey, loadLocalImageAbsolutePath } from './useLocalImageSrc'
 import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
+import { documentResourceAccess } from '@/lib/local-file-access'
 
 export const MARKDOWN_PREVIEW_LOCAL_IMAGE_PREWARM_LIMIT = 64
 export const MARKDOWN_PREVIEW_LOCAL_IMAGE_PREWARM_CONCURRENCY = 4
@@ -97,7 +98,8 @@ export function extractMarkdownPreviewLocalImageCandidates(
     const cacheKey = getLocalImageCacheKey(
       absolutePath,
       options.connectionId,
-      options.runtimeContext
+      options.runtimeContext,
+      documentResourceAccess(filePath)
     )
     if (seenCacheKeys.has(cacheKey)) {
       return
@@ -143,7 +145,8 @@ export function prewarmMarkdownPreviewLocalImages(
       loadLocalImageAbsolutePath(
         candidate.absolutePath,
         options.connectionId,
-        options.runtimeContext
+        options.runtimeContext,
+        documentResourceAccess(filePath)
       ))
   let cancelled = false
   let nextIndex = 0
diff --git a/src/renderer/src/components/editor/markdown-preview-plugins.ts b/src/renderer/src/components/editor/markdown-preview-plugins.ts
index 77fd6850872..84b36524587 100644
--- a/src/renderer/src/components/editor/markdown-preview-plugins.ts
+++ b/src/renderer/src/components/editor/markdown-preview-plugins.ts
@@ -16,7 +16,7 @@ const markdownPreviewSanitizeSchema = {
   tagNames: [...(defaultSchema.tagNames ?? []), 'details', 'summary', 'kbd', 'sub', 'sup', 'ins'],
   protocols: {
     ...defaultSchema.protocols,
-    // Why: keep file:// through sanitize so the click handler can authorize and open the target.
+    // Why: keep file:// through sanitize so the click handler can open the target.
     href: [...(defaultSchema.protocols?.href ?? []), 'file'],
     src: [...(defaultSchema.protocols?.src ?? []), 'file']
   },
diff --git a/src/renderer/src/components/editor/monaco-content-sync.undo-history.test.ts b/src/renderer/src/components/editor/monaco-content-sync.undo-history.test.ts
index 380a44ec8d4..0f8a4069d36 100644
--- a/src/renderer/src/components/editor/monaco-content-sync.undo-history.test.ts
+++ b/src/renderer/src/components/editor/monaco-content-sync.undo-history.test.ts
@@ -35,7 +35,7 @@ describe('Monaco external-content undo history', () => {
 
     syncContentUpdate(editorInstance, 'first line\nappended', 'read-only-live-tail')
 
-    expect(model.getValue()).toBe('first line\nappended')
+    expect(model.getValue()).toBe(['first line', 'appended'].join(model.getEOL()))
     expect(model.canUndo()).toBe(false)
   })
 
diff --git a/src/renderer/src/components/editor/monaco-editor-mount-params.ts b/src/renderer/src/components/editor/monaco-editor-mount-params.ts
index 5e29ffd16c9..38f7cc6d289 100644
--- a/src/renderer/src/components/editor/monaco-editor-mount-params.ts
+++ b/src/renderer/src/components/editor/monaco-editor-mount-params.ts
@@ -14,6 +14,7 @@ export type MonacoEditorPropsRef = MutableRefObject<{
 }>
 
 export type MonacoEditorMountParams = {
+  modelOwnerKey?: string
   fileId: string
   filePath: string
   viewStateKey: string
diff --git a/src/renderer/src/components/editor/monaco-programmatic-sync.test.ts b/src/renderer/src/components/editor/monaco-programmatic-sync.test.ts
index ae7cc67d06b..e61b68a23cb 100644
--- a/src/renderer/src/components/editor/monaco-programmatic-sync.test.ts
+++ b/src/renderer/src/components/editor/monaco-programmatic-sync.test.ts
@@ -12,25 +12,25 @@ afterEach(() => {
 
 describe('shouldIgnoreMonacoContentChange', () => {
   it('ignores echoed shared-model changes in the sibling split pane', () => {
-    const filePath = '/repo/seed.spec.ts'
+    const modelKey = '/repo/seed.spec.ts'
 
-    beginProgrammaticContentSync(filePath)
+    beginProgrammaticContentSync(modelKey)
     try {
       expect(
         shouldIgnoreMonacoContentChange({
-          filePath,
+          modelKey,
           isApplyingProgrammaticContent: false
         })
       ).toBe(true)
     } finally {
-      endProgrammaticContentSync(filePath)
+      endProgrammaticContentSync(modelKey)
     }
   })
 
   it('ignores local programmatic sync even without a sibling pane', () => {
     expect(
       shouldIgnoreMonacoContentChange({
-        filePath: '/repo/seed.spec.ts',
+        modelKey: '/repo/seed.spec.ts',
         isApplyingProgrammaticContent: true
       })
     ).toBe(true)
@@ -39,9 +39,27 @@ describe('shouldIgnoreMonacoContentChange', () => {
   it('does not ignore a real user edit once programmatic sync is finished', () => {
     expect(
       shouldIgnoreMonacoContentChange({
-        filePath: '/repo/seed.spec.ts',
+        modelKey: '/repo/seed.spec.ts',
         isApplyingProgrammaticContent: false
       })
     ).toBe(false)
   })
+
+  it('keeps nested sync suppression scoped to one model owner', () => {
+    const local = 'file:///repo/file.ts'
+    const remote = `${local}#remote-owner`
+    beginProgrammaticContentSync(local)
+    beginProgrammaticContentSync(local)
+    endProgrammaticContentSync(local)
+    expect(
+      shouldIgnoreMonacoContentChange({ modelKey: local, isApplyingProgrammaticContent: false })
+    ).toBe(true)
+    expect(
+      shouldIgnoreMonacoContentChange({ modelKey: remote, isApplyingProgrammaticContent: false })
+    ).toBe(false)
+    endProgrammaticContentSync(local)
+    expect(
+      shouldIgnoreMonacoContentChange({ modelKey: local, isApplyingProgrammaticContent: false })
+    ).toBe(false)
+  })
 })
diff --git a/src/renderer/src/components/editor/monaco-programmatic-sync.ts b/src/renderer/src/components/editor/monaco-programmatic-sync.ts
index 465186df847..1cf28a21fff 100644
--- a/src/renderer/src/components/editor/monaco-programmatic-sync.ts
+++ b/src/renderer/src/components/editor/monaco-programmatic-sync.ts
@@ -1,37 +1,37 @@
-const programmaticContentSyncDepthByFilePath = new Map<string, number>()
+const programmaticContentSyncDepthByModelKey = new Map<string, number>()
 
-export function beginProgrammaticContentSync(filePath: string): void {
-  programmaticContentSyncDepthByFilePath.set(
-    filePath,
-    (programmaticContentSyncDepthByFilePath.get(filePath) ?? 0) + 1
+export function beginProgrammaticContentSync(modelKey: string): void {
+  programmaticContentSyncDepthByModelKey.set(
+    modelKey,
+    (programmaticContentSyncDepthByModelKey.get(modelKey) ?? 0) + 1
   )
 }
 
-export function endProgrammaticContentSync(filePath: string): void {
-  const depth = programmaticContentSyncDepthByFilePath.get(filePath) ?? 0
+export function endProgrammaticContentSync(modelKey: string): void {
+  const depth = programmaticContentSyncDepthByModelKey.get(modelKey) ?? 0
   if (depth <= 1) {
-    programmaticContentSyncDepthByFilePath.delete(filePath)
+    programmaticContentSyncDepthByModelKey.delete(modelKey)
     return
   }
-  programmaticContentSyncDepthByFilePath.set(filePath, depth - 1)
+  programmaticContentSyncDepthByModelKey.set(modelKey, depth - 1)
 }
 
-export function isProgrammaticContentSyncInFlight(filePath: string): boolean {
-  return (programmaticContentSyncDepthByFilePath.get(filePath) ?? 0) > 0
+export function isProgrammaticContentSyncInFlight(modelKey: string): boolean {
+  return (programmaticContentSyncDepthByModelKey.get(modelKey) ?? 0) > 0
 }
 
 export function shouldIgnoreMonacoContentChange(args: {
-  filePath: string
+  modelKey: string
   isApplyingProgrammaticContent: boolean
 }): boolean {
-  const { filePath, isApplyingProgrammaticContent } = args
+  const { modelKey, isApplyingProgrammaticContent } = args
 
-  // Why: split panes can share one retained Monaco model by file path. If any
+  // Why: split panes can share one retained model. If any
   // pane is currently reconciling prop content into that shared model, every
   // pane sees the echoed change event and must treat it as programmatic.
-  return isApplyingProgrammaticContent || isProgrammaticContentSyncInFlight(filePath)
+  return isApplyingProgrammaticContent || isProgrammaticContentSyncInFlight(modelKey)
 }
 
 export function resetProgrammaticContentSyncForTests(): void {
-  programmaticContentSyncDepthByFilePath.clear()
+  programmaticContentSyncDepthByModelKey.clear()
 }
diff --git a/src/renderer/src/components/editor/pdf-scale-preference-storage.ts b/src/renderer/src/components/editor/pdf-scale-preference-storage.ts
index 6906570f036..a7f890fd39c 100644
--- a/src/renderer/src/components/editor/pdf-scale-preference-storage.ts
+++ b/src/renderer/src/components/editor/pdf-scale-preference-storage.ts
@@ -1,87 +1,19 @@
 import type { PdfScalePreference } from './pdf-scale-preference'
+import { readFileViewPreference, writeFileViewPreference } from './file-view-preference-storage'
+export { buildFileViewPreferenceKey as buildPdfScalePreferenceKey } from './file-view-preference-storage'
 
 export const PDF_SCALE_PREFERENCES_STORAGE_KEY = 'orca.pdf.scale-preferences.v1'
 
-const MAX_STORED_PREFERENCES = 100
-
-export function buildPdfScalePreferenceKey(input: {
-  worktreeId: string
-  runtimeEnvironmentId?: string | null
-  externalSshTargetId?: string | null
-  filePath: string
-}): string {
-  return JSON.stringify([
-    input.worktreeId,
-    input.runtimeEnvironmentId?.trim() || 'local',
-    input.externalSshTargetId?.trim() || null,
-    input.filePath
-  ])
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function isPdfScalePreference(value: unknown): value is PdfScalePreference {
-  return value === 'page-width' || (typeof value === 'number' && Number.isFinite(value))
-}
-
-function readStoredPreferences(storage: Storage): Record<string, unknown> {
-  try {
-    const raw = storage.getItem(PDF_SCALE_PREFERENCES_STORAGE_KEY)
-    if (!raw) {
-      return {}
-    }
-    const parsed: unknown = JSON.parse(raw)
-    return isRecord(parsed) ? parsed : {}
-  } catch {
-    return {}
-  }
-}
-
-function getStorage(): Storage | null {
-  try {
-    return globalThis.localStorage === undefined ? null : globalThis.localStorage
-  } catch {
-    return null
-  }
-}
-
-/** Read the last zoom choice for a PDF, if one was persisted. */
 export function readPdfScalePreference(preferenceKey: string): PdfScalePreference | null {
-  const storage = getStorage()
-  if (!storage) {
-    return null
-  }
-  const preference = readStoredPreferences(storage)[preferenceKey]
-  return isPdfScalePreference(preference) ? preference : null
+  const value = readFileViewPreference(PDF_SCALE_PREFERENCES_STORAGE_KEY, preferenceKey)
+  return value === 'page-width' || (typeof value === 'number' && Number.isFinite(value))
+    ? value
+    : null
 }
 
-/** Persist a PDF zoom choice across viewer remounts and app restarts. */
 export function writePdfScalePreference(
   preferenceKey: string,
   preference: PdfScalePreference
 ): void {
-  const storage = getStorage()
-  if (!storage) {
-    return
-  }
-
-  const stored = readStoredPreferences(storage)
-  // Reinsert to keep recently used files at the end of the bounded map.
-  delete stored[preferenceKey]
-  stored[preferenceKey] = preference
-  const keys = Object.keys(stored)
-  while (keys.length > MAX_STORED_PREFERENCES) {
-    const oldestKey = keys.shift()
-    if (oldestKey !== undefined) {
-      delete stored[oldestKey]
-    }
-  }
-
-  try {
-    storage.setItem(PDF_SCALE_PREFERENCES_STORAGE_KEY, JSON.stringify(stored))
-  } catch {
-    // The viewer remains usable when browser storage is unavailable or full.
-  }
+  writeFileViewPreference(PDF_SCALE_PREFERENCES_STORAGE_KEY, preferenceKey, preference)
 }
diff --git a/src/renderer/src/components/editor/rich-markdown-async-image-paste.test.ts b/src/renderer/src/components/editor/rich-markdown-async-image-paste.test.ts
new file mode 100644
index 00000000000..aba0e4b9d26
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-async-image-paste.test.ts
@@ -0,0 +1,531 @@
+// @vitest-environment happy-dom
+
+import { Editor } from '@tiptap/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { importExternalPathsToRuntime } from '@/runtime/runtime-file-client'
+import { toast } from 'sonner'
+import { createRichMarkdownExtensions } from './rich-markdown-extensions'
+import { createRichMarkdownEditorCodec } from './rich-markdown-source-transport'
+import { handleRichMarkdownImagePaste } from './rich-markdown-paste-image'
+import { autoFocusRichEditor } from './rich-markdown-auto-focus'
+import {
+  setRichMarkdownImageResolverContext,
+  type RichMarkdownImageRuntimeContext
+} from './rich-markdown-image-context'
+
+vi.mock('@/runtime/runtime-file-client', () => ({ importExternalPathsToRuntime: vi.fn() }))
+vi.mock('@/lib/connection-context', () => ({ getConnectionId: vi.fn(() => null) }))
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: vi.fn(() => ({
+      settings: null,
+      folderWorkspaces: [],
+      worktreesByRepo: {},
+      openFiles: []
+    }))
+  }
+}))
+vi.mock('@/runtime/runtime-rpc-client', () => ({
+  settingsForRuntimeOwner: vi.fn((settings) => settings)
+}))
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), info: vi.fn() } }))
+
+type ImportResult = Awaited<ReturnType<typeof importExternalPathsToRuntime>>
+const editors: Editor[] = []
+
+function richEditor(markdown = 'hello world'): Editor {
+  const element = document.createElement('div')
+  document.body.append(element)
+  const editor = new Editor({
+    element,
+    extensions: createRichMarkdownExtensions({ codec: createRichMarkdownEditorCodec() }),
+    content: markdown,
+    contentType: 'markdown'
+  })
+  editors.push(editor)
+  return editor
+}
+
+function imported(filename = 'image.png'): ImportResult {
+  return {
+    results: [
+      {
+        sourcePath: '/tmp/image.png',
+        status: 'imported',
+        destPath: `/repo/${filename}`,
+        kind: 'file',
+        renamed: false
+      }
+    ]
+  }
+}
+
+function pendingImport() {
+  let resolve: (result: ImportResult) => void = () => {}
+  const promise = new Promise<ImportResult>((complete) => {
+    resolve = complete
+  })
+  return { promise, resolve }
+}
+
+function pasteImage(editor: Editor): void {
+  const clipboardData = new DataTransfer()
+  clipboardData.items.add(new File(['image'], 'image.png', { type: 'image/png' }))
+  const event = new ClipboardEvent('paste', { clipboardData, cancelable: true })
+  expect(
+    handleRichMarkdownImagePaste({ editor, event, filePath: '/repo/note.md', worktreeId: null })
+  ).toBe(true)
+  expect(event.defaultPrevented).toBe(true)
+}
+
+async function flushPromises(): Promise<void> {
+  for (let index = 0; index < 16; index++) {
+    await Promise.resolve()
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  Object.defineProperty(window, 'api', {
+    configurable: true,
+    value: { ui: { saveClipboardImageAsTempFile: vi.fn().mockResolvedValue('/tmp/image.png') } }
+  })
+  vi.mocked(importExternalPathsToRuntime).mockResolvedValue(imported())
+})
+
+afterEach(() => {
+  editors.splice(0).forEach((editor) => editor.destroy())
+  document.body.replaceChildren()
+})
+
+describe('rich Markdown asynchronous image paste', () => {
+  it.each(['saving', 'importing'])(
+    'reports cancellation once when the selected target changes during %s',
+    async (phase) => {
+      const editor = richEditor()
+      editor.commands.setTextSelection({ from: 7, to: 12 })
+      let completeSave: (path: string) => void = () => {}
+      if (phase === 'saving') {
+        vi.mocked(window.api.ui.saveClipboardImageAsTempFile).mockImplementation(
+          () =>
+            new Promise((resolve) => {
+              completeSave = resolve
+            })
+        )
+      }
+      const pending = pendingImport()
+      vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+      pasteImage(editor)
+      await flushPromises()
+      editor.view.dispatch(editor.state.tr.delete(7, 12))
+      if (phase === 'saving') {
+        completeSave('/tmp/image.png')
+      } else {
+        pending.resolve(imported())
+      }
+      await flushPromises()
+      expect(editor.getMarkdown()).toBe('hello ')
+      expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+        phase === 'saving'
+          ? 'Image insertion canceled because the destination changed. Try again.'
+          : 'Image insertion canceled because the destination changed. The imported file was kept.'
+      )
+      expect(toast.error).not.toHaveBeenCalled()
+      if (phase === 'saving') {
+        expect(importExternalPathsToRuntime).not.toHaveBeenCalled()
+      }
+    }
+  )
+
+  it('leaves an empty clipboard result quiet', async () => {
+    const editor = richEditor()
+    vi.mocked(window.api.ui.saveClipboardImageAsTempFile).mockResolvedValue(null)
+    pasteImage(editor)
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('hello world')
+    expect(importExternalPathsToRuntime).not.toHaveBeenCalled()
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
+  })
+
+  it.each([false, true])('replaces the complete selected text, reversed=%s', async (reversed) => {
+    const editor = richEditor()
+    editor.commands.setTextSelection(reversed ? { from: 12, to: 7 } : { from: 7, to: 12 })
+    pasteImage(editor)
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('hello ![](image.png)')
+    expect(editor.state.selection.empty).toBe(true)
+    expect(editor.state.selection.from).toBe(8)
+    editor.state.doc.check()
+  })
+
+  it('maps edits during both clipboard saving and runtime import', async () => {
+    const editor = richEditor()
+    editor.commands.setTextSelection(7)
+    let completeSave: (path: string) => void = () => {}
+    vi.mocked(window.api.ui.saveClipboardImageAsTempFile).mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          completeSave = resolve
+        })
+    )
+    const pending = pendingImport()
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+    pasteImage(editor)
+    editor.view.dispatch(editor.state.tr.insertText('prefix ', 1))
+    completeSave('/tmp/image.png')
+    await flushPromises()
+    editor.view.dispatch(editor.state.tr.insertText('later ', 14))
+    pending.resolve(imported())
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('prefix hello ![](image.png)later world')
+  })
+
+  it('keeps typing after text entered at the pending paste caret', async () => {
+    const editor = richEditor()
+    editor.commands.setTextSelection(7)
+    const pending = pendingImport()
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+    pasteImage(editor)
+    await flushPromises()
+    editor.commands.insertContent('x')
+    pending.resolve(imported())
+    await flushPromises()
+    editor.commands.insertContent('y')
+    expect(editor.getMarkdown()).toBe('hello ![](image.png)xyworld')
+  })
+
+  it('keeps the live caret when editing another paragraph during import', async () => {
+    const editor = richEditor('hello world\n\nsecond paragraph')
+    editor.commands.setTextSelection(7)
+    const pending = pendingImport()
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+    pasteImage(editor)
+    await flushPromises()
+    editor.commands.setTextSelection(14)
+    editor.commands.insertContent('x')
+    pending.resolve(imported())
+    await flushPromises()
+    editor.commands.insertContent('y')
+    expect(editor.getMarkdown()).toBe('hello ![](image.png)world\n\nxysecond paragraph')
+  })
+
+  it('leaves an outside input focused after image import', async () => {
+    const editor = richEditor()
+    editor.view.dom.focus()
+    editor.commands.setTextSelection(7)
+    const pending = pendingImport()
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+    pasteImage(editor)
+    await flushPromises()
+    const input = document.createElement('input')
+    document.body.append(input)
+    input.focus()
+    pending.resolve(imported())
+    await flushPromises()
+    await new Promise((resolve) => requestAnimationFrame(() => resolve(undefined)))
+    expect(document.activeElement).toBe(input)
+    expect(editor.getMarkdown()).toBe('hello ![](image.png)world')
+  })
+
+  it.each(['delete', 'replace'])(
+    'cancels when the selected content is %s during import',
+    async (operation) => {
+      const editor = richEditor()
+      editor.commands.setTextSelection({ from: 7, to: 12 })
+      const pending = pendingImport()
+      vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+      pasteImage(editor)
+      await flushPromises()
+      editor.view.dispatch(
+        operation === 'delete'
+          ? editor.state.tr.delete(7, 12)
+          : editor.state.tr.insertText('new', 7, 12)
+      )
+      const afterEdit = editor.getMarkdown()
+      pending.resolve(imported())
+      await flushPromises()
+      expect(editor.getMarkdown()).toBe(afterEdit)
+    }
+  )
+
+  it.each([
+    { from: 6, to: 8 },
+    { from: 7, to: 8 },
+    { from: 8, to: 10 },
+    { from: 10, to: 12 },
+    { from: 11, to: 13 }
+  ])('cancels after partial selected-range deletion $from..$to', async ({ from, to }) => {
+    const editor = richEditor()
+    editor.commands.setTextSelection({ from: 7, to: 12 })
+    const pending = pendingImport()
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+    pasteImage(editor)
+    await flushPromises()
+    editor.view.dispatch(editor.state.tr.delete(from, to))
+    const afterEdit = editor.getJSON()
+    pending.resolve(imported())
+    await flushPromises()
+    expect(editor.getJSON()).toEqual(afterEdit)
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+      'Image insertion canceled because the destination changed. The imported file was kept.'
+    )
+    editor.state.doc.check()
+  })
+
+  it('does not resurrect the selected range after partial deletion and Undo', async () => {
+    const editor = richEditor()
+    editor.commands.setTextSelection({ from: 7, to: 12 })
+    const pending = pendingImport()
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+    pasteImage(editor)
+    await flushPromises()
+    editor.view.dispatch(editor.state.tr.delete(8, 10))
+    expect(editor.getMarkdown()).toBe('hello wld')
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.getMarkdown()).toBe('hello world')
+    pending.resolve(imported())
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('hello world')
+    expect(toast.info).toHaveBeenCalledTimes(1)
+  })
+
+  it.each([false, true])(
+    'keeps simultaneous pastes at one caret in request order, reversed completion=%s',
+    async (reversed) => {
+      const editor = richEditor()
+      editor.commands.setTextSelection(7)
+      const first = pendingImport()
+      const second = pendingImport()
+      vi.mocked(importExternalPathsToRuntime)
+        .mockReturnValueOnce(first.promise)
+        .mockReturnValueOnce(second.promise)
+      pasteImage(editor)
+      pasteImage(editor)
+      await flushPromises()
+      const completeFirst = () => first.resolve(imported('first.png'))
+      const completeSecond = () => second.resolve(imported('second.png'))
+      const completionOrder = reversed
+        ? [completeSecond, completeFirst]
+        : [completeFirst, completeSecond]
+      completionOrder[0]()
+      await flushPromises()
+      completionOrder[1]()
+      await flushPromises()
+      expect(editor.getMarkdown()).toBe('hello ![](first.png)![](second.png)world')
+    }
+  )
+
+  it.each([false, true])(
+    'keeps the remaining concurrent import after Undo, reversed completion=%s',
+    async (reversed) => {
+      const editor = richEditor()
+      editor.commands.setTextSelection(7)
+      const first = pendingImport()
+      const second = pendingImport()
+      vi.mocked(importExternalPathsToRuntime)
+        .mockReturnValueOnce(first.promise)
+        .mockReturnValueOnce(second.promise)
+      pasteImage(editor)
+      pasteImage(editor)
+      await flushPromises()
+      const completed = reversed ? second : first
+      const remaining = reversed ? first : second
+      completed.resolve(imported(reversed ? 'second.png' : 'first.png'))
+      await flushPromises()
+      expect(editor.commands.undo()).toBe(true)
+      expect(editor.getMarkdown()).toBe('hello world')
+      remaining.resolve(imported(reversed ? 'first.png' : 'second.png'))
+      await flushPromises()
+      expect(editor.getMarkdown()).toBe(`hello ![](${reversed ? 'first.png' : 'second.png'})world`)
+      expect(toast.info).not.toHaveBeenCalled()
+      expect(toast.error).not.toHaveBeenCalled()
+      editor.state.doc.check()
+    }
+  )
+
+  it('keeps the captured selection and live caret through pending startup focus', async () => {
+    const editor = richEditor()
+    const pending = pendingImport()
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+    const cancelFocus = autoFocusRichEditor(editor, editor.view.dom)
+    editor.view.dom.focus()
+    editor.commands.setTextSelection({ from: 7, to: 12 })
+    pasteImage(editor)
+    await flushPromises()
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
+    expect(editor.state.selection.from).toBe(1)
+    pending.resolve(imported())
+    await flushPromises()
+    editor.commands.insertContent('continued ')
+    expect(editor.getMarkdown()).toBe('continued hello ![](image.png)')
+    cancelFocus()
+  })
+
+  it('keeps different pending insertion positions as another paste finishes', async () => {
+    const editor = richEditor()
+    const first = pendingImport()
+    const second = pendingImport()
+    vi.mocked(importExternalPathsToRuntime)
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(second.promise)
+    editor.commands.setTextSelection(1)
+    pasteImage(editor)
+    editor.commands.setTextSelection(7)
+    pasteImage(editor)
+    await flushPromises()
+    first.resolve(imported('first.png'))
+    await flushPromises()
+    second.resolve(imported('second.png'))
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('![](first.png)hello ![](second.png)world')
+  })
+
+  it('lets a later request succeed after the earlier import was canceled', async () => {
+    const editor = richEditor()
+    editor.commands.setTextSelection(7)
+    const first = pendingImport()
+    const second = pendingImport()
+    vi.mocked(importExternalPathsToRuntime)
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(second.promise)
+    pasteImage(editor)
+    pasteImage(editor)
+    await flushPromises()
+    first.resolve({
+      results: [{ sourcePath: '/tmp/image.png', status: 'skipped', reason: 'missing' }]
+    })
+    await flushPromises()
+    second.resolve(imported('second.png'))
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('hello ![](second.png)world')
+  })
+
+  it('cancels an overlapping request after the first paste replaces its selection', async () => {
+    const editor = richEditor()
+    editor.commands.setTextSelection({ from: 7, to: 12 })
+    const first = pendingImport()
+    const second = pendingImport()
+    vi.mocked(importExternalPathsToRuntime)
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(second.promise)
+    pasteImage(editor)
+    pasteImage(editor)
+    await flushPromises()
+    first.resolve(imported('first.png'))
+    await flushPromises()
+    second.resolve(imported('second.png'))
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('hello ![](first.png)')
+  })
+
+  it.each(['destroy', 'disconnect', 'disable'])(
+    'ignores an imported image after editor %s',
+    async (operation) => {
+      const editor = richEditor()
+      editor.commands.setTextSelection(7)
+      const pending = pendingImport()
+      vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+      pasteImage(editor)
+      await flushPromises()
+      if (operation === 'destroy') {
+        editor.destroy()
+      } else if (operation === 'disconnect') {
+        editor.view.dom.remove()
+      } else {
+        editor.setEditable(false)
+      }
+      pending.resolve(imported())
+      await flushPromises()
+      expect(editor.getMarkdown()).toBe('hello world')
+    }
+  )
+
+  it('preserves a pending selection through a no-op content reload', async () => {
+    const editor = richEditor()
+    editor.commands.setTextSelection({ from: 7, to: 12 })
+    const pending = pendingImport()
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+    pasteImage(editor)
+    await flushPromises()
+    editor.commands.setContent(editor.getJSON())
+    pending.resolve(imported())
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('hello ![](image.png)')
+  })
+
+  it.each(['file', 'worktree', 'root', 'runtime', 'connection', 'external target'])(
+    'cancels before and after import when the same editor changes %s',
+    async (field) => {
+      for (const phase of ['saving', 'importing']) {
+        const editor = richEditor()
+        const runtimeContext: RichMarkdownImageRuntimeContext = {
+          settings: null,
+          worktreeId: 'wt-1',
+          worktreePath: '/repo',
+          connectionId: null
+        }
+        setRichMarkdownImageResolverContext(editor, { filePath: '/repo/note.md', runtimeContext })
+        editor.commands.setTextSelection({ from: 7, to: 12 })
+        let completeSave: (path: string) => void = () => {}
+        vi.mocked(window.api.ui.saveClipboardImageAsTempFile).mockImplementation(
+          () =>
+            new Promise((resolve) => {
+              completeSave = resolve
+            })
+        )
+        const pending = pendingImport()
+        vi.mocked(importExternalPathsToRuntime).mockReturnValue(pending.promise)
+        vi.mocked(importExternalPathsToRuntime).mockClear()
+        pasteImage(editor)
+        if (phase === 'importing') {
+          completeSave('/tmp/image.png')
+          await flushPromises()
+          expect(importExternalPathsToRuntime).toHaveBeenCalledOnce()
+        }
+        const nextContext = { filePath: '/repo/note.md', runtimeContext: { ...runtimeContext } }
+        if (field === 'file') {
+          nextContext.filePath = '/repo/other.md'
+        } else if (field === 'worktree') {
+          nextContext.runtimeContext.worktreeId = 'wt-2'
+        } else if (field === 'root') {
+          nextContext.runtimeContext.worktreePath = '/other-repo'
+        } else if (field === 'runtime') {
+          nextContext.runtimeContext.settings = { activeRuntimeEnvironmentId: 'other-runtime' }
+        } else if (field === 'connection') {
+          nextContext.runtimeContext.connectionId = 'other-connection'
+        } else {
+          nextContext.runtimeContext.expectedExternalSshTargetId = 'other-target'
+        }
+        setRichMarkdownImageResolverContext(editor, nextContext)
+        editor.commands.setContent(editor.getJSON())
+        if (phase === 'saving') {
+          completeSave('/tmp/image.png')
+        } else {
+          pending.resolve(imported())
+        }
+        await flushPromises()
+        expect(editor.getMarkdown()).toBe('hello world')
+        expect(importExternalPathsToRuntime).toHaveBeenCalledTimes(phase === 'saving' ? 0 : 1)
+      }
+    }
+  )
+
+  it('replaces selected code with an image while keeping both fence halves', async () => {
+    const editor = richEditor('```js\nbefore selected after\n```')
+    editor.commands.setTextSelection({ from: 8, to: 16 })
+    pasteImage(editor)
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('```js\nbefore \n```\n\n![](image.png)\n\n```js\n after\n```')
+    editor.state.doc.check()
+  })
+
+  it('replaces a selection spanning blocks without deleting surrounding text', async () => {
+    const editor = richEditor('before selected\n\nselected after')
+    editor.commands.setTextSelection({ from: 8, to: 26 })
+    pasteImage(editor)
+    await flushPromises()
+    expect(editor.getMarkdown()).toBe('before ![](image.png) after')
+    editor.state.doc.check()
+  })
+})
diff --git a/src/renderer/src/components/editor/rich-markdown-async-image-table.test.ts b/src/renderer/src/components/editor/rich-markdown-async-image-table.test.ts
new file mode 100644
index 00000000000..9c973af78d1
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-async-image-table.test.ts
@@ -0,0 +1,244 @@
+// @vitest-environment happy-dom
+import { Editor } from '@tiptap/react'
+import { CellSelection } from '@tiptap/pm/tables'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { importExternalPathsToRuntime } from '@/runtime/runtime-file-client'
+import { createRichMarkdownExtensions } from './rich-markdown-extensions'
+import { createRichMarkdownEditorCodec } from './rich-markdown-source-transport'
+import { handleRichMarkdownImagePaste } from './rich-markdown-paste-image'
+
+vi.mock('@/runtime/runtime-file-client', () => ({ importExternalPathsToRuntime: vi.fn() }))
+vi.mock('@/lib/connection-context', () => ({ getConnectionId: vi.fn(() => null) }))
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: vi.fn(() => ({
+      settings: null,
+      folderWorkspaces: [],
+      worktreesByRepo: {},
+      openFiles: []
+    }))
+  }
+}))
+vi.mock('@/runtime/runtime-rpc-client', () => ({
+  settingsForRuntimeOwner: vi.fn((settings) => settings)
+}))
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), info: vi.fn() } }))
+
+type ImportResult = Awaited<ReturnType<typeof importExternalPathsToRuntime>>
+const editors: Editor[] = []
+const SOURCE = [
+  'Before table',
+  '| Left | Right | Keep |\n| --- | --- | --- |\n| one | two | keep top |\n| three | four | keep bottom |\n| outside one | outside two | outside keep |',
+  'After table'
+].join('\n\n')
+const SELECTED = ['one', 'two', 'three', 'four']
+
+function richEditor(reversed = false): Editor {
+  const element = document.createElement('div')
+  document.body.append(element)
+  const editor = new Editor({
+    element,
+    extensions: createRichMarkdownExtensions({ codec: createRichMarkdownEditorCodec() }),
+    content: SOURCE,
+    contentType: 'markdown'
+  })
+  editor.view.dispatch(editor.state.tr.setMeta('addToHistory', false))
+  editors.push(editor)
+  const first = cellPosition(editor, 'one')
+  const last = cellPosition(editor, 'four')
+  editor.view.dispatch(
+    editor.state.tr.setSelection(
+      CellSelection.create(editor.state.doc, reversed ? last : first, reversed ? first : last)
+    )
+  )
+  expect(editor.state.selection.ranges).toHaveLength(4)
+  return editor
+}
+
+function cellPosition(editor: Editor, text: string): number {
+  let position: number | undefined
+  editor.state.doc.descendants((node, pos) => {
+    if (node.type.name === 'tableCell' && node.textContent === text) {
+      position = pos
+    }
+  })
+  if (position === undefined) {
+    throw new Error(`Table cell missing: ${text}`)
+  }
+  return position
+}
+
+function table(editor: Editor) {
+  const node = Array.from({ length: editor.state.doc.childCount }, (_, index) =>
+    editor.state.doc.child(index)
+  ).find((node) => node.type.name === 'table')
+  if (!node) {
+    throw new Error('Table missing')
+  }
+  return node
+}
+
+function expectReplacedCells(editor: Editor, reversed = false, keepTop = 'keep top') {
+  const node = table(editor)
+  const rows: string[][] = []
+  node.forEach((row) => {
+    const cells: string[] = []
+    row.forEach((cell) => cells.push(cell.textContent))
+    rows.push(cells)
+  })
+  expect(rows).toEqual([
+    ['Left', 'Right', 'Keep'],
+    ['', '', keepTop],
+    ['', '', 'keep bottom'],
+    ['outside one', 'outside two', 'outside keep']
+  ])
+  const images: string[] = []
+  const headCell = node.child(reversed ? 1 : 2).child(reversed ? 0 : 1)
+  headCell.descendants((child) => {
+    if (child.type.name === 'image') {
+      images.push(child.attrs.src)
+    }
+  })
+  expect(images).toEqual(['image.png'])
+  expect(editor.view.dom.querySelectorAll('img')).toHaveLength(1)
+  editor.state.doc.check()
+}
+
+function pendingPaste(editor: Editor) {
+  let resolve: (result: ImportResult) => void = () => {}
+  vi.mocked(importExternalPathsToRuntime).mockReturnValue(
+    new Promise<ImportResult>((complete) => {
+      resolve = complete
+    })
+  )
+  const clipboardData = new DataTransfer()
+  clipboardData.items.add(new File(['image'], 'image.png', { type: 'image/png' }))
+  const event = new ClipboardEvent('paste', { clipboardData, cancelable: true })
+  expect(
+    handleRichMarkdownImagePaste({ editor, event, filePath: '/repo/note.md', worktreeId: null })
+  ).toBe(true)
+  expect(event.defaultPrevented).toBe(true)
+  return () =>
+    resolve({
+      results: [
+        {
+          sourcePath: '/tmp/image.png',
+          status: 'imported',
+          destPath: '/repo/image.png',
+          kind: 'file',
+          renamed: false
+        }
+      ]
+    })
+}
+
+async function flushPromises() {
+  for (let index = 0; index < 16; index++) {
+    await Promise.resolve()
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  Object.defineProperty(window, 'api', {
+    configurable: true,
+    value: { ui: { saveClipboardImageAsTempFile: vi.fn().mockResolvedValue('/tmp/image.png') } }
+  })
+})
+
+afterEach(() => {
+  editors.splice(0).forEach((editor) => editor.destroy())
+  document.body.replaceChildren()
+})
+
+describe('async image paste over table cells', () => {
+  it.each([false, true])(
+    'replaces every selected cell and supports undo, reversed=%s',
+    async (reversed) => {
+      const editor = richEditor(reversed)
+      const before = editor.getJSON()
+      const complete = pendingPaste(editor)
+      await flushPromises()
+      complete()
+      await flushPromises()
+      expectReplacedCells(editor, reversed)
+      expect(editor.state.doc.firstChild?.textContent).toBe('Before table')
+      expect(editor.state.doc.lastChild?.textContent).toBe('After table')
+      expect(editor.commands.undo()).toBe(true)
+      expect(editor.getJSON()).toEqual(before)
+      editor.state.doc.check()
+    }
+  )
+
+  it('maps the complete cell selection through an edit before the table', async () => {
+    const editor = richEditor()
+    const complete = pendingPaste(editor)
+    await flushPromises()
+    editor.view.dispatch(editor.state.tr.insertText('prefix ', 1))
+    complete()
+    await flushPromises()
+    expectReplacedCells(editor)
+    expect(editor.state.doc.firstChild?.textContent).toBe('prefix Before table')
+    expect(editor.state.doc.lastChild?.textContent).toBe('After table')
+  })
+
+  it('does not absorb a new row inserted between the originally selected rows', async () => {
+    const editor = richEditor()
+    const complete = pendingPaste(editor)
+    await flushPromises()
+    const { tableRow, tableCell, paragraph } = editor.schema.nodes
+    const insertedRow = tableRow.create(
+      null,
+      ['new left', 'new right', 'new keep'].map((text) =>
+        tableCell.create(null, paragraph.create(null, editor.schema.text(text)))
+      )
+    )
+    editor.view.dispatch(editor.state.tr.insert(cellPosition(editor, 'three') - 1, insertedRow))
+    const afterEdit = editor.getJSON()
+    complete()
+    await flushPromises()
+    expect(editor.getJSON()).toEqual(afterEdit)
+    expect(editor.view.dom.querySelectorAll('img')).toHaveLength(0)
+    editor.state.doc.check()
+  })
+
+  it('preserves text entered in an unselected column while replacing the original cells', async () => {
+    const editor = richEditor()
+    const complete = pendingPaste(editor)
+    await flushPromises()
+    editor.view.dispatch(
+      editor.state.tr.insertText('updated ', cellPosition(editor, 'keep top') + 2)
+    )
+    complete()
+    await flushPromises()
+    expectReplacedCells(editor, false, 'updated keep top')
+  })
+
+  it.each(SELECTED)('cancels when %s is edited even if it is not the head cell', async (text) => {
+    const editor = richEditor()
+    const complete = pendingPaste(editor)
+    await flushPromises()
+    editor.view.dispatch(editor.state.tr.insertText('changed ', cellPosition(editor, text) + 2))
+    const afterEdit = editor.getJSON()
+    complete()
+    await flushPromises()
+    expect(editor.getJSON()).toEqual(afterEdit)
+    expect(editor.view.dom.querySelectorAll('img')).toHaveLength(0)
+    editor.state.doc.check()
+  })
+
+  it('keeps the live caret in another paragraph after replacing the table cells', async () => {
+    const editor = richEditor()
+    const complete = pendingPaste(editor)
+    await flushPromises()
+    editor.commands.setTextSelection(editor.state.doc.content.size - 1)
+    editor.commands.insertContent('x')
+    complete()
+    await flushPromises()
+    expectReplacedCells(editor)
+    editor.commands.insertContent('y')
+    expect(editor.state.doc.lastChild?.textContent).toBe('After tablexy')
+    expect(editor.state.selection.empty).toBe(true)
+    editor.state.doc.check()
+  })
+})
diff --git a/src/renderer/src/components/editor/rich-markdown-clipboard-insertion-order.ts b/src/renderer/src/components/editor/rich-markdown-clipboard-insertion-order.ts
new file mode 100644
index 00000000000..e7d1182e5ad
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-clipboard-insertion-order.ts
@@ -0,0 +1,13 @@
+import type { Editor } from '@tiptap/core'
+import { PluginKey } from '@tiptap/pm/state'
+
+export const richMarkdownClipboardInsertionOrderKey = new PluginKey<number>(
+  'richMarkdownClipboardInsertionOrder'
+)
+const requestOrders = new WeakMap<Editor, number>()
+
+export function captureRichMarkdownClipboardInsertionOrder(editor: Editor): number {
+  const requestOrder = (requestOrders.get(editor) ?? 0) + 1
+  requestOrders.set(editor, requestOrder)
+  return requestOrder
+}
diff --git a/src/renderer/src/components/editor/rich-markdown-cut-handler.ts b/src/renderer/src/components/editor/rich-markdown-cut-handler.ts
index b6c5e714d82..3f808f1bf78 100644
--- a/src/renderer/src/components/editor/rich-markdown-cut-handler.ts
+++ b/src/renderer/src/components/editor/rich-markdown-cut-handler.ts
@@ -81,7 +81,18 @@ export function handleRichMarkdownCut(view: EditorView, event: ClipboardEvent):
     // Falls through to block-level cut for single-line paragraphs.
   }
 
+  // Images and source atoms can have no visible text.
+  let hasContentAtom = false
   if (!text) {
+    cutNode.descendants((node) => {
+      if (node.isAtom && !node.isText && node.type.name !== 'hardBreak') {
+        hasContentAtom = true
+      }
+      return !hasContentAtom
+    })
+  }
+
+  if (!text && !hasContentAtom) {
     // Still delete the empty block, matching VS Code behavior
     event.preventDefault()
     deleteBlockAndRestoreSelection(view, $from.before(cutDepth), $from.after(cutDepth))
diff --git a/src/renderer/src/components/editor/rich-markdown-extensions.ts b/src/renderer/src/components/editor/rich-markdown-extensions.ts
index c7e69917c25..f7df5e88062 100644
--- a/src/renderer/src/components/editor/rich-markdown-extensions.ts
+++ b/src/renderer/src/components/editor/rich-markdown-extensions.ts
@@ -43,6 +43,7 @@ import { RichMarkdownParagraph } from './rich-markdown-paragraph'
 import { RichMarkdownCodeBlockLowlight } from './rich-markdown-lowlight'
 import { RichMarkdownTaskList } from './rich-markdown-task-list'
 import { createCachedLowlight } from './rich-markdown-lowlight-cache'
+import { documentResourceAccess } from '@/lib/local-file-access'
 
 const lowlight = createCachedLowlight(createLowlight(common))
 
@@ -146,20 +147,29 @@ export function createRichMarkdownExtensions({
               | undefined
             const contextVersionAtLoad = getImageContextVersion(this.storage)
             if (src && fp) {
-              releaseImageLease = acquireLocalImageSrcLease(src, fp, undefined, runtimeContext)
-              void loadLocalImageSrc(src, fp, undefined, runtimeContext).then((resolved) => {
-                if (currentSrc !== src || currentContextVersion !== contextVersionAtLoad) {
-                  return
+              const access = documentResourceAccess(fp)
+              releaseImageLease = acquireLocalImageSrcLease(
+                src,
+                fp,
+                undefined,
+                runtimeContext,
+                access
+              )
+              void loadLocalImageSrc(src, fp, undefined, runtimeContext, access).then(
+                (resolved) => {
+                  if (currentSrc !== src || currentContextVersion !== contextVersionAtLoad) {
+                    return
+                  }
+                  if (resolved) {
+                    img.src = resolved
+                    return
+                  }
+                  // Why: local image paths must go through main's file
+                  // checks; a failed load should render missing, not hand
+                  // the raw path back to Chromium.
+                  img.removeAttribute('src')
                 }
-                if (resolved) {
-                  img.src = resolved
-                  return
-                }
-                // Why: local image paths must stay behind IPC/runtime
-                // authorization; a failed load should render missing, not
-                // hand the raw path back to Chromium.
-                img.removeAttribute('src')
-              })
+              )
             } else if (src) {
               img.src = src
             } else {
diff --git a/src/renderer/src/components/editor/rich-markdown-image-context.ts b/src/renderer/src/components/editor/rich-markdown-image-context.ts
index a86d2cdfcbc..2e9e9e4ed99 100644
--- a/src/renderer/src/components/editor/rich-markdown-image-context.ts
+++ b/src/renderer/src/components/editor/rich-markdown-image-context.ts
@@ -23,6 +23,15 @@ type RichMarkdownImageStorage = {
   }
 }
 
+export function getRichMarkdownImageResolverContextVersion(editor: Editor): number {
+  const image: unknown = 'image' in editor.storage ? editor.storage.image : null
+  if (!image || typeof image !== 'object') {
+    return 0
+  }
+  const version: unknown = 'contextVersion' in image ? image.contextVersion : null
+  return typeof version === 'number' ? version : 0
+}
+
 export function createRichMarkdownImageResolverContext({
   filePath,
   externalSshTargetId,
diff --git a/src/renderer/src/components/editor/rich-markdown-image-cut.test.ts b/src/renderer/src/components/editor/rich-markdown-image-cut.test.ts
new file mode 100644
index 00000000000..574d8d9c46f
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-image-cut.test.ts
@@ -0,0 +1,188 @@
+// @vitest-environment happy-dom
+import { Editor, type JSONContent } from '@tiptap/core'
+import { DOMParser } from '@tiptap/pm/model'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createRichMarkdownExtensions } from './rich-markdown-extensions'
+import { createRichMarkdownEditorCodec } from './rich-markdown-source-transport'
+import { handleRichMarkdownCut } from './rich-markdown-cut-handler'
+
+const showCutLimitError = vi.hoisted(() => vi.fn())
+vi.mock('./rich-markdown-source-owning-cut-feedback', () => ({
+  showRichMarkdownSourceOwningCutLimitError: showCutLimitError
+}))
+
+const editors: Editor[] = []
+
+function createEditor(content: string | JSONContent): Editor {
+  const element = document.createElement('div')
+  document.body.append(element)
+  const editor = new Editor({
+    element,
+    extensions: createRichMarkdownExtensions({ codec: createRichMarkdownEditorCodec() }),
+    content,
+    ...(typeof content === 'string' ? { contentType: 'markdown' as const } : {})
+  })
+  editors.push(editor)
+  vi.spyOn(editor.view, 'coordsAtPos').mockReturnValue({ top: 0, bottom: 20, left: 0, right: 20 })
+  return editor
+}
+
+function clipboard() {
+  const data = new DataTransfer()
+  data.setData('text/plain', 'existing clipboard')
+  data.setData('text/html', '<p>existing clipboard</p>')
+  const event = new ClipboardEvent('cut', { clipboardData: data, cancelable: true })
+  return { data, event }
+}
+
+function imagePosition(editor: Editor) {
+  let position: number | undefined
+  editor.state.doc.descendants((node, pos) => {
+    if (node.type.name === 'image') {
+      position = pos
+    }
+  })
+  if (position === undefined) {
+    throw new Error('Image missing')
+  }
+  return position
+}
+
+afterEach(() => {
+  editors.splice(0).forEach((editor) => editor.destroy())
+  document.body.replaceChildren()
+  showCutLimitError.mockReset()
+  vi.restoreAllMocks()
+})
+
+describe('cutting Markdown images with an empty caret selection', () => {
+  it.each([1, 2])('writes a restorable image before deleting its paragraph at caret %s', (pos) => {
+    const editor = createEditor('![](image.png)')
+    editor.commands.setTextSelection(pos)
+    const { data, event } = clipboard()
+    expect(handleRichMarkdownCut(editor.view, event)).toBe(true)
+    expect(event.defaultPrevented).toBe(true)
+    expect(data.getData('text/html')).toContain('image.png')
+    expect(data.getData('text/plain')).toBe('')
+    expect(editor.getMarkdown()).toBe('')
+    const container = document.createElement('div')
+    container.innerHTML = data.getData('text/html')
+    const restored = DOMParser.fromSchema(editor.schema).parse(container)
+    const images: string[] = []
+    restored.descendants((node) => {
+      if (node.type.name === 'image') {
+        images.push(node.attrs.src)
+      }
+    })
+    expect(images).toEqual(['image.png'])
+    restored.check()
+    editor.state.doc.check()
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.getMarkdown()).toBe('![](image.png)')
+  })
+
+  it('leaves the image intact when no clipboard is available', () => {
+    const editor = createEditor('![](image.png)')
+    editor.commands.setTextSelection(1)
+    const before = editor.getJSON()
+    const event = new ClipboardEvent('cut', { cancelable: true })
+    expect(handleRichMarkdownCut(editor.view, event)).toBe(false)
+    expect(event.defaultPrevented).toBe(false)
+    expect(editor.getJSON()).toEqual(before)
+  })
+
+  it('leaves the image intact and reports failure when the clipboard rejects the write', () => {
+    const editor = createEditor('![](image.png)')
+    editor.commands.setTextSelection(1)
+    const before = editor.getJSON()
+    const { data, event } = clipboard()
+    vi.spyOn(data, 'setData').mockImplementation(() => {})
+    expect(handleRichMarkdownCut(editor.view, event)).toBe(true)
+    expect(event.defaultPrevented).toBe(true)
+    expect(editor.getJSON()).toEqual(before)
+    expect(data.getData('text/plain')).toBe('existing clipboard')
+    expect(showCutLimitError).toHaveBeenCalledTimes(1)
+  })
+
+  it.each([
+    '- ![](image.png)\n- Keep this item',
+    '- [ ] ![](image.png)\n- [ ] Keep this item',
+    '| Image | Keep |\n| --- | --- |\n| ![](image.png) | Keep this cell |'
+  ])('serializes an image nested in a list or table without deleting its neighbor', (source) => {
+    const editor = createEditor(source)
+    editor.commands.setTextSelection(imagePosition(editor))
+    const { data, event } = clipboard()
+    expect(handleRichMarkdownCut(editor.view, event)).toBe(true)
+    expect(data.getData('text/html')).toContain('image.png')
+    expect(editor.getMarkdown()).not.toContain('image.png')
+    expect(editor.getMarkdown()).toContain('Keep this')
+    editor.state.doc.check()
+  })
+})
+
+describe('empty and textual block cut compatibility', () => {
+  it('deletes a truly empty paragraph without overwriting the clipboard', () => {
+    const editor = createEditor({
+      type: 'doc',
+      content: [
+        { type: 'paragraph' },
+        { type: 'paragraph', content: [{ type: 'text', text: 'Keep' }] }
+      ]
+    })
+    editor.commands.setTextSelection(1)
+    const { data, event } = clipboard()
+    expect(handleRichMarkdownCut(editor.view, event)).toBe(true)
+    expect(editor.state.doc.childCount).toBe(1)
+    expect(editor.state.doc.textContent).toBe('Keep')
+    expect(data.getData('text/plain')).toBe('existing clipboard')
+    expect(data.getData('text/html')).toBe('<p>existing clipboard</p>')
+  })
+
+  it.each([
+    { listType: 'bulletList', itemType: 'listItem' },
+    { listType: 'taskList', itemType: 'taskItem' }
+  ])('deletes an empty $itemType without overwriting the clipboard', ({ listType, itemType }) => {
+    const editor = createEditor({
+      type: 'doc',
+      content: [
+        {
+          type: listType,
+          content: [
+            { type: itemType, content: [{ type: 'paragraph' }] },
+            {
+              type: itemType,
+              content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Keep' }] }]
+            }
+          ]
+        }
+      ]
+    })
+    editor.commands.setTextSelection(3)
+    const { data, event } = clipboard()
+    expect(handleRichMarkdownCut(editor.view, event)).toBe(true)
+    expect(editor.state.doc.firstChild?.childCount).toBe(1)
+    expect(editor.state.doc.textContent).toBe('Keep')
+    expect(data.getData('text/plain')).toBe('existing clipboard')
+    expect(data.getData('text/html')).toBe('<p>existing clipboard</p>')
+    editor.state.doc.check()
+  })
+
+  it.each([
+    { content: [{ type: 'hardBreak' }], expected: '\n' },
+    { content: [{ type: 'text', text: '   ' }], expected: '   ' }
+  ])('preserves the existing clipboard behavior for $expected', ({ content, expected }) => {
+    const editor = createEditor({
+      type: 'doc',
+      content: [
+        { type: 'paragraph', content },
+        { type: 'paragraph', content: [{ type: 'text', text: 'Keep' }] }
+      ]
+    })
+    editor.commands.setTextSelection(1)
+    const { data, event } = clipboard()
+    expect(handleRichMarkdownCut(editor.view, event)).toBe(true)
+    expect(data.getData('text/plain')).toBe(expected)
+    expect(editor.state.doc.textContent).toBe('Keep')
+    editor.state.doc.check()
+  })
+})
diff --git a/src/renderer/src/components/editor/rich-markdown-image-insert-code-block.test.ts b/src/renderer/src/components/editor/rich-markdown-image-insert-code-block.test.ts
index a83de8559f8..e343914f2ac 100644
--- a/src/renderer/src/components/editor/rich-markdown-image-insert-code-block.test.ts
+++ b/src/renderer/src/components/editor/rich-markdown-image-insert-code-block.test.ts
@@ -23,6 +23,7 @@ vi.mock('@/store', () => ({
   useAppStore: {
     getState: vi.fn(() => ({
       settings: { activeRuntimeEnvironmentId: null },
+      openFiles: [],
       folderWorkspaces: [],
       worktreesByRepo: { repo1: [{ id: 'wt-1', path: '/repo' }] }
     }))
@@ -34,7 +35,7 @@ vi.mock('@/runtime/runtime-rpc-client', () => ({
 }))
 
 vi.mock('sonner', () => ({
-  toast: { error: vi.fn() }
+  toast: { error: vi.fn(), info: vi.fn() }
 }))
 
 const CODE_BLOCK_SOURCE = '```ts\nconst a = 1\n```\n'
diff --git a/src/renderer/src/components/editor/rich-markdown-image-insert.test.ts b/src/renderer/src/components/editor/rich-markdown-image-insert.test.ts
index d9fba294124..71495d4ceaa 100644
--- a/src/renderer/src/components/editor/rich-markdown-image-insert.test.ts
+++ b/src/renderer/src/components/editor/rich-markdown-image-insert.test.ts
@@ -1,19 +1,21 @@
 // @vitest-environment happy-dom
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { Editor } from '@tiptap/core'
+import { Editor } from '@tiptap/react'
 import { toast } from 'sonner'
 import { insertRichMarkdownImageFromPath } from './rich-markdown-image-insert'
 import { createRichMarkdownExtensions } from './rich-markdown-extensions'
 import { createRichMarkdownEditorCodec } from './rich-markdown-source-transport'
 import { importExternalPathsToRuntime } from '@/runtime/runtime-file-client'
+import { getConnectionIdForFile } from '@/lib/connection-context'
 
 vi.mock('@/runtime/runtime-file-client', () => ({
   importExternalPathsToRuntime: vi.fn()
 }))
 
 vi.mock('@/lib/connection-context', () => ({
-  getConnectionId: vi.fn(() => null)
+  getConnectionId: vi.fn(() => null),
+  getConnectionIdForFile: vi.fn(() => null)
 }))
 
 vi.mock('@/store', () => ({
@@ -29,7 +31,7 @@ vi.mock('@/runtime/runtime-rpc-client', () => ({
 }))
 
 vi.mock('sonner', () => ({
-  toast: { error: vi.fn() }
+  toast: { error: vi.fn(), info: vi.fn() }
 }))
 
 const openEditors: Editor[] = []
@@ -46,27 +48,33 @@ function createRichMarkdownEditor(markdown: string): Editor {
 }
 
 function editorWithRunResult(runResult: boolean, markdown = 'hello world') {
-  const run = vi.fn(() => runResult)
-  const insertContentAt = vi.fn(() => ({ run }))
-  const focus = vi.fn(() => ({ insertContentAt }))
-  const chain = vi.fn(() => ({ focus }))
-  // Why: the insert path reads the real schema and document to decide whether an
-  // inline image fits at the target position, so the stub borrows both.
-  const { schema, state } = createRichMarkdownEditor(markdown)
-  return { editor: { chain, schema, state }, chain, focus, insertContentAt, run }
+  const editor = createRichMarkdownEditor(markdown)
+  editor.commands.setTextSelection(4)
+  const insertion = editor.chain()
+  vi.spyOn(insertion, 'run').mockReturnValue(runResult)
+  const insertContentAt = vi.spyOn(insertion, 'insertContentAt')
+  const chain = vi.spyOn(editor, 'chain').mockReturnValue(insertion)
+  return { editor, chain, insertContentAt }
+}
+
+async function stubStoreState(state: Record<string, unknown>): Promise<void> {
+  const { useAppStore } = await import('@/store')
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the insert path reads only these store members.
+  vi.mocked(useAppStore.getState).mockReturnValue(state as never)
 }
 
 describe('insertRichMarkdownImageFromPath', () => {
   beforeEach(async () => {
     vi.clearAllMocks()
-    const { useAppStore } = await import('@/store')
-    vi.mocked(useAppStore.getState).mockReturnValue({
+    vi.mocked(getConnectionIdForFile).mockReturnValue(null)
+    await stubStoreState({
       settings: { activeRuntimeEnvironmentId: null },
+      openFiles: [],
       folderWorkspaces: [],
       worktreesByRepo: {
         repo1: [{ id: 'wt-1', path: '/repo' }]
       }
-    } as never)
+    })
     vi.mocked(importExternalPathsToRuntime).mockResolvedValue({
       results: [{ status: 'imported', destPath: '/repo/image.png' }]
     } as never)
@@ -82,32 +90,32 @@ describe('insertRichMarkdownImageFromPath', () => {
     const { editor } = editorWithRunResult(false)
 
     await insertRichMarkdownImageFromPath({
-      editor: editor as never,
+      editor,
       filePath: '/repo/note.md',
       sourcePath: '/tmp/image.png',
       worktreeId: 'wt-1',
-      insertPos: 4
+      getInsertionRange: () => ({ from: 4, to: 4, requestOrder: 1 })
     })
 
     expect(toast.error).toHaveBeenCalledWith('Failed to insert image.')
   })
 
   it('uses folder workspace paths for runtime-owned imports', async () => {
-    const { useAppStore } = await import('@/store')
-    vi.mocked(useAppStore.getState).mockReturnValue({
+    await stubStoreState({
       settings: { activeRuntimeEnvironmentId: 'env-1' },
+      openFiles: [],
       folderWorkspaces: [{ id: 'folder-1', folderPath: '/folder-workspace' }],
       worktreesByRepo: {}
-    } as never)
+    })
     const { editor } = editorWithRunResult(true)
 
     await insertRichMarkdownImageFromPath({
-      editor: editor as never,
+      editor,
       filePath: '/folder-workspace/note.md',
       sourcePath: '/tmp/image.png',
       worktreeId: 'folder:folder-1',
       runtimeEnvironmentId: 'env-1',
-      insertPos: 4
+      getInsertionRange: () => ({ from: 4, to: 4, requestOrder: 1 })
     })
 
     expect(importExternalPathsToRuntime).toHaveBeenCalledWith(
@@ -116,7 +124,8 @@ describe('insertRichMarkdownImageFromPath', () => {
         worktreePath: '/folder-workspace'
       }),
       ['/tmp/image.png'],
-      '/folder-workspace'
+      '/folder-workspace',
+      { access: undefined }
     )
   })
 
@@ -132,34 +141,80 @@ describe('insertRichMarkdownImageFromPath', () => {
     const { editor, insertContentAt } = editorWithRunResult(true)
 
     await insertRichMarkdownImageFromPath({
-      editor: editor as never,
+      editor,
       filePath: '/repo/note.md',
       sourcePath: '/tmp/image.png',
       worktreeId: 'wt-1',
-      insertPos: 4
+      getInsertionRange: () => ({ from: 4, to: 4, requestOrder: 1 })
     })
 
-    expect(insertContentAt).toHaveBeenCalledWith(4, {
-      type: 'image',
-      attrs: {
-        src: 'Screenshot%202026-06-22%20at%203.37.19%20PM%20copy.png'
-      }
-    })
+    expect(insertContentAt).toHaveBeenCalledWith(
+      4,
+      {
+        type: 'image',
+        attrs: {
+          src: 'Screenshot%202026-06-22%20at%203.37.19%20PM%20copy.png'
+        }
+      },
+      { updateSelection: true }
+    )
   })
 
+  it.each<[string, string, string | null, unknown]>([
+    [
+      'a local file opened outside every project',
+      '/Users/me/notes/note.md',
+      null,
+      { kind: 'document-folder', documentPath: '/Users/me/notes/note.md' }
+    ],
+    ['a project file', 'note.md', null, undefined],
+    ['an outside file on an SSH host', '/Users/me/notes/note.md', 'ssh-1', undefined]
+  ])(
+    'declares document-folder access only for %s',
+    async (_label, relativePath, connectionId, access) => {
+      const filePath = relativePath === 'note.md' ? '/repo/note.md' : '/Users/me/notes/note.md'
+      await stubStoreState({
+        settings: { activeRuntimeEnvironmentId: null },
+        openFiles: [{ filePath, relativePath, worktreeId: 'wt-1' }],
+        folderWorkspaces: [],
+        worktreesByRepo: { repo1: [{ id: 'wt-1', path: '/repo' }] }
+      })
+      vi.mocked(getConnectionIdForFile).mockReturnValue(connectionId)
+      const { editor, insertContentAt } = editorWithRunResult(true)
+
+      await insertRichMarkdownImageFromPath({
+        editor: editor as never,
+        filePath,
+        sourcePath: '/tmp/image.png',
+        worktreeId: 'wt-1',
+        getInsertionRange: () => ({ from: 4, to: 4, requestOrder: 1 })
+      })
+
+      expect(vi.mocked(importExternalPathsToRuntime).mock.calls[0]?.[3]).toEqual({ access })
+      expect(insertContentAt).toHaveBeenCalledWith(
+        4,
+        { type: 'image', attrs: { src: 'image.png' } },
+        { updateSelection: true }
+      )
+      expect(toast.error).not.toHaveBeenCalled()
+    }
+  )
+
   it('skips editor mutation when the caller rejects the stale target after import', async () => {
     const { editor, chain } = editorWithRunResult(true)
 
     await insertRichMarkdownImageFromPath({
-      editor: editor as never,
+      editor,
       filePath: '/repo/note.md',
       sourcePath: '/tmp/image.png',
       worktreeId: 'wt-1',
-      insertPos: 4,
-      canInsert: () => false
+      getInsertionRange: () => null
     })
 
     expect(chain).not.toHaveBeenCalled()
     expect(toast.error).not.toHaveBeenCalled()
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+      'Image insertion canceled because the destination changed. The imported file was kept.'
+    )
   })
 })
diff --git a/src/renderer/src/components/editor/rich-markdown-image-insert.ts b/src/renderer/src/components/editor/rich-markdown-image-insert.ts
index 3c1354a06b6..1f6f020dfdb 100644
--- a/src/renderer/src/components/editor/rich-markdown-image-insert.ts
+++ b/src/renderer/src/components/editor/rich-markdown-image-insert.ts
@@ -5,12 +5,16 @@ import { getConnectionId } from '@/lib/connection-context'
 import { useAppStore } from '@/store'
 import { importExternalPathsToRuntime } from '@/runtime/runtime-file-client'
 import { getEditorFileOperationContext } from '@/lib/editor-file-operation-owner'
+import { editorTabDocumentFolderAccess } from '@/lib/local-file-access'
 import { settingsForRuntimeOwner } from '@/runtime/runtime-rpc-client'
 import { captureDirectSshMutationExpectation } from '@/lib/ssh-mutation-expectation'
 import { translate } from '@/i18n/i18n'
 import { parseWorkspaceKey } from '../../../../shared/workspace-scope'
 import { extractIpcErrorMessage } from './rich-markdown-ipc-error-message'
 import { buildRichMarkdownImageInsertContent } from './rich-markdown-image-insert-content'
+import { showRichMarkdownImageInsertionCanceled } from './rich-markdown-image-insertion-feedback'
+import type { RichMarkdownImageInsertionRange } from './rich-markdown-image-insertion-target'
+import { richMarkdownClipboardInsertionOrderKey } from './rich-markdown-clipboard-insertion-order'
 
 export type RichMarkdownImageInsertArgs = {
   editor: Editor
@@ -18,8 +22,7 @@ export type RichMarkdownImageInsertArgs = {
   sourcePath: string
   worktreeId: string | null
   runtimeEnvironmentId?: string | null
-  insertPos: number
-  canInsert?: (editor: Editor) => boolean
+  getInsertionRange: () => RichMarkdownImageInsertionRange | null
 }
 
 export async function insertRichMarkdownImageFromPath({
@@ -28,8 +31,7 @@ export async function insertRichMarkdownImageFromPath({
   sourcePath,
   worktreeId,
   runtimeEnvironmentId,
-  insertPos,
-  canInsert
+  getInsertionRange
 }: RichMarkdownImageInsertArgs): Promise<void> {
   try {
     const state = useAppStore.getState()
@@ -68,10 +70,15 @@ export async function insertRichMarkdownImageFromPath({
 
     // Why: image bytes should live beside the note instead of inside markdown;
     // this keeps rich-mode size checks based on document text, not binary data.
+    // Why: a document opened outside every project still gets its image beside it.
+    const openDocument = state.openFiles.find(
+      (file) => file.filePath === filePath && file.worktreeId === worktreeId
+    )
     const { results } = await importExternalPathsToRuntime(
       fileContext,
       [sourcePath],
-      dirname(filePath)
+      dirname(filePath),
+      { access: openDocument ? editorTabDocumentFolderAccess(state, openDocument) : undefined }
     )
     const imported = results.find((result) => result.status === 'imported')
     if (!imported) {
@@ -81,19 +88,35 @@ export async function insertRichMarkdownImageFromPath({
       return
     }
 
-    if (canInsert && !canInsert(editor)) {
+    const range = getInsertionRange()
+    if (!range) {
+      showRichMarkdownImageInsertionCanceled(true)
       return
     }
 
     const imageSrc = encodeMarkdownImageBasename(imported.destPath)
-    const inserted = editor
-      .chain()
-      .focus()
-      .insertContentAt(
-        insertPos,
-        buildRichMarkdownImageInsertContent(editor, insertPos, { src: imageSrc })
-      )
-      .run()
+    const selection = editor.state.selection
+    const cellSelection = range.cellSelection
+    const selectionStillAtTarget = cellSelection
+      ? selection.eq(cellSelection)
+      : selection.from === range.from && selection.to === range.to
+    const chain = cellSelection
+      ? editor.chain().command(({ tr }) => {
+          const liveSelection = tr.selection
+          cellSelection.replaceWith(tr, editor.schema.nodes.image.create({ src: imageSrc }))
+          if (!selectionStillAtTarget) {
+            tr.setSelection(liveSelection.map(tr.doc, tr.mapping))
+          }
+          return true
+        })
+      : editor
+          .chain()
+          .insertContentAt(
+            range.from === range.to ? range.from : range,
+            buildRichMarkdownImageInsertContent(editor, range.from, { src: imageSrc }),
+            { updateSelection: selectionStillAtTarget }
+          )
+    const inserted = chain.setMeta(richMarkdownClipboardInsertionOrderKey, range.requestOrder).run()
     if (!inserted) {
       toast.error(
         translate('auto.components.editor.useLocalImagePick.175cb8b8ce', 'Failed to insert image.')
diff --git a/src/renderer/src/components/editor/rich-markdown-image-insertion-feedback.ts b/src/renderer/src/components/editor/rich-markdown-image-insertion-feedback.ts
new file mode 100644
index 00000000000..1e06808af13
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-image-insertion-feedback.ts
@@ -0,0 +1,16 @@
+import { toast } from 'sonner'
+import { translate } from '@/i18n/i18n'
+
+export function showRichMarkdownImageInsertionCanceled(importedFileKept = false): void {
+  toast.info(
+    importedFileKept
+      ? translate(
+          'auto.components.editor.richMarkdownImageInsertionFeedback.importedFileKept',
+          'Image insertion canceled because the destination changed. The imported file was kept.'
+        )
+      : translate(
+          'auto.components.editor.richMarkdownImageInsertionFeedback.destinationChanged',
+          'Image insertion canceled because the destination changed. Try again.'
+        )
+  )
+}
diff --git a/src/renderer/src/components/editor/rich-markdown-image-insertion-target.test.ts b/src/renderer/src/components/editor/rich-markdown-image-insertion-target.test.ts
new file mode 100644
index 00000000000..a6e74d83e66
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-image-insertion-target.test.ts
@@ -0,0 +1,220 @@
+// @vitest-environment happy-dom
+import { Editor, Extension } from '@tiptap/react'
+import StarterKit from '@tiptap/starter-kit'
+import { Plugin } from '@tiptap/pm/state'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { captureRichMarkdownImageInsertionTarget } from './rich-markdown-image-insertion-target'
+import { setRichMarkdownImageResolverContext } from './rich-markdown-image-context'
+import { createRichMarkdownExtensions } from './rich-markdown-extensions'
+import { createRichMarkdownEditorCodec } from './rich-markdown-source-transport'
+import {
+  captureRichMarkdownClipboardInsertionOrder,
+  richMarkdownClipboardInsertionOrderKey
+} from './rich-markdown-clipboard-insertion-order'
+
+const editors: Editor[] = []
+
+function editorAt(from: number, to = from, extensions: Extension[] = []) {
+  const editor = new Editor({
+    extensions: [StarterKit, ...extensions],
+    content: '<p>hello world</p>'
+  })
+  document.body.append(editor.view.dom)
+  editor.commands.setTextSelection({ from, to })
+  editors.push(editor)
+  return editor
+}
+
+afterEach(() => {
+  editors.splice(0).forEach((editor) => editor.destroy())
+  document.body.replaceChildren()
+  vi.restoreAllMocks()
+})
+
+describe('pending rich Markdown image insertion targets', () => {
+  it('maps both ends of a reversed selection after earlier text changes', () => {
+    const editor = editorAt(12, 7)
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    editor.view.dispatch(editor.state.tr.insertText('prefix ', 1))
+    expect(target?.getRange()).toMatchObject({ from: 14, to: 19 })
+    target?.dispose()
+  })
+
+  it('excludes subsequent typing at either selected-range boundary', () => {
+    const editor = editorAt(7, 12)
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    editor.view.dispatch(editor.state.tr.insertText('start ', 7))
+    editor.view.dispatch(editor.state.tr.insertText(' end', 18))
+    expect(target?.getRange()).toMatchObject({ from: 13, to: 18 })
+    target?.dispose()
+  })
+
+  it('keeps a collapsed pending paste before text typed at the same caret', () => {
+    const editor = editorAt(7)
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    editor.commands.insertContent('typed ')
+    expect(target?.getRange()).toMatchObject({ from: 7, to: 7 })
+    target?.dispose()
+  })
+
+  it.each(['replace', 'delete', 'insert'])(
+    'cancels when %s changes selected content',
+    (operation) => {
+      const editor = editorAt(7, 12)
+      const target = captureRichMarkdownImageInsertionTarget(editor)
+      const tr = editor.state.tr
+      if (operation === 'replace') {
+        tr.insertText('changed', 7, 12)
+      } else if (operation === 'delete') {
+        tr.delete(7, 12)
+      } else {
+        tr.insertText('new', 9)
+      }
+      editor.view.dispatch(tr)
+      expect(target?.getRange()).toBeNull()
+    }
+  )
+
+  it('cancels a collapsed anchor deleted by a document replacement', () => {
+    const editor = editorAt(7)
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    editor.commands.setContent('<p>different document</p>')
+    expect(target?.getRange()).toBeNull()
+  })
+
+  it('keeps the target through a no-op content replacement', () => {
+    const editor = editorAt(7, 12)
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    editor.commands.setContent(editor.getJSON())
+    expect(target?.getRange()).toMatchObject({ from: 7, to: 12 })
+    target?.dispose()
+  })
+
+  it('keeps a target when resolver settings retain the same file and owner', () => {
+    const editor = editorAt(7, 12)
+    const context = { filePath: '/repo/note.md' }
+    setRichMarkdownImageResolverContext(editor, context)
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    expect(setRichMarkdownImageResolverContext(editor, { ...context })).toBe(false)
+    expect(target?.getRange()).toMatchObject({ from: 7, to: 12 })
+    target?.dispose()
+  })
+
+  it('maps the root and appended transaction exactly once', () => {
+    const appendPrefix = Extension.create({
+      name: 'appendPrefix',
+      addProseMirrorPlugins: () => [
+        new Plugin({
+          appendTransaction(transactions, _oldState, state) {
+            return transactions.some((tr) => tr.getMeta('appendPrefix'))
+              ? state.tr.insertText('next ', 1)
+              : null
+          }
+        })
+      ]
+    })
+    const editor = editorAt(7, 12, [appendPrefix])
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    editor.view.dispatch(editor.state.tr.insertText('first ', 1).setMeta('appendPrefix', true))
+    expect(editor.getText()).toBe('next first hello world')
+    expect(target?.getRange()).toMatchObject({ from: 18, to: 23 })
+    target?.dispose()
+  })
+
+  it.each(['first', 'second'])('orders two same-caret requests when %s finishes first', (first) => {
+    const editor = editorAt(7)
+    const earlier = captureRichMarkdownImageInsertionTarget(editor)
+    const later = captureRichMarkdownImageInsertionTarget(editor)
+    const completing = first === 'first' ? earlier : later
+    const pending = first === 'first' ? later : earlier
+    const range = completing?.getRange()
+    if (!range) {
+      throw new Error('Missing image insertion target')
+    }
+    editor.view.dispatch(
+      editor.state.tr
+        .insertText('image ', range.from)
+        .setMeta(richMarkdownClipboardInsertionOrderKey, range.requestOrder)
+    )
+    expect(pending?.getRange()).toMatchObject({ from: first === 'first' ? 13 : 7 })
+    earlier?.dispose()
+    later?.dispose()
+  })
+
+  it('detaches transaction and destroy listeners when disposed or destroyed', () => {
+    const editor = editorAt(7)
+    const off = vi.spyOn(editor, 'off')
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    target?.dispose()
+    target?.dispose()
+    expect(off.mock.calls.map(([event]) => event)).toEqual(['transaction', 'destroy'])
+    expect(target?.getRange()).toBeNull()
+    const pending = captureRichMarkdownImageInsertionTarget(editor)
+    editor.destroy()
+    expect(pending?.getRange()).toBeNull()
+  })
+
+  it('rejects disconnected and disabled editor targets', () => {
+    const editor = editorAt(7)
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    editor.view.dom.remove()
+    expect(target?.getRange()).toBeNull()
+    expect(captureRichMarkdownImageInsertionTarget(editor)).toBeNull()
+    document.body.append(editor.view.dom)
+    editor.setEditable(false)
+    expect(target?.getRange()).toBeNull()
+    expect(captureRichMarkdownImageInsertionTarget(editor)).toBeNull()
+    target?.dispose()
+  })
+
+  it.each(['earlier text paste', 'later text paste', 'ordinary typing'] as const)(
+    'orders a pending image against %s while preserving the live caret',
+    (counterpart) => {
+      const editor = new Editor({
+        extensions: createRichMarkdownExtensions({ codec: createRichMarkdownEditorCodec() }),
+        content: 'hello world',
+        contentType: 'markdown'
+      })
+      editors.push(editor)
+      document.body.append(editor.view.dom)
+      editor.commands.setTextSelection(7)
+      const earlierOrder =
+        counterpart === 'earlier text paste'
+          ? captureRichMarkdownClipboardInsertionOrder(editor)
+          : null
+      const target = captureRichMarkdownImageInsertionTarget(editor)
+      const tr = editor.state.tr.insertText('text', 7)
+      if (counterpart !== 'ordinary typing') {
+        tr.setMeta(
+          richMarkdownClipboardInsertionOrderKey,
+          earlierOrder ?? captureRichMarkdownClipboardInsertionOrder(editor)
+        )
+      }
+      editor.view.dispatch(tr)
+      const range = target?.getRange()
+      if (!range) {
+        throw new Error('Missing image insertion target')
+      }
+      expect(range.from).toBe(counterpart === 'earlier text paste' ? 11 : 7)
+      editor
+        .chain()
+        .insertContentAt(
+          range.from,
+          { type: 'image', attrs: { src: 'image.png' } },
+          {
+            updateSelection: false
+          }
+        )
+        .setMeta(richMarkdownClipboardInsertionOrderKey, range.requestOrder)
+        .run()
+      expect(editor.getMarkdown()).toBe(
+        counterpart === 'earlier text paste'
+          ? 'hello text![](image.png)world'
+          : 'hello ![](image.png)textworld'
+      )
+      expect(editor.state.selection.from).toBe(12)
+      editor.state.doc.check()
+      target?.dispose()
+    }
+  )
+})
diff --git a/src/renderer/src/components/editor/rich-markdown-image-insertion-target.ts b/src/renderer/src/components/editor/rich-markdown-image-insertion-target.ts
new file mode 100644
index 00000000000..de909ab2f06
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-image-insertion-target.ts
@@ -0,0 +1,136 @@
+import type { Editor } from '@tiptap/react'
+import type { Transaction } from '@tiptap/pm/state'
+import { CellSelection } from '@tiptap/pm/tables'
+import { getRichMarkdownImageResolverContextVersion } from './rich-markdown-image-context'
+import {
+  captureRichMarkdownClipboardInsertionOrder,
+  richMarkdownClipboardInsertionOrderKey
+} from './rich-markdown-clipboard-insertion-order'
+
+export type RichMarkdownImageInsertionRange = {
+  from: number
+  to: number
+  requestOrder: number
+  cellSelection?: CellSelection
+}
+
+export type RichMarkdownImageInsertionTarget = {
+  getRange: () => RichMarkdownImageInsertionRange | null
+  dispose: () => void
+}
+
+export function captureRichMarkdownImageInsertionTarget(
+  editor: Editor
+): RichMarkdownImageInsertionTarget | null {
+  if (editor.isDestroyed || !editor.view.dom.isConnected || !editor.isEditable) {
+    return null
+  }
+  const targetDom = editor.view.dom
+  const contextVersion = getRichMarkdownImageResolverContextVersion(editor)
+  const requestOrder = captureRichMarkdownClipboardInsertionOrder(editor)
+  let cellSelection =
+    editor.state.selection instanceof CellSelection && editor.state.selection.ranges.length > 1
+      ? editor.state.selection
+      : null
+  let ranges = editor.state.selection.ranges.map(({ $from, $to }) => ({
+    from: $from.pos,
+    to: $to.pos
+  }))
+  let document = editor.state.doc
+  let active = true
+
+  const dispose = (): void => {
+    if (!active) {
+      return
+    }
+    active = false
+    editor.off('transaction', mapTransactions)
+    editor.off('destroy', dispose)
+  }
+
+  const mapTransactions = ({
+    transaction,
+    appendedTransactions
+  }: {
+    transaction: Transaction
+    appendedTransactions: Transaction[]
+  }): void => {
+    const transactions = [transaction, ...appendedTransactions]
+    const nextDocument = appendedTransactions.at(-1)?.doc ?? transaction.doc
+    if (nextDocument.eq(document)) {
+      document = nextDocument
+      return
+    }
+    if (!transaction.before.eq(document)) {
+      dispose()
+      return
+    }
+    const insertionOrder: unknown = transaction.getMeta(richMarkdownClipboardInsertionOrderKey)
+    for (const nextTransaction of transactions) {
+      for (const map of nextTransaction.mapping.maps) {
+        const mappedRanges: { from: number; to: number }[] = []
+        for (const range of ranges) {
+          const collapsed = range.from === range.to
+          let overlapsSelection = false
+          if (!collapsed) {
+            map.forEach((from, to) => {
+              overlapsSelection ||=
+                to > from
+                  ? from < range.to && to > range.from
+                  : cellSelection
+                    ? from >= range.from && from <= range.to
+                    : from > range.from && from < range.to
+            })
+          }
+          if (overlapsSelection) {
+            dispose()
+            return
+          }
+          // Pending pastes keep their request order, ahead of later ordinary typing.
+          const assoc = typeof insertionOrder === 'number' && insertionOrder < requestOrder ? 1 : -1
+          const from = map.mapResult(range.from, collapsed ? assoc : 1)
+          const to = map.mapResult(range.to, collapsed ? assoc : -1)
+          if (from.deletedAcross || to.deletedAcross || from.pos > to.pos) {
+            dispose()
+            return
+          }
+          mappedRanges.push({ from: from.pos, to: to.pos })
+        }
+        ranges = mappedRanges
+      }
+      if (cellSelection) {
+        const mapped = cellSelection.map(nextTransaction.doc, nextTransaction.mapping)
+        if (
+          !(mapped instanceof CellSelection) ||
+          mapped.ranges.length !== ranges.length ||
+          mapped.ranges.some(
+            ({ $from, $to }, index) =>
+              $from.pos !== ranges[index].from || $to.pos !== ranges[index].to
+          )
+        ) {
+          dispose()
+          return
+        }
+        cellSelection = mapped
+      }
+    }
+    document = nextDocument
+  }
+
+  editor.on('transaction', mapTransactions)
+  editor.on('destroy', dispose)
+
+  return {
+    dispose,
+    getRange: () =>
+      active &&
+      !editor.isDestroyed &&
+      editor.isEditable &&
+      editor.view.dom === targetDom &&
+      targetDom.isConnected &&
+      getRichMarkdownImageResolverContextVersion(editor) === contextVersion &&
+      editor.state.doc.eq(document)
+        ? { ...ranges[0], requestOrder, ...(cellSelection ? { cellSelection } : {}) }
+        : null
+  }
+}
diff --git a/src/renderer/src/components/editor/rich-markdown-key-handler.test.ts b/src/renderer/src/components/editor/rich-markdown-key-handler.test.ts
index e6893049633..bddcdb04cee 100644
--- a/src/renderer/src/components/editor/rich-markdown-key-handler.test.ts
+++ b/src/renderer/src/components/editor/rich-markdown-key-handler.test.ts
@@ -147,6 +147,40 @@ function emptyTopLevelOrderedList(): JSONContent {
 }
 
 describe('rich markdown key handler', () => {
+  it('flushes and saves an unmarked save shortcut while the editor is composing', () => {
+    const editor = createEditor(emptyTopLevelOrderedList())
+    try {
+      Object.defineProperty(editor.view, 'composing', { value: true, configurable: true })
+      const ctx = createContext(editor, false)
+      const event = keyEvent('s', { metaKey: true, code: 'KeyS' })
+
+      expect(createRichMarkdownKeyHandler(ctx)(null, event)).toBe(true)
+      expect(event.preventDefault).toHaveBeenCalledOnce()
+      expect(ctx.flushPendingSerialization).toHaveBeenCalledOnce()
+      expect(ctx.onSaveRef.current).toHaveBeenCalledOnce()
+    } finally {
+      editor.destroy()
+    }
+  })
+
+  it.each([{ isComposing: true }, { keyCode: 229 }])(
+    'does not save when the shortcut event belongs to the IME: %j',
+    (marker) => {
+      const editor = createEditor(emptyTopLevelOrderedList())
+      try {
+        const ctx = createContext(editor, false)
+        const event = keyEvent('s', { metaKey: true, code: 'KeyS', ...marker })
+
+        expect(createRichMarkdownKeyHandler(ctx)(null, event)).toBe(false)
+        expect(event.preventDefault).not.toHaveBeenCalled()
+        expect(ctx.flushPendingSerialization).not.toHaveBeenCalled()
+        expect(ctx.onSaveRef.current).not.toHaveBeenCalled()
+      } finally {
+        editor.destroy()
+      }
+    }
+  )
+
   it('opens the review-note composer on the add-review-note shortcut', () => {
     const editor = createEditor(emptyTopLevelOrderedList())
 
@@ -293,20 +327,58 @@ describe('rich markdown key handler', () => {
     }
   })
 
-  it('does not rewrite empty ordered-list input during IME composition', () => {
-    const editor = createEditor(emptyTopLevelOrderedList())
+  it.each([{ isComposing: true }, { keyCode: 229 }])(
+    'does not rewrite IME list input: %j',
+    (marker) => {
+      const editor = createEditor(emptyTopLevelOrderedList())
 
-    try {
-      editor.commands.setTextSelection(3)
-      const event = keyEvent('Enter', { isComposing: true })
+      try {
+        editor.commands.setTextSelection(3)
+        const event = keyEvent('Enter', marker)
 
-      expect(createRichMarkdownKeyHandler(createContext(editor, true))(null, event)).toBe(false)
-      expect(event.preventDefault).not.toHaveBeenCalled()
-      expect(editor.state.doc.toJSON()).toEqual(emptyTopLevelOrderedList())
-    } finally {
-      editor.destroy()
+        expect(createRichMarkdownKeyHandler(createContext(editor, true))(null, event)).toBe(false)
+        expect(event.preventDefault).not.toHaveBeenCalled()
+        expect(editor.state.doc.toJSON()).toEqual(emptyTopLevelOrderedList())
+      } finally {
+        editor.destroy()
+      }
     }
-  })
+  )
+
+  it.each([{ isComposing: true }, { keyCode: 229 }])(
+    'keeps IME candidate keys out of the slash menu: %j',
+    (marker) => {
+      const editor = createEditor(emptyTopLevelOrderedList())
+      try {
+        const ctx = createContext(editor, false)
+        ctx.slashMenuRef.current = { query: '', from: 1, to: 1, left: 0, top: 0 }
+        const run = vi.fn()
+        ctx.filteredSlashCommandsRef.current = [
+          {
+            id: 'heading-1',
+            label: 'Heading',
+            aliases: [],
+            icon: { kind: 'text', value: 'H' },
+            group: 'Basic blocks',
+            description: 'Heading',
+            run
+          }
+        ]
+        for (const key of ['Enter', 'Escape', 'ArrowDown']) {
+          const event = keyEvent(key, marker)
+          expect(createRichMarkdownKeyHandler(ctx)(null, event)).toBe(false)
+          expect(event.preventDefault).not.toHaveBeenCalled()
+        }
+        expect(run).not.toHaveBeenCalled()
+        expect(ctx.setSlashMenu).not.toHaveBeenCalled()
+        expect(ctx.setSelectedCommandIndex).not.toHaveBeenCalled()
+        expect(createRichMarkdownKeyHandler(ctx)(null, keyEvent('Enter'))).toBe(true)
+        expect(run).toHaveBeenCalledOnce()
+      } finally {
+        editor.destroy()
+      }
+    }
+  )
 
   it('lets slash-menu filter input fall through to document input', () => {
     const editor = createEditor({
diff --git a/src/renderer/src/components/editor/rich-markdown-key-handler.ts b/src/renderer/src/components/editor/rich-markdown-key-handler.ts
index 69ecebf8364..9a3a10a642a 100644
--- a/src/renderer/src/components/editor/rich-markdown-key-handler.ts
+++ b/src/renderer/src/components/editor/rich-markdown-key-handler.ts
@@ -1,3 +1,4 @@
+import { isImeOwnedKeyboardEvent } from '@/lib/ime-composition-keyboard-event'
 import type { MutableRefObject, Dispatch, SetStateAction } from 'react'
 import type { Editor } from '@tiptap/react'
 import { getShortcutPlatform } from '@/lib/shortcut-platform'
@@ -70,7 +71,7 @@ export type KeyHandlerContext = {
 }
 
 function isComposingMarkdownInput(event: KeyboardEvent, editor: Editor | null): boolean {
-  return event.isComposing || editor?.view.composing === true
+  return isImeOwnedKeyboardEvent(event) || editor?.view.composing === true
 }
 
 /**
@@ -81,6 +82,16 @@ export function createRichMarkdownKeyHandler(
   ctx: KeyHandlerContext
 ): (_view: unknown, event: KeyboardEvent) => boolean {
   return (_view, event) => {
+    if (isImeOwnedKeyboardEvent(event)) {
+      return false
+    }
+    // Save must flush pending text even while the editor's composition state lingers.
+    if (handleRichMarkdownSaveShortcut(ctx, event)) {
+      return true
+    }
+    if (isComposingMarkdownInput(event, ctx.editorRef.current)) {
+      return false
+    }
     const mod = ctx.isMac ? event.metaKey && !event.ctrlKey : event.ctrlKey && !event.metaKey
     if (
       handleRichMarkdownCitationKey({
@@ -103,9 +114,6 @@ export function createRichMarkdownKeyHandler(
       ctx.openSearchRef.current()
       return true
     }
-    if (handleRichMarkdownSaveShortcut(ctx, event)) {
-      return true
-    }
     if (handleRichMarkdownAddReviewNoteShortcut(ctx, event)) {
       return true
     }
diff --git a/src/renderer/src/components/editor/rich-markdown-large-paste-history.ts b/src/renderer/src/components/editor/rich-markdown-large-paste-history.ts
new file mode 100644
index 00000000000..bce579dd94b
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-large-paste-history.ts
@@ -0,0 +1,59 @@
+import type { Editor } from '@tiptap/core'
+import { Plugin, PluginKey, type Transaction } from '@tiptap/pm/state'
+import { closeHistory } from '@tiptap/pm/history'
+
+export function trackRichMarkdownLargePasteHistory(editor: Editor, onInterrupt: () => void) {
+  const key = new PluginKey<boolean>('richMarkdownLargePasteHistory')
+  let writingChunk = false
+  let hasWrittenChunk = false
+  let active = true
+  let boundaryAtDisposal = false
+  editor.registerPlugin(
+    new Plugin({
+      key,
+      state: {
+        init: () => false,
+        apply(transaction, externalBoundaryStarted) {
+          if (writingChunk || !hasWrittenChunk) {
+            return false
+          }
+          if (transaction.docChanged && !externalBoundaryStarted) {
+            onInterrupt()
+          }
+          return externalBoundaryStarted || transaction.docChanged
+        }
+      },
+      filterTransaction(transaction, state) {
+        // An external event may first change the document in an appended transaction.
+        if (hasWrittenChunk && !writingChunk && transaction.docChanged && !key.getState(state)) {
+          closeHistory(transaction)
+        }
+        return true
+      }
+    })
+  )
+  return {
+    hasExternalBoundary(): boolean {
+      return active ? key.getState(editor.state) === true : boundaryAtDisposal
+    },
+    dispatchChunk(transaction: Transaction): void {
+      hasWrittenChunk = true
+      writingChunk = true
+      try {
+        editor.view.dispatch(transaction)
+      } finally {
+        writingChunk = false
+      }
+    },
+    dispose(): void {
+      if (!active) {
+        return
+      }
+      boundaryAtDisposal = !editor.isDestroyed && key.getState(editor.state) === true
+      active = false
+      if (!editor.isDestroyed) {
+        editor.unregisterPlugin(key)
+      }
+    }
+  }
+}
diff --git a/src/renderer/src/components/editor/rich-markdown-large-text-paste.fidelity.test.ts b/src/renderer/src/components/editor/rich-markdown-large-text-paste.fidelity.test.ts
new file mode 100644
index 00000000000..d12a9579248
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-large-text-paste.fidelity.test.ts
@@ -0,0 +1,394 @@
+// @vitest-environment happy-dom
+import { Editor } from '@tiptap/core'
+import { Plugin } from '@tiptap/pm/state'
+import { afterEach, expect, it, vi } from 'vitest'
+import { toast } from 'sonner'
+import { createRichMarkdownExtensions } from './rich-markdown-extensions'
+import { createRichMarkdownEditorCodec } from './rich-markdown-source-transport'
+import { handleRichMarkdownLargeTextPaste } from './rich-markdown-large-text-paste'
+import {
+  captureRichMarkdownClipboardInsertionOrder,
+  richMarkdownClipboardInsertionOrderKey
+} from './rich-markdown-clipboard-insertion-order'
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), info: vi.fn() } }))
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+const editors: Editor[] = []
+
+function createProductionEditor(content = 'hello world\n\nsecond paragraph') {
+  const editor = new Editor({
+    extensions: createRichMarkdownExtensions({ codec: createRichMarkdownEditorCodec() }),
+    content,
+    contentType: 'markdown'
+  })
+  editors.push(editor)
+  document.body.append(editor.view.dom)
+  editor.view.dom.focus()
+  editor.commands.setTextSelection({ from: 7, to: 12 })
+  return editor
+}
+
+function pasteEvent(text = 'ABCDE'): ClipboardEvent {
+  const clipboardData = new DataTransfer()
+  clipboardData.setData('text/plain', text)
+  return new ClipboardEvent('paste', { clipboardData, cancelable: true })
+}
+
+function pause() {
+  let resume: () => void = () => {}
+  const promise = new Promise<void>((resolve) => {
+    resume = resolve
+  })
+  return { promise, resume: () => resume() }
+}
+
+async function flush(count = 40) {
+  for (let index = 0; index < count; index += 1) {
+    await Promise.resolve()
+  }
+}
+
+function paragraphs(editor: Editor): string[] {
+  return Array.from(
+    { length: editor.state.doc.childCount },
+    (_, index) => editor.state.doc.child(index).textContent
+  )
+}
+
+afterEach(() => {
+  editors.splice(0).forEach((editor) => editor.destroy())
+  document.body.replaceChildren()
+  vi.restoreAllMocks()
+  vi.clearAllMocks()
+})
+
+it('keeps every byte literal with the production extensions across production chunk boundaries', async () => {
+  const editor = createProductionEditor()
+  const payload = 'PASTE_SENTINEL '.repeat(5500)
+  expect(new TextEncoder().encode(payload).byteLength).toBe(82500)
+  const event = pasteEvent(payload)
+  const delay = pause()
+  const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+  expect(handleRichMarkdownLargeTextPaste(editor, event, { yieldToEventLoop })).toBe(true)
+  expect(event.defaultPrevented).toBe(true)
+  expect(yieldToEventLoop).toHaveBeenCalledOnce()
+  editor.commands.setTextSelection(14)
+  delay.resume()
+  await flush()
+  expect(editor.state.doc.child(0).textContent === `hello ${payload}`).toBe(true)
+  expect(editor.state.doc.child(0).textContent.match(/PASTE_SENTINEL/g)?.length).toBe(5500)
+  expect(editor.state.doc.child(1).textContent).toBe('second paragraph')
+  expect(editor.state.selection.from).toBe(editor.state.doc.child(0).nodeSize + 1)
+  expect(toast.info).not.toHaveBeenCalled()
+  expect(toast.error).not.toHaveBeenCalled()
+  let markedPayload = false
+  editor.state.doc.descendants((node) => {
+    if (node.isText && node.text?.includes('PASTE')) {
+      markedPayload ||= node.marks.length > 0
+    }
+  })
+  expect(markedPayload).toBe(false)
+  editor.commands.insertContent('!')
+  expect(editor.state.doc.child(1).textContent).toBe('!second paragraph')
+})
+
+it('continues after its own chunk converts a document link while the live caret is elsewhere', async () => {
+  const editor = createProductionEditor('hello world\n\nother paragraph')
+  let firstYield = true
+  handleRichMarkdownLargeTextPaste(editor, pasteEvent('aaa[[y]]ZZZ'), {
+    directMaxBytes: 1,
+    chunkMaxBytes: 8,
+    measureYieldAfterCodeUnits: 1,
+    yieldToEventLoop: async () => {
+      if (firstYield) {
+        firstYield = false
+        editor.commands.setTextSelection(editor.state.doc.child(0).nodeSize + 1)
+      }
+    }
+  })
+  await flush(60)
+  expect(editor.getMarkdown()).toBe('hello aaa[[y]]ZZZ\n\nother paragraph')
+  expect(editor.view.dom.querySelector('[data-doc-link-target="y"]')).not.toBeNull()
+  expect(editor.state.selection.from).toBe(editor.state.doc.child(0).nodeSize + 1)
+  expect(toast.info).not.toHaveBeenCalled()
+  expect(toast.error).not.toHaveBeenCalled()
+  editor.state.doc.check()
+  editor.commands.insertContent('!')
+  expect(editor.getMarkdown()).toBe('hello aaa[[y]]ZZZ\n\n!other paragraph')
+})
+
+it.each(['first', 'second', 'interleaved'] as const)(
+  'preserves two pending paste requests, live caret and chronological Undo when %s completes first',
+  async (schedule) => {
+    vi.spyOn(Date, 'now').mockReturnValue(10000)
+    const editor = createProductionEditor()
+    editor.commands.setTextSelection(7)
+    const initialPlugins = editor.state.plugins.length
+    const first = pause()
+    const second = pause()
+    const middle = pause()
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent('AABB'), {
+      directMaxBytes: 1,
+      chunkMaxBytes: 2,
+      measureYieldAfterCodeUnits: 1,
+      yieldToEventLoop: vi
+        .fn()
+        .mockReturnValueOnce(first.promise)
+        .mockImplementation(() =>
+          schedule === 'interleaved' && paragraphs(editor)[0] === 'hello AAworld'
+            ? middle.promise
+            : Promise.resolve()
+        )
+    })
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent('CCDD'), {
+      directMaxBytes: 1,
+      chunkMaxBytes: 2,
+      measureYieldAfterCodeUnits: 1,
+      yieldToEventLoop: vi.fn().mockReturnValueOnce(second.promise).mockResolvedValue(undefined)
+    })
+    expect(paragraphs(editor)[0]).toBe('hello world')
+    if (schedule === 'second') {
+      second.resume()
+      await flush()
+      expect(paragraphs(editor)[0]).toBe('hello CCDDworld')
+    }
+    first.resume()
+    await flush()
+    if (schedule !== 'second') {
+      expect(paragraphs(editor)[0]).toBe(
+        schedule === 'interleaved' ? 'hello AAworld' : 'hello AABBworld'
+      )
+      second.resume()
+      await flush()
+    }
+    middle.resume()
+    await flush()
+    expect(paragraphs(editor)).toEqual(['hello AABBCCDDworld', 'second paragraph'])
+    expect(editor.state.selection.from).toBe(15)
+    expect(document.activeElement).toBe(editor.view.dom)
+    expect(editor.state.plugins.length).toBe(initialPlugins)
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
+    editor.state.doc.check()
+    const undoStates =
+      schedule === 'interleaved'
+        ? ['hello AACCDDworld', 'hello AAworld', 'hello world']
+        : [schedule === 'first' ? 'hello AABBworld' : 'hello CCDDworld', 'hello world']
+    for (const expected of undoStates) {
+      expect(editor.commands.undo()).toBe(true)
+      expect(paragraphs(editor)).toEqual([expected, 'second paragraph'])
+    }
+    expect(editor.commands.undo()).toBe(false)
+  }
+)
+
+it('groups native composition updates without a pending paste', () => {
+  vi.spyOn(Date, 'now').mockReturnValue(10000)
+  const editor = createProductionEditor()
+  const position = editor.state.doc.child(0).nodeSize + 1
+  editor.commands.setTextSelection(position)
+  editor.view.dispatch(editor.state.tr.insertText('n').setMeta('composition', 7))
+  editor.view.dispatch(
+    editor.state.tr.insertText('你', position, position + 1).setMeta('composition', 7)
+  )
+  expect(paragraphs(editor)[1]).toBe('你second paragraph')
+  expect(editor.commands.undo()).toBe(true)
+  expect(paragraphs(editor)[1]).toBe('second paragraph')
+})
+
+it.each(['typing', 'composition'] as const)(
+  'preserves native %s Undo grouping during a paused paste',
+  async (mode) => {
+    vi.spyOn(Date, 'now').mockReturnValue(10000)
+    const editor = createProductionEditor()
+    const delay = pause()
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), {
+      directMaxBytes: 1,
+      chunkMaxBytes: 2,
+      yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    })
+    await flush()
+    const position = editor.state.doc.child(0).nodeSize + 1
+    editor.commands.setTextSelection(position)
+    if (mode === 'typing') {
+      editor.view.dispatch(editor.state.tr.insertText('T'))
+      editor.view.dispatch(editor.state.tr.insertText('U'))
+    } else {
+      editor.view.dispatch(editor.state.tr.insertText('n').setMeta('composition', 7))
+      editor.view.dispatch(
+        editor.state.tr.insertText('你', position, position + 1).setMeta('composition', 7)
+      )
+    }
+    const finishedTyping = mode === 'typing' ? 'TUsecond paragraph' : '你second paragraph'
+    expect(paragraphs(editor)[1]).toBe(finishedTyping)
+    delay.resume()
+    await flush()
+    expect(paragraphs(editor)).toEqual(['hello ABCDE', finishedTyping])
+    expect(editor.commands.undo()).toBe(true)
+    expect(paragraphs(editor)).toEqual(['hello AB', finishedTyping])
+    expect(editor.commands.undo()).toBe(true)
+    expect(paragraphs(editor)).toEqual(['hello AB', 'second paragraph'])
+    expect(editor.commands.undo()).toBe(true)
+    expect(paragraphs(editor)).toEqual(['hello world', 'second paragraph'])
+  }
+)
+
+it.each(['disabled', 'disconnected'] as const)(
+  'isolates partial paste history after a %s editor becomes available again',
+  async (condition) => {
+    vi.spyOn(Date, 'now').mockReturnValue(10000)
+    const editor = createProductionEditor()
+    const initialPlugins = editor.state.plugins.length
+    const delay = pause()
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), {
+      directMaxBytes: 1,
+      chunkMaxBytes: 2,
+      yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    })
+    await flush()
+    expect(paragraphs(editor)[0]).toBe('hello AB')
+    if (condition === 'disabled') {
+      editor.setEditable(false)
+    } else {
+      editor.view.dom.remove()
+    }
+    delay.resume()
+    await flush()
+    expect(editor.state.plugins.length).toBe(initialPlugins)
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith('Large paste stopped before it finished.')
+    expect(toast.error).not.toHaveBeenCalled()
+    if (condition === 'disabled') {
+      editor.setEditable(true)
+    } else {
+      document.body.append(editor.view.dom)
+    }
+    editor.view.dom.focus()
+    editor.commands.insertContent('T')
+    expect(paragraphs(editor)[0]).toBe('hello ABT')
+    expect(editor.commands.undo()).toBe(true)
+    expect(paragraphs(editor)[0]).toBe('hello AB')
+    expect(editor.commands.undo()).toBe(true)
+    expect(paragraphs(editor)[0]).toBe('hello world')
+  }
+)
+
+it('ignores a filtered foreign edit when separating a later accepted edit from paste history', async () => {
+  vi.spyOn(Date, 'now').mockReturnValue(10000)
+  const editor = createProductionEditor()
+  const delay = pause()
+  handleRichMarkdownLargeTextPaste(editor, pasteEvent(), {
+    directMaxBytes: 1,
+    chunkMaxBytes: 2,
+    yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+  })
+  await flush()
+  editor.registerPlugin(new Plugin({ filterTransaction: (tr) => !tr.getMeta('rejectForeign') }))
+  const position = editor.state.doc.child(0).nodeSize + 1
+  editor.commands.setTextSelection(position)
+  editor.view.dispatch(editor.state.tr.insertText('rejected').setMeta('rejectForeign', true))
+  expect(paragraphs(editor)[1]).toBe('second paragraph')
+  editor.view.dispatch(editor.state.tr.insertText('T'))
+  delay.resume()
+  await flush()
+  expect(paragraphs(editor)).toEqual(['hello ABCDE', 'Tsecond paragraph'])
+  expect(editor.commands.undo()).toBe(true)
+  expect(paragraphs(editor)).toEqual(['hello AB', 'Tsecond paragraph'])
+  expect(editor.commands.undo()).toBe(true)
+  expect(paragraphs(editor)).toEqual(['hello AB', 'second paragraph'])
+  expect(editor.commands.undo()).toBe(true)
+  expect(paragraphs(editor)).toEqual(['hello world', 'second paragraph'])
+})
+
+it.each(['typing', 'composition'] as const)(
+  'keeps a cancelling target edit and subsequent native %s grouped after cleanup',
+  async (mode) => {
+    vi.spyOn(Date, 'now').mockReturnValue(10000)
+    const editor = createProductionEditor()
+    const initialPlugins = editor.state.plugins.length
+    const delay = pause()
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), {
+      directMaxBytes: 1,
+      chunkMaxBytes: 2,
+      yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    })
+    await flush()
+    expect(paragraphs(editor)[0]).toBe('hello AB')
+    const edit = editor.state.tr.insertText(mode === 'typing' ? 'T' : 'n', 8, 9)
+    editor.view.dispatch(mode === 'composition' ? edit.setMeta('composition', 7) : edit)
+    delay.resume()
+    await flush()
+    expect(editor.state.plugins.length).toBe(initialPlugins)
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith('Large paste stopped before it finished.')
+    expect(toast.error).not.toHaveBeenCalled()
+    if (mode === 'typing') {
+      editor.view.dispatch(editor.state.tr.insertText('U'))
+    } else {
+      editor.view.dispatch(editor.state.tr.insertText('你', 8, 9).setMeta('composition', 7))
+    }
+    expect(paragraphs(editor)[0]).toBe(mode === 'typing' ? 'hello ATU' : 'hello A你')
+    expect(editor.commands.undo()).toBe(true)
+    expect(paragraphs(editor)[0]).toBe('hello AB')
+    expect(editor.commands.undo()).toBe(true)
+    expect(paragraphs(editor)[0]).toBe('hello world')
+  }
+)
+
+it('rejects the actual 16 MiB limit plus one emoji without changing the document or retaining plugins', async () => {
+  const editor = createProductionEditor()
+  const initial = editor.state.doc
+  const initialPlugins = editor.state.plugins.length
+  const payload = '😀'.repeat(4 * 1024 * 1024 + 1)
+  expect(
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(payload), {
+      yieldToEventLoop: async () => {}
+    })
+  ).toBe(true)
+  await flush(1000)
+  expect(toast.error).toHaveBeenCalledExactlyOnceWith('Paste is too large.')
+  expect(toast.info).not.toHaveBeenCalled()
+  expect(editor.state.doc.eq(initial)).toBe(true)
+  expect(editor.state.plugins.length).toBe(initialPlugins)
+  editor.state.doc.check()
+})
+
+it.each(['earlier image', 'later image', 'ordinary typing'] as const)(
+  'orders a pending text paste against %s without changing the live caret',
+  async (counterpart) => {
+    const editor = createProductionEditor()
+    editor.commands.setTextSelection(7)
+    const earlierOrder =
+      counterpart === 'earlier image' ? captureRichMarkdownClipboardInsertionOrder(editor) : null
+    const delay = pause()
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent('ABCD'), {
+      directMaxBytes: 1,
+      chunkMaxBytes: 2,
+      measureYieldAfterCodeUnits: 1,
+      yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    })
+    if (counterpart === 'ordinary typing') {
+      editor.commands.insertContent('typed ')
+    } else {
+      const order = earlierOrder ?? captureRichMarkdownClipboardInsertionOrder(editor)
+      editor.view.dispatch(
+        editor.state.tr
+          .insert(7, editor.schema.nodes.image.create({ src: 'counterpart.png' }))
+          .setMeta(richMarkdownClipboardInsertionOrderKey, order)
+      )
+    }
+    const caret = editor.state.selection.from
+    delay.resume()
+    await flush()
+    const expected =
+      counterpart === 'earlier image'
+        ? 'hello ![](counterpart.png)ABCDworld'
+        : counterpart === 'later image'
+          ? 'hello ABCD![](counterpart.png)world'
+          : 'hello ABCDtyped world'
+    expect(editor.getMarkdown()).toBe(`${expected}\n\nsecond paragraph`)
+    expect(editor.state.selection.from).toBe(caret + 4)
+    expect(document.activeElement).toBe(editor.view.dom)
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
+    editor.state.doc.check()
+  }
+)
diff --git a/src/renderer/src/components/editor/rich-markdown-large-text-paste.selection.test.ts b/src/renderer/src/components/editor/rich-markdown-large-text-paste.selection.test.ts
new file mode 100644
index 00000000000..e871e7e02ed
--- /dev/null
+++ b/src/renderer/src/components/editor/rich-markdown-large-text-paste.selection.test.ts
@@ -0,0 +1,596 @@
+// @vitest-environment happy-dom
+import { Editor, Extension } from '@tiptap/react'
+import StarterKit from '@tiptap/starter-kit'
+import { TableKit } from '@tiptap/extension-table'
+import { CellSelection } from '@tiptap/pm/tables'
+import { AllSelection, Plugin, TextSelection } from '@tiptap/pm/state'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { toast } from 'sonner'
+import { handleRichMarkdownLargeTextPaste } from './rich-markdown-large-text-paste'
+import { setRichMarkdownImageResolverContext } from './rich-markdown-image-context'
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), info: vi.fn() } }))
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+
+const editors: Editor[] = []
+const largeText = 'X'.repeat(70 * 1024)
+
+function createEditor(
+  content = '<p>hello world</p><p>second paragraph</p>',
+  extensions: Extension[] = []
+) {
+  const editor = new Editor({ extensions: [StarterKit, TableKit, ...extensions], content })
+  document.body.append(editor.view.dom)
+  editor.view.dom.focus()
+  if (editor.state.doc.firstChild?.isTextblock) {
+    editor.commands.setTextSelection({ from: 7, to: 12 })
+  }
+  editors.push(editor)
+  return editor
+}
+
+function pasteEvent(text = largeText): ClipboardEvent {
+  const clipboardData = new DataTransfer()
+  clipboardData.setData('text/plain', text)
+  return new ClipboardEvent('paste', { clipboardData, cancelable: true })
+}
+
+function pause() {
+  let resume: () => void = () => {}
+  const promise = new Promise<void>((resolve) => {
+    resume = resolve
+  })
+  return { promise, resume: () => resume() }
+}
+
+async function flush() {
+  for (let index = 0; index < 40; index += 1) {
+    await Promise.resolve()
+  }
+}
+
+function textPosition(editor: Editor, text: string): number {
+  let position: number | undefined
+  editor.state.doc.descendants((node, pos) => {
+    if (node.isText && node.text === text) {
+      position = pos
+    }
+  })
+  if (position === undefined) {
+    throw new Error(`Missing text ${text}`)
+  }
+  return position
+}
+
+afterEach(() => {
+  editors.splice(0).forEach((editor) => editor.destroy())
+  document.body.replaceChildren()
+  vi.restoreAllMocks()
+  vi.clearAllMocks()
+})
+
+describe('large Markdown paste selection during yields', () => {
+  it('replaces the original selection while preserving a caret moved during production-size measurement', async () => {
+    const editor = createEditor()
+    const delay = pause()
+    const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    expect(handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })).toBe(true)
+    expect(yieldToEventLoop).toHaveBeenCalledOnce()
+    editor.commands.setTextSelection(14)
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.child(0).textContent === `hello ${largeText}`).toBe(true)
+    expect(editor.state.doc.child(1).textContent).toBe('second paragraph')
+    expect(editor.state.selection.from).toBe(editor.state.doc.child(0).nodeSize + 1)
+    expect(document.activeElement).toBe(editor.view.dom)
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
+  })
+
+  it('keeps every remaining production-size chunk at its insertion end after the caret moves', async () => {
+    const editor = createEditor()
+    const delay = pause()
+    const yieldToEventLoop = vi
+      .fn()
+      .mockResolvedValueOnce(undefined)
+      .mockReturnValueOnce(delay.promise)
+      .mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+    await flush()
+    expect(editor.state.doc.child(0).textContent.length).toBe(6 + 16 * 1024)
+    editor.commands.setTextSelection(editor.state.doc.child(0).nodeSize + 1)
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.child(0).textContent === `hello ${largeText}`).toBe(true)
+    expect(editor.state.doc.child(1).textContent).toBe('second paragraph')
+    expect(editor.state.selection.from).toBe(editor.state.doc.child(0).nodeSize + 1)
+  })
+
+  it('maps the original selection through an earlier edit and its appended transaction', async () => {
+    const appendPrefix = Extension.create({
+      name: 'pasteAppendPrefix',
+      addProseMirrorPlugins: () => [
+        new Plugin({
+          appendTransaction(transactions, _old, state) {
+            return transactions.some((tr) => tr.getMeta('appendPastePrefix'))
+              ? state.tr.insertText('next ', 1)
+              : null
+          }
+        })
+      ]
+    })
+    const editor = createEditor(undefined, [appendPrefix])
+    const delay = pause()
+    const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+    editor.view.dispatch(editor.state.tr.insertText('first ', 1).setMeta('appendPastePrefix', true))
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.child(0).textContent === `next first hello ${largeText}`).toBe(true)
+    expect(editor.state.doc.child(1).textContent).toBe('second paragraph')
+  })
+
+  it.each(['replace', 'delete', 'insert'] as const)(
+    'cancels when %s changes the pending selected text',
+    async (operation) => {
+      const editor = createEditor()
+      const delay = pause()
+      const yieldToEventLoop = vi
+        .fn()
+        .mockReturnValueOnce(delay.promise)
+        .mockResolvedValue(undefined)
+      const off = vi.spyOn(editor, 'off')
+      handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+      const tr = editor.state.tr
+      if (operation === 'replace') {
+        tr.insertText('changed', 7, 12)
+      }
+      if (operation === 'delete') {
+        tr.delete(7, 12)
+      }
+      if (operation === 'insert') {
+        tr.insertText('typed', 9)
+      }
+      editor.view.dispatch(tr)
+      const changed = editor.getJSON()
+      delay.resume()
+      await flush()
+      expect(editor.getJSON()).toEqual(changed)
+      expect(off.mock.calls.map(([event]) => event)).toContain('transaction')
+      expect(off.mock.calls.map(([event]) => event)).toContain('destroy')
+      expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+        'Large paste cancelled because its original target changed.'
+      )
+      expect(toast.error).not.toHaveBeenCalled()
+    }
+  )
+
+  it.each(['file', 'host'] as const)(
+    'cancels when the original %s context changes',
+    async (change) => {
+      const editor = createEditor()
+      const context = { filePath: '/repo/note.md' }
+      setRichMarkdownImageResolverContext(editor, context)
+      const delay = pause()
+      const yieldToEventLoop = vi
+        .fn()
+        .mockReturnValueOnce(delay.promise)
+        .mockResolvedValue(undefined)
+      handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+      setRichMarkdownImageResolverContext(
+        editor,
+        change === 'file'
+          ? { filePath: '/repo/other.md' }
+          : {
+              ...context,
+              runtimeContext: {
+                connectionId: 'another-target',
+                settings: null,
+                worktreeId: 'workspace',
+                worktreePath: '/repo'
+              }
+            }
+      )
+      delay.resume()
+      await flush()
+      expect(editor.state.doc.child(0).textContent).toBe('hello world')
+      expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+        'Large paste cancelled because its original target changed.'
+      )
+      expect(toast.error).not.toHaveBeenCalled()
+    }
+  )
+
+  it('uses native multi-cell replacement before continuing in the first inserted cell', async () => {
+    const content =
+      '<table><tbody><tr><td>first</td><td>second</td></tr><tr><td>third</td><td>fourth</td></tr></tbody></table><p>outside</p>'
+    const editor = createEditor(content)
+    const cellPositions: number[] = []
+    editor.state.doc.descendants((node, position) => {
+      if (node.type.spec.tableRole === 'cell') {
+        cellPositions.push(position)
+      }
+    })
+    editor.view.dispatch(
+      editor.state.tr.setSelection(
+        CellSelection.create(editor.state.doc, cellPositions[0]!, cellPositions[3]!)
+      )
+    )
+    const original = editor.state.doc
+    const native = editor.state.tr.insertText(largeText).doc
+    const delay = pause()
+    const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+    const outside = textPosition(editor, 'outside')
+    editor.commands.setTextSelection(outside + 2)
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.eq(native)).toBe(true)
+    expect(editor.state.doc.child(0).childCount).toBe(original.child(0).childCount)
+    expect(editor.state.selection.from).toBe(textPosition(editor, 'outside') + 2)
+  })
+
+  it('releases successful paste listeners and undoes all chunks together', async () => {
+    const editor = createEditor()
+    const original = editor.getJSON()
+    const off = vi.spyOn(editor, 'off')
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop: async () => {} })
+    await flush()
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.getJSON()).toEqual(original)
+    expect(off.mock.calls.map(([event]) => event)).toContain('transaction')
+    expect(off.mock.calls.map(([event]) => event)).toContain('destroy')
+  })
+  it('keeps the pending paste before ordinary typing at its original collapsed caret', async () => {
+    const editor = createEditor()
+    editor.commands.setTextSelection(7)
+    const delay = pause()
+    const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+    editor.commands.insertContent('typed ')
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.child(0).textContent === `hello ${largeText}typed world`).toBe(true)
+    expect(editor.state.selection.from).toBe(7 + largeText.length + 'typed '.length)
+  })
+
+  it('excludes later typing at both ends of a reversed pending selection', async () => {
+    const editor = createEditor()
+    editor.commands.setTextSelection({ from: 12, to: 7 })
+    const delay = pause()
+    const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+    editor.view.dispatch(editor.state.tr.insertText('start ', 7))
+    editor.view.dispatch(editor.state.tr.insertText(' end', 18))
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.child(0).textContent === `hello start ${largeText} end`).toBe(true)
+  })
+
+  it('cancels when a new table row would expand the captured cell rectangle', async () => {
+    const editor = createEditor(
+      '<table><tbody><tr><td>first</td><td>second</td></tr><tr><td>third</td><td>fourth</td></tr></tbody></table>'
+    )
+    const positions: number[] = []
+    editor.state.doc.descendants((node, pos) => {
+      if (node.type.spec.tableRole === 'cell') {
+        positions.push(pos)
+      }
+    })
+    editor.view.dispatch(
+      editor.state.tr.setSelection(
+        CellSelection.create(editor.state.doc, positions[0]!, positions[3]!)
+      )
+    )
+    const delay = pause()
+    const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+    const row = editor.schema.nodeFromJSON({
+      type: 'tableRow',
+      content: [
+        { type: 'tableCell', content: [{ type: 'paragraph' }] },
+        { type: 'tableCell', content: [{ type: 'paragraph' }] }
+      ]
+    })
+    editor.view.dispatch(
+      editor.state.tr.insert(1 + editor.state.doc.child(0).child(0).nodeSize, row)
+    )
+    const changed = editor.state.doc
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.eq(changed)).toBe(true)
+  })
+
+  it('groups slow chunks as one undo step, separate from earlier and later typing', async () => {
+    const editor = createEditor()
+    const initial = editor.state.doc
+    editor.commands.insertContent('before')
+    const beforePaste = editor.state.doc
+    let now = Date.now()
+    vi.spyOn(Date, 'now').mockImplementation(() => now)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), {
+      yieldToEventLoop: async () => {
+        now += 1000
+      }
+    })
+    await flush()
+    const pasted = editor.state.doc
+    editor.commands.insertContent('after')
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.state.doc.eq(pasted)).toBe(true)
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.state.doc.eq(beforePaste)).toBe(true)
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.state.doc.eq(initial)).toBe(true)
+  })
+
+  it('cancels remaining chunks when the user undoes the first chunk', async () => {
+    const editor = createEditor()
+    const initial = editor.state.doc
+    const delay = pause()
+    const yieldToEventLoop = vi
+      .fn()
+      .mockResolvedValueOnce(undefined)
+      .mockReturnValueOnce(delay.promise)
+      .mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop })
+    await flush()
+    expect(editor.commands.undo()).toBe(true)
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.eq(initial)).toBe(true)
+  })
+
+  it('stops and releases listeners when the first paste transaction is filtered', async () => {
+    const rejectPaste = Extension.create({
+      name: 'rejectLargePaste',
+      addProseMirrorPlugins: () => [new Plugin({ filterTransaction: (tr) => !tr.docChanged })]
+    })
+    const editor = createEditor(undefined, [rejectPaste])
+    const initial = editor.state.doc
+    const off = vi.spyOn(editor, 'off')
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop: async () => {} })
+    await flush()
+    expect(editor.state.doc.eq(initial)).toBe(true)
+    expect(off.mock.calls.map(([event]) => event)).toEqual(['transaction', 'destroy'])
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+      'Large paste cancelled because its original target changed.'
+    )
+    expect(toast.error).not.toHaveBeenCalled()
+  })
+
+  it.each(['disabled', 'disconnected', 'destroyed'] as const)(
+    'cancels and releases listeners when the target is %s during measurement',
+    async (condition) => {
+      const editor = createEditor()
+      const initial = editor.state.doc
+      const delay = pause()
+      const off = vi.spyOn(editor, 'off')
+      handleRichMarkdownLargeTextPaste(editor, pasteEvent(), {
+        yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+      })
+      if (condition === 'disabled') {
+        editor.setEditable(false)
+      }
+      if (condition === 'disconnected') {
+        editor.view.dom.remove()
+      }
+      if (condition === 'destroyed') {
+        editor.destroy()
+      }
+      delay.resume()
+      await flush()
+      if (!editor.isDestroyed) {
+        expect(editor.state.doc.eq(initial)).toBe(true)
+      }
+      expect(off.mock.calls.map(([event]) => event)).toContain('transaction')
+      expect(off.mock.calls.map(([event]) => event)).toContain('destroy')
+      expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+        'Large paste cancelled because its original target changed.'
+      )
+      expect(toast.error).not.toHaveBeenCalled()
+    }
+  )
+  it('preserves marks armed at the original collapsed paste caret', async () => {
+    const editor = createEditor()
+    editor.commands.setTextSelection(7)
+    editor.commands.toggleBold()
+    expect(editor.state.storedMarks?.some((mark) => mark.type.name === 'bold')).toBe(true)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), { yieldToEventLoop: async () => {} })
+    await flush()
+    let pastedMarks: string[] = []
+    editor.state.doc.descendants((node) => {
+      if (node.isText && node.text?.includes('X')) {
+        pastedMarks = node.marks.map((mark) => mark.type.name)
+      }
+    })
+    expect(pastedMarks).toEqual(['bold'])
+  })
+
+  it('preserves armed marks at a moved live caret while writing the captured range', async () => {
+    const editor = createEditor()
+    const delay = pause()
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), {
+      yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    })
+    editor.commands.setTextSelection(14)
+    editor.commands.toggleItalic()
+    delay.resume()
+    await flush()
+    expect(editor.state.storedMarks?.some((mark) => mark.type.name === 'italic')).toBe(true)
+    expect(editor.state.selection.from).toBe(editor.state.doc.child(0).nodeSize + 1)
+  })
+  it.each(['adjacent', 'other paragraph'] as const)(
+    'keeps typing at %s separate between chronological paste segments',
+    async (position) => {
+      const editor = createEditor()
+      const initial = editor.state.doc
+      const delay = pause()
+      const yieldToEventLoop = vi
+        .fn()
+        .mockReturnValueOnce(delay.promise)
+        .mockResolvedValue(undefined)
+      handleRichMarkdownLargeTextPaste(editor, pasteEvent('ABCDE'), {
+        directMaxBytes: 1,
+        chunkMaxBytes: 2,
+        yieldToEventLoop
+      })
+      await flush()
+      expect(editor.state.doc.child(0).textContent).toBe('hello AB')
+      if (position === 'other paragraph') {
+        editor.commands.setTextSelection(editor.state.doc.child(0).nodeSize + 1)
+      }
+      editor.commands.insertContent('T')
+      const typed = editor.state.doc
+      delay.resume()
+      await flush()
+      expect(editor.state.doc.child(0).textContent).toBe(
+        position === 'adjacent' ? 'hello ABCDET' : 'hello ABCDE'
+      )
+      expect(editor.state.doc.child(1).textContent).toBe(
+        position === 'adjacent' ? 'second paragraph' : 'Tsecond paragraph'
+      )
+      expect(editor.commands.undo()).toBe(true)
+      expect(editor.state.doc.eq(typed)).toBe(true)
+      expect(editor.commands.undo()).toBe(true)
+      expect(editor.state.doc.child(0).textContent).toBe('hello AB')
+      expect(editor.state.doc.child(1).textContent).toBe('second paragraph')
+      expect(editor.commands.undo()).toBe(true)
+      expect(editor.state.doc.eq(initial)).toBe(true)
+    }
+  )
+
+  it('closes partial paste history after focus cancellation without reclaiming focus', async () => {
+    const editor = createEditor()
+    const initialPlugins = editor.state.plugins
+    const delay = pause()
+    const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent('ABCDE'), {
+      directMaxBytes: 1,
+      chunkMaxBytes: 2,
+      yieldToEventLoop
+    })
+    await flush()
+    expect(editor.state.doc.child(0).textContent).toBe('hello AB')
+    const input = document.createElement('input')
+    document.body.append(input)
+    input.focus()
+    delay.resume()
+    await flush()
+    expect(document.activeElement).toBe(input)
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith('Large paste stopped before it finished.')
+    expect(toast.error).not.toHaveBeenCalled()
+    expect(editor.state.plugins).toEqual(initialPlugins)
+    editor.view.dom.focus()
+    editor.commands.insertContent('T')
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.state.doc.child(0).textContent).toBe('hello AB')
+  })
+
+  it('cancels a full-document selection when a new paragraph appears outside its original range', async () => {
+    const editor = createEditor()
+    editor.view.dispatch(editor.state.tr.setSelection(new AllSelection(editor.state.doc)))
+    const initialPlugins = editor.state.plugins
+    const delay = pause()
+    const yieldToEventLoop = vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent('ABCDE'), {
+      directMaxBytes: 1,
+      measureYieldAfterCodeUnits: 1,
+      yieldToEventLoop
+    })
+    const paragraph = editor.schema.nodeFromJSON({
+      type: 'paragraph',
+      content: [{ type: 'text', text: 'new outside' }]
+    })
+    editor.view.dispatch(editor.state.tr.insert(0, paragraph))
+    const changed = editor.state.doc
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.eq(changed)).toBe(true)
+    expect(editor.state.plugins).toEqual(initialPlugins)
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+      'Large paste cancelled because its original target changed.'
+    )
+    expect(toast.error).not.toHaveBeenCalled()
+  })
+
+  it('keeps an appended-only external edit separate from both paste segments in undo', async () => {
+    const appendTyping = Extension.create({
+      name: 'appendExternalTyping',
+      addProseMirrorPlugins: () => [
+        new Plugin({
+          appendTransaction(transactions, _old, state) {
+            return transactions.some((tr) => tr.getMeta('appendExternalTyping'))
+              ? state.tr.insertText('T')
+              : null
+          }
+        })
+      ]
+    })
+    const editor = createEditor(undefined, [appendTyping])
+    const initial = editor.state.doc
+    const delay = pause()
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent('ABCDE'), {
+      directMaxBytes: 1,
+      chunkMaxBytes: 2,
+      yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    })
+    await flush()
+    expect(editor.state.doc.child(0).textContent).toBe('hello AB')
+    editor.view.dispatch(
+      editor.state.tr
+        .setSelection(
+          TextSelection.create(editor.state.doc, editor.state.doc.child(0).nodeSize + 1)
+        )
+        .setMeta('appendExternalTyping', true)
+    )
+    const typed = editor.state.doc
+    expect(typed.child(1).textContent).toBe('Tsecond paragraph')
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.child(0).textContent).toBe('hello ABCDE')
+    expect(editor.state.doc.child(1).textContent).toBe('Tsecond paragraph')
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.state.doc.eq(typed)).toBe(true)
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.state.doc.child(0).textContent).toBe('hello AB')
+    expect(editor.state.doc.child(1).textContent).toBe('second paragraph')
+    expect(editor.commands.undo()).toBe(true)
+    expect(editor.state.doc.eq(initial)).toBe(true)
+    expect(toast.info).not.toHaveBeenCalled()
+  })
+
+  it('cancels when an external appended edit replaces the pending selected text', async () => {
+    const appendTargetEdit = Extension.create({
+      name: 'appendTargetEdit',
+      addProseMirrorPlugins: () => [
+        new Plugin({
+          appendTransaction(transactions, _old, state) {
+            return transactions.some((tr) => tr.getMeta('appendTargetEdit'))
+              ? state.tr.insertText('changed', 7, 12)
+              : null
+          }
+        })
+      ]
+    })
+    const editor = createEditor(undefined, [appendTargetEdit])
+    const delay = pause()
+    handleRichMarkdownLargeTextPaste(editor, pasteEvent(), {
+      yieldToEventLoop: vi.fn().mockReturnValueOnce(delay.promise).mockResolvedValue(undefined)
+    })
+    editor.view.dispatch(
+      editor.state.tr
+        .setSelection(TextSelection.create(editor.state.doc, 14))
+        .setMeta('appendTargetEdit', true)
+    )
+    const changed = editor.state.doc
+    expect(changed.child(0).textContent).toBe('hello changed')
+    delay.resume()
+    await flush()
+    expect(editor.state.doc.eq(changed)).toBe(true)
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+      'Large paste cancelled because its original target changed.'
+    )
+    expect(document.activeElement).toBe(editor.view.dom)
+  })
+})
diff --git a/src/renderer/src/components/editor/rich-markdown-large-text-paste.test.ts b/src/renderer/src/components/editor/rich-markdown-large-text-paste.test.ts
index 23b3106150b..bf904cc1eed 100644
--- a/src/renderer/src/components/editor/rich-markdown-large-text-paste.test.ts
+++ b/src/renderer/src/components/editor/rich-markdown-large-text-paste.test.ts
@@ -1,31 +1,26 @@
 // @vitest-environment happy-dom
 
-import type { Editor } from '@tiptap/react'
+import { Editor } from '@tiptap/react'
+import StarterKit from '@tiptap/starter-kit'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { toast } from 'sonner'
 import { handleRichMarkdownLargeTextPaste } from './rich-markdown-large-text-paste'
 
 vi.mock('sonner', () => ({
-  toast: { error: vi.fn() }
+  toast: { error: vi.fn(), info: vi.fn() }
 }))
 
 vi.mock('@/i18n/i18n', () => ({
   translate: (_key: string, fallback: string) => fallback
 }))
 
-type InsertTransaction = { text: string }
+const editors: Editor[] = []
 
 function makePasteEvent(text: string, html = ''): ClipboardEvent {
-  const event = new Event('paste', {
-    bubbles: true,
-    cancelable: true
-  }) as ClipboardEvent
-  Object.defineProperty(event, 'clipboardData', {
-    value: {
-      getData: (type: string) => (type === 'text/plain' ? text : type === 'text/html' ? html : '')
-    }
-  })
-  return event
+  const clipboardData = new DataTransfer()
+  clipboardData.setData('text/plain', text)
+  clipboardData.setData('text/html', html)
+  return new ClipboardEvent('paste', { clipboardData, bubbles: true, cancelable: true })
 }
 
 function makeEditor(): {
@@ -34,39 +29,32 @@ function makeEditor(): {
   setDestroyed: (destroyed: boolean) => void
   setFocused: (focused: boolean) => void
 } {
-  const dom = document.createElement('div')
-  document.body.appendChild(dom)
+  const editor = new Editor({ extensions: [StarterKit], content: '<p></p>' })
+  document.body.append(editor.view.dom)
+  editor.view.dom.focus()
+  editors.push(editor)
   const chunks: string[] = []
-  let destroyed = false
-  let focused = true
-  const editor = {
-    get isDestroyed() {
-      return destroyed
-    },
-    get state() {
-      return {
-        tr: {
-          insertText: (text: string): InsertTransaction => ({ text })
-        }
-      }
-    },
-    view: {
-      dom,
-      hasFocus: () => focused,
-      dispatch: (transaction: InsertTransaction): void => {
-        chunks.push(transaction.text)
-      }
+  editor.on('transaction', ({ transaction }) => {
+    if (transaction.docChanged) {
+      chunks.push(transaction.doc.textContent.slice(transaction.before.textContent.length))
     }
-  } as unknown as Editor
-
+  })
   return {
     chunks,
     editor,
-    setDestroyed: (next) => {
-      destroyed = next
+    setDestroyed: (destroyed) => {
+      if (destroyed) {
+        editor.destroy()
+      }
     },
-    setFocused: (next) => {
-      focused = next
+    setFocused: (focused) => {
+      if (focused) {
+        editor.view.dom.focus()
+      } else {
+        const input = document.createElement('input')
+        document.body.append(input)
+        input.focus()
+      }
     }
   }
 }
@@ -78,7 +66,9 @@ async function flushPromises(count = 12): Promise<void> {
 }
 
 afterEach(() => {
+  editors.splice(0).forEach((editor) => editor.destroy())
   document.body.replaceChildren()
+  vi.restoreAllMocks()
   vi.clearAllMocks()
 })
 
@@ -96,6 +86,8 @@ describe('rich markdown large text paste', () => {
     expect(handleRichMarkdownLargeTextPaste(editor, handled, { directMaxBytes: 8 })).toBe(false)
     expect(small.defaultPrevented).toBe(false)
     expect(chunks).toEqual([])
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
   })
 
   it('inserts large plain text through chunked ProseMirror transactions', async () => {
@@ -118,6 +110,8 @@ describe('rich markdown large text paste', () => {
     expect(chunks.join('')).toBe(text)
     expect(chunks.some((chunk) => /[\uD800-\uDBFF]$/.test(chunk))).toBe(false)
     expect(yieldToEventLoop).toHaveBeenCalledTimes(chunks.length - 1)
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
   })
 
   it('claims large plain-text paste before yielded preflight inserts editor content', async () => {
@@ -145,6 +139,8 @@ describe('rich markdown large text paste', () => {
 
     expect(chunks.join('')).toBe(text)
     expect(yieldToEventLoop).toHaveBeenCalled()
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
   })
 
   it('falls back to plain text when rich HTML is too large for synchronous parsing', async () => {
@@ -167,6 +163,8 @@ describe('rich markdown large text paste', () => {
     expect(chunks.join('')).toBe(text)
     expect(chunks.join('')).not.toContain('hidden-token')
     expect(yieldToEventLoop).toHaveBeenCalledTimes(chunks.length - 1)
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
   })
 
   it('uses byte length, not string length, when deciding whether rich HTML is large', async () => {
@@ -186,6 +184,8 @@ describe('rich markdown large text paste', () => {
     expect(event.defaultPrevented).toBe(true)
     expect(chunks.join('')).toBe('fallback')
     expect(yieldToEventLoop).toHaveBeenCalledTimes(1)
+    expect(toast.info).not.toHaveBeenCalled()
+    expect(toast.error).not.toHaveBeenCalled()
   })
 
   it('rejects large rich HTML without a plain-text fallback before editor parsing', () => {
@@ -202,9 +202,8 @@ describe('rich markdown large text paste', () => {
     expect(event.defaultPrevented).toBe(true)
     expect(chunks).toEqual([])
     expect(toast.error).toHaveBeenCalledWith('Paste is too large.')
-    expect(
-      JSON.stringify((toast.error as unknown as { mock: { calls: unknown[] } }).mock.calls)
-    ).not.toContain('hidden-token')
+    expect(JSON.stringify(vi.mocked(toast.error).mock.calls)).not.toContain('hidden-token')
+    expect(toast.info).not.toHaveBeenCalled()
   })
 
   it('rejects oversized rich-editor paste without logging or inserting content', async () => {
@@ -224,9 +223,8 @@ describe('rich markdown large text paste', () => {
     expect(event.defaultPrevented).toBe(true)
     expect(chunks).toEqual([])
     expect(toast.error).toHaveBeenCalledWith('Paste is too large.')
-    expect(
-      JSON.stringify((toast.error as unknown as { mock: { calls: unknown[] } }).mock.calls)
-    ).not.toContain(secret)
+    expect(JSON.stringify(vi.mocked(toast.error).mock.calls)).not.toContain(secret)
+    expect(toast.info).not.toHaveBeenCalled()
   })
 
   it('rejects oversized multibyte rich-editor paste before inserting content', async () => {
@@ -245,6 +243,7 @@ describe('rich markdown large text paste', () => {
     expect(event.defaultPrevented).toBe(true)
     expect(chunks).toEqual([])
     expect(toast.error).toHaveBeenCalledWith('Paste is too large.')
+    expect(toast.info).not.toHaveBeenCalled()
   })
 
   it('stops chunking when the editor is destroyed between chunks', async () => {
@@ -263,6 +262,8 @@ describe('rich markdown large text paste', () => {
 
     expect(event.defaultPrevented).toBe(true)
     expect(chunks).toEqual(['abcdef'])
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith('Large paste stopped before it finished.')
+    expect(toast.error).not.toHaveBeenCalled()
   })
 
   it('stops chunking when focus leaves the original editor target', async () => {
@@ -281,5 +282,8 @@ describe('rich markdown large text paste', () => {
 
     expect(event.defaultPrevented).toBe(true)
     expect(chunks).toEqual(['abcdef'])
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith('Large paste stopped before it finished.')
+    expect(toast.error).not.toHaveBeenCalled()
+    expect(document.activeElement).not.toBe(editor.view.dom)
   })
 })
diff --git a/src/renderer/src/components/editor/rich-markdown-large-text-paste.ts b/src/renderer/src/components/editor/rich-markdown-large-text-paste.ts
index 815e4a27ed0..1e09a0612c4 100644
--- a/src/renderer/src/components/editor/rich-markdown-large-text-paste.ts
+++ b/src/renderer/src/components/editor/rich-markdown-large-text-paste.ts
@@ -1,4 +1,6 @@
 import type { Editor } from '@tiptap/react'
+import { TextSelection, type SelectionBookmark, type Transaction } from '@tiptap/pm/state'
+import { closeHistory } from '@tiptap/pm/history'
 import { toast } from 'sonner'
 import { yieldToEventLoop } from '../../../../shared/event-loop-yield'
 import {
@@ -10,6 +12,12 @@ import {
   measureTextControlPasteByteLengthWithYield
 } from '@/lib/text-control-paste'
 import { translate } from '@/i18n/i18n'
+import { getRichMarkdownImageResolverContextVersion } from './rich-markdown-image-context'
+import { trackRichMarkdownLargePasteHistory } from './rich-markdown-large-paste-history'
+import {
+  captureRichMarkdownClipboardInsertionOrder,
+  richMarkdownClipboardInsertionOrderKey
+} from './rich-markdown-clipboard-insertion-order'
 
 export const RICH_MARKDOWN_PASTE_DIRECT_MAX_BYTES = 64 * 1024
 export const RICH_MARKDOWN_PASTE_CHUNK_MAX_BYTES = 16 * 1024
@@ -41,87 +49,198 @@ function isEditorAvailable(
   editor: Editor,
   canContinue: RichMarkdownLargeTextPasteOptions['canContinue']
 ): boolean {
-  return !editor.isDestroyed && editor.view.dom.isConnected && (canContinue?.(editor) ?? true)
+  return (
+    !editor.isDestroyed &&
+    editor.isEditable &&
+    editor.view.dom.isConnected &&
+    (canContinue?.(editor) ?? true)
+  )
 }
 
 function isEditorPasteTargetCurrent(editor: Editor, targetDom: HTMLElement): boolean {
   return (
-    !editor.isDestroyed &&
-    editor.view.dom === targetDom &&
-    targetDom.isConnected &&
-    editor.view.hasFocus()
+    isEditorAvailable(editor, undefined) && editor.view.dom === targetDom && editor.view.hasFocus()
   )
 }
 
-function readPlainText(event: ClipboardEvent): string {
-  return event.clipboardData?.getData('text/plain') ?? ''
-}
-
-function readHtmlText(event: ClipboardEvent): string {
-  return event.clipboardData?.getData('text/html') ?? ''
-}
-
-function shouldHandleLargeRichMarkdownPaste({
-  plainTextByteLength,
-  plainTextExceededLimit,
-  htmlText,
-  maxDirect
-}: {
-  plainTextByteLength: number
-  plainTextExceededLimit: boolean
-  htmlText: string
-  maxDirect: number
-}): boolean {
-  if (plainTextExceededLimit || plainTextByteLength > maxDirect) {
-    return true
-  }
-  return !isUtf8ByteLengthWithinLimit(htmlText, maxDirect)
-}
-
-async function insertRichMarkdownTextInChunks(
-  editor: Editor,
-  text: string,
-  byteLength: number,
-  options: RichMarkdownLargeTextPasteOptions
-): Promise<RichMarkdownLargeTextPasteResult> {
-  const chunkMaxBytes = options.chunkMaxBytes ?? RICH_MARKDOWN_PASTE_CHUNK_MAX_BYTES
-  let textIndex = 0
-  let chunksWritten = 0
-
-  while (textIndex < text.length) {
-    if (!isEditorAvailable(editor, options.canContinue)) {
-      return { status: 'cancelled', reason: 'target-unavailable', byteLength, chunksWritten }
-    }
-
-    const nextIndex = getUtf8ChunkEndIndex(text, textIndex, chunkMaxBytes)
-    const chunk = text.slice(textIndex, nextIndex)
-    editor.view.dispatch(editor.state.tr.insertText(chunk))
-    textIndex = nextIndex
-    chunksWritten += 1
-
-    if (textIndex < text.length) {
-      await (options.yieldToEventLoop ?? yieldToEventLoop)()
-    }
-  }
-
-  return { status: 'handled', chunksWritten, byteLength }
-}
-
 async function executeRichMarkdownLargeTextPaste(
   editor: Editor,
   text: string,
   options: RichMarkdownLargeTextPasteOptions
 ): Promise<RichMarkdownLargeTextPasteResult> {
-  const maxBytes = options.maxBytes ?? RICH_MARKDOWN_PASTE_MAX_BYTES
-  const byteLengthMeasurement = await measureTextControlPasteByteLengthWithYield(text, {
-    stopAfterBytes: maxBytes,
-    yieldAfterCodeUnits: options.measureYieldAfterCodeUnits,
-    yieldToEventLoop: options.yieldToEventLoop
+  const chunkMaxBytes = Math.max(1, options.chunkMaxBytes ?? RICH_MARKDOWN_PASTE_CHUNK_MAX_BYTES)
+  const yieldBetweenBatches = options.yieldToEventLoop ?? yieldToEventLoop
+  const contextVersion = getRichMarkdownImageResolverContextVersion(editor)
+  const targetDom = editor.view.dom
+  const requestOrder = captureRichMarkdownClipboardInsertionOrder(editor)
+  let document = editor.state.doc
+  let bookmark = editor.state.selection.getBookmark()
+  const pasteMarks = editor.state.storedMarks
+  let insertionTransaction: Transaction | null = null
+  let insertionEnd: SelectionBookmark | null = null
+  let active = true
+  let pasteTime: number | null = null
+  let byteLength = 0
+  let textIndex = 0
+  let chunksWritten = 0
+  const history = trackRichMarkdownLargePasteHistory(editor, () => {
+    pasteTime = null
   })
-  if (byteLengthMeasurement.exceededLimit) {
-    return { status: 'rejected', reason: 'too-large', byteLength: byteLengthMeasurement.byteLength }
+
+  const dispose = (): void => {
+    if (!active) {
+      return
+    }
+    active = false
+    editor.off('transaction', mapTransactions)
+    editor.off('destroy', dispose)
+    history.dispose()
   }
-  return insertRichMarkdownTextInChunks(editor, text, byteLengthMeasurement.byteLength, options)
+  const mapTransactions = ({
+    transaction,
+    appendedTransactions
+  }: {
+    transaction: Transaction
+    appendedTransactions: Transaction[]
+  }): void => {
+    if (!transaction.before.eq(document)) {
+      dispose()
+      return
+    }
+    const ownChunk = transaction === insertionTransaction
+    const insertionOrder: unknown = transaction.getMeta(richMarkdownClipboardInsertionOrderKey)
+    const assoc = typeof insertionOrder === 'number' && insertionOrder < requestOrder ? 1 : -1
+    for (const next of [transaction, ...appendedTransactions]) {
+      if (next === insertionTransaction && insertionEnd) {
+        bookmark = insertionEnd
+        insertionTransaction = null
+      } else if (!next.doc.eq(document)) {
+        const selection = bookmark.resolve(document)
+        let ranges = selection.ranges.map(({ $from, $to }) => ({
+          from: $from.pos,
+          to: $to.pos
+        }))
+        for (const map of next.mapping.maps) {
+          const overlaps = ranges.some((range) => {
+            let changed = false
+            map.forEach((from, to) => {
+              changed ||=
+                range.from === range.to
+                  ? to > from && from <= range.from && to >= range.to
+                  : to > from
+                    ? from < range.to && to > range.from
+                    : from > range.from && from < range.to
+            })
+            return changed
+          })
+          if (overlaps && !ownChunk) {
+            dispose()
+            return
+          }
+          ranges = ranges.map((range) => ({
+            from: map.map(range.from, range.from === range.to ? assoc : 1),
+            to: map.map(range.to, range.from === range.to ? assoc : -1)
+          }))
+        }
+        const range = ranges[0]
+        bookmark =
+          selection instanceof TextSelection && range
+            ? TextSelection.create(
+                next.doc,
+                selection.anchor <= selection.head ? range.from : range.to,
+                selection.anchor <= selection.head ? range.to : range.from
+              ).getBookmark()
+            : bookmark.map(next.mapping)
+        if (!(selection instanceof TextSelection)) {
+          const mapped = bookmark.resolve(next.doc)
+          const expectedRanges = new Set(ranges.map((range) => `${range.from}:${range.to}`))
+          // Native selections must not expand to include content added during the paste.
+          if (
+            mapped.constructor !== selection.constructor ||
+            mapped.ranges.length !== ranges.length ||
+            mapped.ranges.some(({ $from, $to }) => !expectedRanges.has(`${$from.pos}:${$to.pos}`))
+          ) {
+            dispose()
+            return
+          }
+        }
+      }
+      document = next.doc
+    }
+  }
+
+  editor.on('transaction', mapTransactions)
+  editor.on('destroy', dispose)
+  try {
+    const measurement = await measureTextControlPasteByteLengthWithYield(text, {
+      stopAfterBytes: options.maxBytes ?? RICH_MARKDOWN_PASTE_MAX_BYTES,
+      yieldAfterCodeUnits: options.measureYieldAfterCodeUnits,
+      yieldToEventLoop: yieldBetweenBatches
+    })
+    byteLength = measurement.byteLength
+    if (measurement.exceededLimit) {
+      return { status: 'rejected', reason: 'too-large', byteLength }
+    }
+    while (textIndex < text.length) {
+      if (
+        !active ||
+        !isEditorPasteTargetCurrent(editor, targetDom) ||
+        !(options.canContinue?.(editor) ?? true) ||
+        getRichMarkdownImageResolverContextVersion(editor) !== contextVersion ||
+        !editor.state.doc.eq(document)
+      ) {
+        return { status: 'cancelled', reason: 'target-unavailable', byteLength, chunksWritten }
+      }
+      const selection = bookmark.resolve(document)
+      const liveSelection = editor.state.selection
+      const liveMarks = editor.state.storedMarks
+      const nextIndex = getUtf8ChunkEndIndex(text, textIndex, chunkMaxBytes)
+      const tr = editor.state.tr
+        .setSelection(selection)
+        .setStoredMarks(pasteMarks)
+        .insertText(text.slice(textIndex, nextIndex))
+        .setMeta(richMarkdownClipboardInsertionOrderKey, requestOrder)
+      if (pasteTime === null) {
+        closeHistory(tr)
+        pasteTime = tr.time
+      }
+      tr.setTime(pasteTime)
+      insertionEnd = tr.selection.getBookmark()
+      if (!liveSelection.eq(selection)) {
+        tr.setSelection(liveSelection.map(tr.doc, tr.mapping))
+      }
+      tr.setStoredMarks(liveMarks)
+      // Own chunks advance the paste bookmark without following a moved live caret.
+      insertionTransaction = tr
+      history.dispatchChunk(tr)
+      if (insertionTransaction) {
+        return { status: 'cancelled', reason: 'target-unavailable', byteLength, chunksWritten }
+      }
+      textIndex = nextIndex
+      chunksWritten += 1
+      if (textIndex < text.length) {
+        await yieldBetweenBatches()
+      }
+    }
+    return { status: 'handled', chunksWritten, byteLength }
+  } finally {
+    dispose()
+    if (
+      chunksWritten &&
+      !history.hasExternalBoundary() &&
+      !editor.isDestroyed &&
+      editor.view.dom === targetDom &&
+      getRichMarkdownImageResolverContextVersion(editor) === contextVersion
+    ) {
+      editor.view.dispatch(closeHistory(editor.state.tr))
+    }
+  }
+}
+
+function showRichMarkdownLargePasteLimitError(): void {
+  toast.error(
+    translate('auto.components.editor.richMarkdownLargeTextPaste.tooLarge', 'Paste is too large.')
+  )
 }
 
 export function handleRichMarkdownLargeTextPaste(
@@ -129,58 +248,50 @@ export function handleRichMarkdownLargeTextPaste(
   event: ClipboardEvent,
   options: RichMarkdownLargeTextPasteOptions = {}
 ): boolean {
-  if (event.defaultPrevented) {
-    return false
-  }
-  if (!editor) {
+  if (event.defaultPrevented || !editor) {
     return false
   }
 
-  const text = options.plainTextOverride ?? readPlainText(event)
-  const html = options.htmlTextOverride ?? readHtmlText(event)
+  const text = options.plainTextOverride ?? event.clipboardData?.getData('text/plain') ?? ''
+  const html = options.htmlTextOverride ?? event.clipboardData?.getData('text/html') ?? ''
   const directMaxBytes = options.directMaxBytes ?? RICH_MARKDOWN_PASTE_DIRECT_MAX_BYTES
   const maxBytes = options.maxBytes ?? RICH_MARKDOWN_PASTE_MAX_BYTES
   const ownershipMeasurement = measureTextControlPasteByteLength(text, {
     stopAfterBytes: Math.min(directMaxBytes, maxBytes)
   })
   if (
-    !shouldHandleLargeRichMarkdownPaste({
-      plainTextByteLength: ownershipMeasurement.byteLength,
-      plainTextExceededLimit: ownershipMeasurement.exceededLimit,
-      htmlText: html,
-      maxDirect: directMaxBytes
-    })
+    !ownershipMeasurement.exceededLimit &&
+    ownershipMeasurement.byteLength <= directMaxBytes &&
+    isUtf8ByteLengthWithinLimit(html, directMaxBytes)
   ) {
     return false
   }
 
   event.preventDefault()
   if (!text || (maxBytes <= directMaxBytes && ownershipMeasurement.exceededLimit)) {
-    toast.error(
-      translate('auto.components.editor.richMarkdownLargeTextPaste.tooLarge', 'Paste is too large.')
-    )
+    showRichMarkdownLargePasteLimitError()
     return true
   }
 
   if (!isEditorAvailable(editor, options.canContinue)) {
     return true
   }
-  const targetDom = editor.view.dom
-  const guardedOptions: RichMarkdownLargeTextPasteOptions = {
-    ...options,
-    canContinue: (candidate) =>
-      isEditorPasteTargetCurrent(candidate, targetDom) && (options.canContinue?.(candidate) ?? true)
-  }
-
   // Why: large rich-editor text or HTML paste bypasses ProseMirror's
   // synchronous parser and writes bounded plain-text fallback transactions.
-  void executeRichMarkdownLargeTextPaste(editor, text, guardedOptions).then((result) => {
+  void executeRichMarkdownLargeTextPaste(editor, text, options).then((result) => {
     if (result.status === 'rejected' && result.reason === 'too-large') {
-      toast.error(
-        translate(
-          'auto.components.editor.richMarkdownLargeTextPaste.tooLarge',
-          'Paste is too large.'
-        )
+      showRichMarkdownLargePasteLimitError()
+    } else if (result.status === 'cancelled') {
+      toast.info(
+        result.chunksWritten
+          ? translate(
+              'auto.components.editor.richMarkdownLargeTextPaste.stopped',
+              'Large paste stopped before it finished.'
+            )
+          : translate(
+              'auto.components.editor.richMarkdownLargeTextPaste.cancelled',
+              'Large paste cancelled because its original target changed.'
+            )
       )
     }
   })
diff --git a/src/renderer/src/components/editor/rich-markdown-local-image.test.ts b/src/renderer/src/components/editor/rich-markdown-local-image.test.ts
index 056fbdd8d33..d6c74e235a3 100644
--- a/src/renderer/src/components/editor/rich-markdown-local-image.test.ts
+++ b/src/renderer/src/components/editor/rich-markdown-local-image.test.ts
@@ -58,7 +58,8 @@ describe('rich markdown local images', () => {
 
       expect(window.api.fs.readFile).toHaveBeenCalledWith({
         filePath: '/repo/docs/diagram.png',
-        connectionId: undefined
+        connectionId: undefined,
+        access: { kind: 'document-resource', documentPath: '/repo/docs/readme.md' }
       })
       expect(host.querySelector('img')?.src).toBe('blob:rich-local-image')
     } finally {
diff --git a/src/renderer/src/components/editor/rich-markdown-paste-image.test.ts b/src/renderer/src/components/editor/rich-markdown-paste-image.test.ts
index bf4be8ced25..870eb821fe9 100644
--- a/src/renderer/src/components/editor/rich-markdown-paste-image.test.ts
+++ b/src/renderer/src/components/editor/rich-markdown-paste-image.test.ts
@@ -1,6 +1,8 @@
 // @vitest-environment happy-dom
 
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { Editor } from '@tiptap/react'
+import StarterKit from '@tiptap/starter-kit'
 import { clipboardHasImage, handleRichMarkdownImagePaste } from './rich-markdown-paste-image'
 import { insertRichMarkdownImageFromPath } from './rich-markdown-image-insert'
 
@@ -31,28 +33,39 @@ vi.mock('@/runtime/runtime-rpc-client', () => ({
 }))
 
 vi.mock('sonner', () => ({
-  toast: { error: vi.fn() }
+  toast: { error: vi.fn(), info: vi.fn() }
 }))
 
 function pasteEvent(items: Partial<DataTransferItem>[]): ClipboardEvent {
-  return {
-    clipboardData: { items },
-    preventDefault: vi.fn()
-  } as unknown as ClipboardEvent
+  const clipboardData = new DataTransfer()
+  items.forEach((item) => {
+    if (item.kind === 'file') {
+      clipboardData.items.add(new File(['image'], 'image.png', { type: item.type }))
+    } else {
+      clipboardData.items.add('', item.type ?? 'text/plain')
+    }
+  })
+  const event = new ClipboardEvent('paste', { clipboardData, cancelable: true })
+  vi.spyOn(event, 'preventDefault')
+  return event
 }
 
+const openEditors: Editor[] = []
+
 function editorAt(position: number, destroyedRef: { current: boolean } = { current: false }) {
-  const dom = document.createElement('div')
-  document.body.appendChild(dom)
-  return {
-    get isDestroyed() {
-      return destroyedRef.current
-    },
-    state: { selection: { from: position } },
-    view: { dom }
-  }
+  const editor = new Editor({ extensions: [StarterKit], content: `<p>${'x'.repeat(position)}</p>` })
+  document.body.appendChild(editor.view.dom)
+  editor.commands.setTextSelection(position)
+  vi.spyOn(editor, 'isDestroyed', 'get').mockImplementation(() => destroyedRef.current)
+  openEditors.push(editor)
+  return editor
 }
 
+afterEach(() => {
+  openEditors.splice(0).forEach((editor) => editor.destroy())
+  vi.restoreAllMocks()
+})
+
 async function flushPromises(): Promise<void> {
   await Promise.resolve()
   await Promise.resolve()
@@ -62,8 +75,9 @@ describe('rich markdown image paste', () => {
   beforeEach(() => {
     document.body.replaceChildren()
     vi.clearAllMocks()
-    vi.stubGlobal('window', {
-      api: {
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: {
         ui: {
           saveClipboardImageAsTempFile: vi.fn().mockResolvedValue('/tmp/orca-paste-image.png')
         }
@@ -89,7 +103,7 @@ describe('rich markdown image paste', () => {
 
     expect(
       handleRichMarkdownImagePaste({
-        editor: editor as never,
+        editor,
         event,
         filePath: '/repo/note.md',
         worktreeId: 'wt-1'
@@ -107,8 +121,7 @@ describe('rich markdown image paste', () => {
       sourcePath: '/tmp/orca-paste-image.png',
       worktreeId: 'wt-1',
       runtimeEnvironmentId: undefined,
-      insertPos: 7,
-      canInsert: expect.any(Function)
+      getInsertionRange: expect.any(Function)
     })
   })
 
@@ -116,7 +129,7 @@ describe('rich markdown image paste', () => {
     const event = pasteEvent([{ kind: 'file', type: 'image/png' }])
 
     handleRichMarkdownImagePaste({
-      editor: editorAt(3) as never,
+      editor: editorAt(3),
       event,
       filePath: '/repo/note.md',
       worktreeId: 'wt-1',
@@ -140,7 +153,7 @@ describe('rich markdown image paste', () => {
 
     expect(
       handleRichMarkdownImagePaste({
-        editor: editor as never,
+        editor,
         event,
         filePath: '/repo/note.md',
         worktreeId: 'wt-1'
diff --git a/src/renderer/src/components/editor/rich-markdown-paste-image.ts b/src/renderer/src/components/editor/rich-markdown-paste-image.ts
index c34e7ad100d..676014b14be 100644
--- a/src/renderer/src/components/editor/rich-markdown-paste-image.ts
+++ b/src/renderer/src/components/editor/rich-markdown-paste-image.ts
@@ -5,6 +5,8 @@ import { useAppStore } from '@/store'
 import { settingsForRuntimeOwner } from '@/runtime/runtime-rpc-client'
 import { extractIpcErrorMessage } from './rich-markdown-ipc-error-message'
 import { insertRichMarkdownImageFromPath } from './rich-markdown-image-insert'
+import { captureRichMarkdownImageInsertionTarget } from './rich-markdown-image-insertion-target'
+import { showRichMarkdownImageInsertionCanceled } from './rich-markdown-image-insertion-feedback'
 
 export type RichMarkdownImagePasteArgs = {
   editor: Editor | null
@@ -36,12 +38,18 @@ export function handleRichMarkdownImagePaste({
   }
 
   event.preventDefault()
-  const insertPos = editor.state.selection.from
-  const targetDom = editor.view.dom
+  const target = captureRichMarkdownImageInsertionTarget(editor)
+  if (!target) {
+    return true
+  }
 
   void saveClipboardImageForMarkdownPaste(worktreeId, runtimeEnvironmentId)
     .then((sourcePath) => {
-      if (!sourcePath || !isRichMarkdownImagePasteTargetAvailable(editor, targetDom)) {
+      if (!sourcePath) {
+        return
+      }
+      if (!target.getRange()) {
+        showRichMarkdownImageInsertionCanceled()
         return
       }
       return insertRichMarkdownImageFromPath({
@@ -50,21 +58,17 @@ export function handleRichMarkdownImagePaste({
         sourcePath,
         worktreeId,
         runtimeEnvironmentId,
-        insertPos,
-        canInsert: (candidate) => isRichMarkdownImagePasteTargetAvailable(candidate, targetDom)
+        getInsertionRange: target.getRange
       })
     })
     .catch((err) => {
       toast.error(extractIpcErrorMessage(err, 'Failed to insert image.'))
     })
+    .finally(target.dispose)
 
   return true
 }
 
-function isRichMarkdownImagePasteTargetAvailable(editor: Editor, targetDom: HTMLElement): boolean {
-  return !editor.isDestroyed && editor.view.dom === targetDom && targetDom.isConnected
-}
-
 async function saveClipboardImageForMarkdownPaste(
   worktreeId: string | null,
   runtimeEnvironmentId?: string | null
diff --git a/src/renderer/src/components/editor/use-editor-content-change-handler.test.tsx b/src/renderer/src/components/editor/use-editor-content-change-handler.test.tsx
new file mode 100644
index 00000000000..6783c6b8347
--- /dev/null
+++ b/src/renderer/src/components/editor/use-editor-content-change-handler.test.tsx
@@ -0,0 +1,48 @@
+// @vitest-environment happy-dom
+import { act, renderHook, cleanup } from '@testing-library/react'
+import { afterEach, expect, it } from 'vitest'
+import { useAppStore } from '@/store'
+import { useEditorContentChangeHandler } from './use-editor-content-change-handler'
+
+afterEach(() => {
+  cleanup()
+  useAppStore.setState({ openFiles: [], editorDrafts: {} })
+})
+
+it('does not recreate a draft when a pending editor detaches after its tab was closed', () => {
+  useAppStore.getState().openFile({
+    filePath: '/repo/closed.csv',
+    relativePath: 'closed.csv',
+    mode: 'edit',
+    language: 'plaintext',
+    worktreeId: 'csv-close-test'
+  })
+  const file = useAppStore
+    .getState()
+    .openFiles.find((file) => file.filePath === '/repo/closed.csv')!
+  const { result } = renderHook(() =>
+    useEditorContentChangeHandler({ fileContents: {}, diffContents: {} })
+  )
+  act(() => useAppStore.getState().closeFile(file.id))
+  act(() => result.current(file, 'pending,cell'))
+  expect(useAppStore.getState().editorDrafts[file.id]).toBeUndefined()
+})
+
+it('retains a pending draft when the tab is still open but its table view detached', () => {
+  useAppStore.getState().openFile({
+    filePath: '/repo/open.csv',
+    relativePath: 'open.csv',
+    mode: 'edit',
+    language: 'plaintext',
+    worktreeId: 'csv-close-test'
+  })
+  const file = useAppStore.getState().openFiles.find((file) => file.filePath === '/repo/open.csv')!
+  const { result } = renderHook(() =>
+    useEditorContentChangeHandler({ fileContents: {}, diffContents: {} })
+  )
+  act(() => result.current(file, 'pending,cell'))
+  expect(useAppStore.getState().editorDrafts[file.id]).toBe('pending,cell')
+  expect(
+    useAppStore.getState().openFiles.find((candidate) => candidate.id === file.id)?.isDirty
+  ).toBe(true)
+})
diff --git a/src/renderer/src/components/editor/use-editor-content-change-handler.ts b/src/renderer/src/components/editor/use-editor-content-change-handler.ts
index aaad9773c7a..448782ed15c 100644
--- a/src/renderer/src/components/editor/use-editor-content-change-handler.ts
+++ b/src/renderer/src/components/editor/use-editor-content-change-handler.ts
@@ -33,7 +33,10 @@ export function useEditorContentChangeHandler({
 
   return useCallback(
     (file: OpenFile | null, content: string) => {
-      if (!file) {
+      if (
+        !file ||
+        !useAppStore.getState().openFiles.some((candidate) => candidate.id === file.id)
+      ) {
         return
       }
       setEditorDraft(file.id, content)
diff --git a/src/renderer/src/components/editor/use-markdown-preview-components.tsx b/src/renderer/src/components/editor/use-markdown-preview-components.tsx
index 6f5f0b0d63e..1b7d21b2dee 100644
--- a/src/renderer/src/components/editor/use-markdown-preview-components.tsx
+++ b/src/renderer/src/components/editor/use-markdown-preview-components.tsx
@@ -21,6 +21,7 @@ import type { MarkdownPreviewFoundation } from './use-markdown-preview-foundatio
 import type { MarkdownPreviewReviewActions } from './use-markdown-preview-review-actions'
 import type { MarkdownPreviewViewport } from './use-markdown-preview-viewport'
 import { useLocalImageSrc } from './useLocalImageSrc'
+import { documentResourceAccess } from '@/lib/local-file-access'
 
 export function useMarkdownPreviewComponents({
   foundation,
@@ -64,6 +65,8 @@ export function useMarkdownPreviewComponents({
   const { renderAnnotationControls, wrapAnnotatedBlock } = annotationRenderers
 
   return useMemo(() => {
+    // Why: preview images come from document text, so main limits them to the document's roots.
+    const imageAccess = documentResourceAccess(filePath)
     const linkContext = {
       isMac,
       sourceOwner,
@@ -130,7 +133,13 @@ export function useMarkdownPreviewComponents({
         )
       },
       img: function MarkdownImg({ src, alt, ...props }) {
-        const resolvedSrc = useLocalImageSrc(src, filePath, undefined, imageRuntimeContext)
+        const resolvedSrc = useLocalImageSrc(
+          src,
+          filePath,
+          undefined,
+          imageRuntimeContext,
+          imageAccess
+        )
         const handleImageClick = (event: React.MouseEvent<HTMLImageElement>): void => {
           if (!isMarkdownPreviewOpenModifier(event, isMac)) {
             return
diff --git a/src/renderer/src/components/editor/use-markdown-preview-foundation.ts b/src/renderer/src/components/editor/use-markdown-preview-foundation.ts
index 48631ce6897..accf06ca409 100644
--- a/src/renderer/src/components/editor/use-markdown-preview-foundation.ts
+++ b/src/renderer/src/components/editor/use-markdown-preview-foundation.ts
@@ -101,20 +101,16 @@ export function useMarkdownPreviewFoundation({
     () => markdownReviewNotes.filter((note) => !note.sentAt),
     [markdownReviewNotes]
   )
-  const unsentMarkdownReviewPrompt = useMemo(
-    () => formatMarkdownReviewNotes(unsentMarkdownReviewNotes, renderedContent),
-    [renderedContent, unsentMarkdownReviewNotes]
-  )
   const unsentMarkdownReviewScope = useMemo<NotesSendMenuScope<MarkdownReviewNote>[]>(
     () => [
       {
         id: 'all',
         label: translate('auto.components.editor.MarkdownPreview.ddf087d12e', 'All unsent notes'),
         notes: unsentMarkdownReviewNotes,
-        prompt: unsentMarkdownReviewPrompt
+        formatPrompt: (notes) => formatMarkdownReviewNotes(notes, renderedContent)
       }
     ],
-    [unsentMarkdownReviewNotes, unsentMarkdownReviewPrompt]
+    [renderedContent, unsentMarkdownReviewNotes]
   )
   const canShowReviewTools = Boolean(
     markdownAnnotationsEnabled && sourceWorktree && sourceRelativePath !== null
diff --git a/src/renderer/src/components/editor/use-monaco-content-sync-bridge.ts b/src/renderer/src/components/editor/use-monaco-content-sync-bridge.ts
index 6a55d9a1ada..6fd4e63a089 100644
--- a/src/renderer/src/components/editor/use-monaco-content-sync-bridge.ts
+++ b/src/renderer/src/components/editor/use-monaco-content-sync-bridge.ts
@@ -24,10 +24,10 @@ export function useMonacoContentSyncBridge(params: {
   content: string
   contentRef: MutableRefObject<string>
   contentSyncModeRef: MutableRefObject<MonacoContentSyncMode>
-  filePath: string
+  modelKey: string
   onContentChange: (content: string) => void
 }): MonacoContentSyncBridge {
-  const { editorRef, content, contentRef, contentSyncModeRef, filePath, onContentChange } = params
+  const { editorRef, content, contentRef, contentSyncModeRef, modelKey, onContentChange } = params
 
   const lastSyncedContentRef = useRef<string>(content)
 
@@ -38,6 +38,9 @@ export function useMonacoContentSyncBridge(params: {
   const handleChange = useCallback(
     (value: string | undefined) => {
       if (value !== undefined) {
+        if (editorRef.current?.getModel()?.uri.toString() !== modelKey) {
+          return
+        }
         // Why: split panes share one retained model, so a sibling must ignore the echoed programmatic-sync onChange or it marks the file dirty.
         if (isApplyingLargePasteRef.current) {
           lastSyncedContentRef.current = value
@@ -45,7 +48,7 @@ export function useMonacoContentSyncBridge(params: {
         }
         if (
           shouldIgnoreMonacoContentChange({
-            filePath,
+            modelKey,
             isApplyingProgrammaticContent: isApplyingProgrammaticContentRef.current
           })
         ) {
@@ -55,25 +58,29 @@ export function useMonacoContentSyncBridge(params: {
         onContentChange(value)
       }
     },
-    [filePath, onContentChange]
+    [editorRef, modelKey, onContentChange]
   )
 
   // Why: sync the model on external `content` drift; useLayoutEffect lands the overwrite before paint so no stale text flashes. On-mount handled in handleMount.
   useLayoutEffect(() => {
     const ed = editorRef.current
-    if (!ed || lastSyncedContentRef.current === content) {
+    if (
+      !ed ||
+      ed.getModel()?.uri.toString() !== modelKey ||
+      lastSyncedContentRef.current === content
+    ) {
       return
     }
-    beginProgrammaticContentSync(filePath)
+    beginProgrammaticContentSync(modelKey)
     isApplyingProgrammaticContentRef.current = true
     try {
       syncContentUpdate(ed, content, contentSyncModeRef.current)
       lastSyncedContentRef.current = content
     } finally {
       isApplyingProgrammaticContentRef.current = false
-      endProgrammaticContentSync(filePath)
+      endProgrammaticContentSync(modelKey)
     }
-  }, [content, contentSyncModeRef, editorRef, filePath])
+  }, [content, contentSyncModeRef, editorRef, modelKey])
 
   return {
     contentRef,
diff --git a/src/renderer/src/components/editor/use-monaco-editor-mount.ts b/src/renderer/src/components/editor/use-monaco-editor-mount.ts
index da97dc6ec32..3e355ffcefd 100644
--- a/src/renderer/src/components/editor/use-monaco-editor-mount.ts
+++ b/src/renderer/src/components/editor/use-monaco-editor-mount.ts
@@ -3,6 +3,7 @@ import type { OnMount } from '@monaco-editor/react'
 import { useAppStore } from '@/store'
 import { registerFileSearchSelectedTextProvider } from '@/lib/file-search-selection'
 import { syncContentOnMount } from './monaco-content-sync'
+import { toEditorModelUri } from './editor-model-uri'
 import {
   beginProgrammaticContentSync,
   endProgrammaticContentSync
@@ -24,6 +25,7 @@ export function useMonacoEditorMount(params: MonacoEditorMountParams): OnMount {
   const {
     fileId,
     filePath,
+    modelOwnerKey,
     viewStateKey,
     viewStateId,
     worktreeId,
@@ -103,7 +105,8 @@ export function useMonacoEditorMount(params: MonacoEditorMountParams): OnMount {
       updateMarkdownCompletionDocuments()
 
       // Why: see contentRef — reconcile the retained model to the current prop before user interaction (surfaces edits made while unmounted).
-      beginProgrammaticContentSync(filePath)
+      const modelKey = toEditorModelUri(filePath, modelOwnerKey)
+      beginProgrammaticContentSync(modelKey)
       isApplyingProgrammaticContentRef.current = true
       try {
         const didSyncOnMount = syncContentOnMount(
@@ -116,7 +119,7 @@ export function useMonacoEditorMount(params: MonacoEditorMountParams): OnMount {
         }
       } finally {
         isApplyingProgrammaticContentRef.current = false
-        endProgrammaticContentSync(filePath)
+        endProgrammaticContentSync(modelKey)
       }
 
       setupCopy(editorInstance, monaco, filePath, propsRef)
@@ -219,6 +222,7 @@ export function useMonacoEditorMount(params: MonacoEditorMountParams): OnMount {
       setupCopy,
       fileId,
       filePath,
+      modelOwnerKey,
       setEditorCursorLine,
       updateMarkdownCompletionDocuments,
       viewStateKey,
diff --git a/src/renderer/src/components/editor/useEditorPanelContentState.test.tsx b/src/renderer/src/components/editor/useEditorPanelContentState.test.tsx
index 6df420f6abc..3ce87d778fc 100644
--- a/src/renderer/src/components/editor/useEditorPanelContentState.test.tsx
+++ b/src/renderer/src/components/editor/useEditorPanelContentState.test.tsx
@@ -93,10 +93,9 @@ type ProbeProps = {
   gitStatusByWorktree?: Record<string, GitStatusEntry[]>
 }
 
-const authorizeExternalPath = vi.fn()
 // Why: opening any liveTail tab arms useLocalLogTail's change subscription.
 const onLocalLogTailChanged = vi.fn(() => () => {})
-const fsApi = { authorizeExternalPath, onLocalLogTailChanged }
+const fsApi = { onLocalLogTailChanged }
 let latestFileContents: Record<string, FileContent> = {}
 let latestDiffContents: Record<string, DiffContent> = {}
 let latestReloadContent: (file: OpenFile) => void = () => {}
@@ -140,8 +139,6 @@ describe('useEditorPanelContentState', () => {
   beforeEach(() => {
     latestFileContents = {}
     latestDiffContents = {}
-    authorizeExternalPath.mockReset()
-    authorizeExternalPath.mockResolvedValue(undefined)
     onLocalLogTailChanged.mockClear()
     ;(window as unknown as { api: unknown }).api = { fs: fsApi }
     mocks.readRuntimeFileContent.mockReset()
@@ -259,8 +256,6 @@ describe('useEditorPanelContentState', () => {
     })
 
     await vi.waitFor(() => expect(latestFileContents[activeFile.id]?.content).toBe('# remote'))
-    // Why: the client-local grant must not be requested for a remote-owned path.
-    expect(authorizeExternalPath).not.toHaveBeenCalled()
     expect(mocks.readRuntimeFileContent).toHaveBeenCalledWith(
       expect.objectContaining({
         filePath: '/work/reports/audit.md',
@@ -287,35 +282,16 @@ describe('useEditorPanelContentState', () => {
 
     await vi.waitFor(() => expect(latestFileContents[activeFile.id]?.content).toBe('log line'))
     // Why: AI Vault only surfaces client-local logs, so the worktree's SSH target must
-    // not capture this read — it stays a granted client-local path.
-    expect(authorizeExternalPath).toHaveBeenCalledWith({ targetPath: logPath })
+    // not capture this read — it stays a user-named client-local path.
     expect(mocks.readRuntimeFileContent).toHaveBeenCalledWith(
-      expect.objectContaining({ connectionId: undefined, includeLocalLogMetadata: true })
+      expect.objectContaining({
+        connectionId: undefined,
+        includeLocalLogMetadata: true,
+        access: { kind: 'user-file' }
+      })
     )
   })
 
-  it('re-authorizes a client-local external tab before reading it', async () => {
-    const activeFile = createOpenFile({
-      id: '/Users/me/notes/audit.md',
-      filePath: '/Users/me/notes/audit.md',
-      relativePath: '/Users/me/notes/audit.md',
-      worktreeId: 'repo-local::/Users/me/project'
-    })
-    mocks.getConnectionIdForFile.mockReturnValue(undefined)
-    mocks.readRuntimeFileContent.mockResolvedValue({ content: '# local', isBinary: false })
-
-    container = document.createElement('div')
-    document.body.appendChild(container)
-    root = createRoot(container)
-
-    await act(async () => {
-      root?.render(<HookProbe activeFile={activeFile} openFiles={[activeFile]} />)
-    })
-
-    await vi.waitFor(() => expect(latestFileContents[activeFile.id]?.content).toBe('# local'))
-    expect(authorizeExternalPath).toHaveBeenCalledWith({ targetPath: '/Users/me/notes/audit.md' })
-  })
-
   it('rejects an unstamped external tab in a remote runtime workspace', async () => {
     const activeFile = createOpenFile({
       id: '/work/reports/audit.md',
diff --git a/src/renderer/src/components/editor/useEditorPanelFileContentLoader.ts b/src/renderer/src/components/editor/useEditorPanelFileContentLoader.ts
index e7fdfc88754..ed773660390 100644
--- a/src/renderer/src/components/editor/useEditorPanelFileContentLoader.ts
+++ b/src/renderer/src/components/editor/useEditorPanelFileContentLoader.ts
@@ -3,7 +3,8 @@ import type { OpenFile } from '@/store/slices/editor'
 import { getConnectionIdForFile, isWorktreeConnectionResolved } from '@/lib/connection-context'
 import { useAppStore } from '@/store'
 import { getDiskBaselineSignature } from './diff-content-signature'
-import { getRuntimeFileReadScope, readRuntimeFileContent } from '@/runtime/runtime-file-client'
+import { getRuntimeFileReadScope } from '@/runtime/runtime-file-client'
+import { readEditorCsvFileContent } from './csv/csv-file-content'
 import { RuntimeRpcCallError, settingsForRuntimeOwner } from '@/runtime/runtime-rpc-client'
 import { findWorkspaceFileRoute } from '@/lib/runtime-workspace-file-route'
 import { selectWorktreeHostConnectionPhase } from '@/lib/worktree-host-connection-phase'
@@ -19,6 +20,7 @@ import {
 } from './editor-panel-content-types'
 import type { EditorPanelContentLoadOptions } from './useEditorPanelExternalContentEvents'
 import { migrateRestoredEditorFileOwner } from './migrate-restored-editor-file-owner'
+import { editorTabFileAccess } from '@/lib/local-file-access'
 
 const inFlightFileReads = new Map<string, InFlightContentRead<FileContent>>()
 
@@ -44,7 +46,7 @@ type UseEditorPanelFileContentLoaderParams = {
 // the signature was taken over). Best-effort metadata — a failure here must
 // not convert an already-delivered load into an error view, hence the guard.
 function stampCleanTabDiskBaseline(id: string, result: FileContent): void {
-  if (result.isBinary || result.loadError) {
+  if (result.isBinary || result.loadError || result.csvPreview) {
     return
   }
   try {
@@ -120,7 +122,6 @@ export function useEditorPanelFileContentLoader({
             ? undefined
             : readSettings?.activeRuntimeEnvironmentId?.trim()
           if (isLiveTailLogTab) {
-            await window.api.fs.authorizeExternalPath({ targetPath: filePath })
             readConnectionId = undefined
           } else {
             const currentState = useAppStore.getState()
@@ -155,17 +156,21 @@ export function useEditorPanelFileContentLoader({
               throw new Error('External local files are not available for remote workspaces.')
             }
             if (!externalSshOwnerId) {
-              // Why: client-local external tabs need their main-process path grant
-              // refreshed because that authorization is only held in memory.
-              await window.api.fs.authorizeExternalPath({ targetPath: filePath })
-              // Why: that grant covers the client path, so this read must stay off the
-              // worktree's SSH host.
+              // Why: a client-local external tab names a client path, so this read must stay off
+              // the worktree's SSH host.
               readConnectionId = undefined
             }
           }
         }
         const readScope = getRuntimeFileReadScope(readSettings, readConnectionId)
-        const key = inFlightReadKey(readScope, filePath)
+        const access = restoredOpenFile
+          ? editorTabFileAccess(useAppStore.getState(), restoredOpenFile)
+          : undefined
+        const allowPagedPreview =
+          !restoredOpenFile?.isDirty &&
+          (!/\.(csv|tsv)$/i.test(filePath) || useAppStore.getState().editorDrafts[id] === undefined)
+        // Keep file authorization and editable drafts isolated between concurrent reads.
+        const key = `${inFlightReadKey(readScope, filePath)}::${access?.kind ?? ''}${allowPagedPreview ? '' : '::editable'}`
         const registeredRead = inFlightFileReads.get(key)
         if (
           options?.force &&
@@ -178,15 +183,19 @@ export function useEditorPanelFileContentLoader({
         }
         let pending = inFlightFileReads.get(key)
         if (!pending) {
-          const promise = readRuntimeFileContent({
-            settings: readSettings,
-            filePath,
-            relativePath: readRelativePath,
-            worktreeId: readWorktreeId,
-            connectionId: readConnectionId,
-            expectedExternalSshTargetId: restoredOpenFile?.externalSshTargetId,
-            includeLocalLogMetadata: isLiveTailLogTab
-          }) as Promise<FileContent>
+          const promise = readEditorCsvFileContent(
+            {
+              settings: readSettings,
+              filePath,
+              relativePath: readRelativePath,
+              worktreeId: readWorktreeId,
+              connectionId: readConnectionId,
+              expectedExternalSshTargetId: restoredOpenFile?.externalSshTargetId,
+              includeLocalLogMetadata: isLiveTailLogTab,
+              access
+            },
+            allowPagedPreview
+          )
           pending = { externalEventGeneration: options?.externalEventGeneration, promise }
           inFlightFileReads.set(key, pending)
           queueMicrotask(() => {
@@ -199,6 +208,14 @@ export function useEditorPanelFileContentLoader({
         if (fileReadGenerationRef.current[id] !== generation) {
           return
         }
+        if (result.csvPreview && useAppStore.getState().editorDrafts[id] !== undefined) {
+          throw new Error(
+            'CSV grew too large for editing. Your draft has been kept; reopen the file to preview it.'
+          )
+        }
+        if (result.csvPreview || restoredOpenFile?.csvPreviewOnly) {
+          useAppStore.getState().setCsvPreviewOnly(id, Boolean(result.csvPreview))
+        }
         delete fileLoadRetryAttemptsRef.current[id]
         setFileContents((prev) => ({ ...prev, [id]: result }))
         stampCleanTabDiskBaseline(id, result)
diff --git a/src/renderer/src/components/editor/useEditorPanelFloatingTabContentState.test.tsx b/src/renderer/src/components/editor/useEditorPanelFloatingTabContentState.test.tsx
new file mode 100644
index 00000000000..457e437748d
--- /dev/null
+++ b/src/renderer/src/components/editor/useEditorPanelFloatingTabContentState.test.tsx
@@ -0,0 +1,160 @@
+// @vitest-environment happy-dom
+
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { OpenFile } from '@/store/slices/editor'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../../shared/constants'
+import type { FileContent } from './editor-panel-content-types'
+
+const mocks = vi.hoisted(() => ({
+  readRuntimeFileContent: vi.fn(),
+  findWorkspaceFileRoute: vi.fn(),
+  getState: vi.fn()
+}))
+
+vi.mock('@/runtime/runtime-file-client', () => ({
+  getRuntimeFileReadScope: vi.fn(
+    (
+      settings: { activeRuntimeEnvironmentId?: string | null } | null | undefined,
+      connectionId?: string
+    ) => connectionId ?? settings?.activeRuntimeEnvironmentId ?? null
+  ),
+  readRuntimeFileContent: mocks.readRuntimeFileContent,
+  subscribeRuntimeFileChanges: vi.fn()
+}))
+
+vi.mock('@/runtime/runtime-git-client', () => ({
+  getRuntimeGitBranchDiff: vi.fn(),
+  getRuntimeGitCommitDiff: vi.fn(),
+  getRuntimeGitDiff: vi.fn(),
+  getRuntimeGitScope: vi.fn(() => null)
+}))
+
+vi.mock('@/lib/connection-context', () => ({
+  getConnectionId: vi.fn(() => null),
+  getConnectionIdForFile: vi.fn(() => null),
+  isWorktreeConnectionResolved: vi.fn(() => true)
+}))
+
+vi.mock('@/lib/worktree-host-connection-phase', () => import('./local-host-test-fixture'))
+
+vi.mock('@/lib/runtime-workspace-file-route', () => ({
+  findWorkspaceFileRoute: mocks.findWorkspaceFileRoute
+}))
+
+vi.mock('@/store', () => ({ useAppStore: { getState: mocks.getState } }))
+
+vi.mock('./useEditorPanelExternalContentEvents', () => ({
+  useEditorPanelExternalContentEvents: vi.fn(),
+  usePruneClosedEditorContent: vi.fn()
+}))
+
+vi.mock('./useEditorPanelFileLoadRetry', () => ({ useEditorPanelFileLoadRetry: vi.fn() }))
+vi.mock('./useLocalLogTail', () => ({ useLocalLogTail: vi.fn() }))
+
+import { useEditorPanelContentState } from './useEditorPanelContentState'
+
+let latestFileContents: Record<string, FileContent> = {}
+
+function createFloatingFile(filePath: string, overrides: Partial<OpenFile> = {}): OpenFile {
+  return {
+    id: filePath,
+    filePath,
+    // Why: floating tabs store a path relative to the floating root (~ by default).
+    relativePath: filePath.slice('/Users/me/'.length),
+    worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
+    language: 'markdown',
+    isDirty: false,
+    mode: 'edit',
+    ...overrides
+  }
+}
+
+function HookProbe({ activeFile }: { activeFile: OpenFile }): null {
+  latestFileContents = useEditorPanelContentState({
+    activeFile,
+    isChangesMode: false,
+    openFiles: [activeFile],
+    gitStatusEntries: undefined,
+    editorViewMode: {}
+  }).fileContents
+  return null
+}
+
+describe('restored client-local editor tabs', () => {
+  let container: HTMLDivElement | null = null
+  let root: Root | null = null
+
+  beforeEach(() => {
+    latestFileContents = {}
+    // Why an empty fs API: restoring must read with nothing re-granted or prepared first.
+    vi.stubGlobal('api', { fs: {} })
+    mocks.readRuntimeFileContent.mockReset()
+    mocks.readRuntimeFileContent.mockResolvedValue({ content: '# local', isBinary: false })
+    mocks.findWorkspaceFileRoute.mockReset()
+    mocks.findWorkspaceFileRoute.mockReturnValue(null)
+    mocks.getState.mockReset()
+    mocks.getState.mockReturnValue({
+      settings: null,
+      openFiles: [],
+      setLastKnownDiskSignature: vi.fn()
+    })
+    container = document.body.appendChild(document.createElement('div'))
+    root = createRoot(container)
+  })
+
+  afterEach(() => {
+    act(() => root?.unmount())
+    container?.remove()
+  })
+
+  // The notebook kernel and environment handlers check the same file path as user-named.
+  it.each(['/Users/me/notes.txt', '/Users/me/analysis.ipynb'])(
+    'reads %s as the file the user named after a restart',
+    async (filePath) => {
+      const activeFile = createFloatingFile(filePath)
+
+      await act(async () => root?.render(<HookProbe activeFile={activeFile} />))
+
+      await vi.waitFor(() => expect(latestFileContents[activeFile.id]?.content).toBe('# local'))
+      expect(mocks.readRuntimeFileContent).toHaveBeenCalledTimes(1)
+      expect(mocks.readRuntimeFileContent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filePath,
+          connectionId: undefined,
+          access: { kind: 'user-file' }
+        })
+      )
+    }
+  )
+
+  it('reads a local tab stored outside its own project as user-named', async () => {
+    const filePath = '/Users/me/notes/audit.md'
+    const activeFile = createFloatingFile(filePath, {
+      relativePath: filePath,
+      worktreeId: 'repo-local::/Users/me/project'
+    })
+
+    await act(async () => root?.render(<HookProbe activeFile={activeFile} />))
+
+    await vi.waitFor(() => expect(latestFileContents[activeFile.id]?.content).toBe('# local'))
+    expect(mocks.readRuntimeFileContent).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath, access: { kind: 'user-file' } })
+    )
+  })
+
+  it('keeps a project tab inside its root', async () => {
+    const activeFile = createFloatingFile('/Users/me/project/README.md', {
+      relativePath: 'README.md',
+      worktreeId: 'repo::/Users/me/project'
+    })
+
+    await act(async () => root?.render(<HookProbe activeFile={activeFile} />))
+
+    await vi.waitFor(() => expect(latestFileContents[activeFile.id]?.content).toBe('# local'))
+    expect(mocks.readRuntimeFileContent).toHaveBeenCalledWith(
+      expect.objectContaining({ access: undefined })
+    )
+  })
+})
diff --git a/src/renderer/src/components/editor/useEditorPanelHostUnresolvedContentState.test.tsx b/src/renderer/src/components/editor/useEditorPanelHostUnresolvedContentState.test.tsx
index c6ff09f8c97..600b79f8adf 100644
--- a/src/renderer/src/components/editor/useEditorPanelHostUnresolvedContentState.test.tsx
+++ b/src/renderer/src/components/editor/useEditorPanelHostUnresolvedContentState.test.tsx
@@ -98,7 +98,7 @@ describe('useEditorPanelContentState — host cannot resolve a mirrored file (#2
     latestFileContents = {}
     // Why: opening any tab arms useLocalLogTail's change subscription on window.api.
     vi.stubGlobal('api', {
-      fs: { authorizeExternalPath: vi.fn(), onLocalLogTailChanged: vi.fn(() => () => {}) }
+      fs: { onLocalLogTailChanged: vi.fn(() => () => {}) }
     })
     mocks.readRuntimeFileContent.mockReset()
     mocks.getState.mockReset()
diff --git a/src/renderer/src/components/editor/useEditorPanelRemoteSiblingContentState.test.tsx b/src/renderer/src/components/editor/useEditorPanelRemoteSiblingContentState.test.tsx
index 08fcc4df79a..2a35b1308f9 100644
--- a/src/renderer/src/components/editor/useEditorPanelRemoteSiblingContentState.test.tsx
+++ b/src/renderer/src/components/editor/useEditorPanelRemoteSiblingContentState.test.tsx
@@ -63,7 +63,6 @@ vi.mock('./useLocalLogTail', () => ({ useLocalLogTail: vi.fn() }))
 
 import { useEditorPanelContentState } from './useEditorPanelContentState'
 
-const authorizeExternalPath = vi.fn()
 let latestFileContents: Record<string, FileContent> = {}
 
 function createOpenFile(overrides: Partial<OpenFile>): OpenFile {
@@ -96,9 +95,7 @@ describe('remote sibling editor content routing', () => {
 
   beforeEach(() => {
     latestFileContents = {}
-    authorizeExternalPath.mockReset()
-    authorizeExternalPath.mockResolvedValue(undefined)
-    ;(window as unknown as { api: unknown }).api = { fs: { authorizeExternalPath } }
+    vi.stubGlobal('api', { fs: {} })
     mocks.readRuntimeFileContent.mockReset()
     mocks.findWorkspaceFileRoute.mockReset()
     mocks.findWorkspaceFileRoute.mockReturnValue(null)
@@ -135,9 +132,12 @@ describe('remote sibling editor content routing', () => {
 
     await vi.waitFor(() => expect(latestFileContents[activeFile.id]?.content).toBe('log line'))
     expect(mocks.findWorkspaceFileRoute).not.toHaveBeenCalled()
-    expect(authorizeExternalPath).toHaveBeenCalledWith({ targetPath: logPath })
     expect(mocks.readRuntimeFileContent).toHaveBeenCalledWith(
-      expect.objectContaining({ connectionId: undefined, includeLocalLogMetadata: true })
+      expect.objectContaining({
+        connectionId: undefined,
+        includeLocalLogMetadata: true,
+        access: { kind: 'user-file' }
+      })
     )
   })
 
@@ -164,7 +164,6 @@ describe('remote sibling editor content routing', () => {
         'runtime-1'
       )
     )
-    expect(authorizeExternalPath).not.toHaveBeenCalled()
     expect(mocks.readRuntimeFileContent).not.toHaveBeenCalled()
   })
 
diff --git a/src/renderer/src/components/editor/useLocalImagePick.test.tsx b/src/renderer/src/components/editor/useLocalImagePick.test.tsx
new file mode 100644
index 00000000000..0ea9dcab5d8
--- /dev/null
+++ b/src/renderer/src/components/editor/useLocalImagePick.test.tsx
@@ -0,0 +1,229 @@
+// @vitest-environment happy-dom
+
+import { Editor } from '@tiptap/react'
+import { renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { toast } from 'sonner'
+import { importExternalPathsToRuntime } from '@/runtime/runtime-file-client'
+import { createRichMarkdownExtensions } from './rich-markdown-extensions'
+import { createRichMarkdownEditorCodec } from './rich-markdown-source-transport'
+import { useLocalImagePick } from './useLocalImagePick'
+
+vi.mock('@/runtime/runtime-file-client', () => ({ importExternalPathsToRuntime: vi.fn() }))
+vi.mock('@/lib/connection-context', () => ({ getConnectionId: vi.fn(() => null) }))
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: vi.fn(() => ({
+      settings: null,
+      folderWorkspaces: [],
+      worktreesByRepo: {},
+      openFiles: []
+    }))
+  }
+}))
+vi.mock('@/runtime/runtime-rpc-client', () => ({
+  settingsForRuntimeOwner: vi.fn((settings) => settings)
+}))
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), info: vi.fn() } }))
+
+type ImportResult = Awaited<ReturnType<typeof importExternalPathsToRuntime>>
+type PickerContext = {
+  editor: Editor | null
+  filePath: string
+  worktreeId: string | null
+  runtimeId: string | null
+}
+const editors: Editor[] = []
+
+function richEditor(): Editor {
+  const element = document.createElement('div')
+  document.body.append(element)
+  const editor = new Editor({
+    element,
+    extensions: createRichMarkdownExtensions({ codec: createRichMarkdownEditorCodec() }),
+    content: 'hello world',
+    contentType: 'markdown'
+  })
+  editor.commands.setTextSelection({ from: 7, to: 12 })
+  editors.push(editor)
+  return editor
+}
+
+function mountPicker(editor: Editor) {
+  const initialProps: PickerContext = {
+    editor,
+    filePath: '/repo/note.md',
+    worktreeId: null,
+    runtimeId: null
+  }
+  const hook = renderHook(
+    ({ editor, filePath, worktreeId, runtimeId }) =>
+      useLocalImagePick(editor, filePath, worktreeId, runtimeId),
+    { initialProps }
+  )
+  return { ...hook, initialProps }
+}
+
+function pendingPicker() {
+  let resolve: (path: string | null) => void = () => {}
+  const promise = new Promise<string | null>((complete) => {
+    resolve = complete
+  })
+  vi.mocked(window.api.shell.pickImage).mockReturnValue(promise)
+  return { resolve }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  Object.defineProperty(window, 'api', {
+    configurable: true,
+    value: { shell: { pickImage: vi.fn().mockResolvedValue('/tmp/image.png') } }
+  })
+  vi.mocked(importExternalPathsToRuntime).mockResolvedValue({
+    results: [
+      {
+        sourcePath: '/tmp/image.png',
+        status: 'imported',
+        destPath: '/repo/image.png',
+        kind: 'file',
+        renamed: false
+      }
+    ]
+  })
+})
+
+afterEach(() => {
+  editors.splice(0).forEach((editor) => editor.destroy())
+  document.body.replaceChildren()
+})
+
+describe('local image picker pending insertion', () => {
+  it('replaces the selected range after it moves while the picker is open', async () => {
+    const editor = richEditor()
+    const { result, unmount } = mountPicker(editor)
+    const pending = pendingPicker()
+    const request = result.current()
+    editor.view.dispatch(editor.state.tr.insertText('prefix ', 1))
+    pending.resolve('/tmp/image.png')
+    await request
+    expect(editor.getMarkdown()).toBe('prefix hello ![](image.png)')
+    unmount()
+  })
+
+  it('keeps the live caret and outside control focus after the picker completes', async () => {
+    const editor = richEditor()
+    editor.view.dom.focus()
+    const { result, unmount } = mountPicker(editor)
+    const pending = pendingPicker()
+    const request = result.current()
+    editor.commands.setTextSelection(1)
+    editor.commands.insertContent('x')
+    const input = document.createElement('input')
+    document.body.append(input)
+    input.focus()
+    pending.resolve('/tmp/image.png')
+    await request
+    await new Promise((resolve) => requestAnimationFrame(() => resolve(undefined)))
+    expect(document.activeElement).toBe(input)
+    editor.commands.insertContent('y')
+    expect(editor.getMarkdown()).toBe('xyhello ![](image.png)')
+    unmount()
+  })
+
+  it.each(['editor', 'filePath', 'worktreeId', 'runtimeId'])(
+    'cancels before import when %s changes',
+    async (field) => {
+      const editor = richEditor()
+      const { result, rerender, unmount, initialProps } = mountPicker(editor)
+      const pending = pendingPicker()
+      const request = result.current()
+      const nextProps = { ...initialProps }
+      if (field === 'editor') {
+        nextProps.editor = richEditor()
+      } else if (field === 'filePath') {
+        nextProps.filePath = '/repo/other.md'
+      } else if (field === 'worktreeId') {
+        nextProps.worktreeId = 'folder:other'
+      } else {
+        nextProps.runtimeId = 'other-runtime'
+      }
+      rerender(nextProps)
+      pending.resolve('/tmp/image.png')
+      await request
+      expect(importExternalPathsToRuntime).not.toHaveBeenCalled()
+      expect(editor.getMarkdown()).toBe('hello world')
+      expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+        'Image insertion canceled because the destination changed. Try again.'
+      )
+      unmount()
+    }
+  )
+
+  it('cancels after import starts when the current editor is removed', async () => {
+    const editor = richEditor()
+    const { result, rerender, unmount, initialProps } = mountPicker(editor)
+    let completeImport: (result: ImportResult) => void = () => {}
+    vi.mocked(importExternalPathsToRuntime).mockReturnValue(
+      new Promise((resolve) => {
+        completeImport = resolve
+      })
+    )
+    const request = result.current()
+    await Promise.resolve()
+    expect(importExternalPathsToRuntime).toHaveBeenCalledOnce()
+    rerender({ ...initialProps, editor: null })
+    completeImport({
+      results: [
+        {
+          sourcePath: '/tmp/image.png',
+          status: 'imported',
+          destPath: '/repo/image.png',
+          kind: 'file',
+          renamed: false
+        }
+      ]
+    })
+    await request
+    expect(editor.getMarkdown()).toBe('hello world')
+    expect(toast.info).toHaveBeenCalledExactlyOnceWith(
+      'Image insertion canceled because the destination changed. The imported file was kept.'
+    )
+    unmount()
+  })
+
+  it('cancels on unmount before a picker result arrives', async () => {
+    const editor = richEditor()
+    const { result, unmount } = mountPicker(editor)
+    const pending = pendingPicker()
+    const request = result.current()
+    unmount()
+    pending.resolve('/tmp/image.png')
+    await request
+    expect(importExternalPathsToRuntime).not.toHaveBeenCalled()
+    expect(editor.getMarkdown()).toBe('hello world')
+  })
+
+  it.each(['cancel', 'failure'])(
+    'releases its transaction listener on picker %s',
+    async (operation) => {
+      const editor = richEditor()
+      const off = vi.spyOn(editor, 'off')
+      const { result, unmount } = mountPicker(editor)
+      if (operation === 'cancel') {
+        vi.mocked(window.api.shell.pickImage).mockResolvedValue(null)
+      } else {
+        vi.mocked(window.api.shell.pickImage).mockRejectedValue(new Error('Picker failed'))
+      }
+      await result.current()
+      expect(off).toHaveBeenCalledWith('transaction', expect.any(Function))
+      expect(importExternalPathsToRuntime).not.toHaveBeenCalled()
+      if (operation === 'failure') {
+        expect(toast.error).toHaveBeenCalledWith('Picker failed')
+      } else {
+        expect(toast.error).not.toHaveBeenCalled()
+      }
+      expect(toast.info).not.toHaveBeenCalled()
+      unmount()
+    }
+  )
+})
diff --git a/src/renderer/src/components/editor/useLocalImagePick.ts b/src/renderer/src/components/editor/useLocalImagePick.ts
index bf988ef7da2..f5d7642806d 100644
--- a/src/renderer/src/components/editor/useLocalImagePick.ts
+++ b/src/renderer/src/components/editor/useLocalImagePick.ts
@@ -1,8 +1,13 @@
-import { useCallback } from 'react'
+import { useCallback, useLayoutEffect, useRef } from 'react'
 import type { Editor } from '@tiptap/react'
 import { toast } from 'sonner'
 import { insertRichMarkdownImageFromPath } from './rich-markdown-image-insert'
 import { extractIpcErrorMessage } from './rich-markdown-ipc-error-message'
+import { showRichMarkdownImageInsertionCanceled } from './rich-markdown-image-insertion-feedback'
+import {
+  captureRichMarkdownImageInsertionTarget,
+  type RichMarkdownImageInsertionTarget
+} from './rich-markdown-image-insertion-target'
 
 export function useLocalImagePick(
   editor: Editor | null,
@@ -10,33 +15,46 @@ export function useLocalImagePick(
   worktreeId: string | null,
   runtimeEnvironmentId?: string | null
 ): () => Promise<void> {
+  const pendingTargetsRef = useRef(new Set<RichMarkdownImageInsertionTarget>())
+  useLayoutEffect(() => {
+    const pendingTargets = pendingTargetsRef.current
+    return () => {
+      pendingTargets.forEach((target) => target.dispose())
+      pendingTargets.clear()
+    }
+  }, [editor, filePath, runtimeEnvironmentId, worktreeId])
+
   return useCallback(async () => {
     if (!editor) {
       return
     }
-    // Why: the native file picker steals focus from the editor, which can cause
-    // ProseMirror to lose track of its selection. We snapshot the cursor position
-    // before the async dialog so we can insert the image exactly where the user
-    // intended, not at whatever position focus() falls back to afterward.
-    const insertPos = editor.state.selection.from
-    const targetDom = editor.view.dom
+    const target = captureRichMarkdownImageInsertionTarget(editor)
+    if (!target) {
+      return
+    }
+    pendingTargetsRef.current.add(target)
     try {
       const srcPath = await window.api.shell.pickImage()
       if (!srcPath) {
         return
       }
+      if (!target.getRange()) {
+        showRichMarkdownImageInsertionCanceled()
+        return
+      }
       await insertRichMarkdownImageFromPath({
         editor,
         filePath,
         sourcePath: srcPath,
         worktreeId,
         runtimeEnvironmentId,
-        insertPos,
-        canInsert: (candidate) =>
-          !candidate.isDestroyed && candidate.view.dom === targetDom && targetDom.isConnected
+        getInsertionRange: target.getRange
       })
     } catch (err) {
       toast.error(extractIpcErrorMessage(err, 'Failed to insert image.'))
+    } finally {
+      target.dispose()
+      pendingTargetsRef.current.delete(target)
     }
   }, [editor, filePath, runtimeEnvironmentId, worktreeId])
 }
diff --git a/src/renderer/src/components/editor/useLocalImageSrc.test.ts b/src/renderer/src/components/editor/useLocalImageSrc.test.ts
index 1c93693ff1c..26ebe4de483 100644
--- a/src/renderer/src/components/editor/useLocalImageSrc.test.ts
+++ b/src/renderer/src/components/editor/useLocalImageSrc.test.ts
@@ -418,4 +418,22 @@ describe('loadLocalImageSrc', () => {
 
     expect(renders).toEqual([undefined])
   })
+
+  it('never shares a cached image across access kinds', () => {
+    const userFile = getLocalImageCacheKey('/tmp/a.png', undefined, undefined, {
+      kind: 'user-file'
+    })
+    const fromDocA = getLocalImageCacheKey('/tmp/a.png', undefined, undefined, {
+      kind: 'document-resource',
+      documentPath: '/tmp/a.md'
+    })
+    const fromDocB = getLocalImageCacheKey('/tmp/a.png', undefined, undefined, {
+      kind: 'document-resource',
+      documentPath: '/other/b.md'
+    })
+
+    expect(new Set([userFile, fromDocA, fromDocB, getLocalImageCacheKey('/tmp/a.png')]).size).toBe(
+      4
+    )
+  })
 })
diff --git a/src/renderer/src/components/editor/useLocalImageSrc.ts b/src/renderer/src/components/editor/useLocalImageSrc.ts
index 38339ee36ea..2e1224ecb97 100644
--- a/src/renderer/src/components/editor/useLocalImageSrc.ts
+++ b/src/renderer/src/components/editor/useLocalImageSrc.ts
@@ -2,6 +2,7 @@ import { useEffect, useState } from 'react'
 import { resolveImageAbsolutePath } from './markdown-preview-links'
 import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
 import { readLocalImagePreview } from './local-image-src-reader'
+import type { LocalFileAccess } from '../../../../shared/local-file-access'
 import {
   blobUrlCache,
   cacheLocalImageBlob,
@@ -20,7 +21,10 @@ import {
 export function getLocalImageCacheKey(
   absolutePath: string,
   connectionId?: string | null,
-  runtimeContext?: Omit<RuntimeFileOperationArgs, 'connectionId'> & { connectionId?: string | null }
+  runtimeContext?: Omit<RuntimeFileOperationArgs, 'connectionId'> & {
+    connectionId?: string | null
+  },
+  access?: LocalFileAccess
 ): string {
   const runtimeEnvironmentId =
     runtimeContext?.settings?.activeRuntimeEnvironmentId?.trim() ?? 'client'
@@ -33,6 +37,9 @@ export function getLocalImageCacheKey(
     runtimeContext?.expectedExternalSshTargetId ?? '',
     runtimeContext?.worktreeId ?? 'unknown-worktree',
     runtimeContext?.worktreePath ?? '',
+    // Why: an image read under one access kind must never answer a request made under another.
+    access?.kind ?? 'roots',
+    access?.kind === 'document-resource' ? access.documentPath : '',
     absolutePath
   ].join('\0')
 }
@@ -67,13 +74,14 @@ export function useLocalImageSrc(
   connectionId?: string | null,
   runtimeContext?:
     | (Omit<RuntimeFileOperationArgs, 'connectionId'> & { connectionId?: string | null })
-    | null
+    | null,
+  access?: LocalFileAccess
 ): string | undefined {
   const [generation, setGeneration] = useState(getLocalImageCacheGeneration())
 
   useEffect(() => {
-    return acquireLocalImageSrcLease(rawSrc, filePath, connectionId, runtimeContext)
-  }, [rawSrc, filePath, connectionId, runtimeContext])
+    return acquireLocalImageSrcLease(rawSrc, filePath, connectionId, runtimeContext, access)
+  }, [rawSrc, filePath, connectionId, runtimeContext, access])
 
   useEffect(() => {
     return onImageCacheInvalidated(() => setGeneration(getLocalImageCacheGeneration()))
@@ -88,7 +96,7 @@ export function useLocalImageSrc(
     }
     const absolutePath = resolveImageAbsolutePath(rawSrc, filePath)
     if (absolutePath) {
-      const cacheKey = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext)
+      const cacheKey = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext, access)
       if (blobUrlCache.has(cacheKey)) {
         return blobUrlCache.get(cacheKey)
       }
@@ -113,7 +121,7 @@ export function useLocalImageSrc(
       return
     }
 
-    const cacheKey = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext)
+    const cacheKey = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext, access)
     if (blobUrlCache.has(cacheKey)) {
       setDisplaySrc(blobUrlCache.get(cacheKey))
       return
@@ -121,7 +129,7 @@ export function useLocalImageSrc(
 
     let cancelled = false
     const effectGeneration = generation
-    loadLocalImageAbsolutePath(absolutePath, connectionId, runtimeContext)
+    loadLocalImageAbsolutePath(absolutePath, connectionId, runtimeContext, access)
       .then((url) => {
         if (cancelled) {
           return
@@ -137,7 +145,7 @@ export function useLocalImageSrc(
     return () => {
       cancelled = true
     }
-  }, [rawSrc, filePath, generation, connectionId, runtimeContext])
+  }, [rawSrc, filePath, generation, connectionId, runtimeContext, access])
 
   return displaySrc
 }
@@ -153,7 +161,8 @@ export async function loadLocalImageSrc(
   connectionId?: string | null,
   runtimeContext?:
     | (Omit<RuntimeFileOperationArgs, 'connectionId'> & { connectionId?: string | null })
-    | null
+    | null,
+  access?: LocalFileAccess
 ): Promise<string | null> {
   if (isExternalUrl(rawSrc)) {
     return rawSrc
@@ -167,13 +176,13 @@ export async function loadLocalImageSrc(
     return null
   }
 
-  const cacheKey = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext)
+  const cacheKey = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext, access)
   const cached = blobUrlCache.get(cacheKey)
   if (cached) {
     return cached
   }
 
-  return loadLocalImageAbsolutePath(absolutePath, connectionId, runtimeContext)
+  return loadLocalImageAbsolutePath(absolutePath, connectionId, runtimeContext, access)
 }
 
 export function loadLocalImageAbsolutePath(
@@ -181,12 +190,13 @@ export function loadLocalImageAbsolutePath(
   connectionId?: string | null,
   runtimeContext?:
     | (Omit<RuntimeFileOperationArgs, 'connectionId'> & { connectionId?: string | null })
-    | null
+    | null,
+  access?: LocalFileAccess
 ): Promise<string | null> {
   if (runtimeContext === null) {
     return Promise.resolve(null)
   }
-  const cacheKey = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext)
+  const cacheKey = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext, access)
   const cached = blobUrlCache.get(cacheKey)
   if (cached) {
     return Promise.resolve(cached)
@@ -199,7 +209,7 @@ export function loadLocalImageAbsolutePath(
 
   const readGeneration = getLocalImageCacheGeneration()
   const readLeaseVersion = getLocalImageCacheKeyVersion(cacheKey)
-  const loadPromise = readLocalImagePreview(absolutePath, connectionId, runtimeContext)
+  const loadPromise = readLocalImagePreview(absolutePath, connectionId, runtimeContext, access)
     .then((result) => {
       if (
         !result.isBinary ||
@@ -240,7 +250,8 @@ export function acquireLocalImageSrcLease(
   connectionId?: string | null,
   runtimeContext?:
     | (Omit<RuntimeFileOperationArgs, 'connectionId'> & { connectionId?: string | null })
-    | null
+    | null,
+  access?: LocalFileAccess
 ): (() => void) | undefined {
   if (!rawSrc || isExternalUrl(rawSrc) || runtimeContext === null) {
     return undefined
@@ -249,7 +260,7 @@ export function acquireLocalImageSrcLease(
   if (!absolutePath) {
     return undefined
   }
-  const key = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext)
+  const key = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext, access)
   pinLocalImageCache(key)
   return () => unpinLocalImageCache(key)
 }
@@ -261,7 +272,8 @@ export function releaseLocalImageSrc(
   connectionId?: string | null,
   runtimeContext?:
     | (Omit<RuntimeFileOperationArgs, 'connectionId'> & { connectionId?: string | null })
-    | null
+    | null,
+  access?: LocalFileAccess
 ): void {
   if (!rawSrc || isExternalUrl(rawSrc) || runtimeContext === null) {
     return
@@ -270,6 +282,6 @@ export function releaseLocalImageSrc(
   if (!absolutePath) {
     return
   }
-  const key = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext)
+  const key = getLocalImageCacheKey(absolutePath, connectionId, runtimeContext, access)
   releaseLocalImageBlob(key)
 }
diff --git a/src/renderer/src/components/editor/useRichMarkdownReviewData.ts b/src/renderer/src/components/editor/useRichMarkdownReviewData.ts
index a447562f5d4..447bd938b56 100644
--- a/src/renderer/src/components/editor/useRichMarkdownReviewData.ts
+++ b/src/renderer/src/components/editor/useRichMarkdownReviewData.ts
@@ -65,7 +65,7 @@ export function useRichMarkdownReviewData({
           'All unsent notes'
         ),
         notes: unsentNotes,
-        prompt: formatMarkdownReviewNotes(unsentNotes, markdownReviewContent)
+        formatPrompt: (notes) => formatMarkdownReviewNotes(notes, markdownReviewContent)
       }
     ]
   }, [markdownReviewContent, markdownReviewNotes])
diff --git a/src/renderer/src/components/floating-terminal/FloatingTerminalWindowControls.test.tsx b/src/renderer/src/components/floating-terminal/FloatingTerminalWindowControls.test.tsx
index 2a16207c5f4..da9710b965d 100644
--- a/src/renderer/src/components/floating-terminal/FloatingTerminalWindowControls.test.tsx
+++ b/src/renderer/src/components/floating-terminal/FloatingTerminalWindowControls.test.tsx
@@ -174,6 +174,7 @@ describe('FloatingTerminalWindowControls default-agent launch', () => {
     clickLaunch()
 
     expect(mocks.launchAgentInNewTab).toHaveBeenCalledExactlyOnceWith({
+      requestId: expect.any(String),
       agent: 'claude',
       worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
       launchSource: 'shortcut'
diff --git a/src/renderer/src/components/floating-terminal/FloatingTerminalWindowControls.tsx b/src/renderer/src/components/floating-terminal/FloatingTerminalWindowControls.tsx
index 3889a5f342f..28fa197c050 100644
--- a/src/renderer/src/components/floating-terminal/FloatingTerminalWindowControls.tsx
+++ b/src/renderer/src/components/floating-terminal/FloatingTerminalWindowControls.tsx
@@ -6,6 +6,7 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip
 import { getAgentCatalog, AgentIcon } from '@/lib/agent-catalog'
 import { focusTerminalTabSurface } from '@/lib/focus-terminal-tab-surface'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { useAppStore } from '@/store'
 import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../../shared/constants'
 import {
@@ -67,6 +68,7 @@ export function FloatingTerminalWindowControls({
     // Floating resolves the terminal-backed lane: a chat view over a PTY when the chat default is
     // on, never a structured session.
     const result = launchAgentInNewTab({
+      requestId: newAgentLaunchRequestId(),
       agent: defaultAgent,
       worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
       launchSource: 'shortcut'
diff --git a/src/renderer/src/components/github-project/ProjectCellValueEditors.tsx b/src/renderer/src/components/github-project/ProjectCellValueEditors.tsx
index 7610e434cf8..a8601e7c780 100644
--- a/src/renderer/src/components/github-project/ProjectCellValueEditors.tsx
+++ b/src/renderer/src/components/github-project/ProjectCellValueEditors.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React, { useState } from 'react'
 import { Plus } from 'lucide-react'
 import { Input } from '@/components/ui/input'
@@ -89,7 +90,7 @@ export function ProjectDateCell({
     return <span className="text-xs">{value}</span>
   }
   return (
-    <input
+    <ImeInput
       type="date"
       aria-label={label}
       value={draft}
diff --git a/src/renderer/src/components/gitlab-item-dialog/gitlab-item-dialog-view.tsx b/src/renderer/src/components/gitlab-item-dialog/gitlab-item-dialog-view.tsx
index e29008201cf..5a4bc3efed3 100644
--- a/src/renderer/src/components/gitlab-item-dialog/gitlab-item-dialog-view.tsx
+++ b/src/renderer/src/components/gitlab-item-dialog/gitlab-item-dialog-view.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import { CircleDot, ExternalLink, GitMerge, LoaderCircle, RefreshCw, Send, X } from 'lucide-react'
 import { VisuallyHidden } from 'radix-ui'
 import { Button } from '@/components/ui/button'
@@ -202,7 +203,7 @@ export function GitLabItemDialogView({
               {/* Why: comment composer at the top of the footer so the
                   primary actions row stays visually grouped at the bottom. */}
               <div className="flex items-end gap-2">
-                <textarea
+                <ImeTextarea
                   value={commentDraft}
                   onChange={(event) => updateCommentDraft(event.target.value)}
                   placeholder={translate(
diff --git a/src/renderer/src/components/jira-self-user.test.ts b/src/renderer/src/components/jira-self-user.test.ts
new file mode 100644
index 00000000000..6475b1b96bd
--- /dev/null
+++ b/src/renderer/src/components/jira-self-user.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest'
+import type { JiraConnectionStatus } from '../../../shared/jira-types'
+import { getJiraSelfUser } from './jira-self-user'
+
+const viewer = {
+  accountId: 'viewer-1',
+  displayName: 'Viewer One',
+  email: 'viewer@example.com'
+}
+
+function status(partial: Partial<JiraConnectionStatus>): JiraConnectionStatus {
+  return { connected: true, viewer, ...partial }
+}
+
+describe('getJiraSelfUser', () => {
+  it('prefers the stored identity of the target site', () => {
+    const result = getJiraSelfUser(
+      status({
+        activeSiteId: 'a',
+        sites: [
+          {
+            id: 'a',
+            siteUrl: 'https://a',
+            email: 'a@example.com',
+            displayName: 'User A',
+            accountId: 'acc-a'
+          },
+          {
+            id: 'b',
+            siteUrl: 'https://b',
+            email: 'b@example.com',
+            displayName: 'User B',
+            accountId: 'acc-b'
+          }
+        ]
+      }),
+      'b'
+    )
+    expect(result).toEqual({ accountId: 'acc-b', displayName: 'User B' })
+  })
+
+  it('does not fall back to the viewer for a different, unknown site', () => {
+    const result = getJiraSelfUser(
+      status({
+        activeSiteId: 'a',
+        sites: [
+          {
+            id: 'a',
+            siteUrl: 'https://a',
+            email: 'a@example.com',
+            displayName: 'User A',
+            accountId: 'acc-a'
+          },
+          { id: 'b', siteUrl: 'https://b', email: 'b@example.com', displayName: '', accountId: '' }
+        ]
+      }),
+      'b'
+    )
+    expect(result).toBeNull()
+  })
+
+  it('falls back to the viewer for the active site and for siteless single-site setups', () => {
+    const withActive = getJiraSelfUser(
+      status({
+        activeSiteId: 'a',
+        sites: [
+          { id: 'a', siteUrl: 'https://a', email: 'a@example.com', displayName: '', accountId: '' },
+          {
+            id: 'b',
+            siteUrl: 'https://b',
+            email: 'b@example.com',
+            displayName: 'User B',
+            accountId: 'acc-b'
+          }
+        ]
+      }),
+      'a'
+    )
+    expect(withActive?.accountId).toBe('viewer-1')
+
+    const withoutSiteId = getJiraSelfUser(status({}), null)
+    expect(withoutSiteId?.accountId).toBe('viewer-1')
+  })
+
+  it('never borrows the viewer for an explicitly unknown site', () => {
+    expect(getJiraSelfUser(status({ activeSiteId: 'a' }), 'b')).toBeNull()
+    expect(
+      getJiraSelfUser(
+        status({
+          activeSiteId: 'a',
+          sites: [{ id: 'a', siteUrl: 'https://a', email: '', displayName: '', accountId: '' }]
+        }),
+        'b'
+      )
+    ).toBeNull()
+  })
+
+  it('returns null when nothing is connected', () => {
+    expect(getJiraSelfUser(null, 'a')).toBeNull()
+    expect(getJiraSelfUser(status({ connected: false }), null)).toBeNull()
+    expect(getJiraSelfUser({ connected: false, viewer: null }, null)).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/jira-self-user.ts b/src/renderer/src/components/jira-self-user.ts
new file mode 100644
index 00000000000..52ce9ea9912
--- /dev/null
+++ b/src/renderer/src/components/jira-self-user.ts
@@ -0,0 +1,32 @@
+import type { JiraConnectionStatus, JiraUser } from '../../../shared/jira-types'
+
+// Site identities take precedence over the active site's viewer.
+export function getJiraSelfUser(
+  status: JiraConnectionStatus | null | undefined,
+  siteId: string | null | undefined
+): JiraUser | null {
+  if (!status?.connected) {
+    return null
+  }
+  const sites = status?.sites ?? []
+  const site = siteId ? sites.find((candidate) => candidate.id === siteId) : null
+  if (site?.accountId) {
+    return {
+      accountId: site.accountId,
+      displayName: site.displayName || site.email || site.accountId
+    }
+  }
+  const viewer = status?.viewer
+  if (
+    viewer?.accountId &&
+    (!siteId || siteId === status.activeSiteId || (site?.id === siteId && sites.length === 1))
+  ) {
+    return {
+      accountId: viewer.accountId,
+      displayName: viewer.displayName,
+      email: viewer.email,
+      avatarUrl: viewer.avatarUrl
+    }
+  }
+  return null
+}
diff --git a/src/renderer/src/components/jira-user-picker.tsx b/src/renderer/src/components/jira-user-picker.tsx
index 249e295f262..a9770dffec6 100644
--- a/src/renderer/src/components/jira-user-picker.tsx
+++ b/src/renderer/src/components/jira-user-picker.tsx
@@ -43,6 +43,12 @@ export function JiraUserOptionList({
  * not the display name a plain text box would collect, since Jira rejects a bare
  * string for user fields.
  */
+export type JiraUserPickerFixedOption = {
+  key: string
+  label: string
+  onSelect: () => void
+}
+
 export function JiraUserPicker({
   providerSettings,
   siteId,
@@ -50,7 +56,9 @@ export function JiraUserPicker({
   selectedUser,
   onSelect,
   disabled,
-  label
+  label,
+  fixedOptions,
+  searchUsers
 }: {
   providerSettings: TaskSourceContext | GlobalSettings | null
   siteId?: string | null
@@ -59,6 +67,10 @@ export function JiraUserPicker({
   onSelect: (user: JiraUser) => void
   disabled?: boolean
   label: string
+  /** Rows pinned above the search results, e.g. "Automatic" or "Assign to me". */
+  fixedOptions?: JiraUserPickerFixedOption[]
+  /** Replaces the site-wide user search, e.g. with a project-scoped assignable search. Must be referentially stable. */
+  searchUsers?: (query: string) => Promise<JiraUser[]>
 }): React.JSX.Element {
   const [open, setOpen] = useState(false)
   const [query, setQuery] = useState('')
@@ -72,7 +84,7 @@ export function JiraUserPicker({
     let cancelled = false
     setLoading(true)
     const timer = setTimeout(() => {
-      void jiraSearchUsers(providerSettings, query, siteId)
+      void (searchUsers ? searchUsers(query) : jiraSearchUsers(providerSettings, query, siteId))
         .then((found) => {
           if (!cancelled) {
             setUsers(found)
@@ -93,7 +105,7 @@ export function JiraUserPicker({
       cancelled = true
       clearTimeout(timer)
     }
-  }, [open, providerSettings, query, siteId])
+  }, [open, providerSettings, query, searchUsers, siteId])
 
   const triggerLabel = useMemo(() => {
     if (selectedUser?.displayName) {
@@ -130,6 +142,19 @@ export function JiraUserPicker({
           className="mb-1 h-7 text-[12px]"
           autoFocus
         />
+        {fixedOptions?.map((option) => (
+          <button
+            key={option.key}
+            type="button"
+            onClick={() => {
+              option.onSelect()
+              setOpen(false)
+            }}
+            className="flex w-full items-center gap-2 rounded-sm px-2 py-1.5 text-left text-[12px] hover:bg-accent"
+          >
+            {option.label}
+          </button>
+        ))}
         {users.length === 0 && !loading ? (
           <p className="px-2 py-1.5 text-[12px] text-muted-foreground">
             {translate('components.jiraUserPicker.empty', 'No users found')}
diff --git a/src/renderer/src/components/linear-issue-sub-issues.tsx b/src/renderer/src/components/linear-issue-sub-issues.tsx
index 970f7997bfc..8d08f338f43 100644
--- a/src/renderer/src/components/linear-issue-sub-issues.tsx
+++ b/src/renderer/src/components/linear-issue-sub-issues.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React, { useCallback, useMemo, useRef, useState } from 'react'
 import { ArrowRight, LoaderCircle, Plus } from 'lucide-react'
 import { toast } from 'sonner'
@@ -187,7 +188,7 @@ export function LinearIssueSubIssues({
         </PopoverTrigger>
         <PopoverContent className="w-80 p-3" align="start">
           <div className="space-y-3">
-            <input
+            <ImeInput
               value={title}
               onChange={(event) => setTitle(event.target.value)}
               onKeyDown={(event) => {
diff --git a/src/renderer/src/components/linear-item-drawer-comment-footer.tsx b/src/renderer/src/components/linear-item-drawer-comment-footer.tsx
index 09cbe469015..6f6a12fe573 100644
--- a/src/renderer/src/components/linear-item-drawer-comment-footer.tsx
+++ b/src/renderer/src/components/linear-item-drawer-comment-footer.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import React, { useCallback, useRef, useState } from 'react'
 import { LoaderCircle, Send } from 'lucide-react'
 import { toast } from 'sonner'
@@ -123,7 +124,7 @@ export function LinearIssueCommentFooter({
         ref={handleFooterRef}
         className="rounded-xl border border-border/70 bg-background shadow-xs"
       >
-        <textarea
+        <ImeTextarea
           ref={textareaRef}
           value={body}
           onChange={(e) => {
@@ -168,7 +169,7 @@ export function LinearIssueCommentFooter({
       ref={handleFooterRef}
       className="flex items-end gap-2 border-t border-border/60 bg-background/40 px-4 py-3"
     >
-      <textarea
+      <ImeTextarea
         ref={textareaRef}
         value={body}
         onChange={(e) => {
diff --git a/src/renderer/src/components/mobile/mobile-platform-copy.ts b/src/renderer/src/components/mobile/mobile-platform-copy.ts
index f33f9a42196..45149f90858 100644
--- a/src/renderer/src/components/mobile/mobile-platform-copy.ts
+++ b/src/renderer/src/components/mobile/mobile-platform-copy.ts
@@ -22,7 +22,7 @@ const IOS_CHANNEL_COPY: Record<IosChannel, InstallCopy> = {
 
 const ANDROID_COPY: InstallCopy = {
   ctaLabel: 'Download APK',
-  url: 'https://github.com/stablyai/orca/releases/download/mobile-android-v0.0.48/app-release.apk'
+  url: 'https://github.com/stablyai/orca/releases/download/mobile-android-v0.0.52/app-release.apk'
 }
 
 export function getInstallCopy(platform: Platform, iosChannel: IosChannel): InstallCopy {
diff --git a/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.test.tsx b/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.test.tsx
index 2b5924e9826..068592d16c4 100644
--- a/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.test.tsx
@@ -50,6 +50,8 @@ describe('NativeChatImageAttachmentPreview', () => {
     mocks.useLocalImageSrc.mockReturnValue(undefined)
     renderPreview({ id: 'a1', path: '', previewUrl: 'blob:clipboard-1', pending: true })
 
-    expect(mocks.useLocalImageSrc).toHaveBeenCalledWith(undefined, '', undefined)
+    expect(mocks.useLocalImageSrc).toHaveBeenCalledWith(undefined, '', undefined, undefined, {
+      kind: 'chat-image'
+    })
   })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.tsx b/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.tsx
index 52e9a5f7c3a..819cfaeaf9e 100644
--- a/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.tsx
@@ -6,6 +6,7 @@ import { basename } from '@/lib/path'
 import { useLocalImageSrc } from '@/components/editor/useLocalImageSrc'
 import { isNativeChatPastedImagePath } from './native-chat-image-paste'
 import type { NativeChatComposerImageAttachment } from './NativeChatComposerField'
+import { chatImageAccess } from '@/lib/local-file-access'
 
 type Props = {
   attachment: NativeChatComposerImageAttachment
@@ -45,7 +46,10 @@ export function NativeChatImageAttachmentPreview({
   const localSrc = useLocalImageSrc(
     !isPending && (isNearViewport || isOpen) ? attachment.path : undefined,
     attachment.path,
-    attachment.connectionId
+    attachment.connectionId,
+    undefined,
+    // Why chat-image: a draft handed off from the host queue may carry paths a paired client chose.
+    chatImageAccess()
   )
   // The clipboard thumbnail is already in this process, so it renders with no
   // round-trip; the on-disk file only wins for the full-size dialog.
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx
index 13f98dd4249..acce19bcf52 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx
@@ -112,7 +112,8 @@ function session(): NativeChatLiveSession {
 }
 
 describe('NativeChatMessageList folded turn headers', () => {
-  it('says a turn a crash cut off failed and a stopped turn was interrupted, where a finished one worked', () => {
+  // A crash-cut turn reads like a finished one; the chat's notice row is what says it stopped.
+  it('says a crash-cut turn worked like a finished one and a stopped turn was interrupted', () => {
     render(
       <NativeChatMessageList
         session={session()}
@@ -129,7 +130,7 @@ describe('NativeChatMessageList folded turn headers', () => {
       .map((button) => [button.textContent, button.getAttribute('aria-expanded')])
     expect(headers).toEqual([
       ['Worked for 12s', 'false'],
-      ['Failed after 12s', 'false'],
+      ['Worked for 12s', 'false'],
       ['Interrupted after 12s', 'false']
     ])
     // The turn's detail stays inside the fold.
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.provider-retry-runs.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.provider-retry-runs.test.tsx
index eb71e3e6b54..db59afdb19d 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.provider-retry-runs.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.provider-retry-runs.test.tsx
@@ -10,6 +10,8 @@ import { NativeChatMessageList } from './NativeChatMessageList'
 import { installNativeChatMessageListTestViewport } from './native-chat-message-list-test-viewport'
 import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
 
+const NO_CARDS: readonly string[] = []
+
 let restoreViewport = (): void => {}
 beforeAll(() => {
   restoreViewport = installNativeChatMessageListTestViewport()
@@ -42,7 +44,7 @@ function transcript(items: AgentJournalRenderItem[]) {
   return (
     <NativeChatMessageList
       session={{
-        messages: projectStructuredAgentSessionMessages(items, [], []),
+        messages: projectStructuredAgentSessionMessages(items, [], [], NO_CARDS),
         status: 'ready',
         sessionId: 'live-codex',
         agent: 'codex',
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.stream-render.perf.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.stream-render.perf.test.tsx
index 74df2b75bd6..7efb254c619 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.stream-render.perf.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.stream-render.perf.test.tsx
@@ -143,7 +143,9 @@ describe('native chat transcript re-render cost during a streaming turn', () =>
     }
     const view = (items: AgentJournalRenderItem[]) => (
       <NativeChatMessageList
-        session={sessionWith(projectStructuredAgentSessionMessages(items, [], []))}
+        session={sessionWith(
+          projectStructuredAgentSessionMessages(items, [], [], { rejectedInPlace: true })
+        )}
         journalItems={items}
         isWorking={false}
         expandSignal={false}
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tool-stream-cost.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tool-stream-cost.test.tsx
index a77d2907b6a..d8a9379ca19 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tool-stream-cost.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tool-stream-cost.test.tsx
@@ -32,7 +32,7 @@ afterEach(cleanup)
 const EMPTY: never[] = []
 const loadEarlier = () => Promise.resolve('exhausted' as const)
 function Transcript({ items }: { items: AgentJournalRenderItem[] }) {
-  const messages = useStructuredAgentSessionMessages(items, EMPTY, EMPTY)
+  const messages = useStructuredAgentSessionMessages(items, EMPTY, EMPTY, EMPTY)
   const session: NativeChatLiveSession = {
     messages,
     status: 'working',
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-membership.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-membership.test.tsx
index b01675c63a7..29f977046f6 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-membership.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-membership.test.tsx
@@ -88,7 +88,9 @@ function journalList(
   return (
     <NativeChatMessageList
       session={{
-        messages: projectStructuredAgentSessionMessages(items, [], submissions),
+        messages: projectStructuredAgentSessionMessages(items, [], submissions, {
+          rejectedInPlace: true
+        }),
         status: 'ready',
         sessionId: 'session-1',
         agent: 'codex',
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx
index 2df11a22a10..ac6ab467ace 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx
@@ -20,10 +20,14 @@ import {
   createStructuredAgentSessionOutboxEntry,
   type StructuredAgentSessionOutboxEntry
 } from '../../../../shared/structured-agent-session-outbox'
+import { DISPATCH_REJECTED_HOST_RESTARTED } from '../../../../shared/structured-agent-session-dispatch-rejection'
 import { NativeChatMessageList } from './NativeChatMessageList'
+import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
 import { installNativeChatMessageListTestViewport } from './native-chat-message-list-test-viewport'
 import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
 
+const NO_CARDS: readonly string[] = []
+
 let restoreViewport = (): void => {}
 beforeAll(() => {
   restoreViewport = installNativeChatMessageListTestViewport()
@@ -135,7 +139,7 @@ function list(phase: Phase, scoped: boolean, outbox: StructuredAgentSessionOutbo
   return (
     <NativeChatMessageList
       session={{
-        messages: projectStructuredAgentSessionMessages(items, outbox, submissions),
+        messages: projectStructuredAgentSessionMessages(items, outbox, submissions, NO_CARDS),
         status: phase === 'done' ? 'ready' : 'working',
         sessionId: 'session-1',
         agent: 'claude',
@@ -214,3 +218,91 @@ describe.each([
     }
   )
 })
+
+describe('a message the host rejected after a crash, with no outbox entry left', () => {
+  const LOST = agentJournalSubmissionKey('lost')
+
+  function hostList(phase: Phase) {
+    const items = journal(phase, true)
+    const newIndex = items.findIndex((item) => item.itemId === NEW)
+    // Recorded between the seed's answer and the newer prompt; the next open rejected it.
+    items.splice(newIndex, 0, {
+      itemId: LOST,
+      revision: 0,
+      sequence: items[newIndex - 1]!.sequence,
+      sequenceIndex: 1,
+      observedAt: 1002.5,
+      body: said('user', 'LOST PROMPT'),
+      turnScope: { kind: 'thread' }
+    })
+    const submissions: AgentJournalSubmission[] = [
+      submission('seed', 'accepted'),
+      {
+        ...submission('lost', 'rejected'),
+        reason: DISPATCH_REJECTED_HOST_RESTARTED,
+        rejection: { kind: 'hostRestarted' }
+      },
+      submission('new', phase === 'done' ? 'accepted' : 'pending')
+    ]
+    const settledTurns: NativeChatSettledTurns = new Map([
+      [SEED, { startedAt: 1, workedSeconds: 3 }],
+      ...(phase === 'done' ? [[NEW, { startedAt: 2, workedSeconds: 5 }] as const] : [])
+    ])
+    return (
+      <NativeChatMessageList
+        session={{
+          messages: projectStructuredAgentSessionMessages(items, [], submissions, NO_CARDS),
+          status: phase === 'done' ? 'ready' : 'working',
+          sessionId: 'session-1',
+          agent: 'claude',
+          hasMore: false,
+          loadingEarlier: false,
+          olderHistoryGeneration: 0,
+          loadEarlier: vi.fn(),
+          readPhase: 'ready'
+        }}
+        journalItems={items}
+        journalSubmissions={submissions}
+        deliveryNotices={structuredAgentSessionDeliveryNotices(
+          [],
+          'Claude',
+          vi.fn(),
+          submissions,
+          [],
+          new Set()
+        )}
+        isWorking={phase !== 'done'}
+        workingStartedAt={phase === 'done' ? null : Date.now() - 1500}
+        settledTurns={settledTurns}
+        expandSignal={false}
+        fontScale={1}
+      />
+    )
+  }
+
+  it('draws it where it was sent, with its reason and no Retry, outside the newer turn', () => {
+    const { container, rerender } = render(hostList('running'))
+    expect(drawn(container)).toEqual([
+      'SEED PROMPT',
+      'WORKED',
+      'LOST PROMPT',
+      'NEW PROMPT',
+      'WORKING',
+      'ACTIVITY'
+    ])
+    expect(container.textContent).toContain('Orca restarted before this message was sent.')
+    expect(container.querySelector('button[aria-label="Retry"]')).toBeNull()
+    expect(
+      [...container.querySelectorAll('button')].map((button) => button.textContent)
+    ).not.toContain('Retry')
+    rerender(hostList('done'))
+    expect(drawn(container)).toEqual([
+      'SEED PROMPT',
+      'WORKED',
+      'LOST PROMPT',
+      'NEW PROMPT',
+      'WORKED'
+    ])
+    expect(container.textContent).toContain('Worked for 5s')
+  })
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
index bcecab05bc6..f9e247d1354 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
@@ -3,7 +3,7 @@ import '@testing-library/jest-dom/vitest'
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
-import { MessageRow } from './NativeChatMessageRow'
+import { MessageRow, type NativeChatDeliveryNotice } from './NativeChatMessageRow'
 
 afterEach(cleanup)
 
@@ -163,8 +163,8 @@ describe('MessageRow send mode', () => {
   })
 })
 
-describe('a user message that did not go through', () => {
-  function renderUser(deliveryNotice?: { text: string; onRetry?: () => void }) {
+describe('what a user message says about its delivery', () => {
+  function renderUser(deliveryNotice?: NativeChatDeliveryNotice) {
     return render(
       <MessageRow
         message={{
@@ -203,4 +203,41 @@ describe('a user message that did not go through', () => {
     renderUser()
     expect(screen.queryByRole('button', { name: 'Retry' })).toBeNull()
   })
+
+  // Muted, in the time's place, and shown without hover: a message nothing confirmed yet never
+  // looks like one that went through. Copy keeps its hover reveal, and the row its height.
+  it('says quietly that it is still sending in place of its time, with no Retry', () => {
+    renderUser({ sending: true })
+
+    const sending = screen.getByText('Sending…')
+    const copy = screen.getByRole('button', { name: 'Copy message' })
+    expect(sending).toHaveClass('text-xs', 'text-muted-foreground')
+    expect(Array.from(sending.parentElement!.children)).toEqual([copy, sending])
+    expect(sending.parentElement).not.toHaveClass('can-hover:opacity-0')
+    expect(sending.parentElement!.parentElement).toHaveClass('group')
+    expect(copy).toHaveClass('can-hover:opacity-0', 'group-hover:opacity-100')
+    expect(screen.queryByRole('time')).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Retry' })).toBeNull()
+  })
+
+  it('keeps the same row when the message is confirmed, with the time back in its place', () => {
+    const { rerender } = renderUser({ sending: true })
+    const meta = screen.getByText('Sending…').parentElement
+    rerender(
+      <MessageRow
+        message={{
+          id: 'message',
+          role: 'user',
+          timestamp: 0,
+          source: 'transcript',
+          blocks: [{ type: 'text', text: 'Message text' }]
+        }}
+        expandSignal={false}
+        onScrollMessageToTop={vi.fn()}
+      />
+    )
+    expect(screen.queryByText('Sending…')).toBeNull()
+    expect(screen.getByRole('time').parentElement).toBe(meta)
+    expect(meta).toHaveClass('can-hover:opacity-0')
+  })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
index 234934664f4..10c8a68de07 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
@@ -28,12 +28,45 @@ import type {
 } from './native-chat-subagent-sections'
 import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
 
-/** What a user message says under it when it did not go through, with its own Retry when the
- *  surface can send it again. */
-export type NativeChatDeliveryNotice = {
-  text: string
-  onRetry?: () => void
-  onDismiss?: () => void
+/** What a user message says about its delivery: that nothing has confirmed it yet, quietly in
+ *  place of its time, or that it did not go through, with its own Retry when the surface can send
+ *  it again. */
+export type NativeChatDeliveryNotice =
+  | { sending: true; text?: never; onRetry?: never; onDismiss?: never }
+  | { sending?: never; text: string; onRetry?: () => void; onDismiss?: () => void }
+
+const USER_META_REVEAL =
+  'transition-opacity can-hover:pointer-events-none can-hover:opacity-0 group-hover:pointer-events-auto group-hover:opacity-100 [.group:has(:focus-visible)_&]:pointer-events-auto [.group:has(:focus-visible)_&]:opacity-100'
+
+/** Under a user message: copy + timestamp, revealed together like the agent controls row. Until
+ *  confirmed, a quiet "Sending…" stays visible in the time's place and copy keeps its own reveal,
+ *  so the row keeps its height when it clears. Image-only prompts have no text to copy. */
+function UserMessageMeta({
+  markdown,
+  timestamp,
+  sending
+}: {
+  markdown: string
+  timestamp: number | null
+  sending: boolean
+}): React.JSX.Element | null {
+  if (!markdown && timestamp === null && !sending) {
+    return null
+  }
+  return (
+    <div className={cn('flex select-none items-center gap-1', !sending && USER_META_REVEAL)}>
+      {markdown ? (
+        <NativeChatCopyButton text={markdown} className={sending ? USER_META_REVEAL : undefined} />
+      ) : null}
+      {sending ? (
+        <span className="text-xs whitespace-nowrap text-muted-foreground">
+          {translate('components.native-chat.messageSending', 'Sending…')}
+        </span>
+      ) : (
+        <NativeChatMessageTimestamp timestamp={timestamp} focusable />
+      )}
+    </div>
+  )
 }
 
 /** One message: its prose first, then a collapsible run folding all of the
@@ -178,15 +211,12 @@ export const MessageRow = memo(function MessageRow({
             <span>{translate('components.native-chat.goal.sentAsGoal', 'Sent as goal')}</span>
           </div>
         ) : null}
-        {/* Copy + timestamp reveal together, mirroring the agent controls row.
-            Image-only prompts have no text to copy, so the button is omitted. */}
-        {markdown || message.timestamp !== null ? (
-          <div className="flex select-none items-center gap-1 transition-opacity can-hover:pointer-events-none can-hover:opacity-0 group-hover:pointer-events-auto group-hover:opacity-100 [.group:has(:focus-visible)_&]:pointer-events-auto [.group:has(:focus-visible)_&]:opacity-100">
-            {markdown ? <NativeChatCopyButton text={markdown} /> : null}
-            <NativeChatMessageTimestamp timestamp={message.timestamp} focusable />
-          </div>
-        ) : null}
-        {deliveryNotice ? (
+        <UserMessageMeta
+          markdown={markdown}
+          timestamp={message.timestamp}
+          sending={deliveryNotice?.sending === true}
+        />
+        {deliveryNotice?.text !== undefined ? (
           <div className="flex max-w-[85%] items-center gap-2 text-[11px] text-destructive/80">
             <span className="min-w-0 break-words">{deliveryNotice.text}</span>
             {deliveryNotice.onDismiss ? (
diff --git a/src/renderer/src/components/native-chat/NativeChatQuestionCard.tsx b/src/renderer/src/components/native-chat/NativeChatQuestionCard.tsx
index e26131d96f0..b7c5dfefd8e 100644
--- a/src/renderer/src/components/native-chat/NativeChatQuestionCard.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatQuestionCard.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import { useState, type RefObject } from 'react'
 import { Check, Pencil, X } from 'lucide-react'
 import { cn } from '@/lib/utils'
@@ -242,7 +243,7 @@ export function NativeChatQuestionCard({
                       AskUserQuestion tool result: it reaches the model but never the command
                       parser, so `/compact` and friends are inert, while a skill name can
                       still be acted on. */}
-                  <input
+                  <ImeInput
                     ref={answerInputRef}
                     disabled={isSubmitting}
                     value={otherText[index]}
diff --git a/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.menu-request.test.tsx b/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.menu-request.test.tsx
new file mode 100644
index 00000000000..90abdc3ef25
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.menu-request.test.tsx
@@ -0,0 +1,109 @@
+// @vitest-environment happy-dom
+
+// Against the real menu: a `/model` request opens the menu once, and a period while the host still
+// lists models neither opens it later nor reopens one the user closed.
+
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type {
+  SessionOptionDescriptor,
+  SessionOptionsSurface
+} from '../../../../shared/native-chat-session-options'
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn() } }))
+
+vi.mock('@/i18n/i18n', () => ({
+  translate: (_key: string, fallback: string, values?: Record<string, string | number>) =>
+    values
+      ? Object.entries(values).reduce(
+          (text, [name, value]) => text.replaceAll(`{{${name}}}`, String(value)),
+          fallback
+        )
+      : fallback
+}))
+
+import { TooltipProvider } from '@/components/ui/tooltip'
+import { NativeChatSessionOptionPickers } from './NativeChatSessionOptionPickers'
+import type { NativeChatOptionPickerRequest } from './native-chat-composer-types'
+
+function model(pending: boolean): SessionOptionDescriptor {
+  return {
+    id: 'model',
+    label: 'Model',
+    category: 'model',
+    kind: {
+      type: 'select',
+      currentValue: 'opus',
+      choices: [
+        { value: 'opus', label: 'Opus 4.8' },
+        { value: 'sonnet', label: 'Sonnet 5' }
+      ]
+    },
+    valueSource: 'applied',
+    transport: 'agent-session',
+    settable: !pending,
+    ...(pending ? { choicesPending: true as const } : {})
+  }
+}
+
+const surface: SessionOptionsSurface = {
+  getSnapshot: () => [],
+  setOption: vi.fn(async () => ({ snapshot: [] })),
+  invokeAction: vi.fn(async () => ({ snapshot: [] })),
+  subscribe: () => () => {}
+}
+
+function view(pending: boolean, request: NativeChatOptionPickerRequest | null): React.JSX.Element {
+  return (
+    <TooltipProvider>
+      <textarea data-testid="composer" />
+      <NativeChatSessionOptionPickers
+        surface={surface}
+        snapshot={[model(pending)]}
+        isWorking={false}
+        pickerRequest={request}
+      />
+    </TooltipProvider>
+  )
+}
+
+const settle = (): Promise<void> =>
+  act(async () => new Promise((resolve) => setTimeout(resolve, 30)))
+
+afterEach(() => cleanup())
+
+describe('model menu requests while the host lists models', () => {
+  it('spends a request made while pending without opening the menu once the list lands', async () => {
+    const request = { id: 'model', sequence: 1 }
+    const { rerender } = render(view(true, request))
+    const composer = screen.getByTestId('composer')
+    composer.focus()
+    await settle()
+    expect(screen.queryByRole('menu')).toBeNull()
+
+    rerender(view(false, request))
+    await settle()
+    expect(screen.queryByRole('menu')).toBeNull()
+    expect(document.activeElement).toBe(composer)
+
+    // A new request after the list landed still opens it.
+    rerender(view(false, { id: 'model', sequence: 2 }))
+    await settle()
+    expect(screen.queryByRole('menu')).not.toBeNull()
+  })
+
+  it('does not reopen a menu the user closed when a pending period ends', async () => {
+    const request = { id: 'model', sequence: 1 }
+    const { rerender } = render(view(false, request))
+    await settle()
+    fireEvent.keyDown(screen.getByRole('menu'), { key: 'Escape' })
+    await settle()
+    expect(screen.queryByRole('menu')).toBeNull()
+
+    rerender(view(true, request))
+    await settle()
+    rerender(view(false, request))
+    await settle()
+    expect(screen.queryByRole('menu')).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.test.tsx b/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.test.tsx
index c57dba09e56..0c82460833f 100644
--- a/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.test.tsx
@@ -341,6 +341,44 @@ describe('NativeChatSessionOptionPickers', () => {
     ).toBe('true')
   })
 
+  it('keeps the model pill shut, label intact, while its choices are still listed', async () => {
+    const pending = model({ settable: false, choicesPending: true })
+    const { rerender } = render(
+      <NativeChatSessionOptionPickers
+        surface={surface}
+        snapshot={[pending, effort]}
+        isWorking={false}
+        pickerRequest={{ id: 'model', sequence: 1 }}
+      />
+    )
+    const trigger = screen.getByRole('button', { name: 'Model Opus 4.8' })
+    expect(trigger.parentElement?.getAttribute('data-disabled')).toBe('true')
+    expect(trigger.closest('[data-testid="dropdown-root"]')?.getAttribute('data-open')).toBe(
+      'false'
+    )
+    expect(
+      screen
+        .getByRole('button', { name: 'Effort High' })
+        .parentElement?.getAttribute('data-disabled')
+    ).toBeNull()
+
+    rerender(
+      <NativeChatSessionOptionPickers
+        surface={surface}
+        snapshot={[model(), effort]}
+        isWorking={false}
+        pickerRequest={{ id: 'model', sequence: 2 }}
+      />
+    )
+    const listed = screen.getByRole('button', { name: 'Model Opus 4.8' })
+    expect(listed.parentElement?.getAttribute('data-disabled')).toBeNull()
+    await waitFor(() =>
+      expect(listed.closest('[data-testid="dropdown-root"]')?.getAttribute('data-open')).toBe(
+        'true'
+      )
+    )
+  })
+
   it('does not duplicate titles for unknown values or misname generic controls', () => {
     const { rerender } = render(
       <NativeChatSessionOptionPickers
diff --git a/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.tsx b/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.tsx
index 8b86902757f..8f00ecef7a2 100644
--- a/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatSessionOptionPickers.tsx
@@ -226,6 +226,8 @@ function NativeChatSessionOptionPickersInner({
   if (!surface || !model) {
     return null
   }
+  // Still listed by the host: the pill shows its value and does not open, even on request.
+  const modelChoicesPending = model.choicesPending === true
   const requestedModelSequence = pickerRequest?.id === model.id ? pickerRequest.sequence : null
   const requestedOptionsSequence = options.some((descriptor) => descriptor.id === pickerRequest?.id)
     ? (pickerRequest?.sequence ?? null)
@@ -250,12 +252,13 @@ function NativeChatSessionOptionPickersInner({
     <div className="flex min-w-0 items-center gap-0.5">
       <DropdownMenu
         key={`model:${requestedModelSequence ?? 'idle'}`}
-        defaultOpen={requestedModelSequence !== null}
+        // Read only when a request remounts the menu: one made while pending is spent shut.
+        defaultOpen={requestedModelSequence !== null && !modelChoicesPending}
       >
         <PickerTrigger
           label={nativeChatModelPillLabel(model)}
           tooltipLabel={modelTooltip}
-          disabled={isWorking || pendingId !== null}
+          disabled={isWorking || pendingId !== null || modelChoicesPending}
           disabledReason={modelReason}
           dispatched={sessionOptionDispatchUnconfirmed(model)}
         />
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.start-failure-notice.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.start-failure-notice.test.tsx
index 6f529c1d3c9..92548887f0a 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.start-failure-notice.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.start-failure-notice.test.tsx
@@ -82,8 +82,8 @@ function rejected(clientMessageId: string, reason: string, rejection: AgentSessi
   }
 }
 
+// The notices are the host's rows'; a copy an earlier session left in the outbox gives way to them.
 function renderPane(messages: ReturnType<typeof rejected>[]): void {
-  mocks.mode = 'outbox'
   mocks.submissions = messages.map((message) => message.submission)
   localStorage.setItem(
     `orca:desktopStructuredAgentSessionOutbox:v1:${encodeURIComponent(SESSION_ID)}`,
@@ -113,8 +113,9 @@ async function notice(clientMessageId: string): Promise<HTMLElement> {
   })
 }
 
-// The start's own row says why, so its rejected messages say only that they were not sent.
-it("says only 'not sent', with its Retry, on each message the failed start's row explains", async () => {
+// The start's own row says why, so its rejected messages say only that they were not sent. Sending
+// one again is a new message, so none offers a Retry.
+it("says only 'not sent', with no Retry, on each message the failed start's row explains", async () => {
   mocks.journalItems = [startFailureRow(START_FAILED)]
 
   renderPane([
@@ -125,7 +126,7 @@ it("says only 'not sent', with its Retry, on each message the failed start's row
   for (const id of ['first', 'second']) {
     const row = await notice(id)
     expect(within(row).getByText('Your message was not sent.')).toBeTruthy()
-    expect(within(row).getByRole('button', { name: 'Retry' })).toBeTruthy()
+    expect(within(row).queryByRole('button', { name: 'Retry' })).toBeNull()
   }
   expect(screen.queryByText(/stopped before it finished starting/)).toBeNull()
 })
@@ -157,7 +158,5 @@ it('keeps the full notice on a message rejected for a reason no start-failure ro
 it("keeps the start failure's own words when its row is not loaded", async () => {
   renderPane([rejected('first', START_FAILED_REASON, START_FAILED)])
 
-  expect(
-    within(await notice('first')).getByText('Claude stopped before it finished starting.')
-  ).toBeTruthy()
+  expect(within(await notice('first')).getByText(START_FAILED_REASON)).toBeTruthy()
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
index 6e39ec0129d..89fda3f7f31 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -1,3 +1,4 @@
+import { act } from '@testing-library/react'
 import { forwardRef, useImperativeHandle, useRef } from 'react'
 import { vi } from 'vitest'
 import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
@@ -27,7 +28,8 @@ function absent<T>(): T | undefined {
   return undefined
 }
 
-/** Stands in for the transcript: renders only each message's delivery notice and its Retry. */
+/** Stands in for the transcript: renders only each message's delivery notice and its Retry, or the
+ *  row's quiet "Sending…" while nothing has confirmed it. */
 export function DeliveryNoticesMock({
   notices
 }: {
@@ -37,7 +39,7 @@ export function DeliveryNoticesMock({
     <div data-testid="message-list">
       {[...(notices ?? [])].map(([id, notice]) => (
         <div key={id} data-message-id={id}>
-          <span>{notice.text}</span>
+          <span>{notice.sending ? 'Sending…' : notice.text}</span>
           {notice.onRetry ? (
             <button type="button" onClick={notice.onRetry}>
               Retry
@@ -49,6 +51,43 @@ export function DeliveryNoticesMock({
   )
 }
 
+export function useProbeClock(): void {
+  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'Date'] })
+}
+
+export async function advanceProbeClock(milliseconds: number): Promise<void> {
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(milliseconds)
+  })
+}
+
+export function seededEntry(
+  sessionId: string,
+  clientMessageId: string,
+  text: string,
+  state: 'queued' | 'unconfirmed'
+) {
+  return {
+    clientMessageId,
+    sessionId,
+    body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text }] },
+    previewUris: [],
+    state,
+    queuedAt: clientMessageId === 'op-head' ? 1 : 2,
+    lastAttemptAt: null,
+    // Already force-retried once, so the automatic probe leaves the head alone
+    // and only the user's Retry moves it.
+    retryAfterUnknownSubmittedAt: -1
+  }
+}
+
+export function seedOutbox(sessionId: string, entries: unknown[]): void {
+  localStorage.setItem(
+    `orca:desktopStructuredAgentSessionOutbox:v1:${encodeURIComponent(sessionId)}`,
+    JSON.stringify(entries)
+  )
+}
+
 type StructuredSessionMessageListProps = {
   allowFileUriLinks?: boolean
   isVisible?: boolean
@@ -140,6 +179,7 @@ export function createStructuredSessionMocks() {
         }) => {
           mocks.controllerProps = props
           const outbox = useStructuredAgentSessionOutbox({
+            journalItems: mocks.journalItems,
             sessionId: props.sessionId,
             target: props.target,
             fence: props.transportEnabled === false ? null : 1,
@@ -150,7 +190,9 @@ export function createStructuredSessionMocks() {
             messages:
               mocks.messages ??
               (mocks.mode === 'outbox'
-                ? projectStructuredAgentSessionMessages([], outbox.outbox, [])
+                ? projectStructuredAgentSessionMessages([], outbox.outbox, [], {
+                    rejectedInPlace: true
+                  })
                 : [
                     {
                       id: 'message-1',
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index eca921ed086..e69056836c4 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { useMemo, useRef, useState } from 'react'
 import { agentSessionPromptQuestions } from '../../../../shared/agent-session-question-answer'
 import { dispatchStructuredAgentSessionComposerCommand } from '../../../../shared/structured-agent-session-composer'
 import { structuredAgentSessionPaneKey } from '../../../../shared/structured-agent-session-projection'
@@ -29,11 +29,7 @@ import { useAppStore } from '../../store'
 import { structuredAgentLabel } from '@/lib/structured-agent-session-launch-label'
 import { NativeChatThreadGoalBanner } from './NativeChatThreadGoalBanner'
 import { structuredAgentSessionReadFailureNotice } from './structured-agent-session-read-failure-notice'
-import { useStructuredAgentSessionStartFailureFacts } from './use-structured-agent-session-start-failure-facts'
-import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
-import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
-
-const NO_SUBMISSIONS: readonly AgentJournalSubmission[] = []
+import { useStructuredAgentSessionDeliveryNotices } from './use-structured-agent-session-delivery-notices'
 
 export function NativeChatStructuredSession(
   props: Omit<NativeChatStructuredViewProps, 'mode'>
@@ -115,41 +111,16 @@ export function NativeChatStructuredSession(
     }),
     [controller, historyPhase, props.agent, props.sessionId]
   )
-  // Read at click time, so the notices stay put while the outbox's Retry is rebuilt each render.
-  const retryRef = useRef(controller.retry)
-  useEffect(() => {
-    retryRef.current = controller.retry
-  })
-  const retryDelivery = useCallback((clientMessageId: string) => {
-    retryRef.current(clientMessageId)
-  }, [])
   const agentLabel = structuredAgentLabel(props.agent === 'codex' ? 'codex' : 'claude')
-  // Only a rejected message reads the journal's rows, so a new batch of them re-renders no row else.
-  const hasRejected = controller.outbox.some((entry) => entry.state === 'rejected')
-  const rejectionRows = hasRejected ? controller.submissions : NO_SUBMISSIONS
-  const startFailures = useStructuredAgentSessionStartFailureFacts(
-    controller.journalItems,
-    hasRejected
-  )
-  const deliveryNotices = useMemo(
-    () =>
-      structuredAgentSessionDeliveryNotices(
-        controller.outbox,
-        agentLabel,
-        retryDelivery,
-        rejectionRows,
-        startFailures,
-        controller.failedHere
-      ),
-    [
-      controller.outbox,
-      agentLabel,
-      retryDelivery,
-      rejectionRows,
-      startFailures,
-      controller.failedHere
-    ]
-  )
+  const deliveryNotices = useStructuredAgentSessionDeliveryNotices({
+    outbox: controller.outbox,
+    submissions: controller.submissions,
+    journalItems: controller.journalItems,
+    failedHere: controller.failedHere,
+    queuedMessageIds: controller.queuedMessageIds,
+    retry: controller.retry,
+    agentName: agentLabel
+  })
   const viewState = selectNativeChatViewState(session, { readRetries: true })
   // Nothing reads an unread history, so its pane stays blank beside the Retry line.
   const loadingPane = historyPhase === 'unread' ? null : <NativeChatLoadingCue />
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.probe.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.probe.test.tsx
new file mode 100644
index 00000000000..4a89074d23f
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.probe.test.tsx
@@ -0,0 +1,362 @@
+// The automatic probe of an unconfirmed outbox head: when it resends under the same
+// operation id, and when it parks the entry for the user's Retry instead.
+
+// @vitest-environment happy-dom
+
+import { act, cleanup, render, screen } from '@testing-library/react'
+import React from 'react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const { mocks, moduleFactories, resetStructuredSessionMocks } = await vi.hoisted(async () =>
+  (await import('./NativeChatStructuredSession.test-harness')).createStructuredSessionMocks()
+)
+
+vi.mock('@/runtime/structured-agent-session-client', () =>
+  moduleFactories.structuredAgentSessionClient()
+)
+vi.mock('./use-structured-agent-session', () => moduleFactories.useStructuredAgentSession())
+vi.mock('./use-native-chat-font-scale', () => moduleFactories.useNativeChatFontScale())
+vi.mock('./use-native-chat-file-link-context', () => moduleFactories.useNativeChatFileLinkContext())
+vi.mock('./use-native-chat-file-link-click', () => moduleFactories.useNativeChatFileLinkClick())
+vi.mock('./NativeChatMessageList', () => moduleFactories.nativeChatMessageList())
+vi.mock('./NativeChatComposer', () => moduleFactories.nativeChatComposer())
+vi.mock('./NativeChatEmptyState', () => moduleFactories.nativeChatEmptyState())
+vi.mock('./NativeChatApprovalCard', () => moduleFactories.nativeChatApprovalCard())
+vi.mock('./NativeChatQuestionCard', () => moduleFactories.nativeChatQuestionCard())
+
+import { NativeChatStructuredSession } from './NativeChatStructuredSession'
+import {
+  advanceProbeClock,
+  seededEntry,
+  seedOutbox,
+  useProbeClock
+} from './NativeChatStructuredSession.test-harness'
+
+describe('NativeChatStructuredSession delivery probe', () => {
+  afterEach(() => {
+    cleanup()
+    vi.useRealTimers()
+    localStorage.clear()
+    resetStructuredSessionMocks()
+  })
+
+  it('resends a transport-unconfirmed head so later messages are not wedged', async () => {
+    useProbeClock()
+    mocks.mode = 'outbox'
+    mocks.submissions = []
+    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
+    })
+
+    render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-wedge"
+        sessionId="session-wedge"
+        target={{ kind: 'local' }}
+        agent="codex"
+      />
+    )
+
+    const send = mocks.composerProps?.structuredTransport?.send as
+      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
+      | undefined
+    await act(async () => {
+      expect(send?.('first', [])).toBe(true)
+    })
+    expect(mocks.call).toHaveBeenCalledOnce()
+
+    await act(async () => {
+      expect(send?.('second', [])).toBe(true)
+    })
+    await advanceProbeClock(999)
+    expect(mocks.call).toHaveBeenCalledOnce()
+    await advanceProbeClock(1)
+    // The head is probed automatically, clears, and the queue drains.
+    expect(mocks.call).toHaveBeenCalledTimes(3)
+    expect(screen.queryByText('Message delivery is unconfirmed.')).toBeNull()
+  }, 20000)
+
+  it('probes the same operation without marking an explicit user retry', async () => {
+    useProbeClock()
+    mocks.mode = 'outbox'
+    mocks.submissions = []
+    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
+    })
+
+    render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-probe-flag"
+        sessionId="session-probe-flag"
+        target={{ kind: 'local' }}
+        agent="codex"
+      />
+    )
+
+    const send = mocks.composerProps?.structuredTransport?.send as
+      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
+      | undefined
+    await act(async () => {
+      expect(send?.('first', [])).toBe(true)
+    })
+    await advanceProbeClock(999)
+    expect(mocks.call).toHaveBeenCalledOnce()
+    await advanceProbeClock(1)
+    expect(mocks.call).toHaveBeenCalledTimes(2)
+
+    const first = mocks.call.mock.calls[0]?.[2] as Record<string, unknown>
+    const probe = mocks.call.mock.calls[1]?.[2] as Record<string, unknown>
+    expect(probe.retryUnknown).toBeUndefined()
+    // Same operation id: both dedupe layers key off it.
+    expect((probe.envelope as { clientOperationId: string }).clientOperationId).toBe(
+      (first.envelope as { clientOperationId: string }).clientOperationId
+    )
+  }, 20000)
+
+  it('parks a host-confirmed unknown instead of probing it', async () => {
+    useProbeClock()
+    mocks.mode = 'outbox'
+    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
+    })
+
+    render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-parked"
+        sessionId="session-parked"
+        target={{ kind: 'local' }}
+        agent="codex"
+      />
+    )
+
+    const send = mocks.composerProps?.structuredTransport?.send as
+      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
+      | undefined
+    await act(async () => {
+      expect(send?.('first', [])).toBe(true)
+    })
+    expect(mocks.call).toHaveBeenCalledOnce()
+
+    const sent = mocks.call.mock.calls[0]?.[2] as { envelope: { clientOperationId: string } }
+    // The host now reports an unresolved unknown: another replay is the user's call.
+    mocks.submissions = [
+      {
+        clientMessageId: sent.envelope.clientOperationId,
+        fence: 1,
+        payloadFingerprint: 'fp',
+        dispatchState: 'unknown',
+        providerItemId: null,
+        reason: null,
+        submittedAt: 1,
+        resolvedAt: null
+      }
+    ]
+    // Queue a second message purely to re-render so the effect observes the
+    // new submissions; it must stay wedged behind the parked head.
+    await act(async () => {
+      send?.('second', [])
+    })
+    await advanceProbeClock(3000)
+    // From the row on, only the user's Retry moves it, so it says so.
+    expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy()
+    expect(mocks.call).toHaveBeenCalledOnce()
+  }, 20000)
+
+  it('still probes while streaming batches rebuild the submissions array', async () => {
+    useProbeClock()
+    mocks.mode = 'outbox'
+    mocks.submissions = []
+    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
+    })
+
+    const makeView = (): React.ReactElement => (
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-churn"
+        sessionId="session-churn"
+        target={{ kind: 'local' }}
+        agent="codex"
+      />
+    )
+    const { rerender } = render(makeView())
+
+    const send = mocks.composerProps?.structuredTransport?.send as
+      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
+      | undefined
+    await act(async () => {
+      expect(send?.('first', [])).toBe(true)
+    })
+    expect(mocks.call).toHaveBeenCalledOnce()
+
+    // Each batch mints a fresh submissions array for an unrelated message. An
+    // array-identity dependency restarts the backoff on every one of these, so a
+    // stream that outlasts the delay would never let the probe fire.
+    for (let index = 0; index < 12; index += 1) {
+      mocks.submissions = [
+        {
+          clientMessageId: `other-${index}`,
+          fence: 1,
+          payloadFingerprint: 'fp',
+          dispatchState: 'accepted',
+          providerItemId: null,
+          reason: null,
+          submittedAt: index,
+          resolvedAt: index
+        }
+      ]
+      await act(async () => {
+        rerender(makeView())
+        await vi.advanceTimersByTimeAsync(250)
+      })
+    }
+
+    // Asserted with no trailing grace period: the probe must have fired *during*
+    // the stream, not after it went quiet.
+    expect(mocks.call).toHaveBeenCalledTimes(2)
+  }, 20000)
+
+  it('restarts probe delay when the runtime target changes', async () => {
+    useProbeClock()
+    mocks.mode = 'outbox'
+    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
+    })
+
+    const makeView = (
+      target: { kind: 'local' } | { kind: 'environment'; environmentId: string }
+    ) => (
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-target-switch"
+        sessionId="session-target-switch"
+        target={target}
+        agent="codex"
+      />
+    )
+    const { rerender } = render(makeView({ kind: 'local' }))
+    const send = mocks.composerProps?.structuredTransport?.send as
+      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
+      | undefined
+    await act(async () => {
+      expect(send?.('first', [])).toBe(true)
+    })
+    expect(mocks.call).toHaveBeenCalledOnce()
+
+    await advanceProbeClock(300)
+    rerender(makeView({ kind: 'environment', environmentId: 'env-1' }))
+    await advanceProbeClock(600)
+    expect(mocks.call).toHaveBeenCalledOnce()
+    await advanceProbeClock(399)
+    expect(mocks.call).toHaveBeenCalledOnce()
+    await advanceProbeClock(1)
+    expect(mocks.call).toHaveBeenCalledTimes(2)
+  }, 10000)
+
+  it('never auto-probes an entry the user already force-retried', async () => {
+    useProbeClock()
+    mocks.mode = 'outbox'
+    mocks.submissions = []
+    mocks.call.mockRejectedValue(new Error('socket closed'))
+    seedOutbox('session-forced', [seededEntry('session-forced', 'op-head', 'first', 'unconfirmed')])
+
+    render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-forced"
+        sessionId="session-forced"
+        target={{ kind: 'local' }}
+        agent="codex"
+      />
+    )
+
+    await advanceProbeClock(3000)
+    // Only the user's Retry moves it, so it says so.
+    expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy()
+    expect(mocks.call).not.toHaveBeenCalled()
+  }, 20000)
+
+  it('does not hot-loop when the host answers pending', async () => {
+    useProbeClock()
+    mocks.mode = 'outbox'
+    mocks.call.mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'pending' } }
+    })
+
+    render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-pending"
+        sessionId="session-pending"
+        target={{ kind: 'local' }}
+        agent="codex"
+      />
+    )
+
+    const send = mocks.composerProps?.structuredTransport?.send as
+      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
+      | undefined
+    await act(async () => {
+      expect(send?.('first', [])).toBe(true)
+    })
+    expect(mocks.call).toHaveBeenCalledOnce()
+
+    // A host-pending entry stays parked until the journal answers it.
+    await advanceProbeClock(999)
+    expect(mocks.call).toHaveBeenCalledOnce()
+    await advanceProbeClock(1)
+    expect(mocks.call).toHaveBeenCalledOnce()
+    await advanceProbeClock(1500)
+    expect(mocks.call).toHaveBeenCalledOnce()
+  }, 20000)
+
+  it('keeps probing past the old five-attempt budget', async () => {
+    mocks.mode = 'outbox'
+    mocks.call.mockRejectedValue(new Error('socket closed'))
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+    try {
+      render(
+        <NativeChatStructuredSession
+          isVisible
+          isFocusedGroup
+          tabId="structured-tab-budget"
+          sessionId="session-budget"
+          target={{ kind: 'local' }}
+          agent="codex"
+        />
+      )
+
+      const send = mocks.composerProps?.structuredTransport?.send as
+        | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
+        | undefined
+      expect(send?.('first', [])).toBe(true)
+
+      // Backoff is 1+2+4+8+16 = 31s for five probes, which was the old hard budget.
+      // Step past it; a seventh call proves the probe re-arms instead of giving up.
+      for (let step = 0; step < 12; step += 1) {
+        await act(async () => {
+          await vi.advanceTimersByTimeAsync(8_000)
+        })
+      }
+      expect(mocks.call.mock.calls.length).toBeGreaterThanOrEqual(7)
+    } finally {
+      vi.useRealTimers()
+    }
+  }, 30000)
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
index c5553f00edb..d5493654e8e 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
@@ -1,5 +1,5 @@
 // The delivery notice and the outbox queue behind it: which entry a Retry acts
-// on, when no notice is owed at all, and how a host-confirmed unknown is probed.
+// on, and when no notice is owed at all. The automatic probe is in the .probe suite.
 
 // @vitest-environment happy-dom
 
@@ -26,6 +26,7 @@ const mocks = vi.hoisted(() => ({
   },
   questionCardProps: null as NativeChatQuestionCardProps | null,
   promptItems: [] as AgentJournalRenderItem[],
+  noJournalItems: Array.of<AgentJournalRenderItem>(),
   respond: vi.fn(),
   handlePasteEvent: vi.fn(),
   pasteFromClipboard: vi.fn(),
@@ -53,6 +54,7 @@ vi.mock('./use-structured-agent-session', async () => {
       target: { kind: 'local' } | { kind: 'environment'; environmentId: string }
     }) => {
       const outbox = useStructuredAgentSessionOutbox({
+        journalItems: mocks.noJournalItems,
         sessionId: props.sessionId,
         target: props.target,
         fence: 1,
@@ -62,7 +64,9 @@ vi.mock('./use-structured-agent-session', async () => {
         journalItems: [],
         messages:
           mocks.mode === 'outbox'
-            ? projectStructuredAgentSessionMessages([], outbox.outbox, [])
+            ? projectStructuredAgentSessionMessages([], outbox.outbox, [], {
+                rejectedInPlace: true
+              })
             : [
                 {
                   id: 'message-1',
@@ -183,17 +187,13 @@ vi.mock('./NativeChatQuestionCard', () => ({
 }))
 
 import { NativeChatStructuredSession } from './NativeChatStructuredSession'
-import { appendStructuredAgentSessionOutboxMessage } from './structured-agent-session-outbox-storage'
+import { seededEntry, seedOutbox } from './NativeChatStructuredSession.test-harness'
+import {
+  appendStructuredAgentSessionOutboxMessage,
+  getStructuredAgentSessionOutbox
+} from './structured-agent-session-outbox-storage'
 
-function useProbeClock(): void {
-  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'Date'] })
-}
-
-async function advanceProbeClock(milliseconds: number): Promise<void> {
-  await act(async () => {
-    await vi.advanceTimersByTimeAsync(milliseconds)
-  })
-}
+const REFUSED_RESTART = "The agent couldn't restart. Your message was not sent."
 
 describe('NativeChatStructuredSession delivery', () => {
   afterEach(() => {
@@ -216,43 +216,12 @@ describe('NativeChatStructuredSession delivery', () => {
     mocks.backgroundTasks = []
   })
 
-  function seededEntry(
-    sessionId: string,
-    clientMessageId: string,
-    text: string,
-    state: 'queued' | 'unconfirmed'
-  ) {
-    return {
-      clientMessageId,
-      sessionId,
-      body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text }] },
-      previewUris: [],
-      state,
-      queuedAt: clientMessageId === 'op-head' ? 1 : 2,
-      lastAttemptAt: null,
-      // Already force-retried once, so the automatic probe leaves the head alone
-      // and only the user's Retry moves it.
-      retryAfterUnknownSubmittedAt: -1
-    }
-  }
-
-  function seedOutbox(sessionId: string, entries: unknown[]): void {
-    localStorage.setItem(
-      `orca:desktopStructuredAgentSessionOutbox:v1:${encodeURIComponent(sessionId)}`,
-      JSON.stringify(entries)
-    )
-  }
-
-  it('retries an unconfirmed transport send and clears the delivery notice', async () => {
+  // Resent under its own id until the host answers, so its row says only that it is still sending.
+  it('says a send whose answer was lost is sending until it confirms on its own, with no Retry', async () => {
     mocks.mode = 'outbox'
     mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValueOnce({
       ok: true,
-      value: {
-        submission: {
-          clientMessageId: 'client-1',
-          dispatchState: 'accepted'
-        }
-      }
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
     })
 
     render(
@@ -270,14 +239,126 @@ describe('NativeChatStructuredSession delivery', () => {
       | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
       | undefined
     expect(send?.('hello', [])).toBe(true)
-    await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
-    await waitFor(() => expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy())
+    // From the moment it is sent, through the lost answer, until the host confirms it.
+    await waitFor(() => expect(screen.getByText('Sending…')).toBeTruthy())
+    await waitFor(() =>
+      expect(getStructuredAgentSessionOutbox('session-1')).toMatchObject([{ state: 'unconfirmed' }])
+    )
+    expect(screen.getByText('Sending…')).toBeTruthy()
+    expect(screen.queryByText('Message delivery is unconfirmed.')).toBeNull()
+    expect(screen.queryByRole('button', { name: /Retry/ })).toBeNull()
 
-    fireEvent.click(screen.getByRole('button', { name: /Retry/ }))
+    await waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(2), { timeout: 5000 })
+    expect(mocks.call.mock.calls[1]?.[2]).toEqual(mocks.call.mock.calls[0]?.[2])
+    await waitFor(() => expect(screen.queryByText('Sending…')).toBeNull())
+    expect(getStructuredAgentSessionOutbox('session-1')).toEqual([])
+    expect(screen.queryByText('Message delivery is unconfirmed.')).toBeNull()
+  }, 10000)
 
-    await waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(2))
-    await waitFor(() => expect(screen.queryByText('Message delivery is unconfirmed.')).toBeNull())
-  })
+  // Reopened mid-send, the send is read back in doubt; the probe resends it under its own id.
+  function seedMidSend(sessionId: string, patch: Record<string, unknown> = {}): void {
+    seedOutbox(sessionId, [
+      {
+        ...seededEntry(sessionId, 'op-sent', 'first', 'queued'),
+        state: 'dispatching',
+        lastAttemptAt: 1,
+        retryAfterUnknownSubmittedAt: null,
+        ...patch
+      }
+    ])
+  }
+
+  function renderSession(sessionId: string): void {
+    render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId={`structured-tab-${sessionId}`}
+        sessionId={sessionId}
+        target={{ kind: 'local' }}
+        agent="codex"
+      />
+    )
+  }
+
+  it('says a send reopened mid-send is sending while it is resent, until it settles', async () => {
+    mocks.mode = 'outbox'
+    mocks.submissions = []
+    mocks.call.mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'op-sent', dispatchState: 'accepted' } }
+    })
+    seedMidSend('session-reopened')
+
+    renderSession('session-reopened')
+
+    expect(getStructuredAgentSessionOutbox('session-reopened')).toMatchObject([
+      { clientMessageId: 'op-sent', state: 'unconfirmed' }
+    ])
+    expect(screen.getByText('Sending…')).toBeTruthy()
+    expect(screen.queryByText('Message delivery is unconfirmed.')).toBeNull()
+    expect(screen.queryByRole('button', { name: /Retry/ })).toBeNull()
+    await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce(), { timeout: 3000 })
+    expect(mocks.call.mock.calls[0]?.[2]).toMatchObject({
+      envelope: { clientOperationId: 'op-sent' }
+    })
+    await waitFor(() => expect(getStructuredAgentSessionOutbox('session-reopened')).toEqual([]))
+    expect(screen.queryByText('Sending…')).toBeNull()
+    expect(screen.queryByText('Message delivery is unconfirmed.')).toBeNull()
+  }, 10000)
+
+  it.each([
+    ['a live unknown', {}],
+    ['a recovered unknown', { recovered: true }],
+    ["an older host's recovered unknown", { reason: 'host_restarted_before_acknowledgement' }]
+  ])(
+    'says a send reopened mid-send is unconfirmed, with its Retry, once the journal holds %s',
+    async (label, patch) => {
+      mocks.mode = 'outbox'
+      const sessionId = `session-reopened-${label.replace(/\W+/g, '-')}`
+      mocks.submissions = [
+        {
+          clientMessageId: 'op-sent',
+          fence: 1,
+          payloadFingerprint: 'fp',
+          dispatchState: 'unknown',
+          providerItemId: null,
+          reason: null,
+          submittedAt: 1,
+          resolvedAt: null,
+          ...patch
+        }
+      ]
+      seedMidSend(sessionId)
+
+      renderSession(sessionId)
+
+      await waitFor(() => expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy())
+      expect(screen.getByRole('button', { name: /Retry/ })).toBeTruthy()
+      expect(screen.queryByText('Sending…')).toBeNull()
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1500))
+      })
+      expect(mocks.call).not.toHaveBeenCalled()
+    },
+    10000
+  )
+
+  it('says a send a Stop outlived is unconfirmed when reopened, as nothing resends it', async () => {
+    mocks.mode = 'outbox'
+    mocks.submissions = []
+    seedMidSend('session-reopened-stopped', { outlivedStop: true })
+
+    renderSession('session-reopened-stopped')
+
+    expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy()
+    expect(screen.getByRole('button', { name: /Retry/ })).toBeTruthy()
+    expect(screen.queryByText('Sending…')).toBeNull()
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 1500))
+    })
+    expect(mocks.call).not.toHaveBeenCalled()
+  }, 10000)
 
   it('retries the head, not a later stuck message', async () => {
     mocks.mode = 'outbox'
@@ -319,10 +400,11 @@ describe('NativeChatStructuredSession delivery', () => {
     })
     seedOutbox('session-held-rejected', [
       seededEntry('session-held-rejected', 'op-head', 'first', 'unconfirmed'),
+      // Refused before the host recorded it, so its Retry is the only way it goes again.
       {
         ...seededEntry('session-held-rejected', 'op-rejected', 'second', 'queued'),
         state: 'rejected',
-        lastFailure: { kind: 'rejected', reason: 'Claude messages support at most 20 images' }
+        lastFailure: { kind: 'refused', code: 'agent_session_owner_restart_failed' }
       }
     ])
 
@@ -338,7 +420,7 @@ describe('NativeChatStructuredSession delivery', () => {
     )
 
     await waitFor(() => expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy())
-    expect(screen.getByText('Claude messages support at most 20 images')).toBeTruthy()
+    expect(screen.getByText(REFUSED_RESTART)).toBeTruthy()
     // One Retry, the stopped message's: it sends only that one.
     fireEvent.click(screen.getByRole('button', { name: /Retry/ }))
     await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
@@ -348,27 +430,38 @@ describe('NativeChatStructuredSession delivery', () => {
 
     // The queue moved, so the rejected message offers its own Retry again.
     await waitFor(() => expect(screen.queryByText('Message delivery is unconfirmed.')).toBeNull())
-    expect(screen.getByText('Claude messages support at most 20 images')).toBeTruthy()
+    expect(screen.getByText(REFUSED_RESTART)).toBeTruthy()
     expect(screen.getAllByRole('button', { name: /Retry/ })).toHaveLength(1)
     expect(mocks.call).toHaveBeenCalledOnce()
   })
 
-  it("words a failed start on each message by the chat's agent, leaving the resend to its Retry", async () => {
+  // Until the journal carries the row, the message's own copy words it; the host has it, so no Retry.
+  it("words a failed start its reply rejected by the chat's agent, with no Retry", async () => {
     mocks.mode = 'outbox'
     mocks.submissions = []
-    const startFailed = (clientMessageId: string, text: string) => ({
-      ...seededEntry('session-start-failed', clientMessageId, text, 'queued'),
-      state: 'rejected' as const,
-      lastFailure: {
-        kind: 'rejected' as const,
-        reason: 'Codex stopped before it finished starting. Send your message to try again.',
-        rejection: { kind: 'providerStartFailed' as const }
-      }
-    })
-    seedOutbox('session-start-failed', [
-      startFailed('op-first', 'first'),
-      startFailed('op-second', 'second')
-    ])
+    mocks.call.mockImplementation(
+      async (
+        _target: unknown,
+        _method: unknown,
+        params: { envelope: { clientOperationId: string } }
+      ) => ({
+        ok: true,
+        value: {
+          clientMessageId: params.envelope.clientOperationId,
+          submission: {
+            clientMessageId: params.envelope.clientOperationId,
+            fence: 1,
+            payloadFingerprint: 'fingerprint',
+            dispatchState: 'rejected',
+            providerItemId: null,
+            reason: 'Codex stopped before it finished starting. Send your message to try again.',
+            rejection: { kind: 'providerStartFailed' },
+            submittedAt: 1,
+            resolvedAt: 2
+          }
+        }
+      })
+    )
 
     render(
       <NativeChatStructuredSession
@@ -381,15 +474,23 @@ describe('NativeChatStructuredSession delivery', () => {
       />
     )
 
+    const send = mocks.composerProps?.structuredTransport?.send as
+      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
+      | undefined
+    expect(send?.('first', [])).toBe(true)
     await waitFor(() =>
-      expect(screen.getAllByText('Codex stopped before it finished starting.')).toHaveLength(2)
+      expect(
+        screen.getByText(
+          'Codex stopped before it finished starting. Send your message to try again.'
+        )
+      ).toBeTruthy()
     )
-    expect(screen.getAllByRole('button', { name: /Retry/ })).toHaveLength(2)
-    expect(screen.queryByText(/Send your message to try again/)).toBeNull()
+    expect(screen.queryByRole('button', { name: /Retry/ })).toBeNull()
+    expect(mocks.call).toHaveBeenCalledOnce()
   })
 
-  it("words a rejected message from its loaded journal row, not the message's own copy", async () => {
-    mocks.mode = 'outbox'
+  // A copy an earlier session left in the outbox gives way to the host's row.
+  it("words a rejected message from its journal row, not the message's own copy, with no Retry", async () => {
     const reason = "Claude couldn't start. Send your message to try again."
     mocks.submissions = [
       {
@@ -430,6 +531,7 @@ describe('NativeChatStructuredSession delivery', () => {
       expect(screen.getByText("Codex couldn't start. Start a new chat to continue.")).toBeTruthy()
     )
     expect(screen.queryByText(reason)).toBeNull()
+    expect(screen.queryByRole('button', { name: /Retry/ })).toBeNull()
   })
 
   it('names the stuck message behind an admitted head, and its Retry sends that one', async () => {
@@ -471,343 +573,6 @@ describe('NativeChatStructuredSession delivery', () => {
     })
   })
 
-  it('resends a transport-unconfirmed head so later messages are not wedged', async () => {
-    useProbeClock()
-    mocks.mode = 'outbox'
-    mocks.submissions = []
-    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
-      ok: true,
-      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
-    })
-
-    render(
-      <NativeChatStructuredSession
-        isVisible
-        isFocusedGroup
-        tabId="structured-tab-wedge"
-        sessionId="session-wedge"
-        target={{ kind: 'local' }}
-        agent="codex"
-      />
-    )
-
-    const send = mocks.composerProps?.structuredTransport?.send as
-      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
-      | undefined
-    await act(async () => {
-      expect(send?.('first', [])).toBe(true)
-    })
-    expect(mocks.call).toHaveBeenCalledOnce()
-    expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy()
-
-    await act(async () => {
-      expect(send?.('second', [])).toBe(true)
-    })
-    await advanceProbeClock(999)
-    expect(mocks.call).toHaveBeenCalledOnce()
-    await advanceProbeClock(1)
-    // The head is probed automatically, clears, and the queue drains.
-    expect(mocks.call).toHaveBeenCalledTimes(3)
-    expect(screen.queryByText('Message delivery is unconfirmed.')).toBeNull()
-  }, 20000)
-
-  it('probes the same operation without marking an explicit user retry', async () => {
-    useProbeClock()
-    mocks.mode = 'outbox'
-    mocks.submissions = []
-    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
-      ok: true,
-      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
-    })
-
-    render(
-      <NativeChatStructuredSession
-        isVisible
-        isFocusedGroup
-        tabId="structured-tab-probe-flag"
-        sessionId="session-probe-flag"
-        target={{ kind: 'local' }}
-        agent="codex"
-      />
-    )
-
-    const send = mocks.composerProps?.structuredTransport?.send as
-      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
-      | undefined
-    await act(async () => {
-      expect(send?.('first', [])).toBe(true)
-    })
-    await advanceProbeClock(999)
-    expect(mocks.call).toHaveBeenCalledOnce()
-    await advanceProbeClock(1)
-    expect(mocks.call).toHaveBeenCalledTimes(2)
-
-    const first = mocks.call.mock.calls[0]?.[2] as Record<string, unknown>
-    const probe = mocks.call.mock.calls[1]?.[2] as Record<string, unknown>
-    expect(probe.retryUnknown).toBeUndefined()
-    // Same operation id: both dedupe layers key off it.
-    expect((probe.envelope as { clientOperationId: string }).clientOperationId).toBe(
-      (first.envelope as { clientOperationId: string }).clientOperationId
-    )
-  }, 20000)
-
-  it('parks a host-confirmed unknown instead of probing it', async () => {
-    useProbeClock()
-    mocks.mode = 'outbox'
-    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
-      ok: true,
-      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
-    })
-
-    render(
-      <NativeChatStructuredSession
-        isVisible
-        isFocusedGroup
-        tabId="structured-tab-parked"
-        sessionId="session-parked"
-        target={{ kind: 'local' }}
-        agent="codex"
-      />
-    )
-
-    const send = mocks.composerProps?.structuredTransport?.send as
-      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
-      | undefined
-    await act(async () => {
-      expect(send?.('first', [])).toBe(true)
-    })
-    expect(mocks.call).toHaveBeenCalledOnce()
-
-    const sent = mocks.call.mock.calls[0]?.[2] as { envelope: { clientOperationId: string } }
-    // The host now reports an unresolved unknown: another replay is the user's call.
-    mocks.submissions = [
-      {
-        clientMessageId: sent.envelope.clientOperationId,
-        fence: 1,
-        payloadFingerprint: 'fp',
-        dispatchState: 'unknown',
-        providerItemId: null,
-        reason: null,
-        submittedAt: 1,
-        resolvedAt: null
-      }
-    ]
-    // Queue a second message purely to re-render so the effect observes the
-    // new submissions; it must stay wedged behind the parked head.
-    await act(async () => {
-      send?.('second', [])
-    })
-    await advanceProbeClock(3000)
-    expect(mocks.call).toHaveBeenCalledOnce()
-  }, 20000)
-
-  it('still probes while streaming batches rebuild the submissions array', async () => {
-    useProbeClock()
-    mocks.mode = 'outbox'
-    mocks.submissions = []
-    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
-      ok: true,
-      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
-    })
-
-    const makeView = (): React.ReactElement => (
-      <NativeChatStructuredSession
-        isVisible
-        isFocusedGroup
-        tabId="structured-tab-churn"
-        sessionId="session-churn"
-        target={{ kind: 'local' }}
-        agent="codex"
-      />
-    )
-    const { rerender } = render(makeView())
-
-    const send = mocks.composerProps?.structuredTransport?.send as
-      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
-      | undefined
-    await act(async () => {
-      expect(send?.('first', [])).toBe(true)
-    })
-    expect(mocks.call).toHaveBeenCalledOnce()
-
-    // Each batch mints a fresh submissions array for an unrelated message. An
-    // array-identity dependency restarts the backoff on every one of these, so a
-    // stream that outlasts the delay would never let the probe fire.
-    for (let index = 0; index < 12; index += 1) {
-      mocks.submissions = [
-        {
-          clientMessageId: `other-${index}`,
-          fence: 1,
-          payloadFingerprint: 'fp',
-          dispatchState: 'accepted',
-          providerItemId: null,
-          reason: null,
-          submittedAt: index,
-          resolvedAt: index
-        }
-      ]
-      await act(async () => {
-        rerender(makeView())
-        await vi.advanceTimersByTimeAsync(250)
-      })
-    }
-
-    // Asserted with no trailing grace period: the probe must have fired *during*
-    // the stream, not after it went quiet.
-    expect(mocks.call).toHaveBeenCalledTimes(2)
-  }, 20000)
-
-  it('restarts probe delay when the runtime target changes', async () => {
-    useProbeClock()
-    mocks.mode = 'outbox'
-    mocks.call.mockRejectedValueOnce(new Error('socket closed')).mockResolvedValue({
-      ok: true,
-      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
-    })
-
-    const makeView = (
-      target: { kind: 'local' } | { kind: 'environment'; environmentId: string }
-    ) => (
-      <NativeChatStructuredSession
-        isVisible
-        isFocusedGroup
-        tabId="structured-tab-target-switch"
-        sessionId="session-target-switch"
-        target={target}
-        agent="codex"
-      />
-    )
-    const { rerender } = render(makeView({ kind: 'local' }))
-    const send = mocks.composerProps?.structuredTransport?.send as
-      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
-      | undefined
-    await act(async () => {
-      expect(send?.('first', [])).toBe(true)
-    })
-    expect(mocks.call).toHaveBeenCalledOnce()
-    expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy()
-
-    await advanceProbeClock(300)
-    rerender(makeView({ kind: 'environment', environmentId: 'env-1' }))
-    await advanceProbeClock(600)
-    expect(mocks.call).toHaveBeenCalledOnce()
-    await advanceProbeClock(399)
-    expect(mocks.call).toHaveBeenCalledOnce()
-    await advanceProbeClock(1)
-    expect(mocks.call).toHaveBeenCalledTimes(2)
-  }, 10000)
-
-  it('never auto-probes an entry the user already force-retried', async () => {
-    useProbeClock()
-    mocks.mode = 'outbox'
-    mocks.submissions = []
-    // Both the original send and the user's explicit Retry fail at the transport.
-    mocks.call.mockRejectedValue(new Error('socket closed'))
-
-    render(
-      <NativeChatStructuredSession
-        isVisible
-        isFocusedGroup
-        tabId="structured-tab-forced"
-        sessionId="session-forced"
-        target={{ kind: 'local' }}
-        agent="codex"
-      />
-    )
-
-    const send = mocks.composerProps?.structuredTransport?.send as
-      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
-      | undefined
-    await act(async () => {
-      expect(send?.('first', [])).toBe(true)
-    })
-    expect(mocks.call).toHaveBeenCalledOnce()
-    expect(screen.getByText('Message delivery is unconfirmed.')).toBeTruthy()
-
-    // User retries with the same envelope and no legacy redelivery signal.
-    await act(async () => {
-      fireEvent.click(screen.getByRole('button', { name: /Retry/ }))
-    })
-    expect(mocks.call).toHaveBeenCalledTimes(2)
-    const forcedRequest = mocks.call.mock.calls[1]?.[2] as Record<string, unknown> | undefined
-    expect(forcedRequest?.retryUnknown).toBeUndefined()
-
-    // That retry also failed at the transport. The probe must not repeat an
-    // explicit retry automatically.
-    await advanceProbeClock(3000)
-    expect(mocks.call).toHaveBeenCalledTimes(2)
-  }, 20000)
-
-  it('does not hot-loop when the host answers pending', async () => {
-    useProbeClock()
-    mocks.mode = 'outbox'
-    mocks.call.mockResolvedValue({
-      ok: true,
-      value: { submission: { clientMessageId: 'client-1', dispatchState: 'pending' } }
-    })
-
-    render(
-      <NativeChatStructuredSession
-        isVisible
-        isFocusedGroup
-        tabId="structured-tab-pending"
-        sessionId="session-pending"
-        target={{ kind: 'local' }}
-        agent="codex"
-      />
-    )
-
-    const send = mocks.composerProps?.structuredTransport?.send as
-      | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
-      | undefined
-    await act(async () => {
-      expect(send?.('first', [])).toBe(true)
-    })
-    expect(mocks.call).toHaveBeenCalledOnce()
-
-    // A host-pending entry stays parked until the journal answers it.
-    await advanceProbeClock(999)
-    expect(mocks.call).toHaveBeenCalledOnce()
-    await advanceProbeClock(1)
-    expect(mocks.call).toHaveBeenCalledOnce()
-    await advanceProbeClock(1500)
-    expect(mocks.call).toHaveBeenCalledOnce()
-  }, 20000)
-
-  it('keeps probing past the old five-attempt budget', async () => {
-    mocks.mode = 'outbox'
-    mocks.call.mockRejectedValue(new Error('socket closed'))
-    vi.useFakeTimers({ shouldAdvanceTime: true })
-    try {
-      render(
-        <NativeChatStructuredSession
-          isVisible
-          isFocusedGroup
-          tabId="structured-tab-budget"
-          sessionId="session-budget"
-          target={{ kind: 'local' }}
-          agent="codex"
-        />
-      )
-
-      const send = mocks.composerProps?.structuredTransport?.send as
-        | ((text: string, attachments: readonly { id: string; path: string }[]) => boolean)
-        | undefined
-      expect(send?.('first', [])).toBe(true)
-
-      // Backoff is 1+2+4+8+16 = 31s for five probes, which was the old hard budget.
-      // Step past it; a seventh call proves the probe re-arms instead of giving up.
-      for (let step = 0; step < 12; step += 1) {
-        await act(async () => {
-          await vi.advanceTimersByTimeAsync(8_000)
-        })
-      }
-      expect(mocks.call.mock.calls.length).toBeGreaterThanOrEqual(7)
-    } finally {
-      vi.useRealTimers()
-    }
-  }, 30000)
-
   // A cause seen while the chat was open is worded in full; one read back after the chat is
   // reopened may have cleared, until a Retry it still stops brings it back.
   it('words a refusal seen here in full, and after a reopen only once its Retry is refused', async () => {
diff --git a/src/renderer/src/components/native-chat/NativeChatTranscriptChrome.test.tsx b/src/renderer/src/components/native-chat/NativeChatTranscriptChrome.test.tsx
index 3992bbce1f5..2ba15a08d4c 100644
--- a/src/renderer/src/components/native-chat/NativeChatTranscriptChrome.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatTranscriptChrome.test.tsx
@@ -206,4 +206,27 @@ describe('NativeChatImageAttachments', () => {
     expect(container.firstElementChild).toBe(observedElement)
     root.unmount()
   })
+
+  it.each([
+    ['a pasted screenshot in the temp folder', '/tmp/orca-paste-1.png'],
+    ['an agent image outside the project', '/Users/me/.codex/generated/plot.png']
+  ])('reads %s as a chat image, whoever sent it', async (_label, path) => {
+    const container = document.createElement('div')
+    const root = createRoot(container)
+    await act(async () => {
+      root.render(
+        createElement(NativeChatImageAttachments, {
+          blocks: [{ type: 'image-ref' as const, path }],
+          runtimeContext: runtimeContext('wt-1')
+        })
+      )
+      await flushPromises()
+    })
+
+    expect(vi.mocked(window.api.fs.readFile).mock.calls[0]?.[0]).toMatchObject({
+      filePath: path,
+      access: { kind: 'chat-image' }
+    })
+    root.unmount()
+  })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatTranscriptChrome.tsx b/src/renderer/src/components/native-chat/NativeChatTranscriptChrome.tsx
index 4dea3e2d617..402c82816a8 100644
--- a/src/renderer/src/components/native-chat/NativeChatTranscriptChrome.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatTranscriptChrome.tsx
@@ -15,6 +15,7 @@ import {
 } from '@/components/editor/useLocalImageSrc'
 import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
 import { isNativeChatPastedImagePath } from './native-chat-image-paste'
+import { chatImageAccess } from '@/lib/local-file-access'
 
 type VisibilityListener = (isVisible: boolean) => void
 
@@ -70,6 +71,10 @@ function transcriptImageIdentity(
   }`
 }
 
+// Why one access kind for every role: a turn's role says who sent it, not who chose the path, and these
+// load on scroll with no click, so main only serves local image files by their real type.
+const TRANSCRIPT_IMAGE_ACCESS = chatImageAccess()
+
 function TranscriptImagePreview({
   block,
   runtimeContext
@@ -90,7 +95,8 @@ function TranscriptImagePreview({
     leaseActive && !external && runtimeContext !== undefined ? source : undefined,
     filePath,
     runtimeContext?.connectionId,
-    runtimeContext
+    runtimeContext,
+    TRANSCRIPT_IMAGE_ACCESS
   )
   const displaySrc = external && leaseActive ? source : localSrc
   const label =
@@ -124,9 +130,10 @@ function TranscriptImagePreview({
       return
     }
     if (!leaseActive) {
-      releaseLocalImageSrc(source, filePath, context.connectionId, context)
+      releaseLocalImageSrc(source, filePath, context.connectionId, context, TRANSCRIPT_IMAGE_ACCESS)
     }
-    return () => releaseLocalImageSrc(source, filePath, context.connectionId, context)
+    return () =>
+      releaseLocalImageSrc(source, filePath, context.connectionId, context, TRANSCRIPT_IMAGE_ACCESS)
   }, [external, filePath, leaseActive, runtimeContext, source])
 
   const showPreview =
diff --git a/src/renderer/src/components/native-chat/host-model-listing-waits.ts b/src/renderer/src/components/native-chat/host-model-listing-waits.ts
new file mode 100644
index 00000000000..5ba1a9110c0
--- /dev/null
+++ b/src/renderer/src/components/native-chat/host-model-listing-waits.ts
@@ -0,0 +1,62 @@
+import type { AgentSessionModelCatalogResult } from '../../../../shared/agent-session-wire'
+
+// One waiting catalog read per chat, shared by every mount and effect run of that chat's picker:
+// a remote read cannot be withdrawn once sent, so a re-run joins the one in flight instead of
+// sending another. An entry lives exactly as long as its read.
+
+/** Null when the read failed or timed out. */
+export type HostModelListingJoiner = (catalog: AgentSessionModelCatalogResult | null) => void
+
+const waits = new Map<string, Set<HostModelListingJoiner>>()
+const listeners = new Set<() => void>()
+
+function notify(): void {
+  for (const listener of listeners) {
+    listener()
+  }
+}
+
+/** Joins the chat's waiting read, started by `read` only when none is in flight. Returns `leave`. */
+export function joinHostModelListingWait(
+  key: string,
+  read: () => Promise<AgentSessionModelCatalogResult>,
+  onSettled: HostModelListingJoiner
+): () => void {
+  let joiners = waits.get(key)
+  if (!joiners) {
+    const started = new Set<HostModelListingJoiner>()
+    joiners = started
+    waits.set(key, started)
+    const settle = (catalog: AgentSessionModelCatalogResult | null): void => {
+      try {
+        // Every joiner applies before the hold lifts, so the answer and the release commit together.
+        for (const joiner of started) {
+          joiner(catalog)
+        }
+      } finally {
+        waits.delete(key)
+        notify()
+      }
+    }
+    new Promise<AgentSessionModelCatalogResult>((resolve) => resolve(read())).then(settle, () =>
+      settle(null)
+    )
+    notify()
+  }
+  joiners.add(onSettled)
+  const joined = joiners
+  return () => {
+    joined.delete(onSettled)
+  }
+}
+
+export function isHostModelListingWaitInFlight(key: string): boolean {
+  return waits.has(key)
+}
+
+export function subscribeHostModelListingWaits(listener: () => void): () => void {
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+  }
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
index 508a7c20e5e..f25d5d86381 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
@@ -28,7 +28,7 @@ const electron = vi.hoisted(() => ({
 
 const intake = vi.hoisted(() => ({
   owner: { kind: 'local' } as { kind: string; connectionId?: string },
-  authorizeExternalPath: vi.fn(),
+  stat: vi.fn(),
   readFile: vi.fn(),
   upload: vi.fn()
 }))
@@ -153,7 +153,7 @@ describe('native chat composer drop scoping', () => {
   beforeEach(() => {
     intake.owner = { kind: 'local' }
     electron.getPathForFile.mockReset().mockImplementation((file: File) => `/repro/${file.name}`)
-    intake.authorizeExternalPath.mockReset().mockResolvedValue(undefined)
+    intake.stat.mockReset().mockResolvedValue(undefined)
     intake.readFile.mockReset().mockResolvedValue({ content: '', isBinary: false })
     intake.upload.mockReset()
     vi.stubGlobal('IntersectionObserver', undefined)
@@ -184,8 +184,8 @@ describe('native chat composer drop scoping', () => {
     expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
   })
 
-  it('notices an OS drop whose every path fails authorization', async () => {
-    intake.authorizeExternalPath.mockRejectedValue(new Error('denied'))
+  it('notices an OS drop whose every path is unreadable', async () => {
+    intake.stat.mockRejectedValue(new Error('denied'))
     const view = render(<ComposerProbe pane="chat-a" />)
 
     await dropTwoImages(view.container.querySelector('[data-pane="chat-a"] .ProseMirror')!)
@@ -197,8 +197,8 @@ describe('native chat composer drop scoping', () => {
     expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
   })
 
-  it('notices an OS drop whose owner changes during authorization', async () => {
-    intake.authorizeExternalPath.mockImplementation(async () => {
+  it('notices an OS drop whose owner changes while checking the files', async () => {
+    intake.stat.mockImplementation(async () => {
       intake.owner = { kind: 'ssh', connectionId: 'conn-1' }
     })
     const view = render(<ComposerProbe pane="chat-a" />)
@@ -289,15 +289,9 @@ describe('native chat composer drop scoping', () => {
     expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
   })
 
-  it('authorizes only dropped files before preview reads and leaves the other pane untouched', async () => {
-    const authorized = new Set<string>()
-    intake.authorizeExternalPath.mockImplementation(
-      async ({ targetPath }: { targetPath: string }) => {
-        authorized.add(targetPath)
-      }
-    )
-    intake.readFile.mockImplementation(async ({ filePath }: { filePath: string }) => {
-      if (!authorized.has(filePath)) {
+  it('previews dropped files as chat images and leaves the other pane untouched', async () => {
+    intake.readFile.mockImplementation(async ({ access }: { access?: { kind: string } }) => {
+      if (access?.kind !== 'chat-image') {
         throw new Error('Access denied: path resolves outside allowed directories')
       }
       return { content: 'AA==', isBinary: true, mimeType: 'image/png' }
@@ -317,9 +311,9 @@ describe('native chat composer drop scoping', () => {
     )
     expect(await screen.findByRole('img', { name: 'first.png' })).toBeTruthy()
     expect(await screen.findByRole('img', { name: 'second.png' })).toBeTruthy()
-    expect(intake.authorizeExternalPath.mock.calls).toEqual([
-      [{ targetPath: '/repro/first.png' }],
-      [{ targetPath: '/repro/second.png' }]
+    expect(intake.stat.mock.calls).toEqual([
+      [{ filePath: '/repro/first.png', access: { kind: 'user-file' } }],
+      [{ filePath: '/repro/second.png', access: { kind: 'user-file' } }]
     ])
     expect(intake.readFile).toHaveBeenCalledTimes(2)
     expect(intake.upload).not.toHaveBeenCalled()
@@ -330,7 +324,7 @@ describe('native chat composer drop scoping', () => {
     )
   })
 
-  it('uploads once for the SSH drop owner without authorizing remote paths locally', async () => {
+  it('uploads once for the SSH drop owner without checking remote paths locally', async () => {
     intake.owner = { kind: 'ssh', connectionId: 'conn-1' }
     intake.upload.mockResolvedValue(['/remote/first.png', '/remote/second.png'])
     const view = render(
@@ -344,7 +338,7 @@ describe('native chat composer drop scoping', () => {
       ['/repro/first.png', '/repro/second.png'],
       intake.owner
     )
-    expect(intake.authorizeExternalPath).not.toHaveBeenCalled()
+    expect(intake.stat).not.toHaveBeenCalled()
     expect(readNativeChatAttachmentCache('chat-a').map(({ path }) => path)).toEqual([
       '/remote/first.png',
       '/remote/second.png'
diff --git a/src/renderer/src/components/native-chat/native-chat-rail-outline-parity.test.ts b/src/renderer/src/components/native-chat/native-chat-rail-outline-parity.test.ts
index e5254b63e94..16c9a30a397 100644
--- a/src/renderer/src/components/native-chat/native-chat-rail-outline-parity.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-rail-outline-parity.test.ts
@@ -19,6 +19,8 @@ import { buildNativeChatTranscriptSlots } from './native-chat-transcript-slots'
 import type { NativeChatTurnDiff } from './native-chat-turn-diffs'
 import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
 
+const NO_CARDS: readonly string[] = []
+
 function row(sequence: number, body: AgentJournalItemBody, itemId = `item-${sequence}`) {
   return { itemId, revision: 1, sequence, observedAt: 1_000 + sequence, body }
 }
@@ -68,7 +70,7 @@ const JOURNAL: AgentJournalRenderItem[] = [
 /** The renderer's own path from journal items to rail items, as the list runs it. */
 function loadedRailItems(items: AgentJournalRenderItem[], submissions: AgentJournalSubmission[]) {
   const projected = createNativeChatMessageListProjection()(
-    projectStructuredAgentSessionMessages(items, [], submissions)
+    projectStructuredAgentSessionMessages(items, [], submissions, NO_CARDS)
   ).conversation
   const messages = omitNativeChatThreadGoalRows(projectNativeChatTaskListFrames(projected))
   let turn: string | undefined
@@ -93,9 +95,14 @@ function loadedRailItems(items: AgentJournalRenderItem[], submissions: AgentJour
 }
 
 describe('conversation outline parity with the loaded rail', () => {
+  // Except a rejected message: the desktop draws it in place and ticks it once loaded, while the
+  // host's outline, which older clients read too, leaves it out.
   it('lists exactly the user messages the transcript gives a rail tick, with the same ids and previews', () => {
     const outline = projectAgentSessionConversationOutline(JOURNAL, [REJECTED])
-    const loaded = loadedRailItems(JOURNAL, [REJECTED])
+    const rejectedId = agentJournalSubmissionKey(REJECTED.clientMessageId)
+    const loadedWithRejected = loadedRailItems(JOURNAL, [REJECTED])
+    expect(loadedWithRejected.filter((item) => item.id === rejectedId)).toHaveLength(1)
+    const loaded = loadedWithRejected.filter((item) => item.id !== rejectedId)
 
     expect(outline.map((entry) => entry.itemId)).toEqual(loaded.map((item) => item.id))
     expect(
diff --git a/src/renderer/src/components/native-chat/native-chat-session-option-discovery.ts b/src/renderer/src/components/native-chat/native-chat-session-option-discovery.ts
index 17281fa697c..4fa7e279878 100644
--- a/src/renderer/src/components/native-chat/native-chat-session-option-discovery.ts
+++ b/src/renderer/src/components/native-chat/native-chat-session-option-discovery.ts
@@ -10,6 +10,7 @@ import {
   LOCAL_COMMIT_MESSAGE_HOST_KEY
 } from '../../../../shared/commit-message-host-key'
 import { getSettingsForAgentTabRuntimeOwner } from '@/lib/agent-paste-draft'
+import { hasExplicitTuiLaunchCommand } from '../../../../shared/tui-agent-launch-command-override'
 import { getConnectionIdFromState } from '@/lib/connection-context'
 import {
   getLocalProjectExecutionRuntimeContext,
@@ -126,7 +127,12 @@ export async function discoverNativeChatCatalogModels(
   const hostCatalogAgent =
     agent === 'claude' ? ('claude' as const) : agent === 'codex' ? ('codex' as const) : null
   // Only `local` proves a native pane: a paired runtime's key also covers its SSH/WSL worktrees.
-  if (hostCatalogAgent && hostKey === LOCAL_COMMIT_MESSAGE_HOST_KEY) {
+  // A custom launch command runs a binary the structured catalog never lists; the CLI listing honors it.
+  if (
+    hostCatalogAgent &&
+    hostKey === LOCAL_COMMIT_MESSAGE_HOST_KEY &&
+    !hasExplicitTuiLaunchCommand(context.settings, hostCatalogAgent)
+  ) {
     const fromHost = await readLocalHostCatalogModels(hostCatalogAgent)
     if (fromHost) {
       return fromHost
diff --git a/src/renderer/src/components/native-chat/native-chat-session-option-enrichment.test.ts b/src/renderer/src/components/native-chat/native-chat-session-option-enrichment.test.ts
index 4e13a9ee08d..15d890f319e 100644
--- a/src/renderer/src/components/native-chat/native-chat-session-option-enrichment.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-session-option-enrichment.test.ts
@@ -59,6 +59,24 @@ describe('native chat session option enrichment', () => {
     expect(paired?.map(({ id }) => id)).toContain('gpt-cli')
   })
 
+  it('lists through the CLI when this machine runs a custom launch command', async () => {
+    mocks.discoverRuntimeCommitMessageModels.mockResolvedValue({
+      success: true,
+      catalogOrigin: 'probe',
+      models: [{ id: 'gpt-custom', label: 'GPT Custom' }]
+    })
+    const context = {
+      settings: { agentCmdOverrides: { codex: 'codex-nightly' } },
+      worktreeId: 'repo::/worktree',
+      worktreePath: '/worktree'
+    }
+
+    // The structured catalog lists the built-in binary, which this terminal does not run.
+    const models = await discoverNativeChatCatalogModels('codex', context, 'local')
+    expect(mocks.callStructuredAgentSession).not.toHaveBeenCalled()
+    expect(models?.map(({ id }) => id)).toContain('gpt-custom')
+  })
+
   it('bounds settled host enrichment entries', async () => {
     for (let index = 0; index < NATIVE_CHAT_MODEL_ENRICHMENT_MAX_ENTRIES + 4; index += 1) {
       ensureNativeChatModelEnrichment({
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-delivery-notices.test.ts b/src/renderer/src/components/native-chat/structured-agent-session-delivery-notices.test.ts
index 5dde72621ad..9054c35b533 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-delivery-notices.test.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-delivery-notices.test.ts
@@ -37,6 +37,8 @@ function entry(
 }
 
 const NOT_FAILED_HERE: ReadonlySet<string> = new Set()
+// What the row shows, quietly in place of its time, while nothing has confirmed the message.
+const SENDING = 'Sending…'
 
 function texts(
   outbox: StructuredAgentSessionOutboxEntry[],
@@ -52,11 +54,14 @@ function texts(
     startFailures,
     new Set(outbox.map((candidate) => candidate.clientMessageId))
   )
-  return Object.fromEntries([...notices].map(([id, notice]) => [id, notice.text]))
+  return Object.fromEntries(
+    [...notices].map(([id, notice]) => [id, notice.sending ? SENDING : notice.text])
+  )
 }
 
 describe('the notice on each message that did not go through', () => {
-  it('gives two failed messages each their own reason and their own Retry', () => {
+  // Recorded by the host, so sending one again is a new message: no Retry.
+  it('gives two messages the host rejected each their own reason and no Retry', () => {
     const retry = vi.fn()
     const notices = structuredAgentSessionDeliveryNotices(
       [
@@ -77,7 +82,7 @@ describe('the notice on each message that did not go through', () => {
       retry,
       [],
       [],
-      NOT_FAILED_HERE
+      new Set(['first', 'second'])
     )
 
     expect([...notices.keys()]).toEqual([
@@ -90,8 +95,47 @@ describe('the notice on each message that did not go through', () => {
     expect(notices.get(agentJournalSubmissionKey('second'))?.text).toBe(
       'Claude never finished starting, so Orca stopped it.'
     )
-    notices.get(agentJournalSubmissionKey('second'))?.onRetry?.()
-    expect(retry).toHaveBeenCalledExactlyOnceWith('second')
+    expect(notices.get(agentJournalSubmissionKey('first'))?.onRetry).toBeUndefined()
+    expect(notices.get(agentJournalSubmissionKey('second'))?.onRetry).toBeUndefined()
+  })
+
+  // However this chat learned of it: the host recorded it, so it has no control at all.
+  it('gives a message the host rejected before this chat opened no Retry and no Dismiss', () => {
+    const retry = vi.fn()
+    const notice = structuredAgentSessionDeliveryNotices(
+      [
+        entry('earlier', {
+          state: 'rejected',
+          lastFailure: { kind: 'rejected', reason: 'Claude messages support at most 20 images' }
+        })
+      ],
+      'Claude',
+      retry,
+      [],
+      [],
+      NOT_FAILED_HERE
+    ).get(agentJournalSubmissionKey('earlier'))
+    expect(notice).toEqual({ text: 'Claude messages support at most 20 images' })
+    expect(retry).not.toHaveBeenCalled()
+  })
+
+  // Refused before the host recorded it: only its Retry sends it, so it keeps one.
+  it('keeps the Retry on a message refused before the host recorded it', () => {
+    const notice = structuredAgentSessionDeliveryNotices(
+      [
+        entry('refused', {
+          state: 'rejected',
+          lastFailure: { kind: 'refused', code: 'agent_session_owner_restart_failed' }
+        })
+      ],
+      'Claude',
+      () => {},
+      [],
+      [],
+      NOT_FAILED_HERE
+    ).get(agentJournalSubmissionKey('refused'))
+    expect(notice?.onRetry).toBeDefined()
+    expect(notice?.onDismiss).toBeUndefined()
   })
 
   it('chooses the words from the saved refusal on a refused message', () => {
@@ -133,7 +177,9 @@ describe('the notice on each message that did not go through', () => {
   })
 
   it('says a message is unconfirmed, and only that it was not sent when nothing more is known', () => {
-    expect(texts([entry('doubt', { state: 'unconfirmed' })])).toEqual({
+    expect(
+      texts([entry('doubt', { state: 'unconfirmed', retryAfterUnknownSubmittedAt: -1 })])
+    ).toEqual({
       [agentJournalSubmissionKey('doubt')]: 'Message delivery is unconfirmed.'
     })
     expect(texts([entry('bare', { state: 'rejected' })])).toEqual({
@@ -153,21 +199,24 @@ describe('the notice on each message that did not go through', () => {
   })
 
   // The drain's own rule: a message behind the one the queue stopped on is only waiting, so it says
-  // nothing. A rejected or refused message holds nothing up and keeps its words.
+  // only that it is still sending. A rejected or refused message holds nothing up and keeps its words.
   it('says why on the message the queue stopped on and on every rejected or refused one', () => {
     expect(
       texts([
         entry('sent', { state: 'dispatching' }),
         entry('rejected', { state: 'rejected' }),
         entry('failed', { lastFailure: { kind: 'failed' } }),
-        entry('stuck', { state: 'unconfirmed' }),
+        entry('stuck', { state: 'unconfirmed', retryAfterUnknownSubmittedAt: -1 }),
         entry('behind', { state: 'unconfirmed' }),
         entry('queued')
       ])
     ).toEqual({
+      [agentJournalSubmissionKey('sent')]: SENDING,
       [agentJournalSubmissionKey('rejected')]: 'Message was not sent.',
       [agentJournalSubmissionKey('failed')]: 'Your message was not sent.',
-      [agentJournalSubmissionKey('stuck')]: 'Message delivery is unconfirmed.'
+      [agentJournalSubmissionKey('stuck')]: 'Message delivery is unconfirmed.',
+      [agentJournalSubmissionKey('behind')]: SENDING,
+      [agentJournalSubmissionKey('queued')]: SENDING
     })
   })
 
@@ -175,7 +224,10 @@ describe('the notice on each message that did not go through', () => {
   it('keeps a rejected message behind the stopped one its words but not its Retry', () => {
     const retry = vi.fn()
     for (const outbox of [
-      [entry('stuck', { state: 'unconfirmed' }), entry('rejected', { state: 'rejected' })],
+      [
+        entry('stuck', { state: 'unconfirmed', retryAfterUnknownSubmittedAt: -1 }),
+        entry('rejected', { state: 'rejected' })
+      ],
       [entry('held', { outlivedStop: true }), entry('rejected', { state: 'rejected' })]
     ]) {
       const notices = structuredAgentSessionDeliveryNotices(
@@ -194,7 +246,7 @@ describe('the notice on each message that did not go through', () => {
 
   // Ahead of the stopped message, its Retry sends it at once, so the row offers it.
   it.each([
-    ['in doubt', { state: 'unconfirmed' as const }],
+    ['in doubt', { state: 'unconfirmed' as const, retryAfterUnknownSubmittedAt: -1 }],
     ['outlived by a Stop', { outlivedStop: true as const }]
   ])('gives a failed message ahead of one %s its Retry', (_label, patch) => {
     const retry = vi.fn()
@@ -223,39 +275,15 @@ describe('the notice on each message that did not go through', () => {
     expect(retry.mock.calls).toEqual([['refused'], ['rejected'], ['stuck']])
   })
 
-  // Beside its own Retry the resend step is the button; without one the words keep it.
-  it('leaves out sending again only where the message has its own Retry', () => {
-    const startFailed = (clientMessageId: string): StructuredAgentSessionOutboxEntry =>
-      entry(clientMessageId, {
-        state: 'rejected',
-        lastFailure: {
-          kind: 'rejected',
-          reason: 'Claude stopped before it finished starting. Send your message to try again.',
-          rejection: { kind: 'providerStartFailed' }
-        }
-      })
-    expect(texts([startFailed('first'), startFailed('second')])).toEqual({
-      [agentJournalSubmissionKey('first')]: 'Claude stopped before it finished starting.',
-      [agentJournalSubmissionKey('second')]: 'Claude stopped before it finished starting.'
-    })
-    expect(texts([entry('held', { outlivedStop: true }), startFailed('rejected')])).toMatchObject({
-      [agentJournalSubmissionKey('rejected')]:
-        'Claude stopped before it finished starting. Send your message to try again.'
-    })
-  })
-
+  // With no Retry beside it, the words keep the resend step.
   it.each([
     [
-      'notDelivered',
-      'This message was not delivered. Send it again to continue.',
-      'This message was not delivered.'
+      'providerStartFailed',
+      'Claude stopped before it finished starting. Send your message to try again.'
     ],
-    [
-      'hostFault',
-      "Orca ran into a problem, so this didn't go through. Try again.",
-      "Orca ran into a problem, so this didn't go through."
-    ]
-  ] as const)('leaves the step to the Retry beside a %s message', (kind, reason, shown) => {
+    ['notDelivered', 'This message was not delivered. Send it again to continue.'],
+    ['hostFault', "Orca ran into a problem, so this didn't go through. Try again."]
+  ] as const)('keeps the step in the words of a %s message the host rejected', (kind, reason) => {
     expect(
       texts([
         entry('rejected', {
@@ -263,7 +291,7 @@ describe('the notice on each message that did not go through', () => {
           lastFailure: { kind: 'rejected', reason, rejection: { kind } }
         })
       ])
-    ).toEqual({ [agentJournalSubmissionKey('rejected')]: shown })
+    ).toEqual({ [agentJournalSubmissionKey('rejected')]: reason })
   })
 
   // The journal holds the whole fact; the message's own copy keeps only its kind and attachment.
@@ -281,7 +309,7 @@ describe('the notice on each message that did not go through', () => {
     const recorded = (id: string, rejection: AgentSessionFailureFact): AgentJournalSubmission => ({
       clientMessageId: id,
       fence: 1,
-      payloadFingerprint: 'fingerprint',
+      payloadFingerprint: id,
       dispatchState: 'rejected',
       providerItemId: null,
       reason: "The agent couldn't be started.",
@@ -312,7 +340,8 @@ describe('the notice on each message that did not go through', () => {
       [
         'resumable',
         { kind: 'startFailed', refusal: { code: 'agent_session_ownership_unknown' } },
-        "Claude couldn't start."
+        // No Retry beside it, so the words keep the step.
+        "Claude couldn't start. Send your message to try again."
       ],
       [
         'provider',
@@ -392,7 +421,7 @@ describe('the notice on each message that did not go through', () => {
           {
             clientMessageId: 'recorded',
             fence: 1,
-            payloadFingerprint: 'fingerprint',
+            payloadFingerprint: 'recorded',
             dispatchState: 'rejected',
             providerItemId: null,
             reason,
@@ -456,8 +485,231 @@ describe('the notice on each message that did not go through', () => {
     )
   })
 
-  it('says nothing on a message that is only waiting its turn or on its way', () => {
-    expect(texts([entry('queued'), entry('sending', { state: 'dispatching' })])).toEqual({})
+  it('says only that a message waiting its turn or on its way is still sending', () => {
+    const notices = structuredAgentSessionDeliveryNotices(
+      [entry('queued'), entry('sending', { state: 'dispatching' })],
+      'Claude',
+      vi.fn(),
+      [],
+      [],
+      NOT_FAILED_HERE
+    )
+    expect([...notices.values()]).toEqual([{ sending: true }, { sending: true }])
+  })
+
+  // Any row the host holds for it is the answer, whatever its state; the row itself then shows it.
+  it.each(['pending', 'accepted'] as const)(
+    'stops saying a message is sending once the journal holds a %s row for it',
+    (dispatchState) => {
+      const answer = (clientMessageId: string): AgentJournalSubmission => ({
+        clientMessageId,
+        fence: 1,
+        payloadFingerprint: 'fp',
+        dispatchState,
+        providerItemId: null,
+        reason: null,
+        submittedAt: 1,
+        resolvedAt: null
+      })
+      const resent = entry('resent', { state: 'unconfirmed', lastAttemptAt: 1 })
+      const outbox = [entry('queued'), entry('sending', { state: 'dispatching' }), resent]
+      expect(texts(outbox)).toEqual({
+        [agentJournalSubmissionKey('queued')]: SENDING,
+        [agentJournalSubmissionKey('sending')]: SENDING,
+        [agentJournalSubmissionKey('resent')]: SENDING
+      })
+      expect(texts(outbox, [answer('queued'), answer('sending'), answer('resent')])).toEqual({})
+      // Read as the outbox will commit it, so the resent one never says it failed on the way.
+      expect(texts([resent], [answer('resent')])).toEqual({})
+    }
+  )
+
+  // Only a row that has the message ends it; one in doubt leaves it looking sent.
+  describe('a message whose journal row does not have it yet', () => {
+    const row = (
+      clientMessageId: string,
+      dispatchState: AgentJournalSubmission['dispatchState'],
+      patch: Partial<AgentJournalSubmission> = {}
+    ): AgentJournalSubmission => ({
+      clientMessageId,
+      fence: 1,
+      payloadFingerprint: 'fp',
+      dispatchState,
+      providerItemId: null,
+      reason: null,
+      submittedAt: 7,
+      resolvedAt: null,
+      ...patch
+    })
+    const stuck = entry('stuck', { state: 'unconfirmed', retryAfterUnknownSubmittedAt: -1 })
+
+    it.each([
+      ['queued', { state: 'queued' as const }, {}],
+      ['in flight', { state: 'dispatching' as const, lastAttemptAt: 2 }, {}],
+      [
+        'in flight, after a host restart',
+        { state: 'dispatching' as const, lastAttemptAt: 2 },
+        { recovered: true as const }
+      ]
+    ])('says it is sending while your Retry is %s', (_label, patch, rowPatch) => {
+      const doubt = row('m', 'unknown', rowPatch)
+      expect(texts([entry('m', { state: 'unconfirmed', lastAttemptAt: 1 })], [doubt])).toEqual({
+        [agentJournalSubmissionKey('m')]: 'Message delivery is unconfirmed.'
+      })
+      const retried = entry('m', { lastAttemptAt: 1, retryAfterUnknownSubmittedAt: 7, ...patch })
+      expect(texts([retried], [doubt])).toEqual({ [agentJournalSubmissionKey('m')]: SENDING })
+    })
+
+    it.each([
+      ['a live unknown', {}],
+      ['a recovered unknown', { recovered: true as const }]
+    ])('says the second of two in doubt is sending when each row holds %s', (_label, patch) => {
+      const a = entry('a', { state: 'unconfirmed' })
+      const b = entry('b', { state: 'unconfirmed' })
+      expect(texts([a, b], [row('a', 'unknown', patch), row('b', 'unknown', patch)])).toEqual({
+        [agentJournalSubmissionKey('a')]: 'Message delivery is unconfirmed.',
+        [agentJournalSubmissionKey('b')]: SENDING
+      })
+    })
+
+    // The rejection makes it the host's: not sent, in the host's words, whether its outbox copy or
+    // its loaded row draws it.
+    it('says a requeued message whose row was rejected was not sent, never sending', () => {
+      const requeued = entry('q', { state: 'queued', lastAttemptAt: 1 })
+      const rejected = row('q', 'rejected', { reason: 'provider said no', resolvedAt: 8 })
+      const notSent = { [agentJournalSubmissionKey('q')]: 'provider said no' }
+      expect(texts([requeued], [rejected])).toEqual(notSent)
+      expect(texts([stuck, requeued], [rejected])).toEqual({
+        [agentJournalSubmissionKey('stuck')]: 'Message delivery is unconfirmed.',
+        ...notSent
+      })
+      const loadedRow: AgentJournalRenderItem = {
+        itemId: agentJournalSubmissionKey('q'),
+        revision: 1,
+        sequence: 1,
+        observedAt: 8,
+        body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'q' }] }
+      }
+      const loaded = structuredAgentSessionDeliveryNotices(
+        [requeued],
+        'Claude',
+        vi.fn(),
+        [rejected],
+        [],
+        NOT_FAILED_HERE,
+        [],
+        new Set(),
+        [loadedRow]
+      )
+      expect([...loaded]).toEqual([[agentJournalSubmissionKey('q'), { text: 'provider said no' }]])
+    })
+  })
+
+  // One state, one surface: a row that says it did not go through never also says it is sending.
+  it.each([
+    ['rejected', entry('m', { state: 'rejected' }), []],
+    ['held for its Retry', entry('m', { lastFailure: { kind: 'failed' } }), []],
+    [
+      'in doubt with a row the host holds',
+      entry('m', { state: 'unconfirmed', lastAttemptAt: 1 }),
+      [
+        {
+          clientMessageId: 'm',
+          fence: 1,
+          payloadFingerprint: 'fp',
+          dispatchState: 'unknown',
+          providerItemId: null,
+          reason: null,
+          submittedAt: 1,
+          resolvedAt: null
+        } satisfies AgentJournalSubmission
+      ]
+    ],
+    [
+      'retried by the user',
+      entry('m', { state: 'unconfirmed', retryAfterUnknownSubmittedAt: 1 }),
+      []
+    ],
+    ['outlived by a Stop', entry('m', { state: 'unconfirmed', outlivedStop: true }), []]
+  ])('says only why on a message %s, never that it is sending', (_label, failed, rows) => {
+    const notice = structuredAgentSessionDeliveryNotices(
+      [failed],
+      'Claude',
+      vi.fn(),
+      rows,
+      [],
+      NOT_FAILED_HERE
+    ).get(agentJournalSubmissionKey('m'))
+    expect(notice?.sending).toBeUndefined()
+    expect(notice?.text).toMatch(/not sent|unconfirmed/)
+    expect(notice?.onRetry).toBeDefined()
+  })
+
+  // The unconfirmed probe resends it under its own id until the journal answers, so the row says
+  // it is still sending, with no Retry, until a row lands.
+  describe('a message in doubt that Orca resends on its own', () => {
+    const doubt = (patch: Partial<StructuredAgentSessionOutboxEntry> = {}) =>
+      entry('doubt', { state: 'unconfirmed', lastAttemptAt: 1, ...patch })
+    const row = (patch: Partial<AgentJournalSubmission>): AgentJournalSubmission => ({
+      clientMessageId: 'doubt',
+      fence: 1,
+      payloadFingerprint: 'fp',
+      dispatchState: 'unknown',
+      providerItemId: null,
+      reason: null,
+      submittedAt: 1,
+      resolvedAt: null,
+      ...patch
+    })
+    const UNCONFIRMED = { [agentJournalSubmissionKey('doubt')]: 'Message delivery is unconfirmed.' }
+
+    it('says only that it is still sending while the journal holds no row for it', () => {
+      const notices = structuredAgentSessionDeliveryNotices(
+        [doubt(), entry('behind')],
+        'Claude',
+        vi.fn(),
+        [],
+        [],
+        NOT_FAILED_HERE
+      )
+      expect(notices.get(agentJournalSubmissionKey('doubt'))).toEqual({ sending: true })
+      expect(notices.get(agentJournalSubmissionKey('behind'))).toEqual({ sending: true })
+      // Another message's row is not its answer.
+      expect(
+        texts([doubt()], [row({ clientMessageId: 'other', dispatchState: 'accepted' })])
+      ).toEqual({ [agentJournalSubmissionKey('doubt')]: SENDING })
+    })
+
+    it.each([
+      ['a live unknown', row({})],
+      ['a recovered unknown', row({ recovered: true })],
+      [
+        "an older host's recovered unknown",
+        row({ reason: 'host_restarted_before_acknowledgement' })
+      ]
+    ])('says it is unconfirmed, with its Retry, once the journal holds %s', (_label, answer) => {
+      const retry = vi.fn()
+      const notices = structuredAgentSessionDeliveryNotices(
+        [doubt()],
+        'Claude',
+        retry,
+        [answer],
+        [],
+        NOT_FAILED_HERE
+      )
+      expect(Object.fromEntries([...notices].map(([id, notice]) => [id, notice.text]))).toEqual(
+        UNCONFIRMED
+      )
+      notices.get(agentJournalSubmissionKey('doubt'))?.onRetry?.()
+      expect(retry).toHaveBeenCalledExactlyOnceWith('doubt')
+    })
+
+    it.each([
+      ['the user already retried', { retryAfterUnknownSubmittedAt: 1 }],
+      ['a Stop outlived', { outlivedStop: true as const }]
+    ])('says it is unconfirmed when %s it, as nothing resends it', (_label, patch) => {
+      expect(texts([doubt(patch)])).toEqual(UNCONFIRMED)
+    })
   })
 
   // Matched on the typed fact of a row found by its identity, never on either sentence.
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-delivery-notices.ts b/src/renderer/src/components/native-chat/structured-agent-session-delivery-notices.ts
index 6ad655e8f80..52f3832dffa 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-delivery-notices.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-delivery-notices.ts
@@ -1,16 +1,20 @@
-// Which of the structured chat's own messages say, on their row, that they did not go through.
+// Which of the structured chat's own messages say, on their row, that they did not go through, and
+// which say quietly that they are still sending: every other one, until the host holds a row that
+// has it (pending or accepted). A row in doubt does not, so a message resent over one still reads
+// as sending; a rejected row makes it the host's, shown as not sent.
 //
 // Derived from the outbox on every render and never stored: each failed or held message carries
 // its own typed failure, so each row words its own reason. Read through the drain's own rule: while
 // the queue is stopped, the message it stopped on and any failed one ahead of it have a Retry, as
-// each would go out at once; one behind it would wait unseen. One waiting behind says nothing; a
-// rejected or refused message holds nothing up, so it keeps its words and gets its Retry once the
-// queue moves.
+// each would go out at once; one behind it would wait unseen. One waiting behind has no failure of
+// its own, so it reads as sending; a rejected or refused message holds nothing up, so it keeps its
+// words and gets its Retry once the queue moves.
 //
-// A message the host recorded and then rejected is worded from the journal's own fact, found by id;
-// the message keeps only a smaller copy, read when its submission is not loaded. A rejection that
-// is a failed start's, the fact its loaded row states, says only that it was not sent: the row
-// already says why.
+// A message the host recorded and then rejected is drawn from the host's history, worded from the
+// journal's own fact, with no Retry: sending it again is a new message. A rejection that is a
+// failed start's, the fact its loaded row states, says only that it was not sent: the row already
+// says why. Until its row loads, the outbox draws it from its smaller copy, which leaves on the batch
+// or page that loads the row.
 
 import {
   readAgentSessionFailureFact,
@@ -26,18 +30,30 @@ import { agentSessionWriteNotDoneParts } from '../../../../shared/agent-session-
 import { isStructuredAgentSessionStartFailureRow } from '../../../../shared/structured-agent-session-start-failure-row-key'
 import {
   structuredAgentSessionEntryIdExpired,
+  structuredAgentSessionEntryRejectedByHost,
   type StructuredAgentSessionOutboxEntry
 } from '../../../../shared/structured-agent-session-outbox'
 import {
   admitStructuredAgentSessionOutboxEntry,
   structuredAgentSessionEntryHeldForRetry
 } from '../../../../shared/structured-agent-session-outbox-admission'
+import { reconcileStructuredAgentSessionOutboxWithQueue } from '../../../../shared/structured-agent-session-draft-hand-off'
+import { structuredAgentSessionEntryResendsUnconfirmed } from '../../../../shared/structured-agent-session-outbox-unconfirmed-resend'
 import type { AgentSessionFailureWordsContext } from '../../../../shared/agent-session-failure-words'
-import { structuredAgentSessionAttemptFailureParts } from '../../../../shared/structured-agent-session-send-disposition'
+import {
+  structuredAgentSessionAttemptFailureParts,
+  structuredAgentSessionRejectionParts
+} from '../../../../shared/structured-agent-session-send-disposition'
+import { structuredAgentSessionRejectedShownInPlace } from '../../../../shared/structured-agent-session-message-projection'
 import { translate } from '@/i18n/i18n'
 import { agentSessionWriteNoticeText } from './agent-session-write-notice-text'
 import type { NativeChatDeliveryNotice } from './NativeChatMessageRow'
 
+/** One shared value, so a rebuilt map re-renders no row still sending. */
+const STRUCTURED_AGENT_SESSION_DELIVERY_SENDING: NativeChatDeliveryNotice = { sending: true }
+const NO_COMMANDS: ReadonlySet<string> = new Set()
+const NO_ITEMS: readonly AgentJournalRenderItem[] = []
+
 /** The facts the chat's loaded start-failure rows state. */
 export function structuredAgentSessionStartFailureFacts(
   items: readonly AgentJournalRenderItem[]
@@ -87,8 +103,6 @@ export function agentSessionFailureStatedByStartRow(
 function deliveryNoticeText(
   entry: StructuredAgentSessionOutboxEntry,
   context: AgentSessionFailureWordsContext,
-  recorded: AgentJournalSubmission | undefined,
-  startFailures: readonly AgentSessionFailureFact[],
   failedHere: ReadonlySet<string>
 ): string {
   // A send attempted before a Stop and then interrupted may already be with the host.
@@ -114,17 +128,25 @@ function deliveryNoticeText(
   if (structuredAgentSessionEntryHeldForRetry(entry) && !failedHere.has(entry.clientMessageId)) {
     return agentSessionWriteNoticeText(agentSessionWriteNotDoneParts('send'))
   }
-  if (
-    entry.state === 'rejected' &&
-    agentSessionFailureStatedByStartRow(recorded?.rejection, startFailures)
-  ) {
+  return agentSessionWriteNoticeText(
+    structuredAgentSessionAttemptFailureParts(entry.lastFailure, context)
+  )
+}
+
+function hostRejectionNoticeText(
+  submission: AgentJournalSubmission,
+  agentName: string,
+  startFailures: readonly AgentSessionFailureFact[]
+): string {
+  if (agentSessionFailureStatedByStartRow(submission.rejection, startFailures)) {
     return agentSessionWriteNoticeText(agentSessionWriteNotDoneParts('send'))
   }
   return agentSessionWriteNoticeText(
-    structuredAgentSessionAttemptFailureParts(
-      entry.lastFailure,
-      context,
-      readWholeAgentSessionFailureFact(recorded?.rejection)
+    structuredAgentSessionRejectionParts(
+      submission.reason,
+      'send',
+      readWholeAgentSessionFailureFact(submission.rejection),
+      { agentName }
     )
   )
 }
@@ -135,41 +157,72 @@ export function structuredAgentSessionDeliveryNotices(
   outbox: readonly StructuredAgentSessionOutboxEntry[],
   agentName: string,
   retry: (clientMessageId: string) => void,
-  /** The journal's rows, whose rejected ones carry more of a rejection than the message keeps. */
+  /** The journal's rows: rejected ones carry more of a rejection than the message keeps, and a
+   *  message with no pending or accepted one is still sending. */
   submissions: readonly AgentJournalSubmission[],
   /** What the loaded start-failure rows state, from `structuredAgentSessionStartFailureFacts`. */
   startFailures: readonly AgentSessionFailureFact[],
   /** Ids whose send failed or was refused while this chat was open: only they word their cause. */
-  failedHere: ReadonlySet<string>
+  failedHere: ReadonlySet<string>,
+  /** The queue's live cards, which the transcript leaves a rejected message to. */
+  queuedMessageIds: readonly string[] = [],
+  /** The loaded commands, from `structuredAgentSessionCommandItemIds`: they report their own. */
+  commandItemIds: ReadonlySet<string> = NO_COMMANDS,
+  /** The loaded rows: a rejected message's outbox copy leaves once its row is here. */
+  journalItems: readonly AgentJournalRenderItem[] = NO_ITEMS
 ): ReadonlyMap<string, NativeChatDeliveryNotice> {
-  const admission = admitStructuredAgentSessionOutboxEntry(outbox)
+  // As the transcript reads it, so a row that lands is answered here before the outbox commits it.
+  const entries = reconcileStructuredAgentSessionOutboxWithQueue(outbox, submissions, journalItems)
+  const admission = admitStructuredAgentSessionOutboxEntry(entries)
   const held = admission.state === 'blocked' ? admission.entry.clientMessageId : null
-  const stalledFrom = admission.state === 'blocked' ? outbox.indexOf(admission.entry) : -1
+  const stalledFrom = admission.state === 'blocked' ? entries.indexOf(admission.entry) : -1
   const rejected = new Map(
     submissions
       .filter((submission) => submission.dispatchState === 'rejected')
       .map((submission) => [submission.clientMessageId, submission])
   )
   const notices = new Map<string, NativeChatDeliveryNotice>()
-  for (const [index, entry] of outbox.entries()) {
+  for (const [index, entry] of entries.entries()) {
+    // Resent under its own id until the journal answers, so still sending, not failed.
     if (
-      entry.state === 'rejected' ||
-      structuredAgentSessionEntryHeldForRetry(entry) ||
-      entry.clientMessageId === held
+      !structuredAgentSessionEntryResendsUnconfirmed(entry, submissions) &&
+      (entry.state === 'rejected' ||
+        structuredAgentSessionEntryHeldForRetry(entry) ||
+        entry.clientMessageId === held)
     ) {
-      // Its own Retry is the step, so the words leave out sending again.
-      const retryControl = stalledFrom === -1 || index <= stalledFrom
-      const text = deliveryNoticeText(
-        entry,
-        { agentName, retryControl },
-        rejected.get(entry.clientMessageId),
-        startFailures,
-        failedHere
-      )
+      // Its own Retry is the step, so the words leave out sending again. One the host recorded is
+      // the host's: sending it again is a new message, so it has no Retry.
+      const retryControl =
+        (stalledFrom === -1 || index <= stalledFrom) &&
+        !structuredAgentSessionEntryRejectedByHost(entry)
+      const text = deliveryNoticeText(entry, { agentName, retryControl }, failedHere)
       notices.set(
         agentJournalSubmissionKey(entry.clientMessageId),
         retryControl ? { text, onRetry: () => retry(entry.clientMessageId) } : { text }
       )
+    } else if (
+      !submissions.some(
+        (submission) =>
+          submission.clientMessageId === entry.clientMessageId &&
+          (submission.dispatchState === 'pending' || submission.dispatchState === 'accepted')
+      )
+    ) {
+      notices.set(
+        agentJournalSubmissionKey(entry.clientMessageId),
+        STRUCTURED_AGENT_SESSION_DELIVERY_SENDING
+      )
+    }
+  }
+  // After the outbox's: in the host's words, whether its row or the outbox's copy draws it.
+  const shown = structuredAgentSessionRejectedShownInPlace(
+    submissions,
+    queuedMessageIds,
+    commandItemIds
+  )
+  for (const submission of rejected.values()) {
+    const id = agentJournalSubmissionKey(submission.clientMessageId)
+    if (shown.has(id)) {
+      notices.set(id, { text: hostRejectionNoticeText(submission, agentName, startFailures) })
     }
   }
   return notices
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-message-projection.older-host.test.ts b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.older-host.test.ts
new file mode 100644
index 00000000000..7cc13a0a4eb
--- /dev/null
+++ b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.older-host.test.ts
@@ -0,0 +1,161 @@
+// An older host leaves a rejected message where it was sent. When that is older than the loaded
+// window, the chat holds its rejected submission but not its row: the outbox copy keeps drawing it,
+// with no control, until the page holding the row loads, and then the host's row draws it instead.
+
+import { expect, it } from 'vitest'
+import { agentJournalSubmissionKey } from '../../../../shared/agent-session-journal-item-key'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
+import type { AgentSessionHistoryPage } from '../../../../shared/agent-session-wire'
+import { DISPATCH_REJECTED_HOST_RESTARTED } from '../../../../shared/structured-agent-session-dispatch-rejection'
+import { reconcileStructuredAgentSessionOutboxWithQueue } from '../../../../shared/structured-agent-session-draft-hand-off'
+import { createStructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
+import {
+  EMPTY_STRUCTURED_AGENT_SESSION,
+  reduceStructuredAgentSession
+} from '../../../../shared/structured-agent-session-reducer'
+import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
+import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
+
+const NO_CARDS: readonly string[] = []
+const MESSAGE_ID = agentJournalSubmissionKey('m')
+
+function answer(sequence: number): AgentJournalRenderItem {
+  return {
+    itemId: `a-${sequence}`,
+    revision: 1,
+    sequence,
+    observedAt: sequence,
+    body: { kind: 'message', role: 'assistant', blocks: [{ type: 'text', text: 'ok' }] }
+  }
+}
+
+/** Where the older host left it: at its submission, far behind the loaded window. */
+const SENT: AgentJournalRenderItem = {
+  itemId: MESSAGE_ID,
+  revision: 1,
+  sequence: 10,
+  observedAt: 10,
+  body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'queued msg' }] }
+}
+
+const REJECTED: AgentJournalSubmission = {
+  clientMessageId: 'm',
+  fence: 1,
+  payloadFingerprint: 'x',
+  dispatchState: 'rejected',
+  providerItemId: null,
+  reason: DISPATCH_REJECTED_HOST_RESTARTED,
+  rejection: { kind: 'hostRestarted' },
+  submittedAt: 10,
+  resolvedAt: 2000
+}
+
+function page(
+  items: AgentJournalRenderItem[],
+  submissions: AgentJournalSubmission[],
+  hasOlder: boolean
+): AgentSessionHistoryPage {
+  const oldest = items[0]?.sequence ?? 0
+  const newest = items.at(-1)?.sequence ?? 0
+  return {
+    sessionId: 's',
+    epoch: 'e',
+    direction: 'tail',
+    items,
+    removedItemIds: [],
+    submissions,
+    window: {
+      oldest: { epoch: 'e', sequence: oldest },
+      newest: { epoch: 'e', sequence: newest },
+      nextCursor: { epoch: 'e', sequence: oldest }
+    },
+    liveCursor: { epoch: 'e', sequence: 1099 },
+    hasOlder,
+    hasNewer: false
+  }
+}
+
+it("keeps the outbox copy of a rejected message whose row is outside the window, then the host's row takes over", () => {
+  let state = reduceStructuredAgentSession(EMPTY_STRUCTURED_AGENT_SESSION, {
+    type: 'event',
+    event: {
+      type: 'snapshot',
+      sessionId: 's',
+      fence: 1,
+      page: page(
+        Array.from({ length: 100 }, (_, index) => answer(1000 + index)),
+        [],
+        true
+      )
+    }
+  })
+  // The rejection touches the row, which the older host left at its submission.
+  state = reduceStructuredAgentSession(state, {
+    type: 'event',
+    event: {
+      type: 'batch',
+      sessionId: 's',
+      batch: {
+        cursor: { epoch: 'e', sequence: 1100 },
+        items: [SENT],
+        removedItemIds: [],
+        submissions: [REJECTED]
+      }
+    }
+  })
+  expect(state.items.some((item) => item.itemId === MESSAGE_ID)).toBe(false)
+  expect(state.submissions.map((submission) => submission.clientMessageId)).toEqual(['m'])
+
+  const sent = {
+    ...createStructuredAgentSessionOutboxEntry({
+      clientMessageId: 'm',
+      sessionId: 's',
+      text: 'queued msg',
+      attachments: [],
+      queuedAt: 10
+    }),
+    state: 'dispatching' as const
+  }
+  const kept = reconcileStructuredAgentSessionOutboxWithQueue(
+    [sent],
+    state.submissions,
+    state.items
+  )
+  expect(kept).toMatchObject([{ clientMessageId: 'm', state: 'rejected' }])
+  const drawn = (outbox: typeof kept) =>
+    projectStructuredAgentSessionMessages(state.items, outbox, state.submissions, NO_CARDS)
+      .filter((message) => message.role === 'user')
+      .map(({ id, unsent }) => ({ id, unsent }))
+  expect(drawn(kept)).toEqual([{ id: MESSAGE_ID, unsent: true }])
+  const notice = structuredAgentSessionDeliveryNotices(
+    kept,
+    'Claude',
+    () => {},
+    state.submissions,
+    [],
+    new Set()
+  ).get(MESSAGE_ID)
+  expect(notice).toEqual({ text: 'Orca restarted before this message was sent.' })
+
+  // Paging back loads the row: the outbox lets go, and the host's row is the one drawn.
+  state = reduceStructuredAgentSession(state, {
+    type: 'older-page',
+    requestedCursor: { epoch: 'e', sequence: 1000 },
+    page: page(
+      [SENT, ...Array.from({ length: 10 }, (_, index) => answer(990 + index))],
+      [REJECTED],
+      false
+    )
+  })
+  expect(state.items.some((item) => item.itemId === MESSAGE_ID)).toBe(true)
+  const released = reconcileStructuredAgentSessionOutboxWithQueue(
+    kept,
+    state.submissions,
+    state.items
+  )
+  expect(released).toEqual([])
+  expect(drawn(released)).toEqual([{ id: MESSAGE_ID, unsent: true }])
+})
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-message-projection.recorded-copy.test.ts b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.recorded-copy.test.ts
new file mode 100644
index 00000000000..84e10ca18b7
--- /dev/null
+++ b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.recorded-copy.test.ts
@@ -0,0 +1,218 @@
+// An outbox copy of a message the host recorded and then rejected draws it only while the host's row
+// is not loaded, and leaves, with no user action, on the batch or page that loads that row. It never
+// offers a control: sending it again is a new message.
+
+import { expect, it } from 'vitest'
+import { agentJournalSubmissionKey } from '../../../../shared/agent-session-journal-item-key'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
+import type { AgentSessionHistoryPage } from '../../../../shared/agent-session-wire'
+import { DISPATCH_REJECTED_HOST_RESTARTED } from '../../../../shared/structured-agent-session-dispatch-rejection'
+import { reconcileStructuredAgentSessionOutboxWithQueue } from '../../../../shared/structured-agent-session-draft-hand-off'
+import {
+  createStructuredAgentSessionOutboxEntry,
+  structuredAgentSessionRejectedFailure,
+  type StructuredAgentSessionOutboxEntry
+} from '../../../../shared/structured-agent-session-outbox'
+import { admitStructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox-admission'
+import {
+  EMPTY_STRUCTURED_AGENT_SESSION,
+  reduceStructuredAgentSession,
+  type StructuredAgentSessionState
+} from '../../../../shared/structured-agent-session-reducer'
+import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
+import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
+
+const NO_CARDS: readonly string[] = []
+const MESSAGE_ID = agentJournalSubmissionKey('m')
+const WORDS = 'Orca restarted before this message was sent.'
+
+function answer(sequence: number): AgentJournalRenderItem {
+  return {
+    itemId: `a-${sequence}`,
+    revision: 1,
+    sequence,
+    observedAt: sequence,
+    body: { kind: 'message', role: 'assistant', blocks: [{ type: 'text', text: 'ok' }] }
+  }
+}
+
+function hostRow(sequence: number): AgentJournalRenderItem {
+  return {
+    itemId: MESSAGE_ID,
+    revision: 1,
+    sequence,
+    observedAt: sequence,
+    body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'sent text' }] }
+  }
+}
+
+const REJECTED: AgentJournalSubmission = {
+  clientMessageId: 'm',
+  fence: 1,
+  payloadFingerprint: 'm',
+  dispatchState: 'rejected',
+  providerItemId: null,
+  reason: DISPATCH_REJECTED_HOST_RESTARTED,
+  rejection: { kind: 'hostRestarted' },
+  submittedAt: 10,
+  resolvedAt: 1100
+}
+
+function copy(patch: Partial<StructuredAgentSessionOutboxEntry> = {}) {
+  return {
+    ...createStructuredAgentSessionOutboxEntry({
+      clientMessageId: 'm',
+      sessionId: 's',
+      text: 'sent text',
+      attachments: [],
+      queuedAt: 10
+    }),
+    ...patch
+  }
+}
+
+/** A copy the host's own reply already marked rejected, as the outbox stores it. */
+const RECORDED_COPY = copy({
+  state: 'rejected',
+  lastFailure: structuredAgentSessionRejectedFailure(REJECTED)
+})
+
+function page(
+  items: AgentJournalRenderItem[],
+  submissions: AgentJournalSubmission[]
+): AgentSessionHistoryPage {
+  const oldest = items[0]?.sequence ?? 0
+  return {
+    sessionId: 's',
+    epoch: 'e',
+    direction: 'tail',
+    items,
+    removedItemIds: [],
+    submissions,
+    window: {
+      oldest: { epoch: 'e', sequence: oldest },
+      newest: { epoch: 'e', sequence: items.at(-1)?.sequence ?? 0 },
+      nextCursor: { epoch: 'e', sequence: oldest }
+    },
+    liveCursor: { epoch: 'e', sequence: items.at(-1)?.sequence ?? 0 },
+    hasOlder: true,
+    hasNewer: false
+  }
+}
+
+function opened(items: AgentJournalRenderItem[], submissions: AgentJournalSubmission[]) {
+  return reduceStructuredAgentSession(EMPTY_STRUCTURED_AGENT_SESSION, {
+    type: 'event',
+    event: { type: 'snapshot', sessionId: 's', fence: 1, page: page(items, submissions) }
+  })
+}
+
+const WINDOW = Array.from({ length: 100 }, (_, index) => answer(1000 + index))
+
+/** What the chat draws for this message, and the notice its row carries. */
+function shown(
+  state: StructuredAgentSessionState,
+  outbox: readonly StructuredAgentSessionOutboxEntry[]
+) {
+  const kept = reconcileStructuredAgentSessionOutboxWithQueue(
+    outbox,
+    state.submissions,
+    state.items
+  )
+  const rows = projectStructuredAgentSessionMessages(state.items, kept, state.submissions, NO_CARDS)
+    .filter((message) => message.role === 'user')
+    .map(({ id, unsent }) => ({ id, unsent }))
+  const notice = structuredAgentSessionDeliveryNotices(
+    kept,
+    'Claude',
+    () => {},
+    state.submissions,
+    [],
+    new Set()
+  ).get(MESSAGE_ID)
+  return { kept, rows, notice }
+}
+
+it('leaves on the live batch that rejects it on a host that places the row at the rejection', () => {
+  let state = opened(WINDOW, [])
+  const sent = copy({ state: 'dispatching', lastAttemptAt: 9 })
+  state = reduceStructuredAgentSession(state, {
+    type: 'event',
+    event: {
+      type: 'batch',
+      sessionId: 's',
+      batch: {
+        cursor: { epoch: 'e', sequence: 1100 },
+        items: [hostRow(1100)],
+        removedItemIds: [],
+        submissions: [REJECTED]
+      }
+    }
+  })
+
+  expect(shown(state, [sent])).toEqual({
+    kept: [],
+    rows: [{ id: MESSAGE_ID, unsent: true }],
+    notice: { text: WORDS }
+  })
+})
+
+it('leaves on the page that opens the chat when that page holds the row', () => {
+  const state = opened([...WINDOW, hostRow(1100)], [REJECTED])
+
+  expect(shown(state, [RECORDED_COPY])).toEqual({
+    kept: [],
+    rows: [{ id: MESSAGE_ID, unsent: true }],
+    notice: { text: WORDS }
+  })
+})
+
+it('draws once, with no control, while its row is outside the window, and leaves when that page loads', () => {
+  // An older host leaves the row where it was sent; the live batch brings only its record.
+  let state = reduceStructuredAgentSession(opened(WINDOW, []), {
+    type: 'event',
+    event: {
+      type: 'batch',
+      sessionId: 's',
+      batch: {
+        cursor: { epoch: 'e', sequence: 1100 },
+        items: [hostRow(10)],
+        removedItemIds: [],
+        submissions: [REJECTED]
+      }
+    }
+  })
+  const before = shown(state, [copy({ state: 'dispatching', lastAttemptAt: 9 })])
+  expect(before.kept).toMatchObject([{ clientMessageId: 'm', state: 'rejected' }])
+  expect(before.rows).toEqual([{ id: MESSAGE_ID, unsent: true }])
+  expect(before.notice).toEqual({ text: WORDS })
+
+  // Scrolling back loads the page; no control on the copy is involved.
+  state = reduceStructuredAgentSession(state, {
+    type: 'older-page',
+    requestedCursor: { epoch: 'e', sequence: 1000 },
+    page: page(
+      [hostRow(10), ...Array.from({ length: 5 }, (_, index) => answer(995 + index))],
+      [REJECTED]
+    )
+  })
+  expect(shown(state, before.kept)).toEqual({
+    kept: [],
+    rows: [{ id: MESSAGE_ID, unsent: true }],
+    notice: { text: WORDS }
+  })
+})
+
+it('keeps a stored copy whose record is not held drawn, with no control, and never sends it', () => {
+  const state = opened(WINDOW, [])
+  const after = shown(state, [RECORDED_COPY])
+
+  expect(after.kept).toEqual([RECORDED_COPY])
+  expect(after.rows).toEqual([{ id: MESSAGE_ID, unsent: true }])
+  expect(after.notice).toEqual({ text: WORDS })
+  // The drain passes over it: nothing it holds is ever on its way.
+  expect(admitStructuredAgentSessionOutboxEntry(after.kept)).toEqual({ state: 'idle', entry: null })
+})
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-message-projection.rejected-in-place.test.ts b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.rejected-in-place.test.ts
new file mode 100644
index 00000000000..4e757705225
--- /dev/null
+++ b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.rejected-in-place.test.ts
@@ -0,0 +1,465 @@
+// A message the host accepted and then rejected stays in the desktop's chat where it was sent,
+// marked not sent, from the host's own history: a crash can lose the outbox, never the host's row.
+
+import { describe, expect, it } from 'vitest'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
+import { agentJournalSubmissionKey } from '../../../../shared/agent-session-journal-item-key'
+import {
+  DISPATCH_REJECTED_CANCELLED,
+  DISPATCH_REJECTED_HOST_RESTARTED
+} from '../../../../shared/structured-agent-session-dispatch-rejection'
+import {
+  projectStructuredAgentSessionMessages as projectShared,
+  structuredAgentSessionCommandItemIds
+} from '../../../../shared/structured-agent-session-message-projection'
+import {
+  createStructuredAgentSessionOutboxEntry,
+  type StructuredAgentSessionOutboxEntry
+} from '../../../../shared/structured-agent-session-outbox'
+import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
+import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
+
+const NO_CARDS: readonly string[] = []
+
+const SESSION = 'session-1'
+
+function body(text: string) {
+  return {
+    kind: 'message' as const,
+    role: 'user' as const,
+    blocks: [{ type: 'text' as const, text }]
+  }
+}
+
+// Same text, same fingerprint, as the host's body-only hash gives.
+function fingerprint(text: string): string {
+  return `body:${text}`
+}
+
+function userItem(id: string, sequence: number, text: string): AgentJournalRenderItem {
+  return {
+    itemId: agentJournalSubmissionKey(id),
+    revision: 1,
+    sequence,
+    observedAt: sequence,
+    body: body(text)
+  }
+}
+
+function answer(sequence: number): AgentJournalRenderItem {
+  return {
+    itemId: `answer-${sequence}`,
+    revision: 1,
+    sequence,
+    observedAt: sequence,
+    body: { kind: 'message', role: 'assistant', blocks: [{ type: 'text', text: 'ok' }] }
+  }
+}
+
+function submission(
+  id: string,
+  text: string,
+  submittedAt: number,
+  patch: Partial<AgentJournalSubmission> = {}
+): AgentJournalSubmission {
+  return {
+    clientMessageId: id,
+    fence: 1,
+    payloadFingerprint: fingerprint(text),
+    dispatchState: 'accepted',
+    providerItemId: `provider-${id}`,
+    reason: null,
+    submittedAt,
+    resolvedAt: submittedAt,
+    ...patch
+  }
+}
+
+/** Rejected on the next open after a crash, before the agent ever got it. */
+function restartRejected(id: string, text: string, submittedAt: number): AgentJournalSubmission {
+  return submission(id, text, submittedAt, {
+    dispatchState: 'rejected',
+    providerItemId: null,
+    reason: DISPATCH_REJECTED_HOST_RESTARTED,
+    rejection: { kind: 'hostRestarted' }
+  })
+}
+
+function withdrawn(id: string, text: string, submittedAt: number): AgentJournalSubmission {
+  return submission(id, text, submittedAt, {
+    dispatchState: 'rejected',
+    providerItemId: null,
+    reason: DISPATCH_REJECTED_CANCELLED,
+    rejection: { kind: 'cancelled' }
+  })
+}
+
+function outboxEntry(
+  id: string,
+  text: string,
+  patch: Partial<StructuredAgentSessionOutboxEntry> = {}
+): StructuredAgentSessionOutboxEntry {
+  return {
+    ...createStructuredAgentSessionOutboxEntry({
+      clientMessageId: id,
+      sessionId: SESSION,
+      text,
+      attachments: [],
+      queuedAt: 50
+    }),
+    ...patch
+  }
+}
+
+function rows(messages: ReturnType<typeof projectStructuredAgentSessionMessages>) {
+  return messages
+    .filter((message) => message.role === 'user')
+    .map((message) => ({
+      id: message.id,
+      text: message.blocks[0]?.type === 'text' ? message.blocks[0].text : null,
+      unsent: message.unsent ?? false
+    }))
+}
+
+const SEED = submission('seed', 'seed', 1)
+const SEED_ROWS = [userItem('seed', 1, 'seed'), answer(2)]
+
+describe('a message the host accepted and then rejected, on the desktop', () => {
+  it('stays where it was sent, as not sent, with no outbox entry left after a crash', () => {
+    const items = [...SEED_ROWS, userItem('lost', 3, 'fix the parser')]
+    const messages = projectStructuredAgentSessionMessages(
+      items,
+      [],
+      [SEED, restartRejected('lost', 'fix the parser', 3)],
+      NO_CARDS
+    )
+
+    expect(rows(messages)).toEqual([
+      { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false },
+      { id: agentJournalSubmissionKey('lost'), text: 'fix the parser', unsent: true }
+    ])
+    // Its place is the host's: the row keeps the journal position it was recorded at.
+    expect(
+      messages.find((message) => message.id === agentJournalSubmissionKey('lost'))
+    ).toMatchObject({ journalPosition: { sequence: 3, index: 0 }, source: 'transcript' })
+  })
+
+  // An older host never moves it to its rejection: it stays at its submission, still drawn.
+  it('keeps the position an older host gave it, however far back', () => {
+    const later = Array.from({ length: 300 }, (_, index) => answer(4 + index))
+    const items = [...SEED_ROWS, userItem('waited', 3, 'fix the parser'), ...later]
+    const messages = projectStructuredAgentSessionMessages(
+      items,
+      [],
+      [SEED, restartRejected('waited', 'fix the parser', 3)],
+      NO_CARDS
+    )
+
+    expect(
+      messages.find((message) => message.id === agentJournalSubmissionKey('waited'))
+    ).toMatchObject({
+      unsent: true,
+      journalPosition: { sequence: 3, index: 0 }
+    })
+  })
+
+  it('says why from the host fact, with no Retry', () => {
+    const notices = structuredAgentSessionDeliveryNotices(
+      [],
+      'Claude',
+      () => {},
+      [SEED, restartRejected('lost', 'fix the parser', 3)],
+      [],
+      new Set()
+    )
+
+    const notice = notices.get(agentJournalSubmissionKey('lost'))
+    expect(notice?.text).toBe('Orca restarted before this message was sent.')
+    expect(notice?.onRetry).toBeUndefined()
+    expect([...notices.keys()]).toEqual([agentJournalSubmissionKey('lost')])
+  })
+
+  it("says only that it was not sent when the failed start's row already says why", () => {
+    const failedStart = submission('first', 'hello', 3, {
+      dispatchState: 'rejected',
+      providerItemId: null,
+      reason: 'Claude is not signed in.',
+      rejection: { kind: 'notSignedIn' }
+    })
+    const notices = structuredAgentSessionDeliveryNotices(
+      [],
+      'Claude',
+      () => {},
+      [failedStart],
+      [{ kind: 'notSignedIn' }],
+      new Set()
+    )
+
+    expect(notices.get(agentJournalSubmissionKey('first'))).toEqual({
+      text: 'Your message was not sent.'
+    })
+  })
+
+  it('is hidden by a copy of the same body sent once its rejection was known', () => {
+    // An earlier build's Retry resent it under a new id, and that copy was delivered.
+    const items = [...SEED_ROWS, userItem('old', 3, 'retry me'), userItem('resent', 4, 'retry me')]
+    const submissions = [
+      SEED,
+      restartRejected('old', 'retry me', 3),
+      submission('resent', 'retry me', 4)
+    ]
+
+    expect(rows(projectStructuredAgentSessionMessages(items, [], submissions, NO_CARDS))).toEqual([
+      { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false },
+      { id: agentJournalSubmissionKey('resent'), text: 'retry me', unsent: false }
+    ])
+  })
+
+  it('stays when the same text was sent again before it was rejected', () => {
+    // "continue", sent twice on purpose; a restart rejected the first only after the second went.
+    const items = [...SEED_ROWS, userItem('first', 3, 'continue'), userItem('again', 4, 'continue')]
+    const submissions = [
+      SEED,
+      { ...restartRejected('first', 'continue', 3), resolvedAt: 5 },
+      submission('again', 'continue', 4)
+    ]
+
+    expect(rows(projectStructuredAgentSessionMessages(items, [], submissions, NO_CARDS))).toEqual([
+      { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false },
+      { id: agentJournalSubmissionKey('again'), text: 'continue', unsent: false },
+      // Listed after the delivered rows; its journal position keeps its place.
+      { id: agentJournalSubmissionKey('first'), text: 'continue', unsent: true }
+    ])
+  })
+
+  // The host re-delivers its own message under new ids; however close their times, one row stays.
+  it('keeps the last of several copies rejected in the same instant', () => {
+    const items = [...SEED_ROWS, userItem('a', 3, 'pointer'), userItem('b', 4, 'pointer')]
+    const submissions = [
+      SEED,
+      restartRejected('a', 'pointer', 5),
+      restartRejected('b', 'pointer', 5)
+    ]
+
+    expect(rows(projectStructuredAgentSessionMessages(items, [], submissions, NO_CARDS))).toEqual([
+      { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false },
+      { id: agentJournalSubmissionKey('b'), text: 'pointer', unsent: true }
+    ])
+  })
+
+  it('stays when the same body was only sent before it, or by a copy a Stop withdrew', () => {
+    const items = [
+      ...SEED_ROWS,
+      userItem('first', 3, 'again'),
+      userItem('failed', 4, 'again'),
+      userItem('stopped', 5, 'again')
+    ]
+    const submissions = [
+      SEED,
+      submission('first', 'again', 3),
+      restartRejected('failed', 'again', 4),
+      withdrawn('stopped', 'again', 5)
+    ]
+
+    expect(rows(projectStructuredAgentSessionMessages(items, [], submissions, NO_CARDS))).toEqual([
+      { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false },
+      { id: agentJournalSubmissionKey('first'), text: 'again', unsent: false },
+      { id: agentJournalSubmissionKey('failed'), text: 'again', unsent: true }
+    ])
+  })
+
+  // Its own reply reports the rejection, in the composer, as a command's.
+  it('is not drawn when it was a command such as /compact', () => {
+    const compact = {
+      ...userItem('compact', 3, '/compact'),
+      body: { ...body('/compact'), command: { name: 'compact' } }
+    }
+    const submissions = [SEED, restartRejected('compact', '/compact', 3)]
+
+    expect(
+      rows(
+        projectStructuredAgentSessionMessages([...SEED_ROWS, compact], [], submissions, NO_CARDS)
+      )
+    ).toEqual([{ id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false }])
+    // One rule decides for the rows and the notices.
+    expect(
+      structuredAgentSessionDeliveryNotices(
+        [],
+        'Claude',
+        () => {},
+        submissions,
+        [],
+        new Set(),
+        NO_CARDS,
+        structuredAgentSessionCommandItemIds([...SEED_ROWS, compact])
+      ).size
+    ).toBe(0)
+  })
+
+  it('keeps a message a Stop withdrew hidden: it went back to its sender', () => {
+    const items = [...SEED_ROWS, userItem('stopped', 3, 'never mind')]
+    const submissions = [SEED, withdrawn('stopped', 'never mind', 3)]
+
+    expect(rows(projectStructuredAgentSessionMessages(items, [], submissions, NO_CARDS))).toEqual([
+      { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false }
+    ])
+    expect(
+      structuredAgentSessionDeliveryNotices([], 'Claude', () => {}, submissions, [], new Set()).size
+    ).toBe(0)
+  })
+})
+
+describe("one row per rejected message, the host's once it records the rejection", () => {
+  const items = [...SEED_ROWS, userItem('held', 3, 'host copy')]
+  // Fingerprinted from the host's own copy, so only the shared id ties the two rows together.
+  const rejected = restartRejected('held', 'host copy', 3)
+  const held = outboxEntry('held', 'outbox copy', {
+    state: 'rejected',
+    lastFailure: {
+      kind: 'rejected',
+      reason: DISPATCH_REJECTED_HOST_RESTARTED,
+      rejection: { kind: 'hostRestarted' }
+    }
+  })
+  const heldRow = { id: agentJournalSubmissionKey('held'), text: 'outbox copy', unsent: true }
+  const hostRow = { id: agentJournalSubmissionKey('held'), text: 'host copy', unsent: true }
+  const seedRow = { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false }
+
+  it('the reply first: the outbox draws it, saying why, with no Retry', () => {
+    const messages = projectStructuredAgentSessionMessages(SEED_ROWS, [held], [SEED], NO_CARDS)
+    expect(rows(messages)).toEqual([seedRow, heldRow])
+    const notice = structuredAgentSessionDeliveryNotices(
+      [held],
+      'Claude',
+      () => {},
+      [SEED],
+      [],
+      new Set(['held'])
+    ).get(heldRow.id)
+    expect(notice?.text).toBe('Orca restarted before this message was sent.')
+    expect(notice?.onRetry).toBeUndefined()
+  })
+
+  it("the journal first, or next: the host's row replaces the outbox copy at once", () => {
+    const dispatching = { ...held, state: 'dispatching' as const, lastFailure: undefined }
+    expect(
+      rows(projectStructuredAgentSessionMessages(SEED_ROWS, [dispatching], [SEED], NO_CARDS))
+    ).toEqual([seedRow, { ...heldRow, unsent: false }])
+    for (const entry of [dispatching, held]) {
+      // Before the reconcile drops the entry, the host's row is already the one row.
+      const messages = projectStructuredAgentSessionMessages(
+        items,
+        [entry],
+        [SEED, rejected],
+        NO_CARDS
+      )
+      expect(rows(messages)).toEqual([seedRow, hostRow])
+      expect(messages.at(-1)?.journalPosition).toEqual({ sequence: 3, index: 0 })
+      const notices = structuredAgentSessionDeliveryNotices(
+        [entry],
+        'Claude',
+        () => {},
+        [SEED, rejected],
+        [],
+        new Set()
+      )
+      // In the host's words, with no control.
+      expect([...notices]).toEqual([
+        [hostRow.id, { text: 'Orca restarted before this message was sent.' }]
+      ])
+    }
+  })
+
+  it("keeps the old row beside an earlier build's resend until the host records the resend", () => {
+    const hostItems = [...SEED_ROWS, userItem('held', 3, 'outbox copy')]
+    const resent = restartRejected('held', 'outbox copy', 3)
+    const resend = outboxEntry('resend', 'outbox copy')
+    expect(
+      rows(projectStructuredAgentSessionMessages(hostItems, [resend], [SEED, resent], NO_CARDS))
+    ).toEqual([
+      seedRow,
+      { id: agentJournalSubmissionKey('held'), text: 'outbox copy', unsent: true },
+      { id: agentJournalSubmissionKey('resend'), text: 'outbox copy', unsent: false }
+    ])
+
+    const recorded = submission('resend', 'outbox copy', 60, {
+      dispatchState: 'pending',
+      providerItemId: null,
+      resolvedAt: null
+    })
+    expect(
+      rows(
+        projectStructuredAgentSessionMessages(
+          [...hostItems, userItem('resend', 4, 'outbox copy')],
+          [resend],
+          [SEED, resent, recorded],
+          NO_CARDS
+        )
+      )
+    ).toEqual([
+      seedRow,
+      { id: agentJournalSubmissionKey('resend'), text: 'outbox copy', unsent: false }
+    ])
+  })
+})
+
+describe('a rejected message the queue holds', () => {
+  const seedRow = { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false }
+
+  // A hand-off the host rejected sends its draft back to the card list, which shows the text.
+  it('is not drawn when it was a queued draft handed off', () => {
+    const items = [...SEED_ROWS, userItem('handoff', 3, 'queued text')]
+    const submissions = [
+      SEED,
+      { ...restartRejected('handoff', 'queued text', 3), queuedMessageId: 'card-1' }
+    ]
+
+    expect(rows(projectStructuredAgentSessionMessages(items, [], submissions, NO_CARDS))).toEqual([
+      seedRow
+    ])
+    expect(
+      structuredAgentSessionDeliveryNotices([], 'Claude', () => {}, submissions, [], new Set()).size
+    ).toBe(0)
+  })
+
+  // A send kept across a restart comes back as a paused card under its own id.
+  it('is not drawn while a card holds it under its id, and is drawn once that card is gone', () => {
+    const items = [...SEED_ROWS, userItem('kept', 3, 'kept text')]
+    const submissions = [SEED, restartRejected('kept', 'kept text', 3)]
+
+    expect(rows(projectStructuredAgentSessionMessages(items, [], submissions, ['kept']))).toEqual([
+      seedRow
+    ])
+    expect(
+      structuredAgentSessionDeliveryNotices([], 'Claude', () => {}, submissions, [], new Set(), [
+        'kept'
+      ]).size
+    ).toBe(0)
+    expect(rows(projectStructuredAgentSessionMessages(items, [], submissions, []))).toEqual([
+      seedRow,
+      { id: agentJournalSubmissionKey('kept'), text: 'kept text', unsent: true }
+    ])
+  })
+})
+
+describe('the phone', () => {
+  it('still hides every accepted-then-rejected message: it gives the text back to its composer', () => {
+    const items = [
+      ...SEED_ROWS,
+      userItem('lost', 3, 'fix the parser'),
+      userItem('stopped', 4, 'never mind')
+    ]
+    const submissions = [
+      SEED,
+      restartRejected('lost', 'fix the parser', 3),
+      withdrawn('stopped', 'never mind', 4)
+    ]
+
+    expect(rows(projectShared(items, [], submissions, { rejectedInPlace: false }))).toEqual([
+      { id: agentJournalSubmissionKey('seed'), text: 'seed', unsent: false }
+    ])
+  })
+})
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-message-projection.test.ts b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.test.ts
index 3a3562458cb..bd99e8f8cbb 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-message-projection.test.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.test.ts
@@ -7,6 +7,8 @@ import { agentJournalSubmissionKey } from '../../../../shared/agent-session-jour
 import { createStructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
 import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
 
+const NO_CARDS: readonly string[] = []
+
 function submission(index: number): AgentJournalSubmission {
   return {
     clientMessageId: `client-${index}`,
@@ -31,16 +33,8 @@ function item(index: number): AgentJournalRenderItem {
 }
 
 describe('structured agent session message projection', () => {
-  it('does not render a rejected host submission as a sent user message', () => {
-    const rejected = { ...submission(0), dispatchState: 'rejected' as const, providerItemId: null }
-    const refusedItem = { ...item(0), itemId: agentJournalSubmissionKey(rejected.clientMessageId) }
-    const acceptedItem = item(1)
-    expect(
-      projectStructuredAgentSessionMessages([refusedItem, acceptedItem], [], [rejected])
-    ).toMatchObject([{ id: acceptedItem.itemId, role: 'user' }])
-  })
-
-  it('keeps a refused local draft available through its outbox', () => {
+  // The host recorded it, so its row is the message from here; the outbox copy gives way.
+  it("draws a send the host rejected from the host's row, not the outbox copy", () => {
     const rejected = { ...submission(0), dispatchState: 'rejected' as const, providerItemId: null }
     const refusedItem = { ...item(0), itemId: agentJournalSubmissionKey(rejected.clientMessageId) }
     const draft = createStructuredAgentSessionOutboxEntry({
@@ -50,9 +44,15 @@ describe('structured agent session message projection', () => {
       attachments: [],
       queuedAt: 1
     })
-    expect(projectStructuredAgentSessionMessages([refusedItem], [draft], [rejected])).toMatchObject(
-      [{ id: refusedItem.itemId, blocks: [{ text: 'An unsent draft' }] }]
-    )
+    expect(
+      projectStructuredAgentSessionMessages([refusedItem], [draft], [rejected], NO_CARDS)
+    ).toEqual([
+      expect.objectContaining({
+        id: refusedItem.itemId,
+        blocks: [{ type: 'text', text: 'send 0' }],
+        unsent: true
+      })
+    ])
   })
 
   it.each([5, 10])('renders %i rapid accepted desktop sends exactly once', (sendCount) => {
@@ -68,7 +68,8 @@ describe('structured agent session message projection', () => {
     const messages = projectStructuredAgentSessionMessages(
       Array.from({ length: sendCount }, (_, index) => item(index)),
       outbox,
-      Array.from({ length: sendCount }, (_, index) => submission(sendCount - index - 1))
+      Array.from({ length: sendCount }, (_, index) => submission(sendCount - index - 1)),
+      NO_CARDS
     )
 
     expect(messages.filter((message) => message.role === 'user')).toHaveLength(sendCount)
@@ -103,8 +104,8 @@ describe('structured agent session message projection', () => {
       resolvedAt: null
     }
 
-    const messages = projectStructuredAgentSessionMessages([walItem], outbox, [pending])
-    const optimistic = projectStructuredAgentSessionMessages([], outbox, [])
+    const messages = projectStructuredAgentSessionMessages([walItem], outbox, [pending], NO_CARDS)
+    const optimistic = projectStructuredAgentSessionMessages([], outbox, [], NO_CARDS)
 
     expect(messages.filter((message) => message.role === 'user')).toHaveLength(1)
     expect(messages.map((message) => message.id)).toEqual([walItem.itemId])
@@ -122,7 +123,7 @@ describe('structured agent session message projection', () => {
       })
     ]
 
-    expect(projectStructuredAgentSessionMessages([], outbox, [])).toMatchObject([
+    expect(projectStructuredAgentSessionMessages([], outbox, [], NO_CARDS)).toMatchObject([
       { id: agentJournalSubmissionKey('client-pending'), role: 'user' }
     ])
   })
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-message-projection.ts b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.ts
index 0ecfd7aa2f5..f527442c2b1 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-message-projection.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-message-projection.ts
@@ -6,12 +6,22 @@ import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/struc
 import { projectStructuredAgentSessionMessages as projectMessages } from '../../../../shared/structured-agent-session-message-projection'
 import { projectStructuredQuestionMessages } from './structured-agent-question-projection'
 
+/** The desktop's transcript: a message the host accepted and then rejected stays where it was
+ *  sent, as not sent, unless a queued card holds it. */
 export function projectStructuredAgentSessionMessages(
   items: readonly AgentJournalRenderItem[],
   outbox: readonly StructuredAgentSessionOutboxEntry[],
-  submissions: readonly AgentJournalSubmission[]
+  submissions: readonly AgentJournalSubmission[],
+  /** The queue's live cards; required, since a rejected message a card holds must not draw twice. */
+  queuedMessageIds: readonly string[]
 ) {
-  return projectMessages(items, outbox, submissions, projectStructuredQuestionMessages)
+  return projectMessages(
+    items,
+    outbox,
+    submissions,
+    { rejectedInPlace: true, queuedMessageIds },
+    projectStructuredQuestionMessages
+  )
 }
 
 export type StructuredPromptItem = AgentJournalRenderItem & {
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-outbox-entry-watch.ts b/src/renderer/src/components/native-chat/structured-agent-session-outbox-entry-watch.ts
new file mode 100644
index 00000000000..71644f31340
--- /dev/null
+++ b/src/renderer/src/components/native-chat/structured-agent-session-outbox-entry-watch.ts
@@ -0,0 +1,63 @@
+import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
+
+/** How a watched message left its chat's outbox: sent on (accepted, or handed to the host or the
+ *  composer), or thrown away with the chat. */
+export type StructuredAgentSessionOutboxEntryRemoval = 'spent' | 'discarded'
+
+type EntryWatch = {
+  entry: StructuredAgentSessionOutboxEntry
+  onGone: (removal: StructuredAgentSessionOutboxEntryRemoval) => void
+}
+
+const watchesBySession = new Map<string, Set<EntryWatch>>()
+
+// A user's Retry of a refused message gives it a new id; its text and queue time stay.
+function stillQueued(
+  watched: StructuredAgentSessionOutboxEntry,
+  entries: readonly StructuredAgentSessionOutboxEntry[]
+): boolean {
+  const body = JSON.stringify(watched.body)
+  return entries.some(
+    (entry) =>
+      entry.clientMessageId === watched.clientMessageId ||
+      (entry.queuedAt === watched.queuedAt && JSON.stringify(entry.body) === body)
+  )
+}
+
+/** Calls `onGone` once, when `entry` leaves its session's outbox. */
+export function watchStructuredAgentSessionOutboxEntry(
+  entry: StructuredAgentSessionOutboxEntry,
+  onGone: (removal: StructuredAgentSessionOutboxEntryRemoval) => void
+): () => void {
+  const watches = watchesBySession.get(entry.sessionId) ?? new Set()
+  watchesBySession.set(entry.sessionId, watches)
+  const watch: EntryWatch = { entry, onGone }
+  watches.add(watch)
+  return () => {
+    watches.delete(watch)
+    if (watches.size === 0 && watchesBySession.get(entry.sessionId) === watches) {
+      watchesBySession.delete(entry.sessionId)
+    }
+  }
+}
+
+/** Run by the outbox's one write funnel after a change takes effect. */
+export function settleStructuredAgentSessionOutboxEntryWatches(
+  sessionId: string,
+  entries: readonly StructuredAgentSessionOutboxEntry[],
+  removal: StructuredAgentSessionOutboxEntryRemoval
+): void {
+  const watches = watchesBySession.get(sessionId)
+  if (!watches) {
+    return
+  }
+  for (const watch of watches) {
+    if (!stillQueued(watch.entry, entries)) {
+      watches.delete(watch)
+      watch.onGone(removal)
+    }
+  }
+  if (watches.size === 0) {
+    watchesBySession.delete(sessionId)
+  }
+}
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-outbox-retry.ts b/src/renderer/src/components/native-chat/structured-agent-session-outbox-retry.ts
index 73619e71759..d431cccb036 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-outbox-retry.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-outbox-retry.ts
@@ -4,6 +4,7 @@
 import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
 import {
   structuredAgentSessionEntryIdExpired,
+  structuredAgentSessionEntryRejectedByHost,
   type StructuredAgentSessionOutboxEntry
 } from '../../../../shared/structured-agent-session-outbox'
 import {
@@ -30,7 +31,7 @@ export function retryStructuredAgentSessionOutboxEntry(args: {
   // settled the message already rotated it. An expired id is refused for good; its row told the
   // user to check the chat first.
   const recordedRejection =
-    current?.state === 'rejected' && current.lastFailure?.kind === 'rejected'
+    current !== undefined && structuredAgentSessionEntryRejectedByHost(current)
   if (
     current &&
     (recordedRejection ||
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-outbox-storage.ts b/src/renderer/src/components/native-chat/structured-agent-session-outbox-storage.ts
index ce270d60ddb..02b34787cec 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-outbox-storage.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-outbox-storage.ts
@@ -1,11 +1,16 @@
 import {
   createStructuredAgentSessionOutboxEntry,
   parseStructuredAgentSessionOutboxEntry,
+  structuredAgentSessionEntryRejectedByHost,
   type StructuredAgentSessionAttachment,
   type StructuredAgentSessionOutboxEntry
 } from '../../../../shared/structured-agent-session-outbox'
 import { createStructuredAgentSessionOperationId } from '../../../../shared/structured-agent-session-mutation'
 import { createBrowserUuid } from '@/lib/browser-uuid'
+import {
+  settleStructuredAgentSessionOutboxEntryWatches,
+  type StructuredAgentSessionOutboxEntryRemoval
+} from './structured-agent-session-outbox-entry-watch'
 
 const OUTBOX_PREFIX = 'orca:desktopStructuredAgentSessionOutbox:v1:'
 
@@ -54,9 +59,14 @@ function publishUndelivered(sessionId: string, undelivered: boolean): void {
   }
 }
 
+/** Whether any entry still owes a delivery: a copy the host recorded and rejected owes none. */
+function owesDelivery(entries: readonly StructuredAgentSessionOutboxEntry[]): boolean {
+  return entries.some((entry) => !structuredAgentSessionEntryRejectedByHost(entry))
+}
+
 /** Keep the journal subscription alive while this session still owes delivery. */
 export function hasUndeliveredStructuredAgentSessionOutbox(sessionId: string): boolean {
-  return undeliveredSessions.get(sessionId)?.undelivered ?? readOutbox(sessionId).length > 0
+  return undeliveredSessions.get(sessionId)?.undelivered ?? owesDelivery(readOutbox(sessionId))
 }
 
 export function subscribeToUndeliveredStructuredAgentSessionOutbox(
@@ -65,7 +75,7 @@ export function subscribeToUndeliveredStructuredAgentSessionOutbox(
 ): () => void {
   let subscription = undeliveredSessions.get(sessionId)
   if (!subscription) {
-    subscription = { undelivered: readOutbox(sessionId).length > 0, listeners: new Set() }
+    subscription = { undelivered: owesDelivery(readOutbox(sessionId)), listeners: new Set() }
     undeliveredSessions.set(sessionId, subscription)
   }
   const owned = subscription
@@ -92,7 +102,7 @@ export function writeOutbox(
     } else {
       localStorage.setItem(storageKey(sessionId), JSON.stringify(entries))
     }
-    publishUndelivered(sessionId, entries.length > 0)
+    publishUndelivered(sessionId, owesDelivery(entries))
     return true
   } catch {
     return false
@@ -159,6 +169,15 @@ export function commitStructuredAgentSessionOutbox(
   sessionId: string,
   entries: StructuredAgentSessionOutboxEntry[],
   options: { onlyIfSaved?: boolean } = {}
+): boolean {
+  return commitOutbox(sessionId, entries, options, 'spent')
+}
+
+function commitOutbox(
+  sessionId: string,
+  entries: StructuredAgentSessionOutboxEntry[],
+  options: { onlyIfSaved?: boolean },
+  removal: StructuredAgentSessionOutboxEntryRemoval
 ): boolean {
   const saved = writeOutbox(sessionId, entries)
   if (!saved && options.onlyIfSaved) {
@@ -171,6 +190,7 @@ export function commitStructuredAgentSessionOutbox(
       listener()
     }
   }
+  settleStructuredAgentSessionOutboxEntryWatches(sessionId, entries, removal)
   return saved
 }
 
@@ -209,7 +229,7 @@ export function enqueueStructuredAgentSessionLaunchPrompt(
 }
 
 export function discardStructuredAgentSessionLaunchOutbox(sessionId: string): void {
-  commitStructuredAgentSessionOutbox(sessionId, [])
+  commitOutbox(sessionId, [], {}, 'discarded')
 }
 
 export function mutateStructuredAgentSessionLaunchPrompt(
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-transcript-order.test.ts b/src/renderer/src/components/native-chat/structured-agent-session-transcript-order.test.ts
index aa774f7fbf3..3b12ed7b3dc 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-transcript-order.test.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-transcript-order.test.ts
@@ -13,6 +13,8 @@ import {
 import { createNativeChatMessageListProjection } from './native-chat-message-list-projection'
 import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
 
+const NO_CARDS: readonly string[] = []
+
 function journalItem(
   itemId: string,
   sequence: number,
@@ -43,7 +45,7 @@ function drawn(
   submissions: AgentJournalSubmission[] = []
 ): string[] {
   return createNativeChatMessageListProjection()(
-    projectStructuredAgentSessionMessages(items, outbox, submissions)
+    projectStructuredAgentSessionMessages(items, outbox, submissions, NO_CARDS)
   ).conversation.map(({ id }) => id)
 }
 
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.test.tsx b/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.test.tsx
index 150b520bcd3..dde230110dd 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.test.tsx
+++ b/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.test.tsx
@@ -75,6 +75,15 @@ import {
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 import { useStructuredAgentSession } from './use-structured-agent-session'
 
+/** What these hooks render with: the journal's submissions, and the rows loaded so far. */
+type OutboxProps = { submissions: AgentJournalSubmission[]; rows?: AgentJournalRenderItem[] }
+
+function outboxProps(submissions: AgentJournalSubmission[]): OutboxProps {
+  return { submissions }
+}
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 const SESSION = 'session-1'
 const PANE = 'tab-1::session-1'
 const OTHER_PANE = 'tab-2::session-1'
@@ -129,15 +138,16 @@ function answerSendsPending(): void {
 
 function renderOutbox(composerScopeKey: string | null = PANE) {
   return renderHook(
-    (props: { submissions: AgentJournalSubmission[] }) =>
+    (props: OutboxProps) =>
       useStructuredAgentSessionOutbox({
+        journalItems: props.rows ?? NO_JOURNAL_ITEMS,
         sessionId: SESSION,
         target,
         fence: 1,
         submissions: props.submissions,
         ...(composerScopeKey ? { composerScopeKey } : {})
       }),
-    { initialProps: { submissions: NONE } }
+    { initialProps: outboxProps(NONE) }
   )
 }
 
@@ -259,7 +269,7 @@ describe('a message the host withdrew at a Stop', () => {
     expect(readNativeChatDraftCache(PANE)).toBe('hello\n\nhello')
   })
 
-  it('keeps a message refused for any other reason on its Retry, and gives nothing back', async () => {
+  it("leaves a message rejected for any other reason to the host's row, and gives nothing back", async () => {
     answerSendsPending()
     const { result, rerender } = renderOutbox()
     const id = await sendToHost(result, 'hello')
@@ -267,10 +277,19 @@ describe('a message the host withdrew at a Stop', () => {
     rerender({
       submissions: [
         submission(id, { dispatchState: 'rejected', reason: DISPATCH_REJECTED_WRITE_FAILED })
+      ],
+      rows: [
+        {
+          itemId: `orca:${id}`,
+          revision: 1,
+          sequence: 1,
+          observedAt: 1,
+          body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'hello' }] }
+        }
       ]
     })
 
-    await waitFor(() => expect(result.current.outbox[0]?.state).toBe('rejected'))
+    await waitFor(() => expect(result.current.outbox).toEqual([]))
     expect(readNativeChatDraftCache(PANE)).toBe('')
   })
 
diff --git a/src/renderer/src/components/native-chat/use-host-model-catalog-upgrade.test.tsx b/src/renderer/src/components/native-chat/use-host-model-catalog-upgrade.test.tsx
new file mode 100644
index 00000000000..39e44ab5fc6
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-host-model-catalog-upgrade.test.tsx
@@ -0,0 +1,357 @@
+// @vitest-environment happy-dom
+
+import { act, render, renderHook } from '@testing-library/react'
+import { useLayoutEffect } from 'react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({ call: vi.fn() }))
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn() } }))
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.call
+}))
+
+vi.mock('./native-chat-session-option-settings-write', () => ({
+  enqueueSessionOptionSettingsWrite: vi.fn()
+}))
+
+vi.mock('@/lib/structured-agent-session-launch-options', () => ({
+  holdStructuredAgentSessionLaunchOption: vi.fn(() => Promise.resolve({ kind: 'held' })),
+  getStructuredAgentSessionLaunchSelection: () => null
+}))
+
+import type { SessionOptionDescriptor } from '../../../../shared/native-chat-session-options'
+import type { StructuredAgentSessionMutate } from './use-structured-agent-session-mutate'
+import { useStructuredAgentSessionOptions } from './use-structured-agent-session-options'
+
+const PAIRED_TARGET = { kind: 'environment', environmentId: 'server-1' } as const
+const UNKNOWN = { origin: 'unknown' }
+const LISTING = { origin: 'unknown', listingInProgress: true }
+const HOST_CATALOG = {
+  origin: 'probe',
+  models: [{ id: 'gpt-hosted', label: 'GPT Hosted', isDefault: true, efforts: [] }],
+  fetchedAt: 1_000
+}
+
+// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: no test here sends a pick over a fence, so mutate is never called.
+const mutate = vi.fn(async () => null) as unknown as StructuredAgentSessionMutate
+
+type Props = { hidden?: boolean; attached?: boolean; sessionId?: string }
+
+// A chat's waiting read outlives its mounts, so each test gets its own chat.
+let sessionId = ''
+let sessionCount = 0
+
+function renderOptions(initial: Props = {}) {
+  return renderHook(
+    (props: Props) =>
+      useStructuredAgentSessionOptions({
+        agent: 'codex',
+        sessionId: props.sessionId ?? sessionId,
+        target: PAIRED_TARGET,
+        transportEnabled: props.attached === true,
+        isVisible: !props.hidden,
+        providerVisible: props.attached === true && !props.hidden,
+        fence: props.attached ? 1 : null,
+        turnId: null,
+        unloadedTurnRevisions: undefined,
+        mutate,
+        launch: { kind: 'new', seedOptions: { model: 'gpt-5.5' }, heldOptions: {} }
+      }),
+    { initialProps: initial }
+  )
+}
+
+type Deferred = {
+  promise: Promise<unknown>
+  resolve: (value: unknown) => void
+  reject: (error: unknown) => void
+}
+
+function deferred(): Deferred {
+  let resolve!: (value: unknown) => void
+  let reject!: (error: unknown) => void
+  const promise = new Promise<unknown>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  return { promise, resolve, reject }
+}
+
+/** Each catalog read takes the next answer; `options` reads never settle unless given. */
+function answerCatalog(answers: (() => Promise<unknown>)[]): void {
+  let index = 0
+  mocks.call.mockImplementation((_target: unknown, method: string) => {
+    if (method === 'agentSession.modelCatalog') {
+      const next = answers[index]
+      index += 1
+      return next ? next() : new Promise(() => {})
+    }
+    return new Promise(() => {})
+  })
+}
+
+function catalogReads(): unknown[] {
+  return mocks.call.mock.calls
+    .filter(([, method]) => method === 'agentSession.modelCatalog')
+    .map(([, , params]) => params)
+}
+
+function model(snapshot: readonly SessionOptionDescriptor[]): SessionOptionDescriptor {
+  return snapshot.find((entry) => entry.id === 'model')!
+}
+
+function modelChoices(snapshot: readonly SessionOptionDescriptor[]): string[] {
+  const descriptor = model(snapshot)
+  return descriptor.kind.type === 'select' ? descriptor.kind.choices.map((c) => c.value) : []
+}
+
+const flush = (): Promise<void> => act(async () => {})
+
+describe('host model catalog read', () => {
+  beforeEach(() => {
+    mocks.call.mockReset()
+    sessionCount += 1
+    sessionId = `session-${sessionCount}`
+  })
+
+  it('reads a warm catalog once and never holds the picker', async () => {
+    const first = deferred()
+    answerCatalog([() => first.promise])
+    const { result, unmount } = renderOptions()
+    await flush()
+    // A read in flight is not a reason to hold the picker.
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    first.resolve(HOST_CATALOG)
+    await flush()
+    expect(catalogReads()).toEqual([{ agent: 'codex', sessionId }])
+    expect(modelChoices(result.current.optionSnapshot)).toContain('gpt-hosted')
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    unmount()
+  })
+
+  it('waits once for a listing the host reports, holding the picker until it lands', async () => {
+    const waited = deferred()
+    answerCatalog([() => Promise.resolve(LISTING), () => waited.promise])
+    const { result, unmount } = renderOptions()
+    await flush()
+    expect(catalogReads()).toEqual([
+      { agent: 'codex', sessionId },
+      { agent: 'codex', sessionId, waitForListing: true }
+    ])
+    const held = model(result.current.optionSnapshot)
+    expect(held).toMatchObject({ choicesPending: true, settable: false })
+    // The label stays: the pill still names the launch's model.
+    expect(held.kind.type === 'select' ? held.kind.currentValue : null).toBe('gpt-5.5')
+    await act(async () => {
+      expect(await result.current.setStructuredOption('model', 'gpt-5.5')).toBe(false)
+    })
+
+    waited.resolve(HOST_CATALOG)
+    await flush()
+    expect(modelChoices(result.current.optionSnapshot)).toContain('gpt-hosted')
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    expect(catalogReads()).toHaveLength(2)
+    unmount()
+  })
+
+  it('releases the picker on the seed when the waiting read fails or times out', async () => {
+    for (const failure of [
+      () => Promise.resolve(UNKNOWN),
+      () => Promise.reject(Object.assign(new Error('timed out'), { code: 'runtime_timeout' })),
+      () => Promise.reject(Object.assign(new Error('gone'), { code: 'not_connected' }))
+    ]) {
+      mocks.call.mockReset()
+      answerCatalog([() => Promise.resolve(LISTING), failure])
+      const { result, unmount } = renderOptions()
+      await flush()
+      expect(catalogReads()).toHaveLength(2)
+      expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+      expect(model(result.current.optionSnapshot).settable).toBe(true)
+      expect(modelChoices(result.current.optionSnapshot)).not.toContain('gpt-hosted')
+      unmount()
+    }
+  })
+
+  it('asks a host that reports no listing nothing more', async () => {
+    answerCatalog([() => Promise.resolve(UNKNOWN)])
+    const { result, unmount } = renderOptions()
+    await flush()
+    expect(catalogReads()).toHaveLength(1)
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    unmount()
+  })
+
+  it('releases the picker when the running provider reports its own list first', async () => {
+    const live = deferred()
+    answerCatalog([() => Promise.resolve(LISTING), () => new Promise(() => {})])
+    const catalogAnswers = mocks.call.getMockImplementation()!
+    mocks.call.mockImplementation((target: unknown, method: string, params: unknown) =>
+      method === 'agentSession.options' ? live.promise : catalogAnswers(target, method, params)
+    )
+    const { result, unmount } = renderOptions({ attached: true })
+    await flush()
+    expect(model(result.current.optionSnapshot).choicesPending).toBe(true)
+    live.resolve({
+      models: [{ id: 'gpt-live', label: 'GPT Live', isDefault: true, efforts: [] }],
+      current: { model: 'gpt-live', confirmed: ['model'] }
+    })
+    await flush()
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    expect(modelChoices(result.current.optionSnapshot)).toContain('gpt-live')
+    unmount()
+  })
+
+  it('keeps the hold through attach and joins the wait already in flight', async () => {
+    const waited = deferred()
+    answerCatalog([() => Promise.resolve(LISTING), () => waited.promise])
+    const { result, rerender, unmount } = renderOptions()
+    await flush()
+    expect(model(result.current.optionSnapshot).choicesPending).toBe(true)
+    rerender({ attached: true })
+    // No frame on the stand-in list between the old fence and the new one.
+    expect(model(result.current.optionSnapshot).choicesPending).toBe(true)
+    await flush()
+    expect(model(result.current.optionSnapshot).choicesPending).toBe(true)
+    expect(catalogReads()).toHaveLength(2)
+    waited.resolve(HOST_CATALOG)
+    await flush()
+    expect(modelChoices(result.current.optionSnapshot)).toContain('gpt-hosted')
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    unmount()
+  })
+
+  it('joins the wait already in flight when the pane hides and shows again', async () => {
+    const waited = deferred()
+    answerCatalog([() => Promise.resolve(LISTING), () => waited.promise])
+    const { result, rerender, unmount } = renderOptions()
+    await flush()
+    rerender({ hidden: true })
+    await flush()
+    rerender({})
+    await flush()
+    expect(catalogReads()).toHaveLength(2)
+    expect(model(result.current.optionSnapshot).choicesPending).toBe(true)
+    waited.resolve(HOST_CATALOG)
+    await flush()
+    expect(modelChoices(result.current.optionSnapshot)).toContain('gpt-hosted')
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    unmount()
+  })
+
+  it('joins the wait already in flight when the chat mounts again', async () => {
+    const waited = deferred()
+    answerCatalog([() => Promise.resolve(LISTING), () => waited.promise])
+    const first = renderOptions()
+    await flush()
+    first.unmount()
+    const { result, unmount } = renderOptions()
+    await flush()
+    expect(catalogReads()).toHaveLength(2)
+    expect(model(result.current.optionSnapshot).choicesPending).toBe(true)
+    waited.resolve(HOST_CATALOG)
+    await flush()
+    expect(modelChoices(result.current.optionSnapshot)).toContain('gpt-hosted')
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    unmount()
+  })
+
+  it('holds and answers only the chat whose host is listing', async () => {
+    const waited = deferred()
+    answerCatalog([
+      () => Promise.resolve(LISTING),
+      () => waited.promise,
+      () => Promise.resolve(UNKNOWN)
+    ])
+    const { result, rerender, unmount } = renderOptions()
+    await flush()
+    rerender({ sessionId: `${sessionId}-other` })
+    await flush()
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    waited.resolve(HOST_CATALOG)
+    await flush()
+    expect(modelChoices(result.current.optionSnapshot)).not.toContain('gpt-hosted')
+    expect(catalogReads()).toHaveLength(3)
+    unmount()
+  })
+
+  it('applies nothing and keeps nothing when the answer lands after the chat closed', async () => {
+    const waited = deferred()
+    answerCatalog([
+      () => Promise.resolve(LISTING),
+      () => waited.promise,
+      () => Promise.resolve(UNKNOWN)
+    ])
+    const first = renderOptions()
+    await flush()
+    first.unmount()
+    waited.resolve(HOST_CATALOG)
+    await flush()
+    // A later open of the same chat asks afresh instead of joining a finished wait.
+    const { result, unmount } = renderOptions()
+    await flush()
+    expect(catalogReads()).toHaveLength(3)
+    expect(model(result.current.optionSnapshot).choicesPending).toBeUndefined()
+    unmount()
+  })
+})
+
+function CommitRecorder(props: { sessionId: string; attached: boolean; commits: string[] }) {
+  const { optionSnapshot } = useStructuredAgentSessionOptions({
+    agent: 'codex',
+    sessionId: props.sessionId,
+    target: PAIRED_TARGET,
+    transportEnabled: props.attached,
+    isVisible: true,
+    providerVisible: false,
+    fence: props.attached ? 1 : null,
+    turnId: null,
+    unloadedTurnRevisions: undefined,
+    mutate,
+    launch: { kind: 'new', seedOptions: { model: 'gpt-5.5' }, heldOptions: {} }
+  })
+  const descriptor = model(optionSnapshot)
+  const state = `held=${descriptor.choicesPending === true} hosted=${modelChoices(optionSnapshot).includes('gpt-hosted')}`
+  // No deps: one entry per commit, which act() would otherwise batch out of sight.
+  useLayoutEffect(() => {
+    props.commits.push(state)
+  })
+  return null
+}
+
+describe('the end of a host listing wait', () => {
+  beforeEach(() => {
+    mocks.call.mockReset()
+    sessionCount += 1
+    sessionId = `session-${sessionCount}`
+  })
+
+  for (const attachedFirst of [false, true]) {
+    it(`never commits the built-in list unheld before the host list (${attachedFirst ? 'joined after attach' : 'started here'})`, async () => {
+      const waited = deferred()
+      answerCatalog([() => Promise.resolve(LISTING), () => waited.promise])
+      const commits: string[] = []
+      const view = render(
+        <CommitRecorder sessionId={sessionId} attached={false} commits={commits} />
+      )
+      await flush()
+      if (attachedFirst) {
+        view.rerender(<CommitRecorder sessionId={sessionId} attached commits={commits} />)
+        await flush()
+      }
+      expect(commits.at(-1)).toBe('held=true hosted=false')
+      const settledFrom = commits.length
+      Reflect.set(globalThis, 'IS_REACT_ACT_ENVIRONMENT', false)
+      try {
+        waited.resolve(HOST_CATALOG)
+        await vi.waitFor(() => expect(commits.at(-1)).toBe('held=false hosted=true'))
+        await new Promise((resolve) => setTimeout(resolve, 20))
+      } finally {
+        Reflect.set(globalThis, 'IS_REACT_ACT_ENVIRONMENT', true)
+      }
+      expect(commits.slice(settledFrom)).not.toContain('held=false hosted=false')
+      view.unmount()
+    })
+  }
+})
diff --git a/src/renderer/src/components/native-chat/use-host-model-catalog-upgrade.ts b/src/renderer/src/components/native-chat/use-host-model-catalog-upgrade.ts
index 010cd8a68d5..83e7d2a5a36 100644
--- a/src/renderer/src/components/native-chat/use-host-model-catalog-upgrade.ts
+++ b/src/renderer/src/components/native-chat/use-host-model-catalog-upgrade.ts
@@ -1,4 +1,4 @@
-import { useEffect, type MutableRefObject } from 'react'
+import { useEffect, useSyncExternalStore, type MutableRefObject } from 'react'
 import type { AgentSessionModelCatalogResult } from '../../../../shared/agent-session-wire'
 import type { AgentType } from '../../../../shared/agent-status-types'
 import type { AgentSessionOptionCatalog } from '../../../../shared/agent-session-option-catalog'
@@ -8,7 +8,13 @@ import {
 } from '../../../../shared/structured-agent-session-options'
 import type { RuntimeClientTarget } from '@/runtime/runtime-rpc-client'
 import { callStructuredAgentSession } from '@/runtime/structured-agent-session-client'
+import { structuredAgentSessionHostKey } from '@/runtime/structured-agent-session-host-capability'
 import type { NativeChatSessionOptionRecord } from '../../../../shared/native-chat-session-option-state'
+import {
+  isHostModelListingWaitInFlight,
+  joinHostModelListingWait,
+  subscribeHostModelListingWaits
+} from './host-model-listing-waits'
 
 /**
  * Upgrades the static seed with the host's stored catalog without waiting on
@@ -16,6 +22,10 @@ import type { NativeChatSessionOptionRecord } from '../../../../shared/native-ch
  * would pin, so the picker warms during create. An older host answers
  * `forbidden` or `method_not_found` — both mean "no such surface", so the seed
  * stands until the live read lands.
+ *
+ * When the host says its first listing for the account is running, one more
+ * read waits for it — one per chat, joined by every later run and remount.
+ * Returns true while that read is in flight.
  */
 export function useHostModelCatalogUpgrade(args: {
   agent: AgentType
@@ -33,7 +43,7 @@ export function useHostModelCatalogUpgrade(args: {
   updateOptionState: (
     update: (current: StructuredAgentSessionOptionState) => StructuredAgentSessionOptionState
   ) => void
-}): void {
+}): boolean {
   const {
     activeOptionRecordRef,
     agent,
@@ -46,30 +56,62 @@ export function useHostModelCatalogUpgrade(args: {
     updateOptionState,
     worktree
   } = args
+  const waitKey = `${structuredAgentSessionHostKey(target)}\u0000${agent}\u0000${sessionId}`
+  const awaitingListing = useSyncExternalStore(subscribeHostModelListingWaits, () =>
+    isHostModelListingWaitInFlight(waitKey)
+  )
   useEffect(() => {
     if (!enabled || !optionCatalog || (agent !== 'claude' && agent !== 'codex')) {
       return
     }
     let stale = false
-    void callStructuredAgentSession<AgentSessionModelCatalogResult>(
-      target,
-      'agentSession.modelCatalog',
-      { agent, sessionId, ...(namesDefault && worktree ? { worktree } : {}) }
-    )
-      .then((catalog) => {
-        if (!stale) {
-          updateOptionState((current) =>
-            current.record === activeOptionRecordRef.current
-              ? applyStructuredAgentSessionModelCatalog(current, optionCatalog, catalog, {
-                  namesDefault
-                })
-              : current
-          )
+    const params = { agent, sessionId, ...(namesDefault && worktree ? { worktree } : {}) }
+    const read = (waitForListing: boolean): Promise<AgentSessionModelCatalogResult> =>
+      callStructuredAgentSession<AgentSessionModelCatalogResult>(
+        target,
+        'agentSession.modelCatalog',
+        waitForListing ? { ...params, waitForListing } : params
+      )
+    const apply = (catalog: AgentSessionModelCatalogResult): void =>
+      updateOptionState((current) =>
+        current.record === activeOptionRecordRef.current
+          ? applyStructuredAgentSessionModelCatalog(current, optionCatalog, catalog, {
+              namesDefault
+            })
+          : current
+      )
+    let leave: (() => void) | null = null
+    const waitForListing = (): void => {
+      leave = joinHostModelListingWait(
+        waitKey,
+        () => read(true),
+        (catalog) => {
+          if (catalog) {
+            apply(catalog)
+          }
         }
-      })
-      .catch(() => {})
+      )
+    }
+    if (isHostModelListingWaitInFlight(waitKey)) {
+      waitForListing()
+    } else {
+      void read(false)
+        .then((catalog) => {
+          if (stale) {
+            return
+          }
+          // Only a host that reports the listing knows the wait param; an older one refuses it.
+          if (catalog.origin === 'unknown' && catalog.listingInProgress === true) {
+            waitForListing()
+          } else {
+            apply(catalog)
+          }
+        })
+        .catch(() => {})
+    }
     return () => {
       stale = true
+      leave?.()
     }
   }, [
     activeOptionRecordRef,
@@ -81,6 +123,8 @@ export function useHostModelCatalogUpgrade(args: {
     sessionId,
     target,
     updateOptionState,
+    waitKey,
     worktree
   ])
+  return awaitingListing
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
index 341e242901f..088763d835d 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
@@ -235,7 +235,7 @@ function writeNativeChatAttachmentCache(
     .filter((attachment) => !attachment.pending)
     // Preview URLs can retain the full clipboard Blob (or a large data URL) for
     // the lifetime of the scope cache. Settled attachments reload from their
-    // authorized path after a remount, so never retain the transient preview.
+    // on-disk path after a remount, so never retain the transient preview.
     .map(({ previewUrl: _previewUrl, ...attachment }) => attachment)
   if (attachments.length === 0) {
     attachmentCache.delete(scopeKey)
diff --git a/src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx
index 1d8fa94eeb2..3c63879d198 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-external-attachments.test.tsx
@@ -5,7 +5,7 @@ import { createRoot, type Root } from 'react-dom/client'
 import type * as AttachmentUploadModule from './native-chat-attachment-upload'
 
 const mocks = vi.hoisted(() => ({
-  authorizeExternalPath: vi.fn(),
+  stat: vi.fn(),
   resolveNativeChatAttachmentOwner: vi.fn(),
   resolveNativeChatAttachmentOwnerForWorktree: vi.fn(),
   uploadNativeChatAttachmentPaths: vi.fn()
@@ -114,11 +114,9 @@ async function renderProbe(args: {
 }
 
 beforeEach(() => {
-  mocks.authorizeExternalPath.mockReset().mockResolvedValue(undefined)
+  mocks.stat.mockReset().mockResolvedValue(undefined)
   mocks.resolveNativeChatAttachmentOwnerForWorktree.mockReset().mockReturnValue({ kind: 'local' })
-  window.api = {
-    fs: { authorizeExternalPath: mocks.authorizeExternalPath }
-  } as unknown as Window['api']
+  vi.stubGlobal('api', { fs: { stat: mocks.stat } })
 })
 
 afterEach(() => {
@@ -135,52 +133,51 @@ describe('useNativeChatExternalAttachments', () => {
     await act(async () => {
       probe.latest().attachExternalPaths(['/local/a.txt'])
     })
-    expect(mocks.authorizeExternalPath).toHaveBeenCalledExactlyOnceWith({
-      targetPath: '/local/a.txt'
+    expect(mocks.stat).toHaveBeenCalledExactlyOnceWith({
+      filePath: '/local/a.txt',
+      access: { kind: 'user-file' }
     })
     expect(attachResolvedPaths).toHaveBeenCalledWith(['/local/a.txt'])
     expect(mocks.uploadNativeChatAttachmentPaths).not.toHaveBeenCalled()
   })
 
-  it('waits for local authorization and skips rejected paths without blocking other files', async () => {
+  it('waits for the local file check and skips rejected paths without blocking other files', async () => {
     mocks.resolveNativeChatAttachmentOwner.mockReturnValue({ kind: 'local' })
-    const authorization = deferred<void>()
-    mocks.authorizeExternalPath
-      .mockReturnValueOnce(authorization.promise)
-      .mockRejectedValueOnce(new Error('denied'))
+    const fileCheck = deferred<void>()
+    mocks.stat.mockReturnValueOnce(fileCheck.promise).mockRejectedValueOnce(new Error('denied'))
     const attachResolvedPaths = vi.fn()
     const probe = await renderProbe({ attachResolvedPaths })
     act(() =>
       probe.latest().attachExternalPaths(['/external/a.png', '/external/b.png', '/external/c.png'])
     )
     expect(attachResolvedPaths).not.toHaveBeenCalled()
-    expect(mocks.authorizeExternalPath).toHaveBeenCalledTimes(1)
-    await act(async () => authorization.resolve())
+    expect(mocks.stat).toHaveBeenCalledTimes(1)
+    await act(async () => fileCheck.resolve())
     expect(attachResolvedPaths).toHaveBeenCalledExactlyOnceWith([
       '/external/a.png',
       '/external/c.png'
     ])
-    expect(mocks.authorizeExternalPath).toHaveBeenCalledTimes(3)
+    expect(mocks.stat).toHaveBeenCalledTimes(3)
   })
 
-  it('does not attach local paths when disabled during authorization', async () => {
+  it('does not attach local paths when disabled during the file check', async () => {
     mocks.resolveNativeChatAttachmentOwner.mockReturnValue({ kind: 'local' })
-    const authorization = deferred<void>()
-    mocks.authorizeExternalPath.mockReturnValueOnce(authorization.promise)
+    const fileCheck = deferred<void>()
+    mocks.stat.mockReturnValueOnce(fileCheck.promise)
     const attachResolvedPaths = vi.fn()
     const probe = await renderProbe({ attachResolvedPaths })
     act(() => probe.latest().attachExternalPaths(['/external/a.png', '/external/b.png']))
     await probe.setDisabled(true)
-    await act(async () => authorization.resolve())
+    await act(async () => fileCheck.resolve())
     expect(attachResolvedPaths).not.toHaveBeenCalled()
-    expect(mocks.authorizeExternalPath).toHaveBeenCalledTimes(1)
+    expect(mocks.stat).toHaveBeenCalledTimes(1)
   })
 
-  it('does not attach local paths when the owner changes during authorization', async () => {
-    const authorization = deferred<void>()
+  it('does not attach local paths when the owner changes during the file check', async () => {
+    const fileCheck = deferred<void>()
     let owner: { kind: 'local' } | { kind: 'runtime' } = { kind: 'local' }
     mocks.resolveNativeChatAttachmentOwner.mockImplementation(() => owner)
-    mocks.authorizeExternalPath.mockReturnValueOnce(authorization.promise)
+    mocks.stat.mockReturnValueOnce(fileCheck.promise)
     const attachResolvedPaths = vi.fn()
     const notices: (string | null)[] = []
     const probe = await renderProbe({
@@ -190,10 +187,10 @@ describe('useNativeChatExternalAttachments', () => {
 
     act(() => probe.latest().attachExternalPaths(['/external/a.png', '/external/b.png']))
     owner = { kind: 'runtime' }
-    await act(async () => authorization.resolve())
+    await act(async () => fileCheck.resolve())
 
     expect(attachResolvedPaths).not.toHaveBeenCalled()
-    expect(mocks.authorizeExternalPath).toHaveBeenCalledTimes(1)
+    expect(mocks.stat).toHaveBeenCalledTimes(1)
     expect(notices.at(-1)).toBe(
       'This workspace changed hosts while attaching — drop the files again.'
     )
@@ -202,11 +199,11 @@ describe('useNativeChatExternalAttachments', () => {
   // The owner flipping during the LAST path has no next iteration to catch it,
   // so the post-loop check is the only thing standing between a one-file drop
   // and a path attached to a host that no longer owns it.
-  it('reports a one-file drop whose owner changes during its authorization', async () => {
-    const authorization = deferred<void>()
+  it('reports a one-file drop whose owner changes during its file check', async () => {
+    const fileCheck = deferred<void>()
     let owner: { kind: 'local' } | { kind: 'runtime' } = { kind: 'local' }
     mocks.resolveNativeChatAttachmentOwner.mockImplementation(() => owner)
-    mocks.authorizeExternalPath.mockReturnValueOnce(authorization.promise)
+    mocks.stat.mockReturnValueOnce(fileCheck.promise)
     const attachResolvedPaths = vi.fn()
     const notices: (string | null)[] = []
     const probe = await renderProbe({
@@ -216,7 +213,7 @@ describe('useNativeChatExternalAttachments', () => {
 
     act(() => probe.latest().attachExternalPaths(['/external/only.pdf']))
     owner = { kind: 'runtime' }
-    await act(async () => authorization.resolve())
+    await act(async () => fileCheck.resolve())
 
     expect(attachResolvedPaths).not.toHaveBeenCalled()
     expect(notices.at(-1)).toBe(
@@ -226,10 +223,10 @@ describe('useNativeChatExternalAttachments', () => {
 
   // Both workspaces answer `local`, so the owner alone cannot tell them apart:
   // only asking which workspace this composer serves now catches a tab that
-  // moved while the authorization was still in flight.
-  it('does not attach when the pane changes workspace during authorization', async () => {
-    const authorization = deferred<void>()
-    mocks.authorizeExternalPath.mockReturnValueOnce(authorization.promise)
+  // moved while the file check was still in flight.
+  it('does not attach when the pane changes workspace during the file check', async () => {
+    const fileCheck = deferred<void>()
+    mocks.stat.mockReturnValueOnce(fileCheck.promise)
     const attachResolvedPaths = vi.fn()
     const notices: (string | null)[] = []
     const probe = await renderProbe({
@@ -240,7 +237,7 @@ describe('useNativeChatExternalAttachments', () => {
 
     act(() => probe.latest().attachExternalPaths(['/external/only.pdf']))
     await probe.setStructuredWorktreeId('worktree-2')
-    await act(async () => authorization.resolve())
+    await act(async () => fileCheck.resolve())
 
     expect(attachResolvedPaths).not.toHaveBeenCalled()
     expect(notices.at(-1)).toBe(
@@ -305,7 +302,7 @@ describe('useNativeChatExternalAttachments', () => {
       expectedSshConnectionGeneration: 4
     })
     expect(attachResolvedPaths).toHaveBeenCalledWith(['/remote/wt/.orca/drops/a.txt'], 'conn-1')
-    expect(mocks.authorizeExternalPath).not.toHaveBeenCalled()
+    expect(mocks.stat).not.toHaveBeenCalled()
   })
 
   it('delivers concurrent SSH resolutions in order without deduplicating paths', async () => {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts b/src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts
index 98d3bc81446..5e88f793843 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-external-attachments.ts
@@ -11,6 +11,7 @@ import {
   uploadNativeChatAttachmentPaths,
   type NativeChatAttachmentOwner
 } from './native-chat-attachment-upload'
+import { userNamedFileAccess } from '@/lib/local-file-access'
 
 export type UseNativeChatExternalAttachmentsArgs = {
   terminalTabId: string
@@ -94,7 +95,7 @@ export function useNativeChatExternalAttachments({
         nativeChatAttachmentOwnerUnchanged(owner, resolveAttachmentOwner())
       if (owner.kind !== 'ssh') {
         void (async () => {
-          const authorizedPaths: string[] = []
+          const readablePaths: string[] = []
           for (const targetPath of paths) {
             if (disabledRef.current) {
               return
@@ -104,8 +105,8 @@ export function useNativeChatExternalAttachments({
               return
             }
             try {
-              await window.api.fs.authorizeExternalPath({ targetPath })
-              authorizedPaths.push(targetPath)
+              await window.api.fs.stat({ filePath: targetPath, access: userNamedFileAccess() })
+              readablePaths.push(targetPath)
             } catch {
               // Skip unreadable paths, matching workspace composer drops.
             }
@@ -117,11 +118,11 @@ export function useNativeChatExternalAttachments({
             setNotice(nativeChatAttachmentOwnerChangedNotice())
             return
           }
-          if (authorizedPaths.length === 0) {
+          if (readablePaths.length === 0) {
             setNotice(nativeChatAttachmentUnreadableNotice())
             return
           }
-          attachResolvedPaths(authorizedPaths)
+          attachResolvedPaths(readablePaths)
         })()
         return
       }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.test.tsx
index a2055b79e06..3ef80d69955 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.test.tsx
@@ -127,8 +127,8 @@ describe('a chat pane over its own launch', () => {
 
   it('keeps the selection its create seeded when a pick in another chat saves a new one', () => {
     saveSelection('gpt-5.5')
-    startStructuredAgentLaunch('wt-first', 'codex')
-    const second = startStructuredAgentLaunch('wt-second', 'codex')
+    startStructuredAgentLaunch('wt-first', 'codex', { requestId: 'request-1' })
+    const second = startStructuredAgentLaunch('wt-second', 'codex', { requestId: 'request-2' })
     const { result, rerender } = renderLaunchedChat('wt-second', second.sessionId)
     expect(currentModel(result.current.optionSnapshot)).toBe('gpt-5.5')
 
@@ -156,7 +156,7 @@ describe('a chat pane over its own launch', () => {
           })
         : new Promise(() => {})
     )
-    const launch = startStructuredAgentLaunch('wt-refused', 'codex')
+    const launch = startStructuredAgentLaunch('wt-refused', 'codex', { requestId: 'request-3' })
     const { sessionId } = launch
     const { result, rerender } = renderLaunchedChat('wt-refused', sessionId)
     await act(async () => {
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-delivery-notices.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-delivery-notices.test.tsx
new file mode 100644
index 00000000000..28ef88564b9
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-delivery-notices.test.tsx
@@ -0,0 +1,120 @@
+// @vitest-environment happy-dom
+
+import { cleanup, renderHook } from '@testing-library/react'
+import { afterEach, expect, it } from 'vitest'
+import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import { DISPATCH_REJECTED_CANCELLED } from '../../../../shared/structured-agent-session-dispatch-rejection'
+import { useStructuredAgentSessionDeliveryNotices } from './use-structured-agent-session-delivery-notices'
+
+afterEach(cleanup)
+
+const NONE = new Set<string>()
+const NO_CARDS: readonly string[] = []
+const EMPTY: never[] = []
+
+function rejected(
+  clientMessageId: string,
+  kind: 'hostRestarted' | 'notDelivered'
+): AgentJournalSubmission {
+  return {
+    clientMessageId,
+    fence: 1,
+    payloadFingerprint: clientMessageId,
+    dispatchState: 'rejected',
+    providerItemId: null,
+    reason: null,
+    rejection: { kind },
+    submittedAt: 1,
+    resolvedAt: 2
+  }
+}
+
+function accepted(clientMessageId: string): AgentJournalSubmission {
+  return {
+    clientMessageId,
+    fence: 1,
+    payloadFingerprint: clientMessageId,
+    dispatchState: 'accepted',
+    providerItemId: `provider-${clientMessageId}`,
+    reason: null,
+    submittedAt: 3,
+    resolvedAt: 4
+  }
+}
+
+function withdrawn(clientMessageId: string): AgentJournalSubmission {
+  return {
+    clientMessageId,
+    fence: 1,
+    payloadFingerprint: clientMessageId,
+    dispatchState: 'rejected',
+    providerItemId: null,
+    reason: DISPATCH_REJECTED_CANCELLED,
+    rejection: { kind: 'cancelled' },
+    submittedAt: 1,
+    resolvedAt: 2
+  }
+}
+
+// A Stop's withdrawn message draws no row, so a chat that has one rebuilds no notice per batch.
+it('keeps the same notices across batches in a chat whose only rejection a Stop withdrew', () => {
+  const { result, rerender } = renderHook(
+    ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
+      useStructuredAgentSessionDeliveryNotices({
+        outbox: EMPTY,
+        submissions,
+        journalItems: EMPTY,
+        failedHere: NONE,
+        queuedMessageIds: NO_CARDS,
+        retry: () => {},
+        agentName: 'Claude'
+      }),
+    { initialProps: { submissions: [withdrawn('stopped')] } }
+  )
+  const first = result.current
+
+  rerender({ submissions: [withdrawn('stopped')] })
+
+  expect(result.current).toBe(first)
+  expect(result.current.size).toBe(0)
+})
+
+function renderNotices(submissions: readonly AgentJournalSubmission[]) {
+  return renderHook(
+    ({ submissions: current }: { submissions: readonly AgentJournalSubmission[] }) =>
+      useStructuredAgentSessionDeliveryNotices({
+        outbox: EMPTY,
+        submissions: current,
+        journalItems: EMPTY,
+        failedHere: NONE,
+        queuedMessageIds: NO_CARDS,
+        retry: () => {},
+        agentName: 'Claude'
+      }),
+    { initialProps: { submissions } }
+  )
+}
+
+// A batch for another message rebuilds the journal's rows; the rows already marked not sent keep
+// the same notices, so no row wrapper re-renders.
+it('keeps the same notices when a batch leaves every not-sent message as it was', () => {
+  const { result, rerender } = renderNotices([rejected('lost', 'hostRestarted')])
+  const first = result.current
+  expect(first.size).toBe(1)
+
+  rerender({ submissions: [rejected('lost', 'hostRestarted'), accepted('next')] })
+
+  expect(result.current).toBe(first)
+})
+
+it('keeps the notice of a row that did not change when another one does', () => {
+  const { result, rerender } = renderNotices([rejected('lost', 'hostRestarted')])
+  const lost = result.current.get('orca:lost')
+
+  rerender({
+    submissions: [rejected('lost', 'hostRestarted'), rejected('other', 'notDelivered')]
+  })
+
+  expect(result.current.size).toBe(2)
+  expect(result.current.get('orca:lost')).toBe(lost)
+})
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-delivery-notices.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-delivery-notices.ts
new file mode 100644
index 00000000000..2c39d306e82
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-delivery-notices.ts
@@ -0,0 +1,126 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
+import { dispatchWasWithdrawn } from '../../../../shared/structured-agent-session-dispatch-rejection'
+import { structuredAgentSessionCommandItemIds } from '../../../../shared/structured-agent-session-message-projection'
+import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
+import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
+import { useStructuredAgentSessionStartFailureFacts } from './use-structured-agent-session-start-failure-facts'
+import type { NativeChatDeliveryNotice } from './NativeChatMessageRow'
+
+const NO_SUBMISSIONS: readonly AgentJournalSubmission[] = []
+const NO_ITEMS: readonly AgentJournalRenderItem[] = []
+
+/** The structured chat's delivery notices, by the message id each row renders under. */
+export function useStructuredAgentSessionDeliveryNotices(args: {
+  outbox: readonly StructuredAgentSessionOutboxEntry[]
+  submissions: readonly AgentJournalSubmission[]
+  journalItems: readonly AgentJournalRenderItem[]
+  failedHere: ReadonlySet<string>
+  queuedMessageIds: readonly string[]
+  retry: (clientMessageId: string) => void
+  agentName: string
+}): ReadonlyMap<string, NativeChatDeliveryNotice> {
+  const { agentName, failedHere, outbox, queuedMessageIds, submissions } = args
+  // Read at click time, so the notices stay put while the outbox's Retry is rebuilt each render.
+  const retryRef = useRef(args.retry)
+  useEffect(() => {
+    retryRef.current = args.retry
+  })
+  const retry = useCallback((clientMessageId: string) => {
+    retryRef.current(clientMessageId)
+  }, [])
+  // Only a message shown as not sent (a withdrawn one draws nothing) or still in the outbox reads
+  // the journal's rows, so in a chat with neither a new batch of them re-renders no row.
+  const hasRejected =
+    outbox.some((entry) => entry.state === 'rejected') ||
+    submissions.some(
+      (submission) => submission.dispatchState === 'rejected' && !dispatchWasWithdrawn(submission)
+    )
+  const journalRows = hasRejected || outbox.length > 0 ? submissions : NO_SUBMISSIONS
+  // Only an outbox copy of a rejected message reads the loaded rows, so a streaming turn rebuilds
+  // no notice otherwise.
+  const loadedItems = hasRejected && outbox.length > 0 ? args.journalItems : NO_ITEMS
+  const startFailures = useStructuredAgentSessionStartFailureFacts(args.journalItems, hasRejected)
+  const commandItemIds = useCommandItemIds(args.journalItems, hasRejected)
+  const notices = useMemo(
+    () =>
+      structuredAgentSessionDeliveryNotices(
+        outbox,
+        agentName,
+        retry,
+        journalRows,
+        startFailures,
+        failedHere,
+        queuedMessageIds,
+        commandItemIds,
+        loadedItems
+      ),
+    [
+      outbox,
+      agentName,
+      retry,
+      journalRows,
+      startFailures,
+      failedHere,
+      queuedMessageIds,
+      commandItemIds,
+      loadedItems
+    ]
+  )
+  // A submission batch rebuilds the map; one that says the same keeps the old, so no row re-renders.
+  const previousRef = useRef(notices)
+  const stable = sameNoticesKept(previousRef.current, notices)
+  useEffect(() => {
+    previousRef.current = stable
+  }, [stable])
+  return stable
+}
+
+const NO_COMMANDS: ReadonlySet<string> = new Set()
+
+/** The loaded commands, read only while `enabled`, and held while unchanged so a streaming turn
+ *  rebuilds no notice. */
+function useCommandItemIds(
+  items: readonly AgentJournalRenderItem[],
+  enabled: boolean
+): ReadonlySet<string> {
+  const ids = useMemo(
+    () => (enabled ? structuredAgentSessionCommandItemIds(items) : NO_COMMANDS),
+    [enabled, items]
+  )
+  const previousRef = useRef(ids)
+  const previous = previousRef.current
+  const stable =
+    previous.size === ids.size && [...ids].every((id) => previous.has(id)) ? previous : ids
+  useEffect(() => {
+    previousRef.current = stable
+  }, [stable])
+  return stable
+}
+
+/** `next`, reusing each notice `previous` words the same way, and `previous` itself when all are. */
+function sameNoticesKept(
+  previous: ReadonlyMap<string, NativeChatDeliveryNotice>,
+  next: ReadonlyMap<string, NativeChatDeliveryNotice>
+): ReadonlyMap<string, NativeChatDeliveryNotice> {
+  if (previous === next) {
+    return next
+  }
+  let allKept = previous.size === next.size
+  const kept = new Map<string, NativeChatDeliveryNotice>()
+  for (const [id, notice] of next) {
+    const before = previous.get(id)
+    // Each Retry calls the stable `retry` with its own id, so one under the same key is the same.
+    const same =
+      before !== undefined &&
+      before.text === notice.text &&
+      (before.onRetry === undefined) === (notice.onRetry === undefined) &&
+      (before.onDismiss === undefined) === (notice.onDismiss === undefined)
+    allKept &&= same
+    kept.set(id, same ? before : notice)
+  }
+  return allKept ? previous : kept
+}
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-messages.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-messages.test.tsx
index 68e388de58c..419e6a6cae9 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-messages.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-messages.test.tsx
@@ -11,6 +11,7 @@ import { useStructuredAgentSessionMessages } from './use-structured-agent-sessio
 
 afterEach(cleanup)
 const EMPTY: never[] = []
+const NO_CARDS: readonly string[] = []
 function tool(id: string, sequence: number): AgentJournalRenderItem {
   return {
     itemId: id,
@@ -25,7 +26,8 @@ it('retains only unchanged item projections across updates, reorder, deletion, a
   const first = tool('first', 1)
   const second = tool('second', 2)
   const { result, rerender } = renderHook(
-    (items: AgentJournalRenderItem[]) => useStructuredAgentSessionMessages(items, EMPTY, EMPTY),
+    (items: AgentJournalRenderItem[]) =>
+      useStructuredAgentSessionMessages(items, EMPTY, EMPTY, NO_CARDS),
     { initialProps: [first, second] }
   )
   const initial = result.current
@@ -50,7 +52,9 @@ it('retains only unchanged item projections across updates, reorder, deletion, a
     [structuredClone(completed)]
   ]) {
     rerender(items)
-    expect(result.current).toEqual(projectStructuredAgentSessionMessages(items, EMPTY, EMPTY))
+    expect(result.current).toEqual(
+      projectStructuredAgentSessionMessages(items, EMPTY, EMPTY, NO_CARDS)
+    )
     expect(result.current.find((message) => message.id === 'second')).not.toBe(initial[1])
   }
   const replacement = {
@@ -62,7 +66,9 @@ it('retains only unchanged item projections across updates, reorder, deletion, a
     }
   }
   rerender([replacement])
-  expect(result.current).toEqual(projectStructuredAgentSessionMessages([replacement], EMPTY, EMPTY))
+  expect(result.current).toEqual(
+    projectStructuredAgentSessionMessages([replacement], EMPTY, EMPTY, NO_CARDS)
+  )
   expect(result.current[0]).not.toBe(initial[0])
 })
 
@@ -91,14 +97,14 @@ it('keeps optimistic sends and their settlement identical to uncached projection
     }: {
       items: AgentJournalRenderItem[]
       submissions: AgentJournalSubmission[]
-    }) => useStructuredAgentSessionMessages(items, [entry], submissions),
+    }) => useStructuredAgentSessionMessages(items, [entry], submissions, NO_CARDS),
     { initialProps: { items: [tool('tool', 1)], submissions: [submission] } }
   )
   for (const dispatchState of ['pending', 'unknown', 'accepted'] as const) {
     const props = { items: [tool('tool', 1)], submissions: [{ ...submission, dispatchState }] }
     rerender(props)
     expect(result.current).toEqual(
-      projectStructuredAgentSessionMessages(props.items, [entry], props.submissions)
+      projectStructuredAgentSessionMessages(props.items, [entry], props.submissions, NO_CARDS)
     )
   }
 })
@@ -106,7 +112,7 @@ it('keeps optimistic sends and their settlement identical to uncached projection
 it('does no transcript projection work on a status-only render', () => {
   const items = [tool('tool', 1)]
   const { result, rerender } = renderHook(() =>
-    useStructuredAgentSessionMessages(items, EMPTY, EMPTY)
+    useStructuredAgentSessionMessages(items, EMPTY, EMPTY, NO_CARDS)
   )
   const initial = result.current
   rerender()
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-messages.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-messages.ts
index f965c2d3eaa..af38cda41df 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-messages.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-messages.ts
@@ -9,10 +9,11 @@ import { projectStructuredAgentSessionMessages } from './structured-agent-sessio
 export function useStructuredAgentSessionMessages(
   items: readonly AgentJournalRenderItem[],
   outbox: readonly StructuredAgentSessionOutboxEntry[],
-  submissions: readonly AgentJournalSubmission[]
+  submissions: readonly AgentJournalSubmission[],
+  queuedMessageIds: readonly string[]
 ) {
   return useMemo(
-    () => projectStructuredAgentSessionMessages(items, outbox, submissions),
-    [items, outbox, submissions]
+    () => projectStructuredAgentSessionMessages(items, outbox, submissions, queuedMessageIds),
+    [items, outbox, submissions, queuedMessageIds]
   )
 }
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-options.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-options.ts
index e3ee7cd1de0..215f189280d 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-options.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-options.ts
@@ -12,6 +12,7 @@ import {
   canSetStructuredAgentSessionOption,
   commitStructuredAgentSessionOptionValues,
   lockedStructuredAgentSessionOptionSnapshot,
+  pendingModelListStructuredAgentSessionOptionSnapshot,
   structuredAgentSessionOptionPicks,
   structuredAgentSessionOptionSnapshot,
   structuredAgentSessionOptionView,
@@ -89,7 +90,7 @@ export function useStructuredAgentSessionOptions(args: {
     unloadedTurnRevisions: args.unloadedTurnRevisions
   })
 
-  useHostModelCatalogUpgrade({
+  const awaitingHostModelList = useHostModelCatalogUpgrade({
     agent,
     sessionId,
     target,
@@ -103,6 +104,8 @@ export function useStructuredAgentSessionOptions(args: {
     activeOptionRecordRef,
     updateOptionState
   })
+  // The running provider's own list ends the wait for the host's.
+  const modelListPending = awaitingHostModelList && optionState.catalogSource !== 'live'
 
   // What a settled pick must remember so the next launch starts where the user left off.
   const rememberOptionPicks = useCallback(
@@ -205,8 +208,9 @@ export function useStructuredAgentSessionOptions(args: {
     const snapshot = structuredAgentSessionOptionSnapshot(
       structuredAgentSessionOptionView(optionState, launchSeedOptions, held)
     )
-    return acceptsPicks ? snapshot : lockedStructuredAgentSessionOptionSnapshot(snapshot)
-  }, [acceptsPicks, held, launchSeedOptions, optionState])
+    const shown = acceptsPicks ? snapshot : lockedStructuredAgentSessionOptionSnapshot(snapshot)
+    return modelListPending ? pendingModelListStructuredAgentSessionOptionSnapshot(shown) : shown
+  }, [acceptsPicks, held, launchSeedOptions, modelListPending, optionState])
   const setStructuredOption = useCallback(
     async (id: string, value: string | boolean): Promise<boolean> => {
       const view = structuredAgentSessionOptionView(optionStateRef.current, launchSeedOptions, held)
@@ -214,6 +218,8 @@ export function useStructuredAgentSessionOptions(args: {
       if (
         !optionCatalog ||
         encoded === null ||
+        // A typed `/model` reaches here without the picker.
+        optionSnapshot.some((descriptor) => descriptor.id === id && descriptor.choicesPending) ||
         !canSetStructuredAgentSessionOption(view, id, value)
       ) {
         return false
@@ -234,6 +240,7 @@ export function useStructuredAgentSessionOptions(args: {
       held,
       launchSeedOptions,
       optionCatalog,
+      optionSnapshot,
       optionStateRef,
       pendingOptionRef,
       sendStructuredOption,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-admission.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-admission.test.tsx
index 083a128ca0e..a810a331a2c 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-admission.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-admission.test.tsx
@@ -7,7 +7,10 @@
 
 import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
 import type { AgentSessionWireRefusalCode } from '../../../../shared/agent-session-wire'
 
 const mocks = vi.hoisted(() => ({
@@ -26,6 +29,8 @@ import { agentJournalSubmissionKey } from '../../../../shared/agent-session-jour
 import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
 import { structuredAgentSessionEntryHeldForRetry } from '../../../../shared/structured-agent-session-outbox-admission'
 
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 const LOCAL_TARGET = { kind: 'local' } as const
 
 function deferred<T>() {
@@ -93,6 +98,7 @@ function refusedResult(code: AgentSessionWireRefusalCode) {
 function renderOutbox() {
   return renderHook(() =>
     useStructuredAgentSessionOutbox({
+      journalItems: NO_JOURNAL_ITEMS,
       sessionId: 'session-1',
       target: LOCAL_TARGET,
       fence: 1,
@@ -230,6 +236,7 @@ describe('structured agent session outbox admission', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -311,6 +318,7 @@ describe('structured agent session outbox admission', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-fence.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-fence.test.tsx
index 9545c083fa7..86d1ddf8322 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-fence.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-fence.test.tsx
@@ -20,6 +20,10 @@ import { settleStructuredAgentLaunchPrompt } from '@/lib/structured-agent-sessio
 import { enqueueStructuredAgentSessionLaunchPrompt } from './structured-agent-session-outbox-storage'
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 // Why: every hook here shares the session outbox store; one left mounted would drain the next test's.
 afterEach(cleanup)
 
@@ -65,6 +69,7 @@ function render(fence: number | null = 1) {
   return renderHook(
     (props) =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: props.fence,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-owner-change.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-owner-change.test.tsx
index 926d77d4794..fcc0d2a6c62 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-owner-change.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-owner-change.test.tsx
@@ -34,6 +34,10 @@ import {
 import { writeOutbox } from './structured-agent-session-outbox-storage'
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 type SendRequest = { envelope?: { clientOperationId?: string; expectedRuntimeFence?: number } }
 
 // Stable, as the view passes it: a new object each render would re-run the owner-change requeue.
@@ -82,6 +86,7 @@ function mount(fence: number) {
   return renderHook(
     ({ fence: current }: { fence: number }) =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: TARGET,
         fence: current,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-rejection-cause.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-rejection-cause.test.tsx
index 8bf95a8a511..e32006c50d0 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-rejection-cause.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-rejection-cause.test.tsx
@@ -2,7 +2,10 @@
 
 import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
 import { DISPATCH_REJECTED_CANCELLED } from '../../../../shared/structured-agent-session-dispatch-rejection'
 
 const mocks = vi.hoisted(() => ({
@@ -16,13 +19,28 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
 import { setLocalRuntimeCapabilitiesForTests } from '@/runtime/local-runtime-capabilities'
 import { RuntimeRpcCallError } from '@/runtime/runtime-rpc-result'
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
+import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
+import { agentJournalSubmissionKey } from '../../../../shared/agent-session-journal-item-key'
 import { agentSessionWriteNoticeEnglish } from '../../../../shared/agent-session-refusal-notice'
 import { structuredAgentSessionAttemptFailureParts } from '../../../../shared/structured-agent-session-send-disposition'
 import {
   createStructuredAgentSessionOutboxEntry,
   type StructuredAgentSessionOutboxEntry
 } from '../../../../shared/structured-agent-session-outbox'
-import { writeOutbox } from './structured-agent-session-outbox-storage'
+import {
+  hasUndeliveredStructuredAgentSessionOutbox,
+  readOutbox,
+  writeOutbox
+} from './structured-agent-session-outbox-storage'
+
+/** What these hooks render with: the journal's submissions, and the rows loaded so far. */
+type OutboxProps = { submissions: AgentJournalSubmission[]; rows?: AgentJournalRenderItem[] }
+
+function outboxProps(submissions: AgentJournalSubmission[]): OutboxProps {
+  return { submissions }
+}
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
 
 // Why: every hook here shares the session outbox store; one left mounted would drain the next test's.
 afterEach(cleanup)
@@ -88,7 +106,7 @@ describe('a send the host rejected because the agent never started', () => {
     localStorage.clear()
   })
 
-  it('names the cause on the message and keeps it for Retry', async () => {
+  it('names the cause on the message until the journal row takes it over', async () => {
     mocks.call.mockImplementationOnce(
       async (
         _target: unknown,
@@ -98,6 +116,7 @@ describe('a send the host rejected because the agent never started', () => {
     )
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: { kind: 'local' },
         fence: 1,
@@ -108,7 +127,7 @@ describe('a send the host rejected because the agent never started', () => {
     act(() => expect(result.current.send('hello')).toBe(true))
 
     await waitFor(() => expect(shownFailure(result.current.outbox[0])).toBe(REASON))
-    // Settled as not delivered: it waits for Retry and holds no later message up.
+    // Settled as not delivered: it holds no later message up.
     expect(result.current.error).toBeNull()
     expect(result.current.outbox[0]?.state).toBe('rejected')
   })
@@ -126,6 +145,7 @@ describe('a send the host rejected because the agent never started', () => {
     })
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: { kind: 'local' },
         fence: 1,
@@ -151,7 +171,7 @@ describe('a send the host rejected because the agent never started', () => {
     ])
   })
 
-  it('keeps a message the host accepted and then could not deliver, with its reason and Retry', async () => {
+  it('leaves a message the host accepted and then could not deliver to its journal row', async () => {
     const reason = "Codex couldn't restart: spawn codex ENOENT."
     mocks.call.mockImplementation(
       async (
@@ -162,14 +182,15 @@ describe('a send the host rejected because the agent never started', () => {
     )
     const target = { kind: 'local' } as const
     const { result, rerender } = renderHook(
-      (props: { submissions: AgentJournalSubmission[] }) =>
+      (props: OutboxProps) =>
         useStructuredAgentSessionOutbox({
+          journalItems: props.rows ?? NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target,
           fence: 1,
           submissions: props.submissions
         }),
-      { initialProps: { submissions: NO_SUBMISSIONS } }
+      { initialProps: outboxProps(NO_SUBMISSIONS) }
     )
 
     act(() => expect(result.current.send('hello')).toBe(true))
@@ -177,22 +198,17 @@ describe('a send the host rejected because the agent never started', () => {
     const id = result.current.outbox[0]!.clientMessageId
 
     rerender({
-      submissions: [{ ...pendingResultFor(id).value.submission, dispatchState: 'rejected', reason }]
+      submissions: [
+        { ...pendingResultFor(id).value.submission, dispatchState: 'rejected', reason }
+      ],
+      rows: rowsFor(id)
     })
 
-    await waitFor(() => expect(result.current.outbox[0]?.state).toBe('rejected'))
-    expect(shownFailure(result.current.outbox[0])).toBe(reason)
+    // The host's row shows it as not sent, with no Retry: nothing resends it.
+    await waitFor(() => expect(result.current.outbox).toEqual([]))
     expect(result.current.error).toBeNull()
-
-    // Retry is a new message with the same text: a fresh id, sent once.
-    act(() => result.current.retry(id))
-    await waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(2))
-    const retried: {
-      envelope: { clientOperationId: string }
-      body: { blocks: { text?: string }[] }
-    } = mocks.call.mock.calls[1]![2]
-    expect(retried.envelope.clientOperationId).not.toBe(id)
-    expect(retried.body.blocks[0]?.text).toBe('hello')
+    await act(() => new Promise((resolve) => setTimeout(resolve, 50)))
+    expect(mocks.call).toHaveBeenCalledOnce()
   })
 
   it('says nothing when a Stop withdrew the message', async () => {
@@ -205,14 +221,15 @@ describe('a send the host rejected because the agent never started', () => {
     )
     const target = { kind: 'local' } as const
     const { result, rerender } = renderHook(
-      (props: { submissions: AgentJournalSubmission[] }) =>
+      (props: OutboxProps) =>
         useStructuredAgentSessionOutbox({
+          journalItems: props.rows ?? NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target,
           fence: 1,
           submissions: props.submissions
         }),
-      { initialProps: { submissions: NO_SUBMISSIONS } }
+      { initialProps: outboxProps(NO_SUBMISSIONS) }
     )
 
     act(() => expect(result.current.send('hello')).toBe(true))
@@ -233,7 +250,7 @@ describe('a send the host rejected because the agent never started', () => {
     expect(result.current.error).toBeNull()
   })
 
-  it('reads a message rejected while the chat was closed as not sent, and sends past it', async () => {
+  it('leaves a message rejected while the chat was closed to its journal row, and sends past it', async () => {
     const reason = "Codex couldn't restart: spawn codex ENOENT."
     mocks.call.mockImplementation(
       async (
@@ -245,6 +262,7 @@ describe('a send the host rejected because the agent never started', () => {
     const target = { kind: 'local' } as const
     const first = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target,
         fence: 1,
@@ -260,8 +278,10 @@ describe('a send the host rejected because the agent never started', () => {
     const rejected = [
       { ...pendingResultFor(id).value.submission, dispatchState: 'rejected' as const, reason }
     ]
+    const reopenedRows = rowsFor(id)
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: reopenedRows,
         sessionId: 'session-1',
         target,
         fence: 1,
@@ -269,54 +289,192 @@ describe('a send the host rejected because the agent never started', () => {
       })
     )
 
-    await waitFor(() => expect(result.current.outbox[0]?.state).toBe('rejected'))
-    expect(shownFailure(result.current.outbox[0])).toBe(reason)
+    await waitFor(() => expect(result.current.outbox).toEqual([]))
     act(() => expect(result.current.send('second')).toBe(true))
     await waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(2))
   })
 
-  // After a restart nothing in memory remembers the rejection, and its journal row may be older
-  // than the loaded page: the message's own state is what says a resend needs a new id.
-  it('retries a message rejected before a restart under a new id', async () => {
-    const rejected = createStructuredAgentSessionOutboxEntry({
-      clientMessageId: 'rejected-before-restart',
-      sessionId: 'session-1',
-      text: 'first',
-      attachments: [],
-      queuedAt: 1
-    })
+  // One stored host fact, one rendering: a message the host recorded and rejected, whose record this
+  // chat does not hold, keeps showing why on every mount, with no control, and is never sent again.
+  it('keeps a message the host rejected, with no control, on every mount, and never resends it', async () => {
     writeOutbox('session-1', [
       {
-        ...rejected,
-        state: 'rejected',
-        lastFailure: {
-          kind: 'rejected',
-          reason: 'The provider did not accept this message.',
-          rejection: { kind: 'providerRejected' }
-        }
+        ...rejectedBeforeRestart(),
+        state: 'dispatching',
+        lastFailure: undefined,
+        lastAttemptAt: 5
       }
     ])
+    // The host replays its rejection when the reopened chat asks about the send it left in doubt.
     mocks.call.mockImplementation(async (_target, _method, params) =>
-      acceptedResultFor(String(params.envelope.clientOperationId))
+      rejectedResultFor(String(params.envelope.clientOperationId))
     )
-    const { result } = renderHook(() =>
-      useStructuredAgentSessionOutbox({
-        sessionId: 'session-1',
-        target: { kind: 'local' },
-        fence: 1,
-        submissions: []
-      })
-    )
-    expect(result.current.outbox[0]?.state).toBe('rejected')
+    const notice = (
+      outbox: readonly StructuredAgentSessionOutboxEntry[],
+      failedHere: ReadonlySet<string>
+    ) =>
+      structuredAgentSessionDeliveryNotices(
+        outbox,
+        'Claude',
+        () => {},
+        NO_SUBMISSIONS,
+        [],
+        failedHere
+      ).get(agentJournalSubmissionKey('rejected-before-restart'))
+    const mount = () =>
+      renderHook(() =>
+        useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
+          sessionId: 'session-1',
+          target: { kind: 'local' },
+          fence: 1,
+          submissions: NO_SUBMISSIONS
+        })
+      )
 
-    act(() => result.current.retry('rejected-before-restart'))
-    await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
-    const sentId: unknown = mocks.call.mock.calls[0]![2].envelope.clientOperationId
-    expect(sentId).not.toBe('rejected-before-restart')
-    await waitFor(() => expect(result.current.outbox).toHaveLength(0))
+    const first = mount()
+    await waitFor(() => expect(first.result.current.outbox[0]?.state).toBe('rejected'), {
+      timeout: 4000
+    })
+    const onFirst = notice(first.result.current.outbox, first.result.current.failedHere)
+    first.unmount()
+    const second = mount()
+    const onSecond = notice(second.result.current.outbox, second.result.current.failedHere)
+
+    for (const shown of [onFirst, onSecond]) {
+      expect(shown).toEqual({ text: REASON })
+    }
+    await act(() => new Promise((resolve) => setTimeout(resolve, 1500)))
+    // Only the first mount's question about the send it left in doubt; nothing resends it.
+    expect(mocks.call).toHaveBeenCalledOnce()
+    expect(second.result.current.outbox.map((entry) => entry.state)).toEqual(['rejected'])
+    expect(readOutbox('session-1')).toHaveLength(1)
+    expect(hasUndeliveredStructuredAgentSessionOutbox('session-1')).toBe(false)
+  }, 10000)
+
+  // The host's own record is what lets it go, and storage forgets it too: nothing is owed.
+  it('drops a message rejected before a restart once the journal says so, from storage too', async () => {
+    writeOutbox('session-1', [rejectedBeforeRestart()])
+    const { result, rerender } = renderHook(
+      (props: OutboxProps) =>
+        useStructuredAgentSessionOutbox({
+          journalItems: props.rows ?? NO_JOURNAL_ITEMS,
+          sessionId: 'session-1',
+          target: { kind: 'local' },
+          fence: 1,
+          submissions: props.submissions
+        }),
+      { initialProps: outboxProps(NO_SUBMISSIONS) }
+    )
+    expect(result.current.outbox).toHaveLength(1)
+
+    rerender({
+      submissions: [
+        {
+          ...pendingResultFor('rejected-before-restart').value.submission,
+          dispatchState: 'rejected',
+          reason: 'The provider did not accept this message.',
+          resolvedAt: 2
+        }
+      ],
+      rows: rowsFor('rejected-before-restart')
+    })
+
+    await waitFor(() => expect(result.current.outbox).toEqual([]))
+    expect(readOutbox('session-1')).toEqual([])
+    expect(hasUndeliveredStructuredAgentSessionOutbox('session-1')).toBe(false)
+    expect(mocks.call).not.toHaveBeenCalled()
   })
 
-  it('keeps the rejection when the journal settles the message before the send answers', async () => {
+  // An older host leaves a rejected message where it was sent, which may be outside the loaded
+  // window: the entry draws it, with no control, until the row that draws it loads.
+  it('keeps a rejected message whose row is not loaded, then lets it go once the row loads', async () => {
+    writeOutbox('session-1', [
+      { ...rejectedBeforeRestart(), state: 'dispatching', lastFailure: undefined, lastAttemptAt: 5 }
+    ])
+    const rejected = [
+      {
+        ...pendingResultFor('rejected-before-restart').value.submission,
+        dispatchState: 'rejected' as const,
+        reason: REASON,
+        resolvedAt: 2
+      }
+    ]
+    const { result, rerender } = renderHook(
+      (props: OutboxProps) =>
+        useStructuredAgentSessionOutbox({
+          journalItems: props.rows ?? NO_JOURNAL_ITEMS,
+          sessionId: 'session-1',
+          target: { kind: 'local' },
+          fence: 1,
+          submissions: props.submissions
+        }),
+      { initialProps: outboxProps(rejected) }
+    )
+
+    await waitFor(() => expect(result.current.outbox[0]?.state).toBe('rejected'))
+    expect(shownFailure(result.current.outbox[0])).toBe(REASON)
+    expect(readOutbox('session-1')).toHaveLength(1)
+
+    rerender({ submissions: rejected, rows: rowsFor('rejected-before-restart') })
+    await waitFor(() => expect(result.current.outbox).toEqual([]))
+    expect(readOutbox('session-1')).toEqual([])
+    expect(mocks.call).not.toHaveBeenCalled()
+  })
+
+  it('keeps a send its reply rejected without a Retry until the journal row takes it over', async () => {
+    const writeFailed = (clientMessageId: string): AgentJournalSubmission => ({
+      clientMessageId,
+      fence: 1,
+      payloadFingerprint: 'fingerprint',
+      dispatchState: 'rejected',
+      providerItemId: null,
+      reason: 'provider_write_failed: broken pipe',
+      submittedAt: 10,
+      resolvedAt: 10
+    })
+    mocks.call.mockImplementationOnce(
+      async (
+        _target: unknown,
+        _method: unknown,
+        params: { envelope: { clientOperationId: string } }
+      ) => ({
+        ok: true,
+        replayed: false,
+        fence: 1,
+        cursor: { epoch: 'epoch-1', sequence: 10 },
+        value: {
+          clientMessageId: params.envelope.clientOperationId,
+          submission: writeFailed(params.envelope.clientOperationId)
+        }
+      })
+    )
+    const { result, rerender } = renderHook(
+      (props: OutboxProps) =>
+        useStructuredAgentSessionOutbox({
+          journalItems: props.rows ?? NO_JOURNAL_ITEMS,
+          sessionId: 'session-1',
+          target: LOCAL_TARGET,
+          fence: 1,
+          submissions: props.submissions
+        }),
+      { initialProps: outboxProps(NO_SUBMISSIONS) }
+    )
+
+    act(() => expect(result.current.send('first')).toBe(true))
+    await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
+    const firstId = String(mocks.call.mock.calls[0]![2].envelope.clientOperationId)
+
+    // Answered, not doubted: the entry draws the message, saying why, until the journal has it.
+    await waitFor(() => expect(result.current.outbox[0]?.lastFailure?.kind).toBe('rejected'))
+    expect(result.current.outbox[0]?.state).toBe('rejected')
+
+    rerender({ submissions: [writeFailed(firstId)], rows: rowsFor(firstId) })
+    await waitFor(() => expect(result.current.outbox).toHaveLength(0))
+    expect(mocks.call).toHaveBeenCalledOnce()
+  })
+
+  it('lets the journal settle the message when its rejection lands before the send answers', async () => {
     const reason = "Codex couldn't restart: spawn codex ENOENT."
     let answer: (value: unknown) => void = () => undefined
     mocks.call.mockImplementationOnce(
@@ -327,14 +485,15 @@ describe('a send the host rejected because the agent never started', () => {
     )
     const target = { kind: 'local' } as const
     const { result, rerender } = renderHook(
-      (props: { submissions: AgentJournalSubmission[] }) =>
+      (props: OutboxProps) =>
         useStructuredAgentSessionOutbox({
+          journalItems: props.rows ?? NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target,
           fence: 1,
           submissions: props.submissions
         }),
-      { initialProps: { submissions: NO_SUBMISSIONS } }
+      { initialProps: outboxProps(NO_SUBMISSIONS) }
     )
 
     act(() => expect(result.current.send('hello')).toBe(true))
@@ -343,19 +502,51 @@ describe('a send the host rejected because the agent never started', () => {
 
     // A start refused at once: the rejection frame lands before the send's own `pending` answer.
     rerender({
-      submissions: [{ ...pendingResultFor(id).value.submission, dispatchState: 'rejected', reason }]
+      submissions: [
+        { ...pendingResultFor(id).value.submission, dispatchState: 'rejected', reason }
+      ],
+      rows: rowsFor(id)
     })
-    await waitFor(() => expect(result.current.outbox[0]?.state).toBe('rejected'))
+    await waitFor(() => expect(result.current.outbox).toEqual([]))
+    // The late `pending` answer must not bring it back.
     await act(async () => answer(pendingResultFor(id)))
 
-    expect(result.current.outbox[0]?.state).toBe('rejected')
-    expect(shownFailure(result.current.outbox[0])).toBe(reason)
+    expect(result.current.outbox).toEqual([])
     expect(result.current.error).toBeNull()
   })
 })
 
 const NO_SUBMISSIONS: AgentJournalSubmission[] = []
 
+/** The host's rows for these messages, loaded. */
+function rowsFor(...ids: string[]): AgentJournalRenderItem[] {
+  return ids.map((id, index) => ({
+    itemId: agentJournalSubmissionKey(id),
+    revision: 1,
+    sequence: index + 1,
+    observedAt: index + 1,
+    body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: id }] }
+  }))
+}
+
+function rejectedBeforeRestart(): StructuredAgentSessionOutboxEntry {
+  return {
+    ...createStructuredAgentSessionOutboxEntry({
+      clientMessageId: 'rejected-before-restart',
+      sessionId: 'session-1',
+      text: 'first',
+      attachments: [],
+      queuedAt: 1
+    }),
+    state: 'rejected',
+    lastFailure: {
+      kind: 'rejected',
+      reason: 'The provider did not accept this message.',
+      rejection: { kind: 'providerRejected' }
+    }
+  }
+}
+
 function pendingResultFor(clientMessageId: string) {
   const submission: AgentJournalSubmission = {
     clientMessageId,
@@ -426,6 +617,7 @@ describe('a send refused while its agent restarted', () => {
     const { result, rerender } = renderHook(
       ({ fence, submissions }: { fence: number; submissions: AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence,
@@ -485,6 +677,7 @@ describe('a send the host refused by throwing', () => {
     )
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: { kind: 'local' },
         fence: 1,
@@ -525,6 +718,7 @@ describe('a send refused on a journal a newer Orca wrote', () => {
     })
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: { kind: 'local' },
         fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-relaunch-hold.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-relaunch-hold.test.tsx
index 5ef47af4f69..c40123377ea 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-relaunch-hold.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-relaunch-hold.test.tsx
@@ -28,6 +28,10 @@ import { createStructuredAgentSessionOutboxEntry } from '../../../../shared/stru
 import { writeOutbox } from './structured-agent-session-outbox-storage'
 import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
 
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 const SESSION = 'session-1'
 // Stable, as the view passes it: a new object each render would re-run the owner-change requeue.
 const LOCAL_TARGET = { kind: 'local' } as const
@@ -96,6 +100,7 @@ function mount(fence = 1) {
   return renderHook(
     ({ fence: current }: { fence: number }) =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: SESSION,
         target: LOCAL_TARGET,
         fence: current,
@@ -423,6 +428,7 @@ describe('a message whose send could not be saved before it went out', () => {
     const { result, rerender } = renderHook(
       ({ fence }: { fence: number | null }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: SESSION,
           target: LOCAL_TARGET,
           fence,
@@ -541,6 +547,7 @@ describe('a held message whose id expired', () => {
     mocks.call.mockResolvedValue(expired())
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: SESSION,
         target: LOCAL_TARGET,
         fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-unconfirmed-probe.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-unconfirmed-probe.ts
index 1d70ad86b88..819995bee0f 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-unconfirmed-probe.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-unconfirmed-probe.ts
@@ -1,6 +1,7 @@
 import { useEffect, useLayoutEffect, useRef } from 'react'
 import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
 import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
+import { structuredAgentSessionEntryResendsUnconfirmed } from '../../../../shared/structured-agent-session-outbox-unconfirmed-resend'
 import {
   commitStructuredAgentSessionOutbox,
   getStructuredAgentSessionOutbox
@@ -40,17 +41,15 @@ export function useStructuredAgentSessionOutboxUnconfirmedProbe(args: {
   // A non-null `retryAfterUnknownSubmittedAt` means the user already retried, so
   // another request would repeat that explicit action. Only entries that have
   // never been retried, and that no Stop outlived, are safe to probe automatically.
+  // The delivery notices read the same rule: while it is resent here, its row says it is sending.
   const probeId =
     blocker &&
     blocker.sessionId === sessionId &&
-    blocker.retryAfterUnknownSubmittedAt === null &&
-    blocker.outlivedStop !== true
+    structuredAgentSessionEntryResendsUnconfirmed(blocker, submissions)
       ? blocker.clientMessageId
       : null
-  const probeSettled =
-    probeId !== null && submissions.some((submission) => submission.clientMessageId === probeId)
   useEffect(() => {
-    if (probeId === null || probeSettled || !owner.attached) {
+    if (probeId === null || !owner.attached) {
       return
     }
     const attempts = probeAttemptsRef.current.id === probeId ? probeAttemptsRef.current.attempts : 0
@@ -70,5 +69,5 @@ export function useStructuredAgentSessionOutboxUnconfirmedProbe(args: {
       Math.min(UNCONFIRMED_PROBE_BASE_DELAY_MS * 2 ** attempts, UNCONFIRMED_PROBE_MAX_DELAY_MS)
     )
     return () => clearTimeout(timer)
-  }, [owner.attached, owner.ownerChange, owner.targetKey, probeId, probeSettled, sessionId])
+  }, [owner.attached, owner.ownerChange, owner.targetKey, probeId, sessionId])
 }
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-withdrawal.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-withdrawal.test.tsx
index 1c7d69f1aa7..4e815c9252f 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-withdrawal.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-withdrawal.test.tsx
@@ -5,7 +5,10 @@
 
 import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
 import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
 import {
   hasUnsentStructuredAgentSessionOutboxEntry,
@@ -25,6 +28,8 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 import { readOutbox } from './structured-agent-session-outbox-storage'
 
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 // One object: a target rebuilt each render reads as a new owner, which re-sends what is on its way.
 const TARGET = { kind: 'local' } as const
 
@@ -82,6 +87,7 @@ describe('a Stop withdrawing what the host does not hold', () => {
     )
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: TARGET,
         fence: 1,
@@ -147,6 +153,7 @@ describe('a Stop withdrawing what the host does not hold', () => {
     mocks.call.mockRejectedValue(new Error('the host refused the frame'))
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: TARGET,
         fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.batch-churn.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.batch-churn.test.tsx
new file mode 100644
index 00000000000..26e46bd2bbf
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.batch-churn.test.tsx
@@ -0,0 +1,117 @@
+// @vitest-environment happy-dom
+
+// The outbox re-reads the journal on every batch; a batch that settles nothing writes nothing, so a
+// message left in doubt costs no storage write per streamed delta. And a copy the host recorded and
+// rejected owes no delivery, so it keeps no hidden pane reading the journal.
+
+import { act, cleanup, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
+import { createStructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: vi.fn(() => new Promise(() => {}))
+}))
+
+import {
+  hasUndeliveredStructuredAgentSessionOutbox,
+  writeOutbox
+} from './structured-agent-session-outbox-storage'
+import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
+
+afterEach(cleanup)
+
+beforeEach(() => {
+  localStorage.clear()
+})
+
+const SESSION = 'session-churn'
+
+function stored(
+  id: string,
+  patch: Partial<ReturnType<typeof createStructuredAgentSessionOutboxEntry>>
+) {
+  return {
+    ...createStructuredAgentSessionOutboxEntry({
+      clientMessageId: id,
+      sessionId: SESSION,
+      text: id,
+      attachments: [],
+      queuedAt: 1
+    }),
+    ...patch
+  }
+}
+
+function inDoubt(clientMessageId: string): AgentJournalSubmission {
+  return {
+    clientMessageId,
+    fence: 1,
+    payloadFingerprint: clientMessageId,
+    dispatchState: 'unknown',
+    providerItemId: null,
+    reason: 'in doubt',
+    submittedAt: 5,
+    resolvedAt: 6
+  }
+}
+
+function streamed(sequence: number): AgentJournalRenderItem[] {
+  return [
+    {
+      itemId: `answer-${sequence}`,
+      revision: sequence,
+      sequence,
+      observedAt: sequence,
+      body: { kind: 'message', role: 'assistant', blocks: [{ type: 'text', text: 'streaming' }] }
+    }
+  ]
+}
+
+it('writes nothing to storage across 50 batches while a message waits in doubt', async () => {
+  writeOutbox(SESSION, [stored('doubt', { state: 'dispatching', lastAttemptAt: 2 })])
+  const { rerender } = renderHook(
+    (props: { items: AgentJournalRenderItem[]; submissions: AgentJournalSubmission[] }) =>
+      useStructuredAgentSessionOutbox({
+        sessionId: SESSION,
+        target: { kind: 'local' },
+        fence: 1,
+        submissions: props.submissions,
+        journalItems: props.items
+      }),
+    { initialProps: { items: streamed(1), submissions: [inDoubt('doubt')] } }
+  )
+  await act(async () => {})
+  const writes = vi.spyOn(localStorage, 'setItem')
+
+  for (let sequence = 2; sequence <= 51; sequence += 1) {
+    // Each batch is a new journal array and a new submissions array with the same content.
+    rerender({ items: streamed(sequence), submissions: [inDoubt('doubt')] })
+  }
+  await act(async () => {})
+
+  expect(writes).not.toHaveBeenCalled()
+  writes.mockRestore()
+})
+
+it('counts a copy the host recorded and rejected as owing no delivery', () => {
+  writeOutbox(SESSION, [
+    stored('recorded', {
+      state: 'rejected',
+      lastFailure: { kind: 'rejected', reason: 'Orca restarted before this message was sent.' }
+    })
+  ])
+  expect(hasUndeliveredStructuredAgentSessionOutbox(SESSION)).toBe(false)
+
+  writeOutbox(SESSION, [
+    stored('recorded', {
+      state: 'rejected',
+      lastFailure: { kind: 'rejected', reason: 'Orca restarted before this message was sent.' }
+    }),
+    stored('waiting', {})
+  ])
+  expect(hasUndeliveredStructuredAgentSessionOutbox(SESSION)).toBe(true)
+})
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.draft-hand-off.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.draft-hand-off.test.tsx
index ff13958f160..61fc0685816 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.draft-hand-off.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.draft-hand-off.test.tsx
@@ -7,7 +7,10 @@
 
 import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
 import { createStructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
 import { DISPATCH_REJECTED_CANCELLED } from '../../../../shared/structured-agent-session-dispatch-rejection'
 import {
@@ -28,6 +31,8 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 import { writeOutbox } from './structured-agent-session-outbox-storage'
 
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 // Why: every hook here shares the session outbox store; one left mounted would drain the next test's.
 afterEach(cleanup)
 
@@ -77,6 +82,7 @@ function renderOutbox() {
   return renderHook(
     (props: Props) =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: TARGET,
         fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.external-send.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.external-send.test.tsx
index 95d9021413a..0cb70aab14b 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.external-send.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.external-send.test.tsx
@@ -15,6 +15,10 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
 import { appendStructuredAgentSessionOutboxMessage } from './structured-agent-session-outbox-storage'
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 afterEach(cleanup)
 
 beforeEach(() => {
@@ -39,6 +43,7 @@ it('delivers a message queued from outside the chat through the open outbox', as
   })
   const { result } = renderHook(() =>
     useStructuredAgentSessionOutbox({
+      journalItems: NO_JOURNAL_ITEMS,
       sessionId: 'session-1',
       target: { kind: 'local' },
       fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.queue-delivery.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.queue-delivery.test.tsx
index 26e0fd71112..fadb4440534 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.queue-delivery.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.queue-delivery.test.tsx
@@ -31,6 +31,10 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 import { readOutbox } from './structured-agent-session-outbox-storage'
 
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 // Why: every hook here shares the session outbox store; one left mounted would drain the next test's.
 afterEach(cleanup)
 
@@ -53,6 +57,7 @@ function queuedReceipt(clientMessageId: string) {
 function renderOutbox(queue: boolean) {
   return renderHook(() =>
     useStructuredAgentSessionOutbox({
+      journalItems: NO_JOURNAL_ITEMS,
       sessionId: 'session-1',
       target: LOCAL_TARGET,
       fence: 1,
@@ -154,6 +159,7 @@ describe('outbox queue delivery selection', () => {
     const first = renderHook(
       (props: { queuedMessageIds: string[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -184,6 +190,7 @@ describe('outbox queue delivery selection', () => {
     const view = renderHook(
       (props: { queuedMessageIds: string[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -252,6 +259,7 @@ describe('outbox queue delivery selection', () => {
     }))
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: 1,
@@ -306,6 +314,7 @@ async function attemptedQueueSend() {
   const view = renderHook(
     (props: { capability: StructuredAgentSessionQueueCapability }) =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.rejected-reply.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.rejected-reply.test.tsx
new file mode 100644
index 00000000000..bfebc877b2c
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.rejected-reply.test.tsx
@@ -0,0 +1,102 @@
+// @vitest-environment happy-dom
+
+// A send whose own reply says the host recorded it and then rejected it is shown once, in the chat
+// where it was sent; its text never also goes back to the composer.
+
+import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
+import { agentJournalSubmissionKey } from '../../../../shared/agent-session-journal-item-key'
+import { DISPATCH_REJECTED_NOT_DELIVERED } from '../../../../shared/structured-agent-session-dispatch-rejection'
+
+type SendParams = { envelope: { clientOperationId: string; payloadFingerprint: string } }
+
+const mocks = vi.hoisted(() => ({
+  call: vi.fn<(target: unknown, method: string, params: SendParams) => Promise<unknown>>()
+}))
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.call
+}))
+
+import {
+  clearNativeChatDraftCacheForTests,
+  readNativeChatDraftCache
+} from './native-chat-draft-cache'
+import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
+import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
+const NO_CARDS: readonly string[] = []
+
+afterEach(cleanup)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  localStorage.clear()
+  clearNativeChatDraftCacheForTests()
+})
+
+it('draws a send its reply rejected in place once, and leaves the composer empty', async () => {
+  const reply: { submission: AgentJournalSubmission | null } = { submission: null }
+  mocks.call.mockImplementationOnce(async (_target, _method, { envelope }) => {
+    const rejected: AgentJournalSubmission = {
+      clientMessageId: envelope.clientOperationId,
+      fence: 1,
+      payloadFingerprint: envelope.payloadFingerprint,
+      dispatchState: 'rejected',
+      providerItemId: null,
+      reason: DISPATCH_REJECTED_NOT_DELIVERED,
+      rejection: { kind: 'notDelivered' },
+      submittedAt: 10,
+      resolvedAt: 11
+    }
+    reply.submission = rejected
+    return {
+      ok: true,
+      replayed: false,
+      fence: 1,
+      cursor: { epoch: 'epoch-1', sequence: 10 },
+      value: { clientMessageId: envelope.clientOperationId, submission: rejected }
+    }
+  })
+  const { result } = renderHook(() =>
+    useStructuredAgentSessionOutbox({
+      journalItems: NO_JOURNAL_ITEMS,
+      sessionId: 'session-1',
+      target: { kind: 'local' },
+      fence: 1,
+      submissions: [],
+      composerScopeKey: 'pane-1'
+    })
+  )
+
+  act(() => expect(result.current.send('steer this way')).toBe(true))
+  await waitFor(() => expect(result.current.outbox[0]?.state).toBe('rejected'))
+  expect(readNativeChatDraftCache('pane-1')).toBe('')
+
+  const submission = reply.submission
+  if (!submission) {
+    throw new Error('the send was never answered')
+  }
+  const hostItem: AgentJournalRenderItem = {
+    itemId: agentJournalSubmissionKey(submission.clientMessageId),
+    revision: 1,
+    sequence: 10,
+    observedAt: 10,
+    body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'steer this way' }] }
+  }
+  const users = (outbox: typeof result.current.outbox) =>
+    projectStructuredAgentSessionMessages([hostItem], outbox, [submission], NO_CARDS)
+      .filter((message) => message.role === 'user')
+      .map((message) => ({ id: message.id, unsent: message.unsent }))
+
+  expect(users(result.current.outbox)).toEqual([{ id: hostItem.itemId, unsent: true }])
+  // After a crash takes the outbox, the host's row is still the one row.
+  expect(users([])).toEqual([{ id: hostItem.itemId, unsent: true }])
+  expect(readNativeChatDraftCache('pane-1')).toBe('')
+})
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.stop-parks-in-doubt.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.stop-parks-in-doubt.test.tsx
index 293d9719bc0..45d87f26f66 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.stop-parks-in-doubt.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.stop-parks-in-doubt.test.tsx
@@ -25,6 +25,10 @@ import {
   readNativeChatDraftCache
 } from './native-chat-draft-cache'
 
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 // Why: every hook here shares the session outbox store; one left mounted would drain the next test's.
 afterEach(cleanup)
 
@@ -66,6 +70,7 @@ describe('a Stop with a queued send in doubt', () => {
     const view = renderHook(
       (props: { fence: number | null }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: REMOTE,
           fence: props.fence,
@@ -110,6 +115,7 @@ describe('a Stop with a queued send in doubt', () => {
     mocks.call.mockImplementationOnce(() => answer.promise)
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: TARGET,
         fence: 1,
@@ -170,6 +176,7 @@ describe('a Stop with a queued send in doubt', () => {
     ])
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: TARGET,
         fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
index 422d94b618a..f9957ed41cc 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
@@ -4,7 +4,10 @@ import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
 import { useLayoutEffect } from 'react'
 import { createRoot } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
 import type { AgentSessionWireRefusalCode } from '../../../../shared/agent-session-wire'
 import { enqueueStructuredAgentSessionLaunchPrompt } from './structured-agent-session-outbox-storage'
 
@@ -19,6 +22,16 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 import { settleStructuredAgentLaunchPrompt } from '@/lib/structured-agent-session-launch-prompt'
 
+const hostRow = (id: string): AgentJournalRenderItem => ({
+  itemId: `orca:${id}`,
+  revision: 1,
+  sequence: 1,
+  observedAt: 1,
+  body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: id }] }
+})
+
+const NO_JOURNAL_ITEMS: readonly AgentJournalRenderItem[] = []
+
 // Why: every hook here shares the session outbox store; one left mounted would drain the next test's.
 afterEach(cleanup)
 
@@ -149,6 +162,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ fence }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence,
@@ -190,6 +204,7 @@ describe('useStructuredAgentSessionOutbox', () => {
 
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: 1,
@@ -211,6 +226,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ fence }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence,
@@ -245,6 +261,7 @@ describe('useStructuredAgentSessionOutbox', () => {
       mocks.call.mockResolvedValueOnce(refusedResult(code)).mockResolvedValueOnce(acceptedResult(1))
       const { result } = renderHook(() =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -277,6 +294,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -316,6 +334,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -346,6 +365,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -375,6 +395,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -400,6 +421,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -431,6 +453,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     })
     const first = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: 1,
@@ -445,6 +468,7 @@ describe('useStructuredAgentSessionOutbox', () => {
 
     const restored = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: 1,
@@ -476,6 +500,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -515,6 +540,7 @@ describe('useStructuredAgentSessionOutbox', () => {
       .mockResolvedValueOnce(acceptedResult(1))
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: 1,
@@ -544,6 +570,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     })
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: 1,
@@ -581,6 +608,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     mocks.call.mockResolvedValue(acceptedResult(1))
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId: 'session-1',
         target: LOCAL_TARGET,
         fence: 1,
@@ -628,6 +656,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -667,12 +696,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     expect(retryParams?.retryUnknown).toBeUndefined()
   })
 
-  it('rotates a history-rejected unknown head so the queued tail can advance', async () => {
-    // oxlint-disable-next-line no-restricted-properties -- stubbing the global the generator reads, to pin ids in this test
-    vi.mocked(globalThis.crypto.randomUUID)
-      .mockReturnValueOnce('aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa')
-      .mockReturnValueOnce('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb')
-      .mockReturnValueOnce('cccccccc-cccc-4ccc-8ccc-cccccccccccc')
+  it('lets a history-rejected unknown head go to the journal so the queued tail advances', async () => {
     mocks.call
       .mockImplementationOnce(async (_target, _method, params) => {
         const clientMessageId = (params as { envelope: { clientOperationId: string } }).envelope
@@ -684,14 +708,11 @@ describe('useStructuredAgentSessionOutbox', () => {
           .clientOperationId
         return acceptedResultFor(clientMessageId, 11)
       })
-      .mockImplementationOnce(async (_target, _method, params) => {
-        const clientMessageId = (params as { envelope: { clientOperationId: string } }).envelope
-          .clientOperationId
-        return acceptedResultFor(clientMessageId, 12)
-      })
+    let rows = NO_JOURNAL_ITEMS
     const { result, rerender } = renderHook(
       ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: rows,
           sessionId: 'session-1',
           target: LOCAL_TARGET,
           fence: 1,
@@ -704,6 +725,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     await waitFor(() => expect(result.current.outbox[0]?.state).toBe('unconfirmed'))
     const firstId = result.current.outbox[0]!.clientMessageId
     act(() => expect(result.current.send('second')).toBe(true))
+    rows = [hostRow(firstId)]
     rerender({
       submissions: [
         {
@@ -719,83 +741,13 @@ describe('useStructuredAgentSessionOutbox', () => {
       ]
     })
 
-    act(() => result.current.retry(firstId))
-    await waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(3))
+    // The host's row shows the first as not sent; nothing resends it.
+    await waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(2))
     await waitFor(() => expect(result.current.outbox).toHaveLength(0))
-    const retryParams = mocks.call.mock.calls[1]?.[2] as
-      | { envelope: { clientOperationId: string } }
-      | undefined
-    expect(retryParams?.envelope.clientOperationId).not.toBe(firstId)
-  })
-
-  it('rotates the id after a refused write and delivers the message exactly once', async () => {
-    // oxlint-disable-next-line no-restricted-properties -- stubbing the global the generator reads, to pin ids in this test
-    vi.mocked(globalThis.crypto.randomUUID)
-      .mockReturnValueOnce('aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa')
-      .mockReturnValueOnce('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb')
-    const writeFailed = (clientMessageId: string) => ({
-      clientMessageId,
-      fence: 1,
-      payloadFingerprint: 'fingerprint',
-      dispatchState: 'rejected' as const,
-      providerItemId: null,
-      reason: 'provider_write_failed: broken pipe',
-      submittedAt: 10,
-      resolvedAt: 10
+    expect(mocks.call.mock.calls[1]?.[2]).toMatchObject({ body: { blocks: [{ text: 'second' }] } })
+    expect(mocks.call.mock.calls[1]?.[2]).not.toMatchObject({
+      envelope: { clientOperationId: firstId }
     })
-    mocks.call
-      .mockImplementationOnce(async (_target, _method, params) => ({
-        ok: true,
-        replayed: false,
-        fence: 1,
-        cursor: { epoch: 'epoch-1', sequence: 10 },
-        value: {
-          clientMessageId: (params as { envelope: { clientOperationId: string } }).envelope
-            .clientOperationId,
-          submission: writeFailed(
-            (params as { envelope: { clientOperationId: string } }).envelope.clientOperationId
-          )
-        }
-      }))
-      .mockImplementationOnce(async (_target, _method, params) =>
-        acceptedResultFor(
-          (params as { envelope: { clientOperationId: string } }).envelope.clientOperationId,
-          11
-        )
-      )
-    const { result } = renderHook(
-      ({ submissions }: { submissions: readonly AgentJournalSubmission[] }) =>
-        useStructuredAgentSessionOutbox({
-          sessionId: 'session-1',
-          target: LOCAL_TARGET,
-          fence: 1,
-          submissions
-        }),
-      { initialProps: { submissions: [] as readonly AgentJournalSubmission[] } }
-    )
-
-    act(() => expect(result.current.send('first')).toBe(true))
-    await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
-    const firstId = mocks.call.mock.calls[0]![2].envelope.clientOperationId as string
-
-    // A refused write is answered, not doubted: the entry parks with its rejection rather than
-    // under the "delivery is unconfirmed" banner. The disposition tests pin its words.
-    await waitFor(() => expect(result.current.outbox[0]?.lastFailure?.kind).toBe('rejected'))
-    expect(result.current.outbox[0]?.state).toBe('rejected')
-
-    // Retry immediately, before the journal subscription can publish the rejected row.
-    act(() => result.current.retry(firstId))
-    await waitFor(() => expect(result.current.outbox).toHaveLength(0))
-
-    // Exactly one further delivery, under a new id, and with no `retryUnknown`:
-    // this is a first delivery of a new message, so it cannot duplicate.
-    expect(mocks.call).toHaveBeenCalledTimes(2)
-    const retryParams = mocks.call.mock.calls[1]?.[2] as {
-      envelope: { clientOperationId: string }
-      retryUnknown?: true
-    }
-    expect(retryParams.envelope.clientOperationId).not.toBe(firstId)
-    expect(retryParams.retryUnknown).toBeUndefined()
   })
 
   it('loads the new session outbox when a pane switches sessions', async () => {
@@ -808,6 +760,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ sessionId }: { sessionId: string }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId,
           target: LOCAL_TARGET,
           fence: 1,
@@ -840,6 +793,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     const { result, rerender } = renderHook(
       ({ sessionId }: { sessionId: string }) =>
         useStructuredAgentSessionOutbox({
+          journalItems: NO_JOURNAL_ITEMS,
           sessionId,
           target: LOCAL_TARGET,
           fence: 1,
@@ -869,6 +823,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     } = { current: null }
     function Probe({ sessionId }: { sessionId: string }): null {
       controllerRef.current = useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
         sessionId,
         target: LOCAL_TARGET,
         fence: 1,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
index 28bf17b8aa7..46f2f482e52 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
@@ -6,7 +6,10 @@ import {
   useState,
   useSyncExternalStore
 } from 'react'
-import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type {
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
 import { createStructuredAgentSessionOperationId } from '../../../../shared/structured-agent-session-mutation'
 import {
   admitStructuredAgentSessionOutboxEntry,
@@ -63,6 +66,8 @@ export function useStructuredAgentSessionOutbox(args: {
   target: RuntimeClientTarget
   fence: number | null
   submissions: readonly AgentJournalSubmission[]
+  /** The loaded journal rows: a rejected message stays here until the row that draws it loads. */
+  journalItems: readonly AgentJournalRenderItem[]
   /** The composer that gets back what a Stop withdrew from this client's outbox. */
   composerScopeKey?: string
   /** The host's queued-messages capability and the user's setting; a send stamped
@@ -76,6 +81,7 @@ export function useStructuredAgentSessionOutbox(args: {
   const {
     composerScopeKey,
     fence,
+    journalItems,
     queueDelivery = NO_QUEUE_DELIVERY,
     queuedMessageIds,
     sessionId,
@@ -147,15 +153,13 @@ export function useStructuredAgentSessionOutbox(args: {
         .map((submission) => submission.clientMessageId),
       ...handedOffQueuedMessageIds(submissions)
     ])
-    const next = reconcileStructuredAgentSessionOutboxWithQueue(current, submissions)
+    const next = reconcileStructuredAgentSessionOutboxWithQueue(current, submissions, journalItems)
     const admittedInFlight = journalAnswersInFlightSend(submissions, inFlightIdRef.current)
-    if (
-      admittedInFlight ||
-      next.some((entry, index) => entry !== current[index]) ||
-      next.length !== current.length
-    ) {
+    // The reconcile returns `current` itself when no entry changed, so a batch that changes
+    // nothing writes nothing.
+    if (admittedInFlight || next !== current) {
       restoreWithdrawn.byHost(current, submissions)
-      commitStructuredAgentSessionOutbox(sessionId, next)
+      commitStructuredAgentSessionOutbox(sessionId, [...next])
     }
     // Keyed on the entry actually in flight, which is no longer always the head: the journal
     // owning it outranks a send promise that has not settled, so release single-flight and make
@@ -174,7 +178,7 @@ export function useStructuredAgentSessionOutbox(args: {
     ) {
       setError(null)
     }
-  }, [restoreWithdrawn, sessionId, submissions])
+  }, [journalItems, restoreWithdrawn, sessionId, submissions])
 
   // The one place that owns the refs, the React state and the storage write.
   const applyDisposition = useCallback(
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.cut-turn-notice.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.cut-turn-notice.test.tsx
new file mode 100644
index 00000000000..fcb474f2acc
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.cut-turn-notice.test.tsx
@@ -0,0 +1,97 @@
+// @vitest-environment happy-dom
+
+import { renderHook } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
+
+const SCOPE = { kind: 'turn' as const, turnItemId: 'turn-1' }
+const items: AgentJournalRenderItem[] = [
+  {
+    itemId: 'user-1',
+    revision: 0,
+    sequence: 1,
+    observedAt: 1,
+    turnScope: { kind: 'thread' },
+    body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'long job' }] }
+  },
+  {
+    itemId: 'turn-1',
+    revision: 1,
+    sequence: 2,
+    observedAt: 2,
+    turnScope: { kind: 'thread' },
+    body: {
+      kind: 'turn',
+      turnId: 'turn-1',
+      userItemId: 'user-1',
+      state: 'interrupted',
+      startedAt: 2,
+      completedAt: 9
+    }
+  },
+  {
+    itemId: 'reply-1',
+    revision: 0,
+    sequence: 3,
+    observedAt: 3,
+    turnScope: SCOPE,
+    body: { kind: 'message', role: 'assistant', blocks: [{ type: 'text', text: 'half' }] }
+  }
+]
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), message: vi.fn() } }))
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: vi.fn(async () => null),
+  supportsStructuredAgentSessionQuietRepeatedStop: vi.fn(async () => false)
+}))
+vi.mock('./use-structured-agent-session-read', () => ({
+  useStructuredAgentSessionRead: () => ({
+    state: {
+      fence: 3,
+      items,
+      submissions: [],
+      status: 'ready',
+      error: null,
+      hasOlder: false,
+      handoff: null
+    },
+    loadingOlder: false,
+    loadOlder: vi.fn()
+  })
+}))
+vi.mock('./use-structured-agent-session-outbox', () => ({
+  structuredSessionOperationId: vi.fn(),
+  useStructuredAgentSessionOutbox: () => ({
+    outbox: [],
+    error: null,
+    send: vi.fn(),
+    retry: vi.fn()
+  })
+}))
+
+import { useStructuredAgentSession } from './use-structured-agent-session'
+
+describe('useStructuredAgentSession transcript', () => {
+  it('shows a cut turn no row explains with its one notice, placed in that turn', () => {
+    const { result } = renderHook(() =>
+      useStructuredAgentSession({
+        sessionId: 'session-1',
+        agent: 'codex',
+        target: { kind: 'local' },
+        isVisible: true
+      })
+    )
+
+    expect(result.current.messages.at(-1)).toMatchObject({
+      role: 'system',
+      blocks: [
+        {
+          text: 'Codex stopped while this response was in progress. You can continue in this conversation.',
+          tone: 'error'
+        }
+      ]
+    })
+    // The list places rows by the same items, so the notice joins the cut turn.
+    expect(result.current.journalItems.at(-1)).toMatchObject({ turnScope: SCOPE })
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.rejected-card.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.rejected-card.test.tsx
new file mode 100644
index 00000000000..b37350cb39d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.rejected-card.test.tsx
@@ -0,0 +1,116 @@
+// @vitest-environment happy-dom
+
+// The session controller hands the queue's live cards to the transcript: a rejected message one of
+// them holds under its own id is drawn as that card, never also as a not-sent row.
+
+import { renderHook } from '@testing-library/react'
+import { beforeEach, expect, it, vi } from 'vitest'
+import { agentJournalSubmissionKey } from '../../../../shared/agent-session-journal-item-key'
+import type {
+  AgentJournalMessageItem,
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
+import type { AgentSessionQueuedMessage } from '../../../../shared/agent-session-wire'
+import { DISPATCH_REJECTED_HOST_RESTARTED } from '../../../../shared/structured-agent-session-dispatch-rejection'
+
+let queuedMessages: AgentSessionQueuedMessage[] = []
+
+const KEPT_BODY: AgentJournalMessageItem = {
+  kind: 'message',
+  role: 'user',
+  blocks: [{ type: 'text', text: 'kept text' }]
+}
+
+const KEPT_ITEM: AgentJournalRenderItem = {
+  itemId: agentJournalSubmissionKey('kept'),
+  revision: 1,
+  sequence: 1,
+  observedAt: 1,
+  body: KEPT_BODY
+}
+
+const KEPT_SUBMISSION: AgentJournalSubmission = {
+  clientMessageId: 'kept',
+  fence: 3,
+  payloadFingerprint: 'fingerprint',
+  dispatchState: 'rejected',
+  providerItemId: null,
+  reason: DISPATCH_REJECTED_HOST_RESTARTED,
+  rejection: { kind: 'hostRestarted' },
+  submittedAt: 1,
+  resolvedAt: 2
+}
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: vi.fn(async () => null),
+  supportsStructuredAgentSessionPromptCancel: vi.fn(async () => false)
+}))
+
+vi.mock('./use-structured-agent-session-read', () => ({
+  useStructuredAgentSessionRead: () => ({
+    state: {
+      fence: 3,
+      items: [KEPT_ITEM],
+      submissions: [KEPT_SUBMISSION],
+      status: 'ready',
+      error: null,
+      hasOlder: false,
+      queuedMessages
+    },
+    loadingOlder: false,
+    loadOlder: vi.fn()
+  })
+}))
+
+vi.mock('./use-structured-agent-session-outbox', () => ({
+  structuredSessionOperationId: () => 'operation-1',
+  useStructuredAgentSessionOutbox: () => ({
+    outbox: [],
+    error: null,
+    send: vi.fn(),
+    retry: vi.fn(),
+    withdrawUnsent: vi.fn()
+  })
+}))
+
+import { useStructuredAgentSession } from './use-structured-agent-session'
+
+function card(messageId: string): AgentSessionQueuedMessage {
+  return {
+    messageId,
+    position: 1,
+    body: KEPT_BODY,
+    state: 'waiting'
+  }
+}
+
+function keptRows(): { id: string; unsent?: true }[] {
+  const { result, unmount } = renderHook(() =>
+    useStructuredAgentSession({
+      sessionId: 'session-1',
+      agent: 'claude',
+      target: { kind: 'local' },
+      isVisible: true,
+      composerScopeKey: 'scope-1'
+    })
+  )
+  const rows = result.current.messages
+    .filter((message) => message.id === KEPT_ITEM.itemId)
+    .map(({ id, unsent }) => ({ id, ...(unsent ? { unsent } : {}) }))
+  unmount()
+  return rows
+}
+
+beforeEach(() => {
+  queuedMessages = []
+})
+
+it('draws no row for a rejected message while a card holds it under its id', () => {
+  queuedMessages = [card('kept')]
+  expect(keptRows()).toEqual([])
+})
+
+it('draws it as not sent once no card holds it', () => {
+  expect(keptRows()).toEqual([{ id: KEPT_ITEM.itemId, unsent: true }])
+})
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.ts b/src/renderer/src/components/native-chat/use-structured-agent-session.ts
index 96ad805560d..0f126fe0559 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.ts
@@ -38,6 +38,8 @@ import { useStructuredAgentSessionQueuedMessages } from './use-structured-agent-
 import { outboxOutsideQueuedCards } from './structured-agent-session-queued-cards'
 import { structuredAgentSessionStartFailureFacts } from './structured-agent-session-delivery-notices'
 import { hostStatesTurnScopes } from '../../../../shared/native-chat-turn-membership'
+import { withNativeChatCutTurnNotices } from '../../../../shared/native-chat-cut-turn-notice'
+import { TUI_AGENT_DISPLAY_NAMES } from '../../../../shared/tui-agent-display-names'
 
 export type { StructuredPromptItem } from './structured-agent-session-message-projection'
 
@@ -120,6 +122,7 @@ export function useStructuredAgentSession(args: {
     target,
     fence: transportState.fence,
     submissions: transportState.submissions,
+    journalItems: transportState.journalItems,
     composerScopeKey,
     queueDelivery: { capability: queueCapability, enabled: queueFollowUps },
     queuedMessageIds
@@ -163,10 +166,19 @@ export function useStructuredAgentSession(args: {
       }),
     [isWorking, outbox, queueCapability, queueFollowUps, queuedMessageIds]
   )
+  // What the transcript reads: the journal plus the one notice a cut turn with no row gets.
+  const transcriptItems = useMemo(
+    () =>
+      withNativeChatCutTurnNotices(transportState.journalItems, {
+        agentName: TUI_AGENT_DISPLAY_NAMES[agent === 'codex' ? 'codex' : 'claude']
+      }),
+    [agent, transportState.journalItems]
+  )
   const messages = useStructuredAgentSessionMessages(
-    transportState.journalItems,
+    transcriptItems,
     transcriptOutbox,
-    transportState.submissions
+    transportState.submissions,
+    queuedMessageIds
   )
   const queuedController = useStructuredAgentSessionQueuedMessages({
     enabled: queueCapable && transportState.fence !== null,
@@ -198,7 +210,7 @@ export function useStructuredAgentSession(args: {
             { command }
           )
       }),
-    journalItems: transportState.journalItems,
+    journalItems: transcriptItems,
     subagentRoster: transportState.subagentRoster,
     messages,
     status: transportEnabled ? state.status : 'ready',
@@ -216,6 +228,8 @@ export function useStructuredAgentSession(args: {
     failedHere: outboxController.failedHere,
     /** The journal's rows for sent messages, which carry a rejected message's whole fact. */
     submissions: transportState.submissions,
+    /** The host's queued cards, which hold their own rejected hand-offs. */
+    queuedMessageIds,
     // A message typed during a command queues behind it on the host.
     send: (...input: Parameters<typeof outboxController.send>) =>
       // Legacy: an older host refuses sends while a command runs; removable once those hosts age out.
diff --git a/src/renderer/src/components/new-workspace/ComposerParentWorktreePicker.test.tsx b/src/renderer/src/components/new-workspace/ComposerParentWorktreePicker.test.tsx
index c512abcebdb..808c7ad7b28 100644
--- a/src/renderer/src/components/new-workspace/ComposerParentWorktreePicker.test.tsx
+++ b/src/renderer/src/components/new-workspace/ComposerParentWorktreePicker.test.tsx
@@ -88,56 +88,6 @@ vi.mock('@/components/ui/popover', async () => {
   }
 })
 
-vi.mock('@/components/ui/command', () => ({
-  Command: ({ children, className }: { children: React.ReactNode; className?: string }) => (
-    <div className={className}>{children}</div>
-  ),
-  CommandInput: ({
-    ref,
-    value,
-    placeholder,
-    onValueChange,
-    onKeyDown,
-    onKeyUp,
-    onCompositionStart,
-    onCompositionEnd
-  }: {
-    ref?: React.Ref<HTMLInputElement>
-    value?: string
-    placeholder?: string
-    onValueChange?: (value: string) => void
-    onKeyDown?: React.KeyboardEventHandler<HTMLInputElement>
-    onKeyUp?: React.KeyboardEventHandler<HTMLInputElement>
-    onCompositionStart?: React.CompositionEventHandler<HTMLInputElement>
-    onCompositionEnd?: React.CompositionEventHandler<HTMLInputElement>
-  }) => (
-    <input
-      ref={ref}
-      data-slot="command-input"
-      value={value}
-      placeholder={placeholder}
-      onChange={(event) => onValueChange?.(event.target.value)}
-      onKeyDown={onKeyDown}
-      onKeyUp={onKeyUp}
-      onCompositionStart={onCompositionStart}
-      onCompositionEnd={onCompositionEnd}
-    />
-  ),
-  CommandList: ({
-    ref,
-    children,
-    className
-  }: {
-    ref?: React.Ref<HTMLDivElement>
-    children: React.ReactNode
-    className?: string
-  }) => (
-    <div ref={ref} className={className}>
-      {children}
-    </div>
-  )
-}))
-
 // The virtual window needs real layout the test DOM has none of; render every row.
 vi.mock('@tanstack/react-virtual', () => ({
   useVirtualizer: ({ count }: { count: number }) => ({
diff --git a/src/renderer/src/components/new-workspace/ComposerParentWorktreePicker.tsx b/src/renderer/src/components/new-workspace/ComposerParentWorktreePicker.tsx
index 41c22978f14..df6cd92cf3e 100644
--- a/src/renderer/src/components/new-workspace/ComposerParentWorktreePicker.tsx
+++ b/src/renderer/src/components/new-workspace/ComposerParentWorktreePicker.tsx
@@ -6,10 +6,6 @@ import { Button } from '@/components/ui/button'
 import { Command, CommandInput, CommandList } from '@/components/ui/command'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { cn } from '@/lib/utils'
-import {
-  isImeCompositionKeyDown,
-  useImeEnterGestureOwnership
-} from '@/lib/ime-composition-keyboard-event'
 import { translate } from '@/i18n/i18n'
 import { useAppStore } from '@/store'
 import {
@@ -219,7 +215,6 @@ function ParentWorktreeCandidateList({
   const workspaceLineageByChildKey = useAppStore((s) => s.workspaceLineageByChildKey)
   const listRef = useRef<HTMLDivElement>(null)
   const inputRef = useRef<HTMLInputElement>(null)
-  const imeEnter = useImeEnterGestureOwnership()
   const optionIdPrefix = `${useId()}option`
   const [search, setSearch] = useState('')
   const [highlightedIndex, setHighlightedIndex] = useState(0)
@@ -307,11 +302,6 @@ function ParentWorktreeCandidateList({
   const handleKeyDown = useCallback(
     (event: React.KeyboardEvent<HTMLInputElement>) => {
       // Why: cmdk's root handler only knows the mounted virtual window, so own navigation here.
-      // A CJK confirm sends two Enter keydowns and only the first is marked, so the marked-only
-      // check must be paired with the gesture carry or the unmarked one commits a selection.
-      if (imeEnter.ownsKeyDown(event) || isImeCompositionKeyDown(event)) {
-        return
-      }
       const navigate = (nextIndex: number): void => {
         event.preventDefault()
         event.stopPropagation()
@@ -334,7 +324,7 @@ function ParentWorktreeCandidateList({
         }
       }
     },
-    [activeIndex, filtered, imeEnter, moveHighlight, onSelect]
+    [activeIndex, filtered, moveHighlight, onSelect]
   )
 
   // Why: cmdk's Input owns aria-activedescendant and points it at its own empty
@@ -352,9 +342,6 @@ function ParentWorktreeCandidateList({
         value={search}
         onValueChange={handleSearchChange}
         onKeyDown={handleKeyDown}
-        onKeyUp={imeEnter.onKeyUp}
-        onCompositionStart={() => imeEnter.setComposing(true)}
-        onCompositionEnd={() => imeEnter.setComposing(false)}
         wrapperClassName="shrink-0"
         placeholder={translate(
           'auto.components.ComposerParentWorktreePicker.searchPlaceholder',
diff --git a/src/renderer/src/components/new-workspace/ProjectCombobox.tsx b/src/renderer/src/components/new-workspace/ProjectCombobox.tsx
index 7d31007ddbc..b81fe005b38 100644
--- a/src/renderer/src/components/new-workspace/ProjectCombobox.tsx
+++ b/src/renderer/src/components/new-workspace/ProjectCombobox.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React, { useCallback, useMemo } from 'react'
 import { ChevronDown, FolderPlus } from 'lucide-react'
 import { Popover, PopoverAnchor, PopoverContent } from '@/components/ui/popover'
@@ -160,7 +161,7 @@ export default function ProjectCombobox({
             {committed && selected ? <ProjectOptionMark option={selected} /> : null}
           </span>
           <div className="relative min-w-0 flex-1 overflow-hidden">
-            <input
+            <ImeInput
               ref={inputRef}
               type="text"
               role="combobox"
diff --git a/src/renderer/src/components/new-workspace/RunTargetField.tsx b/src/renderer/src/components/new-workspace/RunTargetField.tsx
index 4694eae3070..3951ded529d 100644
--- a/src/renderer/src/components/new-workspace/RunTargetField.tsx
+++ b/src/renderer/src/components/new-workspace/RunTargetField.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React from 'react'
 import { ChevronDown, Cloud } from 'lucide-react'
 import { PopoverAnchor } from '@/components/ui/popover'
@@ -63,7 +64,7 @@ export default function RunTargetField({
           ) : null}
         </span>
         <div className="relative min-w-0 flex-1 overflow-hidden">
-          <input
+          <ImeInput
             ref={inputRef}
             type="text"
             role="combobox"
diff --git a/src/renderer/src/components/pull-request-page/mentions/textarea.tsx b/src/renderer/src/components/pull-request-page/mentions/textarea.tsx
index f272998204c..7af0efbfd93 100644
--- a/src/renderer/src/components/pull-request-page/mentions/textarea.tsx
+++ b/src/renderer/src/components/pull-request-page/mentions/textarea.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import React, { useCallback, useId, useMemo, useState } from 'react'
 import { cn } from '@/lib/utils'
 import { filterGitHubMentionOptions } from '@/components/github/github-mention-option-filter'
@@ -108,7 +109,7 @@ export function MentionTextarea({
           ))}
         </div>
       )}
-      <textarea
+      <ImeTextarea
         ref={textareaRef}
         role="combobox"
         aria-expanded={showSuggestions}
diff --git a/src/renderer/src/components/right-sidebar/AiVaultPanelHeader.tsx b/src/renderer/src/components/right-sidebar/AiVaultPanelHeader.tsx
index 6e4c805f6a5..141b75000a3 100644
--- a/src/renderer/src/components/right-sidebar/AiVaultPanelHeader.tsx
+++ b/src/renderer/src/components/right-sidebar/AiVaultPanelHeader.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import { useEffect, useRef } from 'react'
 import { LoaderCircle, RefreshCw, Search, X } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -149,7 +150,7 @@ export function AiVaultPanelHeader({
 
       <div className="mt-2 flex h-8 items-center gap-1.5 rounded-md border border-sidebar-border bg-input/50 px-2 focus-within:border-sidebar-ring focus-within:ring-[2px] focus-within:ring-sidebar-ring/30">
         <Search className="size-3.5 shrink-0 text-muted-foreground" />
-        <input
+        <ImeInput
           ref={searchInputRef}
           value={query}
           onChange={(event) => onQueryChange(event.target.value)}
diff --git a/src/renderer/src/components/right-sidebar/SearchQueryRow.tsx b/src/renderer/src/components/right-sidebar/SearchQueryRow.tsx
index 301b216f510..035d6409be7 100644
--- a/src/renderer/src/components/right-sidebar/SearchQueryRow.tsx
+++ b/src/renderer/src/components/right-sidebar/SearchQueryRow.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React from 'react'
 import { Search as SearchIcon, CaseSensitive, WholeWord, Regex, X, Loader2 } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -39,7 +40,7 @@ export function SearchQueryRow({
       data-ignore-file-explorer-keys="true"
     >
       <SearchIcon className="size-3.5 shrink-0 text-muted-foreground" />
-      <input
+      <ImeInput
         ref={inputRef}
         type="text"
         className="min-w-0 flex-1 bg-transparent py-1 text-xs text-foreground outline-none placeholder:text-muted-foreground/50"
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.ts
index 577b700a98c..d9e2b3e1d4d 100644
--- a/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.ts
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.ts
@@ -16,6 +16,7 @@ import { prepareAiVaultSessionContinuation } from './ai-vault-session-continuati
 import type { AgentSessionContinuationRequest } from '@/lib/agent-session-continuation'
 import { activateAiVaultStructuredSession } from '@/lib/activate-ai-vault-structured-session'
 import { isAgentSessionHandleProvider } from '../../../../shared/agent-session-provider-handle'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import {
   activateAiVaultResumeWorkspace,
   resumeAiVaultSessionInNewChat
@@ -161,7 +162,12 @@ export function useAiVaultSessionLaunchActions({
         )
         return
       }
-      void resumeAiVaultSessionInNewChat(session, session.agent, worktreeId)
+      void resumeAiVaultSessionInNewChat(
+        session,
+        session.agent,
+        worktreeId,
+        newAgentLaunchRequestId()
+      )
     },
     [activeWorktree?.id, activeWorktreeId]
   )
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-log-open.test.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-log-open.test.ts
index bde07f87540..6baa96675e6 100644
--- a/src/renderer/src/components/right-sidebar/ai-vault-session-log-open.test.ts
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-log-open.test.ts
@@ -44,11 +44,8 @@ function makeState(overrides: Partial<FakeState> = {}): FakeState {
   }
 }
 
-let authorizeMock: ReturnType<typeof vi.fn>
-
 beforeEach(() => {
-  authorizeMock = vi.fn().mockResolvedValue(undefined)
-  vi.stubGlobal('window', { api: { fs: { authorizeExternalPath: authorizeMock } } })
+  vi.stubGlobal('window', { api: { fs: {} } })
 })
 
 afterEach(() => {
@@ -57,13 +54,12 @@ afterEach(() => {
 })
 
 describe('openAiVaultSessionLogInOrca', () => {
-  it('authorizes the exact path and opens a permanent read-only local tab', async () => {
+  it('opens the exact path as a permanent read-only local tab', async () => {
     const state = makeState()
     getStateMock.mockReturnValue(state)
 
     await openAiVaultSessionLogInOrca({ filePath: LOG_PATH, executionHostId: 'local' })
 
-    expect(authorizeMock).toHaveBeenCalledWith({ targetPath: LOG_PATH })
     expect(state.openFile).toHaveBeenCalledTimes(1)
     const [file, options] = state.openFile.mock.calls[0]
     expect(file).toEqual({
@@ -85,7 +81,7 @@ describe('openAiVaultSessionLogInOrca', () => {
     expect(toastErrorMock).not.toHaveBeenCalled()
   })
 
-  it('withholds blank, remote, and synthetic paths without authorizing', async () => {
+  it('withholds blank, remote, and synthetic paths', async () => {
     const state = makeState()
     getStateMock.mockReturnValue(state)
 
@@ -96,30 +92,16 @@ describe('openAiVaultSessionLogInOrca', () => {
       executionHostId: 'local'
     })
 
-    expect(authorizeMock).not.toHaveBeenCalled()
     expect(state.openFile).not.toHaveBeenCalled()
   })
 
-  it('toasts and creates no tab when authorization rejects', async () => {
-    const state = makeState()
+  it('toasts and creates no tab when the workspace no longer exists', async () => {
+    const state = makeState({ worktreesByRepo: {}, folderWorkspaces: [] })
     getStateMock.mockReturnValue(state)
-    authorizeMock.mockRejectedValue(new Error('denied'))
 
     await openAiVaultSessionLogInOrca({ filePath: LOG_PATH, executionHostId: 'local' })
 
     expect(state.openFile).not.toHaveBeenCalled()
-    expect(toastErrorMock).toHaveBeenCalledWith("Couldn't open log — path not authorized.")
-  })
-
-  it('toasts and creates no tab when the workspace vanishes after authorization', async () => {
-    const state = makeState()
-    const stateAfter = makeState({ worktreesByRepo: {}, folderWorkspaces: [] })
-    getStateMock.mockReturnValueOnce(state).mockReturnValue(stateAfter)
-
-    await openAiVaultSessionLogInOrca({ filePath: LOG_PATH, executionHostId: 'local' })
-
-    expect(state.openFile).not.toHaveBeenCalled()
-    expect(stateAfter.openFile).not.toHaveBeenCalled()
     expect(toastErrorMock).toHaveBeenCalledWith(
       "Couldn't open log — workspace is no longer available."
     )
@@ -145,24 +127,4 @@ describe('openAiVaultSessionLogInOrca', () => {
     expect(toastMock).toHaveBeenCalledWith('Log is already open for editing.')
     expect(toastErrorMock).not.toHaveBeenCalled()
   })
-
-  it('shares one in-flight open for concurrent clicks of the same path', async () => {
-    const state = makeState()
-    getStateMock.mockReturnValue(state)
-    let resolveAuth: (() => void) | undefined
-    authorizeMock.mockImplementation(
-      () =>
-        new Promise<void>((resolve) => {
-          resolveAuth = resolve
-        })
-    )
-
-    const first = openAiVaultSessionLogInOrca({ filePath: LOG_PATH, executionHostId: 'local' })
-    const second = openAiVaultSessionLogInOrca({ filePath: LOG_PATH, executionHostId: 'local' })
-    resolveAuth?.()
-    await Promise.all([first, second])
-
-    expect(authorizeMock).toHaveBeenCalledTimes(1)
-    expect(state.openFile).toHaveBeenCalledTimes(1)
-  })
 })
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-log-open.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-log-open.ts
index 2f4b6ff495c..5b941719ad4 100644
--- a/src/renderer/src/components/right-sidebar/ai-vault-session-log-open.ts
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-log-open.ts
@@ -10,11 +10,6 @@ import { canOpenAiVaultSessionLogInOrca } from './ai-vault-session-path-actions'
 
 type AiVaultLogSession = Pick<AiVaultSession, 'filePath' | 'executionHostId'>
 
-// Why: rapid double-clicks of View Log during the authorize await must share one
-// in-flight open (and toast-once on failure) so a slow FS grant can't spawn
-// duplicate tabs or spam error toasts. Keyed by the exact requested path.
-const inFlightOpenPaths = new Set<string>()
-
 function worktreeStillExists(state: AppState, worktreeId: string): boolean {
   if (findWorktreeById(state.worktreesByRepo ?? {}, worktreeId)) {
     return true
@@ -44,8 +39,8 @@ function focusEditorContent(): void {
 /**
  * Open a local AI Vault session log inside Orca as a permanent, read-only editor
  * tab (or activate an existing tab without reducing its authority). Reuses
- * Orca's external-file authorize + `openFile` pipeline; it never grants write
- * capability by itself and never redirects the open to a remote host.
+ * Orca's external-file `openFile` pipeline; it never grants write capability by
+ * itself and never redirects the open to a remote host.
  */
 export async function openAiVaultSessionLogInOrca(session: AiVaultLogSession): Promise<void> {
   const filePath = session.filePath?.trim()
@@ -54,98 +49,73 @@ export async function openAiVaultSessionLogInOrca(session: AiVaultLogSession): P
   if (!filePath || !canOpenAiVaultSessionLogInOrca(session)) {
     return
   }
-  if (inFlightOpenPaths.has(filePath)) {
+  const state = useAppStore.getState()
+  const worktreeId = state.activeWorktreeId
+  if (!worktreeId) {
+    toast.error(
+      translate(
+        'auto.components.right.sidebar.aiVaultSessionLogOpen.workspaceGone',
+        "Couldn't open log — workspace is no longer available."
+      )
+    )
     return
   }
-  inFlightOpenPaths.add(filePath)
-  try {
-    const state = useAppStore.getState()
-    // Snapshot the invoking workspace/group before the authorization await so a
-    // delayed grant can't retarget the tab into a workspace the user moved to.
-    const worktreeId = state.activeWorktreeId
-    if (!worktreeId) {
-      toast.error(
-        translate(
-          'auto.components.right.sidebar.aiVaultSessionLogOpen.workspaceGone',
-          "Couldn't open log — workspace is no longer available."
-        )
+  const targetGroupId = state.activeGroupIdByWorktree?.[worktreeId] ?? undefined
+  // Why: an already-open *writable* tab must keep its edit authority — View Log
+  // only activates it and notifies. Local ownership only (runtimeEnvironmentId
+  // null) matches the tab this action would create/activate.
+  const existingWritableTab = state.openFiles.find(
+    (file) =>
+      file.filePath === filePath &&
+      file.mode === 'edit' &&
+      file.worktreeId === worktreeId &&
+      (file.runtimeEnvironmentId ?? null) === null &&
+      file.readOnly !== true
+  )
+
+  if (!worktreeStillExists(state, worktreeId)) {
+    toast.error(
+      translate(
+        'auto.components.right.sidebar.aiVaultSessionLogOpen.workspaceGone',
+        "Couldn't open log — workspace is no longer available."
       )
-      return
-    }
-    const targetGroupId = state.activeGroupIdByWorktree?.[worktreeId] ?? undefined
-    // Why: an already-open *writable* tab must keep its edit authority — View Log
-    // only activates it and notifies. Local ownership only (runtimeEnvironmentId
-    // null) matches the tab this action would create/activate.
-    const existingWritableTab = state.openFiles.find(
-      (file) =>
-        file.filePath === filePath &&
-        file.mode === 'edit' &&
-        file.worktreeId === worktreeId &&
-        (file.runtimeEnvironmentId ?? null) === null &&
-        file.readOnly !== true
     )
-
-    try {
-      // The exact scanned path is the authorization oracle; the user click is the
-      // trust gesture. Reuses Orca's existing external R/W open grant.
-      await window.api.fs.authorizeExternalPath({ targetPath: filePath })
-    } catch {
-      toast.error(
-        translate(
-          'auto.components.right.sidebar.aiVaultSessionLogOpen.notAuthorized',
-          "Couldn't open log — path not authorized."
-        )
-      )
-      return
-    }
-
-    const stateAfterAuth = useAppStore.getState()
-    if (!worktreeStillExists(stateAfterAuth, worktreeId)) {
-      toast.error(
-        translate(
-          'auto.components.right.sidebar.aiVaultSessionLogOpen.workspaceGone',
-          "Couldn't open log — workspace is no longer available."
-        )
-      )
-      return
-    }
-
-    stateAfterAuth.openFile(
-      {
-        filePath,
-        // Why: keep relativePath === filePath so the external-file contract reads
-        // the exact authorized path, not a worktree-relative reinterpretation.
-        relativePath: filePath,
-        worktreeId,
-        // Why: the path was discovered on the client-local host — pin local
-        // ownership so an active runtime can't reinterpret it as a remote path.
-        runtimeEnvironmentId: null,
-        language: detectLanguage(filePath),
-        mode: 'edit',
-        readOnly: true,
-        liveTail: true
-      },
-      {
-        preview: false,
-        // Why: a repeated View Log refreshes a non-dirty tab; the store skips the
-        // reload nonce for a dirty writable buffer (no buffer replacement).
-        forceContentReload: true,
-        suppressActiveRuntimeFallback: true,
-        targetGroupId
-      }
-    )
-
-    if (existingWritableTab) {
-      toast(
-        translate(
-          'auto.components.right.sidebar.aiVaultSessionLogOpen.alreadyEditable',
-          'Log is already open for editing.'
-        )
-      )
-    }
-
-    focusEditorContent()
-  } finally {
-    inFlightOpenPaths.delete(filePath)
+    return
   }
+
+  state.openFile(
+    {
+      filePath,
+      // Why: keep relativePath === filePath so the external-file contract reads
+      // the exact named path, not a worktree-relative reinterpretation.
+      relativePath: filePath,
+      worktreeId,
+      // Why: the path was discovered on the client-local host — pin local
+      // ownership so an active runtime can't reinterpret it as a remote path.
+      runtimeEnvironmentId: null,
+      language: detectLanguage(filePath),
+      mode: 'edit',
+      readOnly: true,
+      liveTail: true
+    },
+    {
+      preview: false,
+      // Why: a repeated View Log refreshes a non-dirty tab; the store skips the
+      // reload nonce for a dirty writable buffer (no buffer replacement).
+      forceContentReload: true,
+      suppressActiveRuntimeFallback: true,
+      targetGroupId
+    }
+  )
+
+  if (existingWritableTab) {
+    toast(
+      translate(
+        'auto.components.right.sidebar.aiVaultSessionLogOpen.alreadyEditable',
+        'Log is already open for editing.'
+      )
+    )
+  }
+
+  focusEditorContent()
 }
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-launch.test.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-launch.test.ts
index f0c307ae0ca..0dbc81ae4a4 100644
--- a/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-launch.test.ts
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-launch.test.ts
@@ -83,7 +83,7 @@ describe('resumeAiVaultSessionInNewChat', () => {
       return { sessionId: 'session-1', tab: { id: 'agent-session:session-1' }, settlement }
     })
 
-    await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1')
+    await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1', 'resume-click')
 
     expect(mocks.beginStructuredAgentSessionProvisionalLaunch).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -104,7 +104,7 @@ describe('resumeAiVaultSessionInNewChat', () => {
       settlement: Promise.resolve({ kind: 'failed', error })
     })
 
-    await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1')
+    await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1', 'resume-click')
     await vi.waitFor(() =>
       expect(mocks.toastError).toHaveBeenCalledWith(
         'Another chat is already holding this conversation.'
@@ -119,7 +119,7 @@ describe('resumeAiVaultSessionInNewChat', () => {
       settlement: Promise.resolve({ kind: 'visibility-unknown', sessionId: 'session-1' })
     })
 
-    await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1')
+    await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1', 'resume-click')
     await Promise.resolve()
     expect(mocks.toastError).not.toHaveBeenCalled()
   })
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-launch.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-launch.ts
index dbf98a13cfb..b309dd31de3 100644
--- a/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-launch.ts
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-launch.ts
@@ -7,6 +7,7 @@ import { hasRuntimeRpcErrorCode } from '../../../../shared/runtime-rpc-error-cod
 import { parseWorkspaceKey } from '../../../../shared/workspace-scope'
 import { prepareAiVaultSessionForResume } from '@/lib/ai-vault-session-resume-preparation'
 import { adoptAgentSessionLaunchVerdict } from '@/lib/agent-session-launch-plan'
+import type { AgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import {
   activateAndRevealFolderWorkspace,
   activateAndRevealWorktree
@@ -28,7 +29,8 @@ export function activateAiVaultResumeWorkspace(workspaceId: string): boolean {
 export async function resumeAiVaultSessionInNewChat(
   session: AiVaultSession,
   agent: AgentSessionHandleProvider,
-  worktreeId: string
+  worktreeId: string,
+  requestId: AgentLaunchRequestId
 ): Promise<void> {
   try {
     // Codex rows can live under a shared legacy home; the same preparation the terminal resume
@@ -36,6 +38,7 @@ export async function resumeAiVaultSessionInNewChat(
     const preparedSession = await prepareAiVaultSessionForResume(session)
     const plan = adoptAgentSessionLaunchVerdict({
       route: 'structured-native-chat',
+      requestId,
       agent,
       worktreeId,
       resumeFrom: { providerSessionId: preparedSession.sessionId }
diff --git a/src/renderer/src/components/right-sidebar/checks-panel/active-content.tsx b/src/renderer/src/components/right-sidebar/checks-panel/active-content.tsx
index 9f1cc498e31..767913b6559 100644
--- a/src/renderer/src/components/right-sidebar/checks-panel/active-content.tsx
+++ b/src/renderer/src/components/right-sidebar/checks-panel/active-content.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React from 'react'
 import { Check, LoaderCircle, Pencil, X } from 'lucide-react'
 import { toast } from 'sonner'
@@ -152,7 +153,7 @@ export function ChecksPanelActiveContent({
         {/* Review title */}
         {editingTitle ? (
           <div className="flex items-center gap-1">
-            <input
+            <ImeInput
               ref={titleInputRef}
               className="flex-1 text-[12px] bg-background border border-border rounded px-2 py-1 text-foreground outline-none focus:ring-1 focus:ring-ring"
               value={titleDraft}
diff --git a/src/renderer/src/components/right-sidebar/file-explorer-drag-scroll-marker.test.tsx b/src/renderer/src/components/right-sidebar/file-explorer-drag-scroll-marker.test.tsx
index d14caca306a..039854bf0d8 100644
--- a/src/renderer/src/components/right-sidebar/file-explorer-drag-scroll-marker.test.tsx
+++ b/src/renderer/src/components/right-sidebar/file-explorer-drag-scroll-marker.test.tsx
@@ -267,7 +267,6 @@ function HandlersProbe({ scrollRef }: { scrollRef: React.RefObject<HTMLDivElemen
     toggleDir: vi.fn(),
     loadDir: vi.fn(),
     statPath: vi.fn(),
-    authorizeExternalPath: vi.fn(),
     markPathAsDirectory: vi.fn(),
     setSelectedPath: vi.fn(),
     scrollRef
diff --git a/src/renderer/src/components/right-sidebar/file-explorer-inline-input-ime-enter.test.tsx b/src/renderer/src/components/right-sidebar/file-explorer-inline-input-ime-enter.test.tsx
new file mode 100644
index 00000000000..4c6b8fc6d6e
--- /dev/null
+++ b/src/renderer/src/components/right-sidebar/file-explorer-inline-input-ime-enter.test.tsx
@@ -0,0 +1,182 @@
+// @vitest-environment happy-dom
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, fireEvent, render } from '@testing-library/react'
+import { InlineInputRow } from './file-explorer-inline-input-row'
+import type { InlineInput } from './file-explorer-inline-input-row'
+
+const newFileInput: InlineInput = {
+  parentPath: '/repo/src',
+  type: 'file',
+  depth: 1
+}
+
+// Why: the input focuses itself a frame after mount, then arms itself once the
+// 200ms menu-close grace period has elapsed.
+async function advance(ms: number): Promise<void> {
+  await act(async () => {
+    vi.advanceTimersByTime(ms)
+    await Promise.resolve()
+  })
+}
+
+async function settleInlineInput(): Promise<void> {
+  await advance(0)
+  await advance(250)
+}
+
+// Why: the carry armed by a confirm Enter expires on the animation frame after keyup.
+async function flushFrame(): Promise<void> {
+  await advance(20)
+}
+
+function renderNewFileRow(): {
+  input: HTMLElement
+  onSubmit: ReturnType<typeof vi.fn>
+  onCancel: ReturnType<typeof vi.fn>
+  rerenderWith: (inlineInput: InlineInput) => HTMLElement
+} {
+  const onSubmit = vi.fn()
+  const onCancel = vi.fn()
+  const renderRow = (inlineInput: InlineInput): React.JSX.Element => (
+    <InlineInputRow depth={1} inlineInput={inlineInput} onSubmit={onSubmit} onCancel={onCancel} />
+  )
+  const view = render(renderRow(newFileInput))
+  const rerenderWith = (inlineInput: InlineInput): HTMLElement => {
+    view.rerender(renderRow(inlineInput))
+    return view.getByRole('textbox')
+  }
+  return { input: view.getByRole('textbox'), onSubmit, onCancel, rerenderWith }
+}
+
+describe('file explorer inline input with an IME', () => {
+  beforeEach(() => vi.useFakeTimers())
+  afterEach(() => {
+    cleanup()
+    vi.useRealTimers()
+  })
+
+  it('ignores every marked confirm Enter, then submits the full name on a plain Enter', async () => {
+    const { input, onSubmit, onCancel } = renderNewFileRow()
+    await settleInlineInput()
+
+    fireEvent.change(input, { target: { value: '議事録' } })
+    const markedConfirmEnters = [
+      { key: 'Enter', isComposing: true },
+      { key: 'Enter', isComposing: true, keyCode: 229 },
+      { key: 'Enter', keyCode: 229 }
+    ]
+    for (const markedEnter of markedConfirmEnters) {
+      fireEvent.keyDown(input, markedEnter)
+      fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+      await flushFrame()
+    }
+    expect(onSubmit).not.toHaveBeenCalled()
+
+    fireEvent.change(input, { target: { value: '議事録.md' } })
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+
+    expect(onSubmit).toHaveBeenCalledTimes(1)
+    expect(onSubmit).toHaveBeenCalledWith('議事録.md')
+    expect(onCancel).not.toHaveBeenCalled()
+  })
+
+  it('swallows the unmarked Enter redispatched after a confirm until the carry expires', async () => {
+    const { input, onSubmit } = renderNewFileRow()
+    await settleInlineInput()
+    fireEvent.change(input, { target: { value: '議事録' } })
+
+    // macOS order: marked keydown, keyup, then the unmarked redispatch.
+    fireEvent.keyDown(input, { key: 'Enter', isComposing: true, keyCode: 229 })
+    fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+    expect(onSubmit).not.toHaveBeenCalled()
+    await flushFrame()
+
+    // Windows/Linux order: the unmarked redispatch arrives before keyup.
+    fireEvent.keyDown(input, { key: 'Enter', isComposing: true, keyCode: 229 })
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+    fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+    expect(onSubmit).not.toHaveBeenCalled()
+    await flushFrame()
+
+    fireEvent.change(input, { target: { value: '議事録.md' } })
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+
+    expect(onSubmit).toHaveBeenCalledTimes(1)
+    expect(onSubmit).toHaveBeenCalledWith('議事録.md')
+  })
+
+  it('releases composition ownership on blur even when compositionend never arrives', async () => {
+    const { input, onSubmit } = renderNewFileRow()
+    await settleInlineInput()
+
+    fireEvent.compositionStart(input)
+    fireEvent.change(input, { target: { value: '議事録.md' } })
+    fireEvent.blur(input)
+    // Refocusing cancels the component's 150ms blur-commit, so only Enter can submit.
+    fireEvent.focus(input)
+    await advance(200)
+    expect(onSubmit).not.toHaveBeenCalled()
+
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+
+    expect(onSubmit).toHaveBeenCalledTimes(1)
+    expect(onSubmit).toHaveBeenCalledWith('議事録.md')
+  })
+
+  it('drops composition ownership when a keyed remount skips blur', async () => {
+    const { input, onSubmit, rerenderWith } = renderNewFileRow()
+    await settleInlineInput()
+    fireEvent.compositionStart(input)
+
+    const remountedInput = rerenderWith({
+      parentPath: '/repo/src',
+      type: 'rename',
+      depth: 1,
+      existingName: 'notes.md',
+      existingPath: '/repo/src/notes.md'
+    })
+    await settleInlineInput()
+    fireEvent.keyDown(remountedInput, { key: 'Enter', keyCode: 13 })
+
+    expect(onSubmit).toHaveBeenCalledTimes(1)
+    expect(onSubmit).toHaveBeenCalledWith('notes.md')
+  })
+
+  it('cancels only on a non-composition Escape', async () => {
+    const { input, onSubmit, onCancel } = renderNewFileRow()
+    await settleInlineInput()
+
+    fireEvent.change(input, { target: { value: 'ぎじろく' } })
+    fireEvent.keyDown(input, { key: 'Escape', isComposing: true })
+    fireEvent.keyDown(input, { key: 'Escape', keyCode: 229 })
+    fireEvent.compositionStart(input)
+    fireEvent.keyDown(input, { key: 'Escape', keyCode: 27 })
+    expect(onCancel).not.toHaveBeenCalled()
+
+    fireEvent.compositionEnd(input)
+    fireEvent.keyDown(input, { key: 'Escape', keyCode: 27 })
+
+    expect(onCancel).toHaveBeenCalledTimes(1)
+    expect(onSubmit).not.toHaveBeenCalled()
+  })
+
+  it.each(['file', 'folder', 'rename'] as const)(
+    'ignores a keyCode-only confirmation and its unmarked redispatch for %s',
+    async (type) => {
+      const { rerenderWith, onSubmit } = renderNewFileRow()
+      const input = rerenderWith({ ...newFileInput, type, existingName: 'notes.md' })
+      await settleInlineInput()
+      fireEvent.change(input, { target: { value: '議事録' } })
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
+      fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+      expect(onSubmit).not.toHaveBeenCalled()
+      await flushFrame()
+      fireEvent.change(input, { target: { value: '議事録.md' } })
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+      expect(onSubmit).toHaveBeenCalledExactlyOnceWith('議事録.md')
+    }
+  )
+})
diff --git a/src/renderer/src/components/right-sidebar/file-explorer-inline-input-row.tsx b/src/renderer/src/components/right-sidebar/file-explorer-inline-input-row.tsx
index 05b38239cbe..ee71068a1cc 100644
--- a/src/renderer/src/components/right-sidebar/file-explorer-inline-input-row.tsx
+++ b/src/renderer/src/components/right-sidebar/file-explorer-inline-input-row.tsx
@@ -1,5 +1,9 @@
 import React, { useCallback, useRef } from 'react'
 import { File, Folder } from 'lucide-react'
+import {
+  isImeCompositionKeyDown,
+  useImeEnterGestureOwnership
+} from '@/lib/ime-composition-keyboard-event'
 import type { TreeNode } from './file-explorer-types'
 
 export type InlineInput = {
@@ -25,6 +29,7 @@ export function InlineInputRow({
   const inputRef = useRef<HTMLInputElement>(null)
   const blurTimeout = useRef<ReturnType<typeof setTimeout> | null>(null)
   const submitted = useRef(false)
+  const imeEnter = useImeEnterGestureOwnership()
   // Grace period flag: when a menu (context or dropdown) closes, its focus
   // management can momentarily steal focus from this input before the user
   // has a chance to type. During the grace window we re-focus on blur instead
@@ -76,6 +81,8 @@ export function InlineInputRow({
     (el: HTMLInputElement | null): void => {
       inputRef.current = el
       clearInlineInputTimers()
+      // Why: a keyed remount skips blur, so composition ownership must not outlive the element.
+      imeEnter.reset()
       if (!el) {
         return
       }
@@ -106,7 +113,7 @@ export function InlineInputRow({
         }, 200)
       })
     },
-    [clearInlineInputTimers, inlineInput.existingName, inlineInput.type]
+    [clearInlineInputTimers, imeEnter, inlineInput.existingName, inlineInput.type]
   )
 
   const clearBlurTimeout = useCallback(() => {
@@ -145,6 +152,11 @@ export function InlineInputRow({
         className="flex-1 min-w-0 bg-transparent text-xs text-foreground outline-none border border-ring rounded-sm px-1"
         defaultValue={inlineInput.type === 'rename' ? inlineInput.existingName : ''}
         onKeyDown={(e) => {
+          // Why: a CJK confirm Enter arrives twice and only the first is marked, so
+          // pair the marked check with the gesture carry; IME-owned Escape is ignored too.
+          if (imeEnter.ownsKeyDown(e) || imeEnter.isComposing() || isImeCompositionKeyDown(e)) {
+            return
+          }
           if (e.key === 'Enter') {
             e.preventDefault()
             submit(e.currentTarget.value)
@@ -154,8 +166,12 @@ export function InlineInputRow({
             onCancel()
           }
         }}
+        onKeyUp={imeEnter.onKeyUp}
+        onCompositionStart={() => imeEnter.setComposing(true)}
+        onCompositionEnd={() => imeEnter.setComposing(false)}
         onFocus={clearBlurTimeout}
         onBlur={(e) => {
+          imeEnter.reset()
           // During the grace period after mount, menu close focus management
           // may shift focus away before the user can type. Re-focus instead of
           // dismissing the still-empty input. Past that window a blur is the
diff --git a/src/renderer/src/components/right-sidebar/file-explorer-instant-dir-toggle.test.ts b/src/renderer/src/components/right-sidebar/file-explorer-instant-dir-toggle.test.ts
index 79d0cdf13f7..3ba85c87e28 100644
--- a/src/renderer/src/components/right-sidebar/file-explorer-instant-dir-toggle.test.ts
+++ b/src/renderer/src/components/right-sidebar/file-explorer-instant-dir-toggle.test.ts
@@ -53,7 +53,6 @@ function createHandlerParams(toggleDir: (worktreeId: string, dirPath: string) =>
     toggleDir,
     loadDir: vi.fn().mockResolvedValue(true),
     statPath: vi.fn().mockResolvedValue({ isDirectory: true }),
-    authorizeExternalPath: vi.fn(),
     markPathAsDirectory: vi.fn(),
     setSelectedPath: vi.fn(),
     scrollRef: createRef<HTMLDivElement>()
diff --git a/src/renderer/src/components/right-sidebar/right-panel-comment-composer.tsx b/src/renderer/src/components/right-sidebar/right-panel-comment-composer.tsx
index bb6744525e1..b35a4b319c4 100644
--- a/src/renderer/src/components/right-sidebar/right-panel-comment-composer.tsx
+++ b/src/renderer/src/components/right-sidebar/right-panel-comment-composer.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import React, { useCallback, useEffect, useRef, useState } from 'react'
 import { Bold, Code2, Italic, List, Quote } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -238,7 +239,7 @@ export function RightPanelCommentComposer({
       onClick={stopPropagation}
       onMouseDown={stopPropagation}
     >
-      <textarea
+      <ImeTextarea
         ref={setTextareaRef}
         value={body}
         rows={3}
diff --git a/src/renderer/src/components/right-sidebar/runSourceControlAgentActionStart.ts b/src/renderer/src/components/right-sidebar/runSourceControlAgentActionStart.ts
index 2f5c044ab1d..c01d43da511 100644
--- a/src/renderer/src/components/right-sidebar/runSourceControlAgentActionStart.ts
+++ b/src/renderer/src/components/right-sidebar/runSourceControlAgentActionStart.ts
@@ -1,5 +1,6 @@
 import { focusTerminalTabSurface } from '@/lib/focus-terminal-tab-surface'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import type { GlobalSettings } from '../../../../shared/global-settings-types'
 import type { Repo } from '../../../../shared/repo-types'
 import type { TuiAgent } from '../../../../shared/tui-agent'
@@ -102,6 +103,7 @@ export async function runSourceControlAgentActionStart({
     }
   } else if (worktreeId) {
     const result = launchAgentInNewTab({
+      requestId: newAgentLaunchRequestId(),
       agent: selectedAgent,
       worktreeId,
       groupId: groupId ?? worktreeId,
diff --git a/src/renderer/src/components/right-sidebar/source-control-discard-localization.test.ts b/src/renderer/src/components/right-sidebar/source-control-discard-localization.test.ts
index 39b1b9e4048..025ff4d87b8 100644
--- a/src/renderer/src/components/right-sidebar/source-control-discard-localization.test.ts
+++ b/src/renderer/src/components/right-sidebar/source-control-discard-localization.test.ts
@@ -7,9 +7,40 @@ afterEach(async () => {
 })
 
 describe('discard descriptions with real locale catalogs', () => {
-  it.each(['en', 'es', 'fr', 'ja', 'ko', 'zh'] as const)(
+  it.each([
+    [
+      'en',
+      'This will revert the unstaged changes to this file. This cannot be undone.',
+      'This will restore the last staged version and discard the deletion. This cannot be undone.'
+    ],
+    [
+      'es',
+      'Esto revertirá los cambios no preparados de este archivo. No se puede deshacer.',
+      'Esto restaurará la última versión preparada y descartará la eliminación. No se puede deshacer.'
+    ],
+    [
+      'fr',
+      'Cela annulera les modifications non planifiées apportées à ce fichier. Cela ne peut pas être annulé.',
+      'Cela restaurera la dernière version intermédiaire et annulera la suppression. Cela ne peut pas être annulé.'
+    ],
+    [
+      'ja',
+      'これにより、このファイルに対するステージングされていない変更が元に戻ります。これを元に戻すことはできません。',
+      'これにより、最後にステージングされたバージョンが復元され、削除が破棄されます。これを元に戻すことはできません。'
+    ],
+    [
+      'ko',
+      '이렇게 하면 단계가 지정되지 않은 변경 사항이 이 파일로 되돌아갑니다. 이 작업은 취소할 수 없습니다.',
+      '이렇게 하면 마지막 단계 버전이 복원되고 삭제가 취소됩니다. 이 작업은 취소할 수 없습니다.'
+    ],
+    [
+      'zh',
+      '这将恢复对此文件的未暂存更改。此操作无法撤消。',
+      '这将恢复最后一个暂存版本并放弃删除。此操作无法撤消。'
+    ]
+  ] as const)(
     'uses current index-preserving descriptions in %s',
-    async (locale) => {
+    async (locale, modifiedDescription, deletedDescription) => {
       await i18n.changeLanguage(locale)
       expect(
         getDiscardEntryConfirmationCopy({
@@ -17,16 +48,14 @@ describe('discard descriptions with real locale catalogs', () => {
           path: 'changed.txt',
           status: 'modified'
         }).description
-      ).toBe('This will revert the unstaged changes to this file. This cannot be undone.')
+      ).toBe(modifiedDescription)
       expect(
         getDiscardEntryConfirmationCopy({
           area: 'unstaged',
           path: 'removed.txt',
           status: 'deleted'
         }).description
-      ).toBe(
-        'This will restore the last staged version and discard the deletion. This cannot be undone.'
-      )
+      ).toBe(deletedDescription)
     }
   )
 })
diff --git a/src/renderer/src/components/right-sidebar/source-control-launch-agent-args-applicability.test.ts b/src/renderer/src/components/right-sidebar/source-control-launch-agent-args-applicability.test.ts
index b13bf2cac5a..44e844bc4d6 100644
--- a/src/renderer/src/components/right-sidebar/source-control-launch-agent-args-applicability.test.ts
+++ b/src/renderer/src/components/right-sidebar/source-control-launch-agent-args-applicability.test.ts
@@ -1,12 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const mocks = vi.hoisted(() => ({
-  planAgentSessionLaunch: vi.fn(),
+  resolveAgentSessionLaunchRoute: vi.fn(),
   getState: vi.fn(() => ({}))
 }))
 
 vi.mock('@/lib/agent-session-launch-plan', () => ({
-  planAgentSessionLaunch: mocks.planAgentSessionLaunch
+  resolveAgentSessionLaunchRoute: mocks.resolveAgentSessionLaunchRoute
 }))
 vi.mock('@/store', () => ({ useAppStore: { getState: mocks.getState } }))
 
@@ -15,7 +15,7 @@ import { sourceControlLaunchAppliesAgentArgs } from './source-control-launch-age
 describe('sourceControlLaunchAppliesAgentArgs', () => {
   beforeEach(() => {
     vi.clearAllMocks()
-    mocks.planAgentSessionLaunch.mockReturnValue({ route: 'terminal-tui' })
+    mocks.resolveAgentSessionLaunchRoute.mockReturnValue('terminal-tui')
   })
 
   it('applies arguments when the user launches into a terminal by default', () => {
@@ -28,7 +28,7 @@ describe('sourceControlLaunchAppliesAgentArgs', () => {
   })
 
   it('drops arguments only when this launch would really be a structured session', () => {
-    mocks.planAgentSessionLaunch.mockReturnValue({ route: 'structured-native-chat' })
+    mocks.resolveAgentSessionLaunchRoute.mockReturnValue('structured-native-chat')
     expect(
       sourceControlLaunchAppliesAgentArgs({
         agent: 'codex',
@@ -39,7 +39,7 @@ describe('sourceControlLaunchAppliesAgentArgs', () => {
 
   it('keeps arguments for a chat-by-default user whose launch falls back to a terminal', () => {
     // A remote host, an agent without a structured session, or a floating workspace all land here.
-    mocks.planAgentSessionLaunch.mockReturnValue({ route: 'legacy-native-chat' })
+    mocks.resolveAgentSessionLaunchRoute.mockReturnValue('legacy-native-chat')
     expect(
       sourceControlLaunchAppliesAgentArgs({
         agent: 'codex',
@@ -55,7 +55,7 @@ describe('sourceControlLaunchAppliesAgentArgs', () => {
         worktreeId: 'wt-1'
       })
     ).toBe(true)
-    expect(mocks.planAgentSessionLaunch).not.toHaveBeenCalled()
+    expect(mocks.resolveAgentSessionLaunchRoute).not.toHaveBeenCalled()
   })
 
   it('names the repo and its host when the workspace does not exist yet', () => {
@@ -64,7 +64,7 @@ describe('sourceControlLaunchAppliesAgentArgs', () => {
       repoId: 'repo-1',
       executionHostId: 'ssh:build-box'
     })
-    expect(mocks.planAgentSessionLaunch).toHaveBeenCalledWith(
+    expect(mocks.resolveAgentSessionLaunchRoute).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
         workspace: {
diff --git a/src/renderer/src/components/right-sidebar/source-control-launch-agent-args-applicability.ts b/src/renderer/src/components/right-sidebar/source-control-launch-agent-args-applicability.ts
index ea16d595ae3..20a53621097 100644
--- a/src/renderer/src/components/right-sidebar/source-control-launch-agent-args-applicability.ts
+++ b/src/renderer/src/components/right-sidebar/source-control-launch-agent-args-applicability.ts
@@ -4,7 +4,7 @@ import {
   workspaceKindForWorktreeId,
   type ProspectiveWorkspace
 } from '@/lib/agent-launch-route-input'
-import { planAgentSessionLaunch } from '@/lib/agent-session-launch-plan'
+import { resolveAgentSessionLaunchRoute } from '@/lib/agent-session-launch-plan'
 import { useAppStore } from '@/store'
 
 export type SourceControlLaunchAgentArgsApplicabilityInput = {
@@ -47,9 +47,9 @@ export function sourceControlLaunchAppliesAgentArgs(
     return true
   }
   return (
-    planAgentSessionLaunch(useAppStore.getState(), {
+    resolveAgentSessionLaunchRoute(useAppStore.getState(), {
       agent: input.agent,
       workspace: prospectiveWorkspace(input)
-    }).route !== 'structured-native-chat'
+    }) !== 'structured-native-chat'
   )
 }
diff --git a/src/renderer/src/components/right-sidebar/source-control/ai/recovery-launch.ts b/src/renderer/src/components/right-sidebar/source-control/ai/recovery-launch.ts
index 4a055a613ee..dd2979ce031 100644
--- a/src/renderer/src/components/right-sidebar/source-control/ai/recovery-launch.ts
+++ b/src/renderer/src/components/right-sidebar/source-control/ai/recovery-launch.ts
@@ -2,6 +2,7 @@ import { toast } from 'sonner'
 import type { AppState } from '@/store'
 import { focusTerminalTabSurface } from '@/lib/focus-terminal-tab-surface'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { getConnectionId } from '@/lib/connection-context'
 import { planAgentCliArgsSuffix } from '@/lib/tui-agent-startup'
 import {
@@ -156,6 +157,7 @@ export async function launchSourceControlRecoveryAgentWithDefault({
     return false
   }
   const result = launchAgentInNewTab({
+    requestId: newAgentLaunchRequestId(),
     agent,
     worktreeId: activeWorktreeId,
     groupId: activeGroupId ?? activeWorktreeId,
diff --git a/src/renderer/src/components/right-sidebar/source-control/panel/header-toolbar.tsx b/src/renderer/src/components/right-sidebar/source-control/panel/header-toolbar.tsx
index 39aa1defa69..f465f395bc2 100644
--- a/src/renderer/src/components/right-sidebar/source-control/panel/header-toolbar.tsx
+++ b/src/renderer/src/components/right-sidebar/source-control/panel/header-toolbar.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React, { useCallback, useEffect, useRef } from 'react'
 import { GitPullRequestArrow, Loader2, Search, X } from 'lucide-react'
 import type { GitBranchCompareSummary } from '../../../../../../shared/git-diff-compare-types'
@@ -262,7 +263,7 @@ export function SourceControlHeaderToolbar({
                 beside PR links or overflow actions — collapse to reach those. */}
             <div className="flex min-w-0 w-full flex-1 items-center gap-1.5">
               <Search className="size-3.5 shrink-0 text-muted-foreground" />
-              <input
+              <ImeInput
                 ref={filterInputRef}
                 data-testid="source-control-filter-input"
                 type="text"
diff --git a/src/renderer/src/components/right-sidebar/source-control/sync/use-git-history-commit-actions.ts b/src/renderer/src/components/right-sidebar/source-control/sync/use-git-history-commit-actions.ts
index bd755652350..36d4fec9313 100644
--- a/src/renderer/src/components/right-sidebar/source-control/sync/use-git-history-commit-actions.ts
+++ b/src/renderer/src/components/right-sidebar/source-control/sync/use-git-history-commit-actions.ts
@@ -9,6 +9,7 @@ import {
 import { getConnectionId } from '@/lib/connection-context'
 import { detectLanguage } from '@/lib/language-detect'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { resolveDefaultAgentForNewTab } from '@/lib/agent-tab-shortcuts'
 import { translate } from '@/i18n/i18n'
 import type { GitHistoryItem } from '../../../../../../shared/git-history'
@@ -280,6 +281,7 @@ export function useGitHistoryCommitActions({
         `Run \`git show --no-ext-diff ${item.id}\` to inspect the full diff, then summarize what changed and why at a high level, calling out the most important files and any risks.`
       ].join('\n')
       launchAgentInNewTab({
+        requestId: newAgentLaunchRequestId(),
         agent,
         worktreeId: activeWorktreeId,
         prompt: explainPrompt,
diff --git a/src/renderer/src/components/right-sidebar/use-file-explorer-tree-pane-state.ts b/src/renderer/src/components/right-sidebar/use-file-explorer-tree-pane-state.ts
index 2eca309a9e3..dfafbcfd029 100644
--- a/src/renderer/src/components/right-sidebar/use-file-explorer-tree-pane-state.ts
+++ b/src/renderer/src/components/right-sidebar/use-file-explorer-tree-pane-state.ts
@@ -253,7 +253,6 @@ export function useFileExplorerTreePaneState({
     toggleDir: hasNameFilter ? handleToggleNameFilterDir : toggleDir,
     loadDir,
     statPath,
-    authorizeExternalPath: window.api.fs.authorizeExternalPath,
     markPathAsDirectory,
     setSelectedPath: setSingleSelectedPath,
     scrollRef
diff --git a/src/renderer/src/components/right-sidebar/useFileExplorerHandlers.test.ts b/src/renderer/src/components/right-sidebar/useFileExplorerHandlers.test.ts
index 0b55ffbc3a1..efe5f476744 100644
--- a/src/renderer/src/components/right-sidebar/useFileExplorerHandlers.test.ts
+++ b/src/renderer/src/components/right-sidebar/useFileExplorerHandlers.test.ts
@@ -1,4 +1,7 @@
 import { describe, expect, it, vi } from 'vitest'
+
+const { toastError } = vi.hoisted(() => ({ toastError: vi.fn() }))
+vi.mock('sonner', () => ({ toast: { error: toastError } }))
 import { useAppStore } from '@/store'
 import type { TreeNode } from './file-explorer-types'
 import { activateFileExplorerNode } from './useFileExplorerHandlers'
@@ -37,7 +40,6 @@ describe('activateFileExplorerNode', () => {
       canToggleDirectories: false,
       loadDir: vi.fn(),
       statPath: vi.fn(),
-      authorizeExternalPath: vi.fn(),
       markPathAsDirectory: vi.fn(),
       setSelectedPath
     })
@@ -59,7 +61,6 @@ describe('activateFileExplorerNode', () => {
       toggleDir,
       loadDir,
       statPath: vi.fn().mockResolvedValue({ isDirectory: true }),
-      authorizeExternalPath: vi.fn(),
       markPathAsDirectory,
       setSelectedPath: vi.fn()
     })
@@ -74,6 +75,59 @@ describe('activateFileExplorerNode', () => {
     expect(openFile).not.toHaveBeenCalled()
   })
 
+  it('does not follow a folder link that leads out of the project', async () => {
+    const loadDir = vi.fn()
+    const openFile = vi.fn()
+
+    await activateFileExplorerNode({
+      node: { ...symlinkNode, operationOwner: { kind: 'local' } },
+      activeWorktreeId: 'wt-1',
+      openFile,
+      toggleDir: vi.fn(),
+      loadDir,
+      statPath: vi.fn().mockResolvedValue({ isDirectory: true, escapesWorktree: true }),
+      markPathAsDirectory: vi.fn(),
+      setSelectedPath: vi.fn()
+    })
+
+    expect(loadDir).not.toHaveBeenCalled()
+    expect(openFile).not.toHaveBeenCalled()
+    expect(toastError).toHaveBeenCalledWith(
+      "This folder links outside the project, so it can't be opened here."
+    )
+  })
+
+  it('opens a file link that leads out of the project by its absolute path', async () => {
+    const openFile = vi.fn()
+    useAppStore.setState({
+      worktreesByRepo: {
+        'repo-1': [{ id: 'wt-1', repoId: 'repo-1', path: '/repo', hostId: 'local' } as never]
+      }
+    })
+
+    await activateFileExplorerNode({
+      node: { ...symlinkNode, operationOwner: { kind: 'local' } },
+      activeWorktreeId: 'wt-1',
+      runtimeEnvironmentId: null,
+      openFile,
+      toggleDir: vi.fn(),
+      loadDir: vi.fn(),
+      statPath: vi.fn().mockResolvedValue({ isDirectory: false, escapesWorktree: true }),
+      markPathAsDirectory: vi.fn(),
+      setSelectedPath: vi.fn()
+    })
+
+    // The absolute relativePath marks the tab as user-named, which survives a restart.
+    expect(openFile).toHaveBeenCalledWith(
+      expect.objectContaining({
+        filePath: '/repo/linked-docs',
+        relativePath: '/repo/linked-docs',
+        worktreeId: 'wt-1'
+      }),
+      expect.anything()
+    )
+  })
+
   it('opens a symlink as a file when target stat fails', async () => {
     const openFile = vi.fn()
     useAppStore.setState({
@@ -97,7 +151,6 @@ describe('activateFileExplorerNode', () => {
       toggleDir: vi.fn(),
       loadDir: vi.fn(),
       statPath: vi.fn().mockRejectedValue(new Error('stat failed')),
-      authorizeExternalPath: vi.fn(),
       markPathAsDirectory: vi.fn(),
       setSelectedPath: vi.fn()
     })
@@ -115,98 +168,6 @@ describe('activateFileExplorerNode', () => {
     )
   })
 
-  it('grants the symlink target local path access before resolving it', async () => {
-    const order: string[] = []
-    const authorizeExternalPath = vi.fn(async () => {
-      order.push('authorize')
-    })
-    const statPath = vi.fn(async () => {
-      order.push('stat')
-      return { isDirectory: false }
-    })
-    const openFile = vi.fn()
-    useAppStore.setState({
-      worktreesByRepo: {
-        'repo-1': [{ id: 'wt-1', repoId: 'repo-1', path: '/repo', hostId: 'local' } as never]
-      }
-    })
-
-    await activateFileExplorerNode({
-      node: { ...symlinkNode, operationOwner: { kind: 'local' } },
-      activeWorktreeId: 'wt-1',
-      runtimeEnvironmentId: null,
-      openFile,
-      toggleDir: vi.fn(),
-      loadDir: vi.fn(),
-      statPath,
-      authorizeExternalPath,
-      markPathAsDirectory: vi.fn(),
-      setSelectedPath: vi.fn()
-    })
-
-    // Why: the grant has to land before the stat, or the allow-list denies the
-    // target and the row can never open.
-    expect(order).toEqual(['authorize', 'stat'])
-    expect(authorizeExternalPath).toHaveBeenCalledWith({ targetPath: '/repo/linked-docs' })
-    expect(openFile).toHaveBeenCalledTimes(1)
-  })
-
-  it('still opens the symlink when the path grant itself fails', async () => {
-    const openFile = vi.fn()
-    useAppStore.setState({
-      worktreesByRepo: {
-        'repo-1': [{ id: 'wt-1', repoId: 'repo-1', path: '/repo', hostId: 'local' } as never]
-      }
-    })
-
-    await activateFileExplorerNode({
-      node: { ...symlinkNode, operationOwner: { kind: 'local' } },
-      activeWorktreeId: 'wt-1',
-      runtimeEnvironmentId: null,
-      openFile,
-      toggleDir: vi.fn(),
-      loadDir: vi.fn(),
-      statPath: vi.fn().mockResolvedValue({ isDirectory: false }),
-      authorizeExternalPath: vi.fn().mockRejectedValue(new Error('ipc unavailable')),
-      markPathAsDirectory: vi.fn(),
-      setSelectedPath: vi.fn()
-    })
-
-    // Why: a rejected grant must degrade to the editor's real error, not a dead click.
-    expect(openFile).toHaveBeenCalledTimes(1)
-  })
-
-  it('leaves symlink authorization to the host for a remote-owned workspace', async () => {
-    const authorizeExternalPath = vi.fn()
-    useAppStore.setState({
-      worktreesByRepo: {
-        'repo-1': [
-          {
-            id: 'wt-1',
-            repoId: 'repo-1',
-            path: '/repo',
-            hostId: 'runtime:runtime-env-1'
-          } as never
-        ]
-      }
-    })
-
-    await activateFileExplorerNode({
-      node: symlinkNode,
-      activeWorktreeId: 'wt-1',
-      runtimeEnvironmentId: 'runtime-env-1',
-      openFile: vi.fn(),
-      toggleDir: vi.fn(),
-      loadDir: vi.fn(),
-      statPath: vi.fn().mockResolvedValue({ isDirectory: false }),
-      authorizeExternalPath,
-      markPathAsDirectory: vi.fn(),
-      setSelectedPath: vi.fn()
-    })
-
-    expect(authorizeExternalPath).not.toHaveBeenCalled()
-  })
-
   it('opens local files without runtime fallback when no runtime owner is set', async () => {
     const fileNode: TreeNode = {
       name: 'README.md',
@@ -231,7 +192,6 @@ describe('activateFileExplorerNode', () => {
       toggleDir: vi.fn(),
       loadDir: vi.fn(),
       statPath: vi.fn(),
-      authorizeExternalPath: vi.fn(),
       markPathAsDirectory: vi.fn(),
       setSelectedPath: vi.fn()
     })
diff --git a/src/renderer/src/components/right-sidebar/useFileExplorerHandlers.ts b/src/renderer/src/components/right-sidebar/useFileExplorerHandlers.ts
index 5b91445639a..3464763cf55 100644
--- a/src/renderer/src/components/right-sidebar/useFileExplorerHandlers.ts
+++ b/src/renderer/src/components/right-sidebar/useFileExplorerHandlers.ts
@@ -38,8 +38,7 @@ type UseFileExplorerHandlersParams = {
     depth: number,
     options?: { force?: boolean; failOnError?: boolean }
   ) => Promise<boolean>
-  statPath: (path: string) => Promise<{ isDirectory: boolean }>
-  authorizeExternalPath: (args: { targetPath: string }) => Promise<void>
+  statPath: (path: string) => Promise<{ isDirectory: boolean; escapesWorktree?: boolean }>
   markPathAsDirectory: (path: string) => void
   setSelectedPath: (path: string) => void
   scrollRef: RefObject<HTMLDivElement | null>
@@ -63,7 +62,6 @@ export async function activateFileExplorerNode(args: {
   canToggleDirectories?: boolean
   loadDir: UseFileExplorerHandlersParams['loadDir']
   statPath: UseFileExplorerHandlersParams['statPath']
-  authorizeExternalPath: UseFileExplorerHandlersParams['authorizeExternalPath']
   markPathAsDirectory: (path: string) => void
   setSelectedPath: (path: string) => void
 }): Promise<void> {
@@ -75,7 +73,6 @@ export async function activateFileExplorerNode(args: {
     canToggleDirectories = true,
     loadDir,
     statPath,
-    authorizeExternalPath,
     markPathAsDirectory,
     setSelectedPath
   } = args
@@ -90,23 +87,29 @@ export async function activateFileExplorerNode(args: {
     toggleDir(activeWorktreeId, node.path)
     return
   }
+  let escapesWorktree = false
   if (node.isSymlink) {
     // Why: symlink targets may live in macOS TCC-protected app data. Resolve
     // them only after the user explicitly activates the row.
-    let targetIsDirectory = false
+    let target: { isDirectory: boolean; escapesWorktree?: boolean } | null = null
     try {
-      // Why: activation is explicit intent to follow the link, so grant its target the
-      // access a terminal-link click already grants. Remote owners skip it — the
-      // relay/runtime is their security boundary.
-      if (node.operationOwner?.kind === 'local') {
-        await authorizeExternalPath({ targetPath: node.path })
-      }
-      targetIsDirectory = (await statPath(node.path)).isDirectory
+      target = await statPath(node.path)
     } catch {
       // Why: an unresolvable target can't be proven to be a directory; fall through so
       // the editor reports the real error instead of the click dead-ending here.
     }
-    if (targetIsDirectory) {
+    escapesWorktree = target?.escapesWorktree === true
+    if (target?.isDirectory && escapesWorktree) {
+      // Why: project listings stay inside the project, so a folder link out of it isn't followed.
+      toast.error(
+        translate(
+          'auto.components.right.sidebar.useFileExplorerHandlers.folderLinksOutsideProject',
+          "This folder links outside the project, so it can't be opened here."
+        )
+      )
+      return
+    }
+    if (target?.isDirectory) {
       const loadedAsDirectory = await loadDir(node.path, node.depth, {
         force: true,
         failOnError: true
@@ -138,7 +141,9 @@ export async function activateFileExplorerNode(args: {
   openFile(
     {
       filePath: node.path,
-      relativePath: node.relativePath,
+      // Why: a file link out of the project opens by its absolute path, as a file the user named,
+      // so it reads the same before and after a restart instead of being refused as a project file.
+      relativePath: escapesWorktree ? node.path : node.relativePath,
       worktreeId: activeWorktreeId,
       runtimeEnvironmentId: fileRuntimeEnvironmentId ?? undefined,
       language: detectLanguage(node.name),
@@ -165,7 +170,6 @@ export function useFileExplorerHandlers({
   canToggleDirectories = true,
   loadDir,
   statPath,
-  authorizeExternalPath,
   markPathAsDirectory,
   setSelectedPath,
   scrollRef
@@ -187,7 +191,6 @@ export function useFileExplorerHandlers({
         canToggleDirectories,
         loadDir,
         statPath,
-        authorizeExternalPath,
         markPathAsDirectory,
         setSelectedPath
       })
@@ -200,7 +203,6 @@ export function useFileExplorerHandlers({
       markPathAsDirectory,
       openFile,
       statPath,
-      authorizeExternalPath,
       toggleDir,
       setSelectedPath
     ]
diff --git a/src/renderer/src/components/right-sidebar/useFileExplorerTree.ts b/src/renderer/src/components/right-sidebar/useFileExplorerTree.ts
index ee186eac965..fe1cea422a6 100644
--- a/src/renderer/src/components/right-sidebar/useFileExplorerTree.ts
+++ b/src/renderer/src/components/right-sidebar/useFileExplorerTree.ts
@@ -2,7 +2,6 @@ import type { Dispatch, SetStateAction } from 'react'
 import { useCallback, useRef, useState } from 'react'
 import type { DirCache, FileExplorerTreeRefreshOutcome } from './file-explorer-types'
 import { splitPathSegments } from './path-tree'
-import { statRuntimePath } from '@/runtime/runtime-file-client'
 import { createFileExplorerDirLoadTracker } from './file-explorer-dir-load-tracker'
 import {
   getFileExplorerOperationOwner,
@@ -22,6 +21,7 @@ import {
   markFileExplorerDirsLoading,
   withPendingFileExplorerDirCacheEntries
 } from './file-explorer-dir-load-state'
+import { statUserOpenedPath, type UserOpenedPathStat } from '@/lib/user-opened-local-path'
 
 type UseFileExplorerTreeResult = {
   dirCache: Record<string, DirCache>
@@ -37,7 +37,7 @@ type UseFileExplorerTreeResult = {
     depth: number,
     options?: { force?: boolean; failOnError?: boolean }
   ) => Promise<boolean>
-  statPath: (path: string) => Promise<{ isDirectory: boolean }>
+  statPath: (path: string) => Promise<UserOpenedPathStat>
   markPathAsDirectory: (path: string) => void
   refreshTree: () => Promise<FileExplorerTreeRefreshOutcome>
   refreshDir: (dirPath: string) => Promise<void>
@@ -182,7 +182,7 @@ export function useFileExplorerTree(
       if (!route) {
         throw new Error(getFileExplorerOwnerUnresolvedMessage())
       }
-      return statRuntimePath(
+      return statUserOpenedPath(
         {
           settings: route.settings,
           worktreeId: activeWorktreeId,
diff --git a/src/renderer/src/components/settings/AgentsPane.test.tsx b/src/renderer/src/components/settings/AgentsPane.test.tsx
index b3a282a72e0..25cebb04b0d 100644
--- a/src/renderer/src/components/settings/AgentsPane.test.tsx
+++ b/src/renderer/src/components/settings/AgentsPane.test.tsx
@@ -12,7 +12,11 @@ import {
   getAgentWorkspaceTrustDescription,
   getAgentWorkspaceTrustTitle
 } from './agent-workspace-trust-copy'
-import { getAgentAwakeDescription, getAgentAwakeTitle } from './agent-awake-copy'
+import {
+  getAgentAwakeDescription,
+  getAgentAwakeLidNote,
+  getAgentAwakeTitle
+} from './agent-awake-copy'
 import { getCodexTerminalServerIsolationTitle } from './codex-terminal-server-isolation-copy'
 import { AgentAwakeSetting } from './AgentAwakeSetting'
 import { AgentRuntimeSetting } from './AgentRuntimeSetting'
@@ -353,6 +357,24 @@ describe('AgentsPane', () => {
     )
   })
 
+  it('describes macOS lid behavior without promising lid-closed wake', () => {
+    expect(getAgentAwakeDescription('Macintosh')).toBe(
+      'Choose On, Agent, or Off. Agent mode prevents idle sleep while agents work, so long runs finish with the lid open. Closing the lid still puts this Mac to sleep.'
+    )
+  })
+
+  it('picks the lid note for each platform', () => {
+    expect(getAgentAwakeLidNote('Macintosh')).toBe(
+      'Prevents idle sleep with the lid open; closing the lid still puts this Mac to sleep.'
+    )
+    expect(getAgentAwakeLidNote('Windows')).toBe(
+      "Lid-close behavior follows this device's power settings."
+    )
+    expect(getAgentAwakeLidNote('X11; Linux x86_64')).toBe(
+      'Orca also asks this device to stay awake when the lid is closed, subject to its power policy.'
+    )
+  })
+
   it('updates the keep-awake mode with its legacy fallback', () => {
     const updateSettings = vi.fn()
     const element = AgentAwakeSetting({
diff --git a/src/renderer/src/components/settings/KeybindingsFileActions.tsx b/src/renderer/src/components/settings/KeybindingsFileActions.tsx
index 5d355b10949..f9b1288a73e 100644
--- a/src/renderer/src/components/settings/KeybindingsFileActions.tsx
+++ b/src/renderer/src/components/settings/KeybindingsFileActions.tsx
@@ -83,8 +83,8 @@ export function KeybindingsFileActions(): React.JSX.Element {
         (file) => file.filePath === filePath && file.worktreeId === FLOATING_TERMINAL_WORKTREE_ID
       )
       if (existingFile && !existingFile.isDirty) {
-        // Why: a prior denied read can leave a focused error tab. Reopen a
-        // clean tab after authorization so the editor retries the file load.
+        // Why: a prior failed read can leave a focused error tab. Reopen a
+        // clean tab so the editor retries the file load.
         closeFile(existingFile.id)
       }
       openFile(
diff --git a/src/renderer/src/components/settings/MobileAutoRestoreFitSection.tsx b/src/renderer/src/components/settings/MobileAutoRestoreFitSection.tsx
index 5560189db11..e3fc9c2188c 100644
--- a/src/renderer/src/components/settings/MobileAutoRestoreFitSection.tsx
+++ b/src/renderer/src/components/settings/MobileAutoRestoreFitSection.tsx
@@ -25,8 +25,8 @@ export function MobileAutoRestoreFitSection({
       </div>
       <p className="text-muted-foreground mb-3 text-xs">
         {translate(
-          'auto.components.settings.MobilePane.35100bca5d',
-          "While you're using a terminal on your phone, Orca shrinks it to fit your phone screen. When you close the app or switch away, this controls whether it stays at phone size (so interactive CLI tools don't reflow) or resizes back to your desktop. You can always use Restore this terminal or Restore all terminals on the banner to resize manually."
+          'auto.components.settings.MobilePane.5e2c7a1f84',
+          "While you're using a terminal on your phone, Orca shrinks it to fit your phone screen. When you close the app or switch away, this controls whether it stays at phone size (so interactive CLI tools don't reflow) or resizes back to your desktop. You can always use Restore or Restore all on the banner to resize manually."
         )}
       </p>
       <Select
diff --git a/src/renderer/src/components/settings/MobileSettingsPane.tsx b/src/renderer/src/components/settings/MobileSettingsPane.tsx
index 2dd10a006f4..203e95abbae 100644
--- a/src/renderer/src/components/settings/MobileSettingsPane.tsx
+++ b/src/renderer/src/components/settings/MobileSettingsPane.tsx
@@ -13,7 +13,7 @@ export { getMobileSettingsPaneSearchEntries }
 
 const ORCA_IOS_APP_STORE_URL = 'https://apps.apple.com/app/orca-ide/id6766130217'
 const ORCA_ANDROID_APK_URL =
-  'https://github.com/stablyai/orca/releases/download/mobile-android-v0.0.48/app-release.apk'
+  'https://github.com/stablyai/orca/releases/download/mobile-android-v0.0.52/app-release.apk'
 
 export function MobileSettingsPane(): React.JSX.Element {
   const showMobileButton = useAppStore((s) => s.settings?.showMobileButton !== false)
diff --git a/src/renderer/src/components/settings/NativeChatSupportedAgents.test.tsx b/src/renderer/src/components/settings/NativeChatSupportedAgents.test.tsx
index 18c4ab37182..1a6ae82bece 100644
--- a/src/renderer/src/components/settings/NativeChatSupportedAgents.test.tsx
+++ b/src/renderer/src/components/settings/NativeChatSupportedAgents.test.tsx
@@ -37,6 +37,7 @@ function getRenderedChips(): { agent: string; label: string; role: string }[] {
 describe('NativeChatSupportedAgents', () => {
   afterEach(async () => {
     await i18n.changeLanguage('en')
+    i18n.removeResourceBundle('test', 'translation')
   })
 
   it('keeps the advertised list and support predicate on the independent contract', () => {
@@ -85,8 +86,9 @@ describe('NativeChatSupportedAgents', () => {
   })
 
   it('renders the English fallback when the active locale lacks the label key', async () => {
-    await i18n.changeLanguage('es')
-    expect(i18n.getResource('es', 'translation', SUPPORTED_AGENTS_LABEL_KEY)).toBeUndefined()
+    i18n.addResourceBundle('test', 'translation', {})
+    await i18n.changeLanguage('test')
+    expect(i18n.getResource('test', 'translation', SUPPORTED_AGENTS_LABEL_KEY)).toBeUndefined()
 
     const markup = renderToStaticMarkup(<NativeChatSupportedAgents />)
 
diff --git a/src/renderer/src/components/settings/TerminalPane.tsx b/src/renderer/src/components/settings/TerminalPane.tsx
index 20f1391223c..622fd3c1625 100644
--- a/src/renderer/src/components/settings/TerminalPane.tsx
+++ b/src/renderer/src/components/settings/TerminalPane.tsx
@@ -30,6 +30,8 @@ import { TerminalRenderingSection } from './TerminalRenderingSection'
 import { TerminalSetupScriptSection } from './TerminalSetupScriptSection'
 import { TerminalWindowsShellSection } from './TerminalWindowsShellSection'
 import { SettingsSegmentedControl, SettingsSubsectionHeader } from './SettingsFormControls'
+import { translate } from '@/i18n/i18n'
+import { translateSearchKeyword } from './settings-search-keywords'
 
 type TerminalPaneProps = {
   settings: GlobalSettings
@@ -87,37 +89,56 @@ export function TerminalPane({
       return
     }
     const exists = await window.api.shell.pathExists(shell)
-    setShellValidationError(exists ? null : `Shell not found: ${shell}`)
+    setShellValidationError(
+      exists
+        ? null
+        : translate(
+            'auto.components.settings.TerminalPane.5a5eac2f44',
+            'Shell not found: {{value0}}',
+            {
+              value0: shell
+            }
+          )
+    )
   }
 
   const defaultShellSection =
     !showWindowsHostSettings &&
     matchesSettingsSearch(searchQuery, {
-      title: 'Default shell',
-      description: 'Shell used for new terminal panes',
+      title: translate('auto.components.settings.TerminalPane.9589abc009', 'Default shell'),
+      description: translate(
+        'auto.components.settings.TerminalPane.1c29734248',
+        'Shell used for new terminal panes'
+      ),
       keywords: [
-        'shell',
-        'terminal',
-        'fish',
-        'zsh',
-        'bash',
-        'nushell',
-        'default',
-        'arguments',
-        'args',
-        'login',
-        'wrapper',
-        'rcfile'
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.a909136b3f', 'shell'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.81694f1584', 'terminal'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.0cbe5ad727', 'fish'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.c9bc93d343', 'zsh'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.17ad899ba4', 'bash'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.d469840b75', 'nushell'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.ddc72a4860', 'default'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.af893aa433', 'arguments'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.44f8a56f66', 'args'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.4faf688f78', 'login'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.73c211e979', 'wrapper'),
+        ...translateSearchKeyword('auto.components.settings.TerminalPane.c2ddb189e7', 'rcfile')
       ]
     }) ? (
       <section key="default-shell" className="space-y-3">
         <SettingsSubsectionHeader
-          title="Terminal shell"
-          description="Choose what Orca opens for new local terminal panes."
+          title={translate('auto.components.settings.TerminalPane.fd05fb109c', 'Terminal shell')}
+          description={translate(
+            'auto.components.settings.TerminalPane.69724e8f0c',
+            'Choose what Orca opens for new local terminal panes.'
+          )}
         />
         <div className="space-y-3">
           <SettingsSegmentedControl
-            ariaLabel="Terminal shell"
+            ariaLabel={translate(
+              'auto.components.settings.TerminalPane.fd05fb109c',
+              'Terminal shell'
+            )}
             value={shellMode}
             onChange={(value) => {
               setShellValidationError(null)
@@ -131,32 +152,54 @@ export function TerminalPane({
               )
             }}
             options={[
-              { value: 'system', label: `System shell (${systemShell})` },
-              { value: 'custom', label: 'Custom shell' }
+              {
+                value: 'system',
+                label: translate(
+                  'auto.components.settings.TerminalPane.dd3f4c35da',
+                  'System shell ({{value0}})',
+                  { value0: systemShell }
+                )
+              },
+              {
+                value: 'custom',
+                label: translate('auto.components.settings.TerminalPane.f51cc79784', 'Custom shell')
+              }
             ]}
           />
           {shellMode === 'custom' ? (
             <div className="space-y-1.5">
               <Input
                 value={settings.terminalDefaultShell ?? ''}
-                placeholder="fish, nu, or /bin/zsh"
+                placeholder={translate(
+                  'auto.components.settings.TerminalPane.c2bf02ce2f',
+                  'fish, nu, or /bin/zsh'
+                )}
                 onChange={(event) => {
                   setShellValidationError(null)
                   updateSettings({ terminalDefaultShell: event.target.value.trimStart() })
                 }}
                 onBlur={() => void validateShell()}
                 className="w-full"
-                aria-label="Custom shell executable"
+                aria-label={translate(
+                  'auto.components.settings.TerminalPane.5e06e87730',
+                  'Custom shell executable'
+                )}
                 aria-invalid={shellValidationError != null}
                 aria-describedby={shellValidationError ? 'default-shell-error' : undefined}
               />
               <p id="default-shell-help" className="text-xs text-muted-foreground">
-                Enter a shell name on PATH or an executable path. Orca starts it as a login shell.
+                {translate(
+                  'auto.components.settings.TerminalPane.59573d0b33',
+                  'Enter a shell name on PATH or an executable path. Orca starts it as a login shell.'
+                )}
               </p>
               {shellValidationError ? (
                 <p id="default-shell-error" role="alert" className="text-xs text-destructive">
-                  {shellValidationError}. Switch to System shell or choose an executable on this
-                  host.
+                  {shellValidationError}
+                  {translate(
+                    'auto.components.settings.TerminalPane.e3ae5aed18',
+                    '. Switch to System shell or choose an executable on this host.'
+                  )}
                 </p>
               ) : null}
               <Collapsible open={shellArgsOpen} onOpenChange={setShellArgsOpen}>
@@ -166,7 +209,7 @@ export function TerminalPane({
                     className="inline-flex h-7 items-center gap-1.5 px-1 text-xs font-medium text-muted-foreground transition-colors hover:text-foreground"
                     aria-controls="default-shell-args-content"
                   >
-                    Advanced
+                    {translate('auto.components.settings.TerminalPane.5e5f06c82c', 'Advanced')}
                     <ChevronDown
                       className={cn('size-3.5 transition-transform', shellArgsOpen && 'rotate-180')}
                     />
@@ -176,16 +219,28 @@ export function TerminalPane({
                   <div className="mt-1.5 space-y-2 rounded-md border border-border/60 bg-muted/20 px-3 py-3">
                     <div className="space-y-1">
                       <label htmlFor="default-shell-args" className="text-xs font-medium">
-                        Shell arguments
+                        {translate(
+                          'auto.components.settings.TerminalPane.01c600daff',
+                          'Shell arguments'
+                        )}
                       </label>
                       <p className="text-xs text-muted-foreground">
                         {shellArgsMode === 'default'
-                          ? 'Starts the shell as a login shell with -l.'
-                          : 'Enter one argument per line. Leave it empty to pass no arguments.'}
+                          ? translate(
+                              'auto.components.settings.TerminalPane.884a006065',
+                              'Starts the shell as a login shell with -l.'
+                            )
+                          : translate(
+                              'auto.components.settings.TerminalPane.578ec79449',
+                              'Enter one argument per line. Leave it empty to pass no arguments.'
+                            )}
                       </p>
                     </div>
                     <SettingsSegmentedControl
-                      ariaLabel="Shell argument mode"
+                      ariaLabel={translate(
+                        'auto.components.settings.TerminalPane.5ffc4777b6',
+                        'Shell argument mode'
+                      )}
                       value={shellArgsMode}
                       onChange={(value) => {
                         setShellArgsMode(value)
@@ -195,8 +250,20 @@ export function TerminalPane({
                         })
                       }}
                       options={[
-                        { value: 'default', label: '-l (default)' },
-                        { value: 'custom', label: 'Custom args' }
+                        {
+                          value: 'default',
+                          label: translate(
+                            'auto.components.settings.TerminalPane.7bd83fc1d0',
+                            '-l (default)'
+                          )
+                        },
+                        {
+                          value: 'custom',
+                          label: translate(
+                            'auto.components.settings.TerminalPane.48b91a3ed2',
+                            'Custom args'
+                          )
+                        }
                       ]}
                     />
                     {shellArgsMode === 'custom' ? (
@@ -210,10 +277,16 @@ export function TerminalPane({
                           setCustomShellArgs(nextArgs)
                           updateSettings({ terminalDefaultShellArgs: nextArgs })
                         }}
-                        placeholder={'--rcfile\n/path/to/rcfile'}
+                        placeholder={translate(
+                          'auto.components.settings.TerminalPane.f58cb71f53',
+                          '--rcfile\n/path/to/rcfile'
+                        )}
                         className="min-h-20"
                         spellCheck={false}
-                        aria-label="Shell arguments, one per line"
+                        aria-label={translate(
+                          'auto.components.settings.TerminalPane.8dbe0bc942',
+                          'Shell arguments, one per line'
+                        )}
                       />
                     ) : null}
                   </div>
diff --git a/src/renderer/src/components/settings/agent-awake-copy.ts b/src/renderer/src/components/settings/agent-awake-copy.ts
index 4a9512ed066..81229813b91 100644
--- a/src/renderer/src/components/settings/agent-awake-copy.ts
+++ b/src/renderer/src/components/settings/agent-awake-copy.ts
@@ -5,6 +5,8 @@ import { searchKeywords } from './settings-search-keywords'
 const AGENT_AWAKE_TITLE_KEY = 'auto.components.settings.agent-awake-copy.modeTitle'
 const AGENT_AWAKE_DESCRIPTION_WINDOWS_KEY =
   'auto.components.settings.agent-awake-copy.modeDescriptionWindows'
+const AGENT_AWAKE_DESCRIPTION_MAC_KEY =
+  'auto.components.settings.agent-awake-copy.modeDescriptionMac'
 const AGENT_AWAKE_DESCRIPTION_DEFAULT_KEY =
   'auto.components.settings.agent-awake-copy.modeDescriptionDefault'
 
@@ -31,6 +33,13 @@ export function getAgentAwakeDescription(
       "Choose On, Agent, or Off. Agent mode stays awake while agents are working; lid-close behavior follows this device's power settings."
     )
   }
+  // macOS caffeinate can't hold a closed lid awake; Linux blocks logind's lid switch.
+  if (userAgent.includes('Mac')) {
+    return translate(
+      AGENT_AWAKE_DESCRIPTION_MAC_KEY,
+      'Choose On, Agent, or Off. Agent mode prevents idle sleep while agents work, so long runs finish with the lid open. Closing the lid still puts this Mac to sleep.'
+    )
+  }
 
   return translate(
     AGENT_AWAKE_DESCRIPTION_DEFAULT_KEY,
@@ -38,6 +47,27 @@ export function getAgentAwakeDescription(
   )
 }
 
+export function getAgentAwakeLidNote(
+  userAgent = typeof navigator === 'undefined' ? '' : navigator.userAgent
+): string {
+  if (userAgent.includes('Windows')) {
+    return translate(
+      'auto.components.settings.agent-awake-copy.lidNoteWindows',
+      "Lid-close behavior follows this device's power settings."
+    )
+  }
+  if (userAgent.includes('Mac')) {
+    return translate(
+      'auto.components.settings.agent-awake-copy.lidNoteMac',
+      'Prevents idle sleep with the lid open; closing the lid still puts this Mac to sleep.'
+    )
+  }
+  return translate(
+    'auto.components.settings.agent-awake-copy.lidNoteDefault',
+    'Orca also asks this device to stay awake when the lid is closed, subject to its power policy.'
+  )
+}
+
 export function getAgentAwakeSearchKeywords(
   userAgent = typeof navigator === 'undefined' ? '' : navigator.userAgent
 ): string[] {
diff --git a/src/renderer/src/components/settings/terminal-search.ts b/src/renderer/src/components/settings/terminal-search.ts
index dc60715d727..f2013d087d1 100644
--- a/src/renderer/src/components/settings/terminal-search.ts
+++ b/src/renderer/src/components/settings/terminal-search.ts
@@ -32,6 +32,8 @@ import {
   getTerminalWindowSearchEntries
 } from './terminal-window-setup-search'
 import { createLocalizedCatalog } from '@/i18n/localized-catalog'
+import { translate } from '@/i18n/i18n'
+import { translateSearchKeyword } from './settings-search-keywords'
 
 export {
   getTerminalAdvancedTypographySearchEntries,
@@ -111,20 +113,59 @@ export function getTerminalPaneSearchEntries(platform: {
     ...(!isWindowsTerminalHost
       ? [
           {
-            title: 'Terminal shell',
-            description: 'Shell and arguments used for new local interactive terminal panes',
+            title: translate(
+              'auto.components.settings.terminal.search.1733ccd3e9',
+              'Terminal shell'
+            ),
+            description: translate(
+              'auto.components.settings.terminal.search.3de504994c',
+              'Shell and arguments used for new local interactive terminal panes'
+            ),
             keywords: [
-              'shell',
-              'terminal',
-              'fish',
-              'zsh',
-              'bash',
-              'nushell',
-              'arguments',
-              'args',
-              'login',
-              'wrapper',
-              'rcfile'
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.ddd5efe113',
+                'shell'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.f66a7cf715',
+                'terminal'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.454df22a5e',
+                'fish'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.d26257a80d',
+                'zsh'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.bf09070e31',
+                'bash'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.7c3ede6f12',
+                'nushell'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.5304b12d5c',
+                'arguments'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.36ba1a1357',
+                'args'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.50ba80b6dd',
+                'login'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.d9e29543a1',
+                'wrapper'
+              ),
+              ...translateSearchKeyword(
+                'auto.components.settings.terminal.search.d31ed1ac1c',
+                'rcfile'
+              )
             ]
           }
         ]
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeDialog.test.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeDialog.test.tsx
index d1f3e8121de..7b4989a9c5a 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeDialog.test.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeDialog.test.tsx
@@ -359,7 +359,9 @@ describe('DeleteWorktreeDialog lineage copy', () => {
     const markup = renderToStaticMarkup(<DeleteWorktreeDialog />)
 
     expect(markup).toContain('2 uncommitted or untracked changes')
-    expect(markup).toContain('Deleting this workspace permanently removes these changes from disk.')
+    expect(markup).toContain(
+      'Any uncommitted or untracked changes in Git workspaces will be permanently deleted.'
+    )
     expect(markup).not.toContain('Also delete local branch')
   })
 
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeDialog.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeDialog.tsx
index d1b0dfea5c8..f8f7731e3cb 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeDialog.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeDialog.tsx
@@ -23,6 +23,7 @@ import { DeleteWorktreeTargetPreview } from './DeleteWorktreeTargetPreview'
 import { DeleteWorktreeWarningPanels } from './DeleteWorktreeWarningPanels'
 import { persistDeleteWorktreeConfirmSkipPreference } from './delete-worktree-preference-toast'
 import {
+  getDeleteWorktreeChangeCheckStates,
   getDeleteWorktreeDirtyChangeCounts,
   getDeleteWorktreeDirtyChangePreviews
 } from './delete-worktree-dirty-change-counts'
@@ -117,15 +118,11 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
   const repoMap = useMemo(() => new Map(repos.map((repo) => [repo.id, repo])), [repos])
   const isBatchDelete = worktreeIds.length > 1
   const isFolderWorkspaceDelete = !isBatchDelete && getIsFolderWorkspaceDelete(repoMap, worktree)
-  const folderWorkspaceDeleteCount = useMemo(
-    () => countFolderWorkspaceDeletes(repoMap, worktrees),
-    [repoMap, worktrees]
-  )
   const deleteCopy = getDeleteWorktreeDialogCopy({
     isBatchDelete,
     worktree,
     worktreeCount: worktrees.length,
-    folderWorkspaceDeleteCount,
+    folderWorkspaceDeleteCount: countFolderWorkspaceDeletes(repoMap, worktrees),
     isFolderWorkspaceDelete
   })
   const deleteStateByWorktreeId = useAppStore((s) => s.deleteStateByWorktreeId)
@@ -183,6 +180,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
   const dirtyChanges = useMemo(() => {
     const statusInput = { deleteTargets, gitStatusByWorktree, gitStatusByWorktreeIdentity, repoMap }
     return {
+      checkStates: getDeleteWorktreeChangeCheckStates(statusInput),
       counts: getDeleteWorktreeDirtyChangeCounts({ ...statusInput, deleteStateByWorktreeId }),
       previews: getDeleteWorktreeDirtyChangePreviews(statusInput)
     }
@@ -365,6 +363,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
                 )}
           </DialogTitle>
           <DeleteWorktreeDialogDescription
+            showChangeLossWarning={dirtyChanges.checkStates.size > 0}
             targetClassName={deleteCopy.targetClassName}
             targetLabel={deleteCopy.targetLabel}
             canDeleteAllLineage={canDeleteAllLineage}
@@ -385,6 +384,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
             collisionWorktrees={allWorktrees}
             hostLabelById={hostLabelById}
             deleteStateByWorktreeId={deleteStateByWorktreeId}
+            changeCheckStatesByWorktreeId={dirtyChanges.checkStates}
             dirtyChangeCountsByWorktreeId={dirtyChanges.counts}
             dirtyChangePreviewsByWorktreeId={dirtyChanges.previews}
           />
@@ -392,6 +392,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
           {hasLineageChildren && (
             <DeleteWorktreeLineageNotice
               descendants={lineageDelete.descendants}
+              changeCheckStatesByWorktreeId={dirtyChanges.checkStates}
               dirtyChangeCountsByWorktreeId={dirtyChanges.counts}
               dirtyChangePreviewsByWorktreeId={dirtyChanges.previews}
             />
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeDialogDescription.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeDialogDescription.tsx
index 60beeda6759..5543348a8d7 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeDialogDescription.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeDialogDescription.tsx
@@ -6,13 +6,15 @@ export function DeleteWorktreeDialogDescription({
   targetLabel,
   canDeleteAllLineage,
   childTargetLabel,
-  descriptionSuffix
+  descriptionSuffix,
+  showChangeLossWarning
 }: {
   targetClassName: string
   targetLabel: string | undefined
   canDeleteAllLineage: boolean
   childTargetLabel: string
   descriptionSuffix: string
+  showChangeLossWarning?: boolean
 }): React.JSX.Element {
   return (
     <DialogDescription className="text-xs">
@@ -28,6 +30,14 @@ export function DeleteWorktreeDialogDescription({
       ) : (
         <> {descriptionSuffix}</>
       )}
+      {showChangeLossWarning && (
+        <span className="mt-1 block">
+          {translate(
+            'components.workspace.delete.changes.permanentLoss',
+            'Any uncommitted or untracked changes in Git workspaces will be permanently deleted.'
+          )}
+        </span>
+      )}
     </DialogDescription>
   )
 }
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeDirtyChangeHint.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeDirtyChangeHint.tsx
index 18fa0360c13..75deea5df63 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeDirtyChangeHint.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeDirtyChangeHint.tsx
@@ -1,19 +1,43 @@
 import type { JSX } from 'react'
 import { AlertTriangle, ChevronRight } from 'lucide-react'
-import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '@/components/ui/collapsible'
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { translate } from '@/i18n/i18n'
 import { STATUS_COLORS, STATUS_LABELS } from '../right-sidebar/status-display'
-import type { DeleteWorktreeDirtyChangePreview } from './delete-worktree-dirty-change-counts'
+import type {
+  DeleteWorktreeChangeCheckState,
+  DeleteWorktreeDirtyChangePreview
+} from './delete-worktree-dirty-change-counts'
 
 export function DeleteWorktreeDirtyChangeHint({
   changeCount,
+  checkState,
   preview
 }: {
   changeCount: number | undefined
+  checkState?: DeleteWorktreeChangeCheckState
   preview?: DeleteWorktreeDirtyChangePreview
 }): JSX.Element | null {
   if (changeCount === undefined) {
-    return null
+    if (!checkState) {
+      return null
+    }
+    const statusLabel =
+      checkState === 'complete'
+        ? translate(
+            'components.workspace.delete.changes.clean',
+            'No uncommitted or untracked changes'
+          )
+        : checkState === 'unavailable'
+          ? translate(
+              'components.workspace.delete.changes.unavailable',
+              'Changes could not be checked'
+            )
+          : translate('components.workspace.delete.changes.checking', 'Checking for changes…')
+    return (
+      <div className="mt-0.5 flex h-4 min-w-0 items-center text-muted-foreground">
+        <span className="truncate">{statusLabel}</span>
+      </div>
+    )
   }
 
   const label =
@@ -21,10 +45,6 @@ export function DeleteWorktreeDirtyChangeHint({
       ? `${changeCount} uncommitted or untracked ${changeCount === 1 ? 'change' : 'changes'}`
       : 'Uncommitted or untracked changes'
 
-  const warning = translate(
-    'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.8e2994ce28',
-    'Deleting this workspace permanently removes these changes from disk.'
-  )
   const warningLabel = (
     <>
       <AlertTriangle className="size-3 shrink-0" />
@@ -33,82 +53,107 @@ export function DeleteWorktreeDirtyChangeHint({
   )
 
   if (!preview?.files.length) {
+    const detailsLabel =
+      checkState === 'checking'
+        ? translate('components.workspace.delete.changes.checkingDetails', 'Checking…')
+        : checkState === 'unavailable'
+          ? translate(
+              'components.workspace.delete.changes.unavailableDetails',
+              'Details unavailable'
+            )
+          : null
     return (
-      <div className="mt-1 min-w-0">
+      <div className="mt-0.5 flex h-4 min-w-0 items-center">
         <div className="flex w-fit max-w-full items-center gap-1.5 text-destructive">
           {warningLabel}
+          {detailsLabel && <span className="shrink-0 text-muted-foreground">· {detailsLabel}</span>}
         </div>
-        <p className="mt-1 text-muted-foreground">{warning}</p>
       </div>
     )
   }
 
   return (
-    <Collapsible className="mt-1 min-w-0">
-      <CollapsibleTrigger asChild>
-        <button
-          type="button"
-          aria-label={`${label}: ${translate('auto.components.sidebar.DeleteWorktreeDirtyChangeHint.showLoadedPaths', 'Show loaded paths')}`}
-          className="group flex w-fit max-w-full cursor-pointer items-center gap-1.5 rounded-sm text-destructive hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
-        >
-          {warningLabel}
-          <ChevronRight className="size-3 shrink-0 group-data-[state=open]:rotate-90" />
-        </button>
-      </CollapsibleTrigger>
-      <p className="mt-1 text-muted-foreground">{warning}</p>
-      <CollapsibleContent>
-        <div className="mt-1 min-w-0 rounded-sm border border-border/60 bg-background/60 px-2 py-1.5">
-          <p className="text-muted-foreground">
-            {translate(
-              'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.loadedPathsNotice',
-              'Loaded paths may be incomplete or out of date.'
-            )}
-          </p>
-          <div
-            role="region"
-            aria-label={translate(
-              'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.loadedChangedPaths',
-              'Loaded changed paths'
-            )}
-            tabIndex={0}
-            className="scrollbar-sleek mt-1 max-h-40 min-w-0 overflow-y-auto"
+    <div className="mt-0.5 flex h-4 min-w-0 items-center">
+      <Popover>
+        <PopoverTrigger asChild>
+          <button
+            type="button"
+            aria-label={`${label}: ${translate('auto.components.sidebar.DeleteWorktreeDirtyChangeHint.showLoadedPaths', 'Show loaded paths')}`}
+            className="flex h-4 w-fit max-w-full cursor-pointer items-center gap-1.5 rounded-sm text-destructive hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
           >
-            <ul className="min-w-0 space-y-0.5 font-mono">
-              {preview.files.map((file) => (
-                <li key={file.path} className="flex min-w-0 items-baseline gap-2">
-                  <span
-                    className="w-3 shrink-0 font-semibold"
-                    style={{ color: STATUS_COLORS[file.status] }}
-                    aria-label={file.status}
-                  >
-                    {STATUS_LABELS[file.status]}
-                  </span>
-                  <div className="min-w-0 break-all text-foreground">
-                    {file.path}
-                    {file.hasUnresolvedConflict ? (
-                      <span className="ml-2 font-sans text-destructive">
-                        {translate(
-                          'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.unresolvedConflict',
-                          'Unresolved conflict'
-                        )}
-                      </span>
-                    ) : null}
-                  </div>
-                </li>
-              ))}
-            </ul>
-          </div>
-          {preview.remainingPathCount > 0 ? (
-            <p className="mt-1 text-muted-foreground">
+            {warningLabel}
+            <ChevronRight className="size-3 shrink-0" />
+          </button>
+        </PopoverTrigger>
+        <PopoverContent
+          align="start"
+          side="bottom"
+          aria-label={translate(
+            'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.loadedChangedPaths',
+            'Loaded changed paths'
+          )}
+          className="w-80 max-w-[calc(100vw-2rem)]"
+          wheelScroll
+        >
+          <div className="scrollbar-sleek max-h-[var(--radix-popover-content-available-height)] overflow-y-auto p-3 text-xs">
+            <p className="mb-1 font-medium">
               {translate(
-                'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.moreLoadedPaths',
-                'and {{value0}} more loaded paths',
-                { value0: preview.remainingPathCount }
+                'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.loadedChangedPaths',
+                'Loaded changed paths'
               )}
             </p>
-          ) : null}
-        </div>
-      </CollapsibleContent>
-    </Collapsible>
+            <p className="text-muted-foreground">
+              {translate(
+                'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.loadedPathsNotice',
+                'Loaded paths may be incomplete or out of date.'
+              )}
+            </p>
+            <div
+              role="region"
+              aria-label={translate(
+                'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.loadedChangedPaths',
+                'Loaded changed paths'
+              )}
+              tabIndex={0}
+              className="scrollbar-sleek mt-1 max-h-40 min-w-0 overflow-y-auto"
+            >
+              <ul className="min-w-0 space-y-0.5 font-mono">
+                {preview.files.map((file) => (
+                  <li key={file.path} className="flex min-w-0 items-baseline gap-2">
+                    <span
+                      className="w-3 shrink-0 font-semibold"
+                      style={{ color: STATUS_COLORS[file.status] }}
+                      aria-label={file.status}
+                    >
+                      {STATUS_LABELS[file.status]}
+                    </span>
+                    <div className="min-w-0 break-all text-foreground">
+                      {file.path}
+                      {file.hasUnresolvedConflict ? (
+                        <span className="ml-2 font-sans text-destructive">
+                          {translate(
+                            'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.unresolvedConflict',
+                            'Unresolved conflict'
+                          )}
+                        </span>
+                      ) : null}
+                    </div>
+                  </li>
+                ))}
+              </ul>
+            </div>
+            {preview.remainingPathCount > 0 ? (
+              <p className="mt-1 text-muted-foreground">
+                {translate(
+                  'auto.components.sidebar.DeleteWorktreeDirtyChangeHint.moreLoadedPaths',
+                  'and {{value0}} more loaded paths',
+                  { value0: preview.remainingPathCount }
+                )}
+              </p>
+            ) : null}
+          </div>
+        </PopoverContent>
+      </Popover>
+    </div>
   )
 }
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeLineageNotice.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeLineageNotice.tsx
index 3338be2ace8..153feee65b8 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeLineageNotice.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeLineageNotice.tsx
@@ -3,19 +3,24 @@ import type { JSX } from 'react'
 import type { Worktree } from '../../../../shared/worktree/types'
 import { getWorktreeHostIdentity } from '../../../../shared/worktree/host-qualified-identity'
 import { DeleteWorktreeDirtyChangeHint } from './DeleteWorktreeDirtyChangeHint'
-import type { DeleteWorktreeDirtyChangePreview } from './delete-worktree-dirty-change-counts'
+import type {
+  DeleteWorktreeChangeCheckState,
+  DeleteWorktreeDirtyChangePreview
+} from './delete-worktree-dirty-change-counts'
 import { translate } from '@/i18n/i18n'
 
 type DeleteWorktreeLineageNoticeProps = {
   descendants: readonly Worktree[]
   dirtyChangeCountsByWorktreeId: ReadonlyMap<string, number>
   dirtyChangePreviewsByWorktreeId: ReadonlyMap<string, DeleteWorktreeDirtyChangePreview>
+  changeCheckStatesByWorktreeId?: ReadonlyMap<string, DeleteWorktreeChangeCheckState>
 }
 
 export function DeleteWorktreeLineageNotice({
   descendants,
   dirtyChangeCountsByWorktreeId,
-  dirtyChangePreviewsByWorktreeId
+  dirtyChangePreviewsByWorktreeId,
+  changeCheckStatesByWorktreeId
 }: DeleteWorktreeLineageNoticeProps): JSX.Element | null {
   const childWorkspaceCount = descendants.length
   if (childWorkspaceCount === 0) {
@@ -53,6 +58,9 @@ export function DeleteWorktreeLineageNotice({
                 <div className="truncate font-medium text-foreground">{child.displayName}</div>
                 <div className="truncate text-muted-foreground">{child.path}</div>
                 <DeleteWorktreeDirtyChangeHint
+                  checkState={changeCheckStatesByWorktreeId?.get(
+                    child.hostId ? getWorktreeHostIdentity(child) : child.id
+                  )}
                   changeCount={dirtyChangeCountsByWorktreeId.get(
                     child.hostId ? getWorktreeHostIdentity(child) : child.id
                   )}
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeTargetPreview.test.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeTargetPreview.test.tsx
index f744f4f4b63..a93ec554d1b 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeTargetPreview.test.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeTargetPreview.test.tsx
@@ -190,9 +190,6 @@ describe('DeleteWorktreeTargetPreview loaded paths', () => {
     })
     expect(trigger).toHaveAttribute('aria-expanded', 'false')
     expect(screen.queryByText('src/app.ts')).not.toBeInTheDocument()
-    expect(
-      screen.getByText('Deleting this workspace permanently removes these changes from disk.')
-    ).toBeVisible()
     fireEvent.click(trigger)
 
     expect(trigger).toHaveAttribute('aria-expanded', 'true')
@@ -222,7 +219,7 @@ describe('DeleteWorktreeTargetPreview loaded paths', () => {
     expect(screen.queryByText(/No files|clean|0 changes/)).not.toBeInTheDocument()
   })
 
-  it('expands each qualified batch target independently', () => {
+  it('opens the selected host preview and closes the previous preview', () => {
     const local = makeWorktree('same', 'collide', 'local')
     const runtime = makeWorktree('same', 'collide', 'runtime:runtime-7')
     const localKey = getWorktreeHostIdentity(local)
@@ -251,11 +248,12 @@ describe('DeleteWorktreeTargetPreview loaded paths', () => {
     const localRow = screen.getByRole('listitem', { name: /Local/ })
     const runtimeRow = screen.getByRole('listitem', { name: /Build Mac/ })
     fireEvent.click(within(localRow).getByRole('button'))
-    expect(within(localRow).getByText('local.ts')).toBeVisible()
+    expect(screen.getByText('local.ts')).toBeVisible()
     expect(within(runtimeRow).queryByText('runtime.ts')).not.toBeInTheDocument()
+    expect(screen.getByLabelText('deleted')).toHaveTextContent('D')
     fireEvent.click(within(runtimeRow).getByRole('button'))
-    expect(within(runtimeRow).getByText('runtime.ts')).toBeVisible()
-    expect(within(localRow).getByLabelText('deleted')).toHaveTextContent('D')
-    expect(within(runtimeRow).getByLabelText('renamed')).toHaveTextContent('R')
+    expect(screen.getByText('runtime.ts')).toBeVisible()
+    expect(screen.queryByText('local.ts')).not.toBeInTheDocument()
+    expect(screen.getByLabelText('renamed')).toHaveTextContent('R')
   })
 })
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeTargetPreview.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeTargetPreview.tsx
index 9253346f9d4..633fe7d17d4 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeTargetPreview.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeTargetPreview.tsx
@@ -4,7 +4,10 @@ import { ScrollArea } from '@/components/ui/scroll-area'
 import type { Worktree } from '../../../../shared/worktree/types'
 import { getWorktreeHostIdentity } from '../../../../shared/worktree/host-qualified-identity'
 import { DeleteWorktreeDirtyChangeHint } from './DeleteWorktreeDirtyChangeHint'
-import type { DeleteWorktreeDirtyChangePreview } from './delete-worktree-dirty-change-counts'
+import type {
+  DeleteWorktreeChangeCheckState,
+  DeleteWorktreeDirtyChangePreview
+} from './delete-worktree-dirty-change-counts'
 import type { AppState } from '@/store/types'
 import { getDeleteStateForWorktreeHost } from './worktree-delete-state-host-match'
 import { getWorktreeDeleteErrorToShow } from './worktree-delete-error-display'
@@ -46,7 +49,8 @@ export function DeleteWorktreeTargetPreview({
   hostLabelById,
   deleteStateByWorktreeId,
   dirtyChangeCountsByWorktreeId,
-  dirtyChangePreviewsByWorktreeId
+  dirtyChangePreviewsByWorktreeId,
+  changeCheckStatesByWorktreeId
 }: {
   isBatchDelete: boolean
   worktree: Worktree | null
@@ -56,6 +60,7 @@ export function DeleteWorktreeTargetPreview({
   deleteStateByWorktreeId: AppState['deleteStateByWorktreeId']
   dirtyChangeCountsByWorktreeId: ReadonlyMap<string, number>
   dirtyChangePreviewsByWorktreeId: ReadonlyMap<string, DeleteWorktreeDirtyChangePreview>
+  changeCheckStatesByWorktreeId?: ReadonlyMap<string, DeleteWorktreeChangeCheckState>
 }): JSX.Element | null {
   const targetIdPrefix = useId()
   const collisionIds = getCollisionIds(collisionWorktrees)
@@ -94,6 +99,9 @@ export function DeleteWorktreeTargetPreview({
                     ) : null}
                     <DeleteWorktreeDirtyChangeHint
                       key={getWorktreeHostIdentity(item)}
+                      checkState={changeCheckStatesByWorktreeId?.get(
+                        item.hostId ? getWorktreeHostIdentity(item) : item.id
+                      )}
                       changeCount={dirtyChangeCountsByWorktreeId.get(
                         item.hostId ? getWorktreeHostIdentity(item) : item.id
                       )}
@@ -147,6 +155,9 @@ export function DeleteWorktreeTargetPreview({
       ) : null}
       <DeleteWorktreeDirtyChangeHint
         key={getWorktreeHostIdentity(worktree)}
+        checkState={changeCheckStatesByWorktreeId?.get(
+          worktree.hostId ? getWorktreeHostIdentity(worktree) : worktree.id
+        )}
         changeCount={dirtyChangeCountsByWorktreeId.get(
           worktree.hostId ? getWorktreeHostIdentity(worktree) : worktree.id
         )}
diff --git a/src/renderer/src/components/sidebar/RemoteFileBrowser.tsx b/src/renderer/src/components/sidebar/RemoteFileBrowser.tsx
index dbd134775c9..423c72d2f51 100644
--- a/src/renderer/src/components/sidebar/RemoteFileBrowser.tsx
+++ b/src/renderer/src/components/sidebar/RemoteFileBrowser.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import type React from 'react'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { LoaderCircle, Search } from 'lucide-react'
@@ -245,7 +246,7 @@ export function RemoteFileBrowser({
       {/* Filter input */}
       <div className="relative">
         <Search className="size-3.5 text-muted-foreground absolute left-2 top-1/2 -translate-y-1/2 pointer-events-none" />
-        <input
+        <ImeInput
           ref={inputRef}
           type="text"
           autoFocus
diff --git a/src/renderer/src/components/sidebar/WorkspaceKanbanDrawer.tsx b/src/renderer/src/components/sidebar/WorkspaceKanbanDrawer.tsx
index a8ada9cc612..63e7880fa03 100644
--- a/src/renderer/src/components/sidebar/WorkspaceKanbanDrawer.tsx
+++ b/src/renderer/src/components/sidebar/WorkspaceKanbanDrawer.tsx
@@ -68,7 +68,6 @@ function WorkspaceKanbanDrawerContent({
   const workspaceBoardColumnWidth = useAppStore((s) => s.workspaceBoardColumnWidth)
   const setWorkspaceBoardColumnWidth = useAppStore((s) => s.setWorkspaceBoardColumnWidth)
   const sortBy = useAppStore((s) => s.sortBy)
-  const setSortBy = useAppStore((s) => s.setSortBy)
   const sidebarOpen = useAppStore((s) => s.sidebarOpen)
   const sidebarWidth = useAppStore((s) => s.sidebarWidth)
   const boardRef = useRef<HTMLDivElement>(null)
@@ -135,7 +134,6 @@ function WorkspaceKanbanDrawerContent({
     laneFullWorktreeIds,
     laneViews,
     maybeSyncTaskStatuses: maybeSyncWorkspaceBoardTaskStatuses,
-    setSortBy,
     sortBy,
     updateWorktreeMeta,
     updateWorktreesMeta,
diff --git a/src/renderer/src/components/sidebar/WorkspaceKanbanSettingsMenu.tsx b/src/renderer/src/components/sidebar/WorkspaceKanbanSettingsMenu.tsx
index d4bceb02494..df866439633 100644
--- a/src/renderer/src/components/sidebar/WorkspaceKanbanSettingsMenu.tsx
+++ b/src/renderer/src/components/sidebar/WorkspaceKanbanSettingsMenu.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import React from 'react'
 import { ArrowDown, ArrowUp, Plus, Settings, Trash2 } from 'lucide-react'
 import { Button } from '@/components/ui/button'
@@ -120,7 +121,7 @@ export default function WorkspaceKanbanSettingsMenu({
               >
                 <div className="flex items-center gap-1">
                   <meta.icon className={cn('size-3.5 shrink-0', meta.tone)} />
-                  <input
+                  <ImeInput
                     defaultValue={status.label}
                     onBlur={(event) => onRenameStatus(status.id, event.target.value)}
                     onKeyDown={(event) => {
diff --git a/src/renderer/src/components/sidebar/WorktreeList.tsx b/src/renderer/src/components/sidebar/WorktreeList.tsx
index d50f06c0026..8fe26780866 100644
--- a/src/renderer/src/components/sidebar/WorktreeList.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeList.tsx
@@ -108,7 +108,7 @@ const WorktreeList = React.memo(function WorktreeList({
   const agentSendTargetWorktreeId = useAgentSendTargetWorktreeId()
   const { filterState, hasFilters, clearFilters, revealWorkspaceFilters } =
     useSidebarWorktreeFilters()
-  const sortedIds = useSidebarWorktreeSortOrder({ allWorktrees, repoMap, sortBy })
+  const sortedIds = useSidebarWorktreeSortOrder({ repoMap, sortBy })
   const manualOrderCatalog = useMemo(
     () => buildWorktreeManualOrderCatalog({ worktrees: allWorktrees, folderWorkspaces }),
     [allWorktrees, folderWorkspaces]
diff --git a/src/renderer/src/components/sidebar/WorktreeMetaDialog.test.tsx b/src/renderer/src/components/sidebar/WorktreeMetaDialog.test.tsx
index d367c6ef44c..1b1eeb8f81d 100644
--- a/src/renderer/src/components/sidebar/WorktreeMetaDialog.test.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeMetaDialog.test.tsx
@@ -57,6 +57,26 @@ import WorktreeMetaDialog from './WorktreeMetaDialog'
 const REPO_ID = 'repo-1'
 const WORKTREE_ID = 'repo-1::/repo/worktrees/feature'
 
+const IME_FIELDS = [
+  {
+    placeholder: 'Notes about this worktree...',
+    value: '日本語',
+    updates: { comment: '日本語' }
+  },
+  {
+    placeholder: 'Custom display name...',
+    value: '日本語の名前',
+    updates: { displayName: '日本語の名前' }
+  },
+  {
+    placeholder: 'Issue #, or a GitHub or Linear URL',
+    value: '42',
+    updates: { linkedIssue: 42 }
+  },
+  { placeholder: 'PR # or GitHub URL', value: '43', updates: { linkedPR: 43 } },
+  { placeholder: 'MR ! or GitLab URL', value: '!44', updates: { linkedGitLabMR: 44 } }
+] as const
+
 const initialState = useAppStore.getInitialState()
 const updateWorktreeMeta =
   vi.fn<
@@ -223,9 +243,166 @@ describe('WorktreeMetaDialog issue link row', () => {
 
   afterEach(() => {
     cleanup()
+    vi.restoreAllMocks()
     useAppStore.setState(initialState, true)
   })
 
+  it.each(IME_FIELDS)(
+    'ignores IME Enter and resets on blur in $placeholder',
+    async ({ placeholder, value, updates }) => {
+      openDialog(placeholder === 'MR ! or GitLab URL' ? { modalReviewProvider: 'gitlab' } : {})
+      const input = screen.getByPlaceholderText(placeholder)
+      fireEvent.change(input, { target: { value } })
+      for (const marker of [{ isComposing: true, keyCode: 13 }, { keyCode: 229 }]) {
+        expect(fireEvent.keyDown(input, { key: 'Enter', ...marker })).toBe(true)
+        expect(updateWorktreeMeta).not.toHaveBeenCalled()
+        expect(useAppStore.getState().activeModal).toBe('edit-meta')
+      }
+      fireEvent.compositionStart(input)
+      expect(fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })).toBe(true)
+      expect(updateWorktreeMeta).not.toHaveBeenCalled()
+      fireEvent.blur(input)
+      await act(async () => {
+        fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+      })
+      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
+      expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual(expect.objectContaining(updates))
+      expect(useAppStore.getState().activeModal).toBe('none')
+    }
+  )
+
+  it.each(
+    ['before keyup', 'after keyup'].flatMap((order) =>
+      IME_FIELDS.map((field) => ({ ...field, order }))
+    )
+  )(
+    'ignores the IME Enter redispatch $order in $placeholder',
+    async ({ order, placeholder, value, updates }) => {
+      openDialog(placeholder === 'MR ! or GitLab URL' ? { modalReviewProvider: 'gitlab' } : {})
+      const input = screen.getByPlaceholderText(placeholder)
+      const frames: FrameRequestCallback[] = []
+      vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) =>
+        frames.push(callback)
+      )
+      fireEvent.compositionStart(input)
+      fireEvent.keyDown(input, { key: 'Process', keyCode: 229, isComposing: true })
+      fireEvent.change(input, { target: { value } })
+      fireEvent.compositionEnd(input)
+      if (order === 'after keyup') {
+        fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+      }
+      expect(fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })).toBe(false)
+      expect(updateWorktreeMeta).not.toHaveBeenCalled()
+      expect(useAppStore.getState().activeModal).toBe('edit-meta')
+      fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+      act(() => frames.forEach((callback) => callback(0)))
+      await act(async () => {
+        fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+      })
+      expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual(expect.objectContaining(updates))
+      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
+      expect(useAppStore.getState().activeModal).toBe('none')
+    }
+  )
+
+  it.each(IME_FIELDS)(
+    'expires an IME gesture without redispatch in $placeholder',
+    async ({ placeholder }) => {
+      openDialog(placeholder === 'MR ! or GitLab URL' ? { modalReviewProvider: 'gitlab' } : {})
+      const input = screen.getByPlaceholderText(placeholder)
+      const frames: FrameRequestCallback[] = []
+      vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) =>
+        frames.push(callback)
+      )
+      fireEvent.compositionStart(input)
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
+      fireEvent.compositionEnd(input)
+      fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
+      act(() => frames.forEach((callback) => callback(0)))
+      await act(async () => {
+        fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+      })
+      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
+      expect(useAppStore.getState().activeModal).toBe('none')
+    }
+  )
+
+  it.each(
+    ['active composition', 'pending confirmation'].flatMap((phase) =>
+      IME_FIELDS.map((field) => ({ ...field, phase }))
+    )
+  )(
+    'allows a deliberate save after closing with $phase in $placeholder',
+    async ({ phase, placeholder, value, updates }) => {
+      openDialog(placeholder === 'MR ! or GitLab URL' ? { modalReviewProvider: 'gitlab' } : {})
+      const input = screen.getByPlaceholderText(placeholder)
+      const modalData = useAppStore.getState().modalData
+      fireEvent.compositionStart(input)
+      if (phase === 'pending confirmation') {
+        fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
+        fireEvent.compositionEnd(input)
+      }
+      act(() => useAppStore.getState().closeModal())
+      expect(screen.queryByPlaceholderText(placeholder)).toBeNull()
+      act(() => useAppStore.setState({ activeModal: 'edit-meta', modalData }))
+      const reopenedInput = screen.getByPlaceholderText(placeholder)
+      fireEvent.change(reopenedInput, { target: { value } })
+      await act(async () => {
+        fireEvent.keyDown(reopenedInput, { key: 'Enter', keyCode: 13 })
+      })
+      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
+      expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual(expect.objectContaining(updates))
+      expect(useAppStore.getState().activeModal).toBe('none')
+    }
+  )
+
+  it('keeps a folder workspace note open through composition confirmation', async () => {
+    const worktreeId = folderWorkspaceKey('fw-1')
+    openDialog({ worktreeId, folderWorkspace: {} })
+    const input = screen.getByPlaceholderText('Notes about this worktree...')
+    fireEvent.change(input, { target: { value: '日本語' } })
+    fireEvent.compositionStart(input)
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
+    fireEvent.compositionEnd(input)
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+    expect(updateWorktreeMeta).not.toHaveBeenCalled()
+    expect(useAppStore.getState().activeModal).toBe('edit-meta')
+    await act(async () => {
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+    })
+    expect(updateWorktreeMeta).toHaveBeenCalledExactlyOnceWith(worktreeId, { comment: '日本語' })
+    expect(useAppStore.getState().activeModal).toBe('none')
+  })
+
+  it.each([
+    { userAgent: 'Macintosh', modifier: { metaKey: true } },
+    { userAgent: 'Windows', modifier: { ctrlKey: true } },
+    { userAgent: 'Linux', modifier: { ctrlKey: true } }
+  ])(
+    'keeps the save shortcut outside composition on $userAgent',
+    async ({ userAgent, modifier }) => {
+      vi.spyOn(navigator, 'userAgent', 'get').mockReturnValue(userAgent)
+      openDialog()
+      const input = screen.getByPlaceholderText('Notes about this worktree...')
+      fireEvent.compositionStart(input)
+      fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, ...modifier })
+      expect(updateWorktreeMeta).not.toHaveBeenCalled()
+      fireEvent.compositionEnd(input)
+      await act(async () => {
+        fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, ...modifier })
+      })
+      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
+    }
+  )
+
+  it('leaves Shift+Enter available for a newline', () => {
+    openDialog()
+    const input = screen.getByPlaceholderText('Notes about this worktree...')
+    expect(fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, shiftKey: true })).toBe(true)
+    expect(updateWorktreeMeta).not.toHaveBeenCalled()
+    expect(useAppStore.getState().activeModal).toBe('edit-meta')
+  })
+
   it('seeds the chip and value from a GitHub link', () => {
     openDialog({ worktree: { linkedIssue: 42 } })
 
diff --git a/src/renderer/src/components/sidebar/WorktreeMetaDialog.tsx b/src/renderer/src/components/sidebar/WorktreeMetaDialog.tsx
index 87b67039a0f..197485851a4 100644
--- a/src/renderer/src/components/sidebar/WorktreeMetaDialog.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeMetaDialog.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import React, { useCallback, useMemo, useRef, useState } from 'react'
 import { useAppStore } from '@/store'
 import {
@@ -34,11 +35,7 @@ import {
 import { parseExecutionHostId } from '../../../../shared/execution-host'
 import { WorktreeDisplayNameField } from './WorktreeDisplayNameField'
 import { WorktreeReviewLinkField } from './WorktreeReviewLinkField'
-
-function resizeCommentTextarea(textarea: HTMLTextAreaElement): void {
-  textarea.style.height = 'auto'
-  textarea.style.height = `${textarea.scrollHeight}px`
-}
+import { resizeCommentTextarea } from './worktree-comment-textarea-sizing'
 
 /** Only read before the first open, when nothing can be saved yet. */
 const EMPTY_SNAPSHOT: WorktreeMetaSnapshot = {
@@ -54,10 +51,8 @@ const WorktreeMetaDialog = React.memo(function WorktreeMetaDialog() {
   const modalData = useAppStore((s) => s.modalData)
   const closeModal = useAppStore((s) => s.closeModal)
   const updateWorktreeMeta = useAppStore((s) => s.updateWorktreeMeta)
-  const submitShortcutLabel = getScreenSubmitShortcutLabel()
 
-  const isEditMeta = activeModal === 'edit-meta'
-  const isOpen = isEditMeta
+  const isOpen = activeModal === 'edit-meta'
 
   const worktreeId = typeof modalData.worktreeId === 'string' ? modalData.worktreeId : ''
   const executionHostId =
@@ -172,11 +167,11 @@ const WorktreeMetaDialog = React.memo(function WorktreeMetaDialog() {
   const setCommentTextareaRef = useCallback(
     (textarea: HTMLTextAreaElement | null) => {
       textareaRef.current = textarea
-      if (textarea && isEditMeta) {
+      if (textarea && isOpen) {
         resizeCommentTextarea(textarea)
       }
     },
-    [isEditMeta]
+    [isOpen]
   )
 
   const handleCommentChange = useCallback((event: React.ChangeEvent<HTMLTextAreaElement>) => {
@@ -386,7 +381,7 @@ const WorktreeMetaDialog = React.memo(function WorktreeMetaDialog() {
             <label className="text-[11px] font-medium text-muted-foreground">
               {translate('auto.components.sidebar.WorktreeMetaDialog.9c1d1e9b71', 'Comment')}
             </label>
-            <textarea
+            <ImeTextarea
               ref={setCommentTextareaRef}
               value={commentInput}
               onChange={handleCommentChange}
@@ -403,7 +398,7 @@ const WorktreeMetaDialog = React.memo(function WorktreeMetaDialog() {
                 'auto.components.sidebar.WorktreeMetaDialog.7f0be5e9a6',
                 'Supports **markdown** — bold, lists, `code`, links. Press Enter or'
               )}{' '}
-              {submitShortcutLabel}{' '}
+              {getScreenSubmitShortcutLabel()}{' '}
               {translate(
                 'auto.components.sidebar.WorktreeMetaDialog.b48c271d39',
                 'to save, Shift+Enter for a new line.'
diff --git a/src/renderer/src/components/sidebar/delete-worktree-dirty-change-counts.test.ts b/src/renderer/src/components/sidebar/delete-worktree-dirty-change-counts.test.ts
index 4c0475e51f5..07cb1452332 100644
--- a/src/renderer/src/components/sidebar/delete-worktree-dirty-change-counts.test.ts
+++ b/src/renderer/src/components/sidebar/delete-worktree-dirty-change-counts.test.ts
@@ -4,6 +4,7 @@ import type { Repo } from '../../../../shared/repo-types'
 import type { GitStatusEntry } from '../../../../shared/git-status-types'
 import { getWorktreeHostIdentity } from '../../../../shared/worktree/host-qualified-identity'
 import {
+  getDeleteWorktreeChangeCheckStates,
   getDeleteWorktreeDirtyChangeCounts,
   getDeleteWorktreeDirtyChangePreview,
   getDeleteWorktreeDirtyChangePreviews,
@@ -176,5 +177,51 @@ describe('delete-worktree loaded change previews', () => {
       0
     )
     expect(getDeleteWorktreeDirtyChangePreviews(input).size).toBe(0)
+    expect(getDeleteWorktreeChangeCheckStates(input).size).toBe(0)
+  })
+})
+
+describe('deletion check states', () => {
+  it('distinguishes pending, failed and completed reads on the target host', () => {
+    const pending = worktree('same', 'ssh:pending')
+    const failed = worktree('same', 'ssh:failed')
+    const clean = worktree('same', 'local')
+    const input = {
+      deleteTargets: [pending, failed, clean],
+      gitStatusByWorktree: { same: [{ path: 'wrong-host.ts' }] },
+      gitStatusByWorktreeIdentity: new Map([
+        [getWorktreeHostIdentity(failed), null],
+        [getWorktreeHostIdentity(clean), []]
+      ]),
+      repoMap: new Map()
+    }
+    expect(getDeleteWorktreeChangeCheckStates(input)).toEqual(
+      new Map([
+        [getWorktreeHostIdentity(pending), 'checking'],
+        [getWorktreeHostIdentity(failed), 'unavailable'],
+        [getWorktreeHostIdentity(clean), 'complete']
+      ])
+    )
+    expect(getDeleteWorktreeDirtyChangeCounts({ ...input, deleteStateByWorktreeId: {} }).size).toBe(
+      0
+    )
+  })
+
+  it('uses a hydrated read for a target without an explicit host', () => {
+    const target = worktree('legacy')
+    const entries: GitStatusEntry[] = [{ path: 'pending.ts', status: 'modified', area: 'unstaged' }]
+    const input = {
+      deleteTargets: [target],
+      gitStatusByWorktree: {},
+      gitStatusByWorktreeIdentity: new Map([[getWorktreeHostIdentity(target), entries]]),
+      repoMap: new Map()
+    }
+    expect(getDeleteWorktreeChangeCheckStates(input).get('legacy')).toBe('complete')
+    expect(
+      getDeleteWorktreeDirtyChangeCounts({ ...input, deleteStateByWorktreeId: {} }).get('legacy')
+    ).toBe(1)
+    expect(getDeleteWorktreeDirtyChangePreviews(input).get('legacy')?.files[0]?.path).toBe(
+      'pending.ts'
+    )
   })
 })
diff --git a/src/renderer/src/components/sidebar/delete-worktree-dirty-change-counts.ts b/src/renderer/src/components/sidebar/delete-worktree-dirty-change-counts.ts
index ce3bab3e6be..0fdd7cdd7e2 100644
--- a/src/renderer/src/components/sidebar/delete-worktree-dirty-change-counts.ts
+++ b/src/renderer/src/components/sidebar/delete-worktree-dirty-change-counts.ts
@@ -6,6 +6,43 @@ import type { WorktreeDeleteState } from '../../store/slices/worktree-helpers'
 import { normalizeRelativePath } from '@/lib/path'
 import { buildStatusMap } from '../right-sidebar/status-display'
 import { isFolderWorkspaceDelete } from './delete-worktree-dialog-copy'
+import { getDeleteStateForWorktreeHost } from './worktree-delete-state-host-match'
+
+export type DeleteWorktreeChangeCheckState = 'checking' | 'complete' | 'unavailable'
+
+type DeleteWorktreeStatusInput<Entry> = {
+  deleteTargets: readonly Worktree[]
+  gitStatusByWorktree: Record<string, readonly Entry[] | undefined>
+  gitStatusByWorktreeIdentity?: ReadonlyMap<string, readonly Entry[] | null>
+  repoMap: ReadonlyMap<string, Repo>
+}
+
+function getStatusEntries<Entry>(
+  item: Worktree,
+  input: DeleteWorktreeStatusInput<Entry>
+): readonly Entry[] | null | undefined {
+  return item.hostId
+    ? input.gitStatusByWorktreeIdentity?.get(getWorktreeHostIdentity(item))
+    : (input.gitStatusByWorktree[item.id] ??
+        input.gitStatusByWorktreeIdentity?.get(getWorktreeHostIdentity(item)))
+}
+
+export function getDeleteWorktreeChangeCheckStates(
+  input: DeleteWorktreeStatusInput<unknown>
+): Map<string, DeleteWorktreeChangeCheckState> {
+  const result = new Map<string, DeleteWorktreeChangeCheckState>()
+  for (const item of input.deleteTargets) {
+    if (item.isMainWorktree || isFolderWorkspaceDelete(input.repoMap, item)) {
+      continue
+    }
+    const entries = getStatusEntries(item, input)
+    result.set(
+      item.hostId ? getWorktreeHostIdentity(item) : item.id,
+      entries === null ? 'unavailable' : entries === undefined ? 'checking' : 'complete'
+    )
+  }
+  return result
+}
 
 export function orderDeleteWorktreeStatusHydrationTargets({
   targets,
@@ -30,7 +67,6 @@ export function orderDeleteWorktreeStatusHydrationTargets({
     .sort((left, right) => left.rank - right.rank || left.index - right.index)
     .map(({ target }) => target)
 }
-import { getDeleteStateForWorktreeHost } from './worktree-delete-state-host-match'
 
 export function getDeleteWorktreeDirtyChangeCounts({
   deleteTargets,
@@ -42,7 +78,7 @@ export function getDeleteWorktreeDirtyChangeCounts({
   deleteTargets: readonly Worktree[]
   deleteStateByWorktreeId: Record<string, WorktreeDeleteState | undefined>
   gitStatusByWorktree: Record<string, readonly unknown[] | undefined>
-  gitStatusByWorktreeIdentity?: ReadonlyMap<string, readonly unknown[]>
+  gitStatusByWorktreeIdentity?: ReadonlyMap<string, readonly unknown[] | null>
   repoMap: ReadonlyMap<string, Repo>
 }): Map<string, number> {
   const result = new Map<string, number>()
@@ -55,11 +91,12 @@ export function getDeleteWorktreeDirtyChangeCounts({
       item,
       deleteStateByWorktreeId
     )?.forceDeleteReason
-    const changeCount = (
-      item.hostId
-        ? gitStatusByWorktreeIdentity?.get(getWorktreeHostIdentity(item))
-        : gitStatusByWorktree[item.id]
-    )?.length
+    const changeCount = getStatusEntries(item, {
+      deleteTargets,
+      gitStatusByWorktree,
+      gitStatusByWorktreeIdentity,
+      repoMap
+    })?.length
     if ((changeCount ?? 0) > 0) {
       result.set(resultKey, changeCount ?? 0)
     } else if (forceDeleteReason === 'dirty') {
@@ -109,7 +146,7 @@ export function getDeleteWorktreeDirtyChangePreviews({
 }: {
   deleteTargets: readonly Worktree[]
   gitStatusByWorktree: Record<string, readonly GitStatusEntry[] | undefined>
-  gitStatusByWorktreeIdentity?: ReadonlyMap<string, readonly GitStatusEntry[]>
+  gitStatusByWorktreeIdentity?: ReadonlyMap<string, readonly GitStatusEntry[] | null>
   repoMap: ReadonlyMap<string, Repo>
 }): Map<string, DeleteWorktreeDirtyChangePreview> {
   const result = new Map<string, DeleteWorktreeDirtyChangePreview>()
@@ -118,9 +155,12 @@ export function getDeleteWorktreeDirtyChangePreviews({
       continue
     }
     const resultKey = item.hostId ? getWorktreeHostIdentity(item) : item.id
-    const entries = item.hostId
-      ? gitStatusByWorktreeIdentity?.get(getWorktreeHostIdentity(item))
-      : gitStatusByWorktree[item.id]
+    const entries = getStatusEntries(item, {
+      deleteTargets,
+      gitStatusByWorktree,
+      gitStatusByWorktreeIdentity,
+      repoMap
+    })
     if (entries?.length) {
       result.set(resultKey, getDeleteWorktreeDirtyChangePreview(entries))
     }
diff --git a/src/renderer/src/components/sidebar/delete-worktree-dirty-change-hydration.test.tsx b/src/renderer/src/components/sidebar/delete-worktree-dirty-change-hydration.test.tsx
index 297bfa66a0e..14755d8ead7 100644
--- a/src/renderer/src/components/sidebar/delete-worktree-dirty-change-hydration.test.tsx
+++ b/src/renderer/src/components/sidebar/delete-worktree-dirty-change-hydration.test.tsx
@@ -11,6 +11,7 @@ import { DeleteWorktreeTargetPreview } from './DeleteWorktreeTargetPreview'
 import { DeleteWorktreeLineageNotice } from './DeleteWorktreeLineageNotice'
 import { useDeleteWorktreeStatusHydration } from './use-delete-worktree-status-hydration'
 import {
+  getDeleteWorktreeChangeCheckStates,
   getDeleteWorktreeDirtyChangeCounts,
   getDeleteWorktreeDirtyChangePreview,
   getDeleteWorktreeDirtyChangePreviews
@@ -92,6 +93,7 @@ function Preview({ worktree }: { worktree: Worktree }): JSX.Element {
       collisionWorktrees={targets}
       hostLabelById={new Map()}
       deleteStateByWorktreeId={input.deleteStateByWorktreeId}
+      changeCheckStatesByWorktreeId={getDeleteWorktreeChangeCheckStates(input)}
       dirtyChangeCountsByWorktreeId={getDeleteWorktreeDirtyChangeCounts(input)}
       dirtyChangePreviewsByWorktreeId={getDeleteWorktreeDirtyChangePreviews(input)}
     />
@@ -102,6 +104,28 @@ afterEach(cleanup)
 beforeEach(() => vi.clearAllMocks())
 
 describe('loaded deletion disclosure and existing hydration', () => {
+  it('shows pending and failed detail checks alongside a known dirty warning', async () => {
+    let failRead: (error: Error) => void = () => {
+      throw new Error('Status read has not started')
+    }
+    vi.mocked(getRuntimeGitStatus).mockImplementationOnce(
+      () =>
+        new Promise((_resolve, reject) => {
+          failRead = reject
+        })
+    )
+    render(<Preview worktree={target('known-dirty')} />)
+    expect(screen.getByText('Uncommitted or untracked changes')).toBeVisible()
+    expect(screen.getByText('· Checking…')).toBeVisible()
+    await act(async () => {
+      failRead(new Error('Details unavailable'))
+    })
+    expect(screen.getByText('Uncommitted or untracked changes')).toBeVisible()
+    expect(screen.getByText('· Details unavailable')).toBeVisible()
+    expect(screen.queryByRole('button')).not.toBeInTheDocument()
+    expect(screen.queryByText(/No uncommitted|0 changes/)).not.toBeInTheDocument()
+  })
+
   it('expands and collapses a hydrated snapshot without requesting status again', async () => {
     vi.mocked(getRuntimeGitStatus).mockResolvedValue({
       entries: [
@@ -155,6 +179,7 @@ describe('loaded deletion disclosure and existing hydration', () => {
     })
     await waitFor(() => expect(getRuntimeGitStatus).toHaveBeenCalledTimes(2))
     expect(screen.getByText('Uncommitted or untracked changes')).toBeVisible()
+    expect(screen.getByText('· Details unavailable')).toBeVisible()
     expect(screen.queryByRole('button')).not.toBeInTheDocument()
     expect(screen.queryByText('old-host.ts')).not.toBeInTheDocument()
     expect(screen.queryByText(/No files|clean|0 changes/)).not.toBeInTheDocument()
diff --git a/src/renderer/src/components/sidebar/folder-workspace-composer-submit.ts b/src/renderer/src/components/sidebar/folder-workspace-composer-submit.ts
index c4857877e11..40d65b759e2 100644
--- a/src/renderer/src/components/sidebar/folder-workspace-composer-submit.ts
+++ b/src/renderer/src/components/sidebar/folder-workspace-composer-submit.ts
@@ -18,6 +18,7 @@ import {
   toFolderWorkspaceLinkedTask
 } from './folder-workspace-composer-helpers'
 import { planAgentSessionLaunch } from '@/lib/agent-session-launch-plan'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { beginStructuredAgentSessionProvisionalLaunch } from '@/lib/structured-agent-session-provisional-tab'
 import { getNewWorkspaceProjectGroupHostId } from '@/lib/new-workspace-project-options'
 import { useAppStore } from '@/store'
@@ -132,6 +133,7 @@ export async function submitFolderWorkspaceCreate({
     quickAgent && linkedWorkItem ? resolveFolderWorkspaceLaunchDraft(linkedWorkItem, note) : null
   const plan = quickAgent
     ? planAgentSessionLaunch(useAppStore.getState(), {
+        requestId: newAgentLaunchRequestId(),
         agent: quickAgent,
         workspace: {
           kind: 'folder',
diff --git a/src/renderer/src/components/sidebar/manual-sort-switch-toast.test.ts b/src/renderer/src/components/sidebar/manual-sort-switch-toast.test.ts
new file mode 100644
index 00000000000..bafe2a6f7cb
--- /dev/null
+++ b/src/renderer/src/components/sidebar/manual-sort-switch-toast.test.ts
@@ -0,0 +1,73 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import { switchSortToManualAfterDrop } from './manual-sort-switch-toast'
+
+const { toastInfo, toastDismiss } = vi.hoisted(() => ({
+  toastInfo: vi.fn(),
+  toastDismiss: vi.fn()
+}))
+vi.mock('sonner', () => ({ toast: { info: toastInfo, dismiss: toastDismiss } }))
+
+const initialState = useAppStore.getInitialState()
+
+type ToastOptions = {
+  id?: string
+  onDismiss?: () => void
+  action?: { label: string; onClick: () => void }
+}
+
+function lastToastOptions(): ToastOptions {
+  const options: unknown = toastInfo.mock.calls.at(-1)?.[1]
+  expect(options).toBeTypeOf('object')
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: asserted to be the options object passed to toast.info above.
+  return options as ToastOptions
+}
+
+describe('switchSortToManualAfterDrop', () => {
+  beforeEach(() => {
+    useAppStore.setState(initialState, true)
+    toastInfo.mockClear()
+    toastDismiss.mockClear()
+  })
+
+  afterEach(() => {
+    if (toastInfo.mock.calls.length > 0) {
+      lastToastOptions().onDismiss?.()
+    }
+    useAppStore.setState(initialState, true)
+  })
+
+  it('switches to Manual and offers a way back to the previous sort', () => {
+    useAppStore.setState({ sortBy: 'smart' })
+    switchSortToManualAfterDrop()
+
+    expect(useAppStore.getState().sortBy).toBe('manual')
+    expect(toastInfo).toHaveBeenCalledTimes(1)
+    const options = lastToastOptions()
+    expect(options.action?.label).toBe('Back to Agent Activity')
+
+    options.action?.onClick()
+    expect(useAppStore.getState().sortBy).toBe('smart')
+  })
+
+  it('does nothing when Manual is already active', () => {
+    useAppStore.setState({ sortBy: 'manual' })
+    switchSortToManualAfterDrop()
+
+    expect(toastInfo).not.toHaveBeenCalled()
+  })
+
+  it('retires the toast once the user picks another sort', () => {
+    useAppStore.setState({ sortBy: 'recent' })
+    switchSortToManualAfterDrop()
+    const options = lastToastOptions()
+
+    useAppStore.setState({ sortBy: 'name' })
+    expect(toastDismiss).toHaveBeenCalledWith(options.id)
+
+    // A round trip back to Manual must not let the stale action override it.
+    useAppStore.setState({ sortBy: 'manual' })
+    options.action?.onClick()
+    expect(useAppStore.getState().sortBy).toBe('manual')
+  })
+})
diff --git a/src/renderer/src/components/sidebar/manual-sort-switch-toast.ts b/src/renderer/src/components/sidebar/manual-sort-switch-toast.ts
new file mode 100644
index 00000000000..5018cf5b6b5
--- /dev/null
+++ b/src/renderer/src/components/sidebar/manual-sort-switch-toast.ts
@@ -0,0 +1,59 @@
+import { toast } from 'sonner'
+import { translate } from '@/i18n/i18n'
+import { useAppStore } from '@/store'
+import { SORT_OPTIONS } from './sidebar-workspace-option-items'
+
+const MANUAL_SORT_SWITCH_TOAST_ID = 'sidebar-manual-sort-switch'
+
+// Why: a drop that reorders must switch to Manual so the placement sticks; say so, since it changes a shared setting.
+export function switchSortToManualAfterDrop(): void {
+  const { sortBy: previousSortBy, setSortBy } = useAppStore.getState()
+  if (previousSortBy === 'manual') {
+    return
+  }
+  setSortBy('manual')
+
+  // Why: any later sort change makes "Back to …" stale, so retire the toast instead of letting it clobber that choice.
+  let retired = false
+  const retire = (): void => {
+    retired = true
+    unsubscribe()
+  }
+  const unsubscribe = useAppStore.subscribe((state, prev) => {
+    if (state.sortBy !== prev.sortBy) {
+      retire()
+      toast.dismiss(MANUAL_SORT_SWITCH_TOAST_ID)
+    }
+  })
+  const previousLabel = SORT_OPTIONS.find((option) => option.id === previousSortBy)?.label
+  toast.info(
+    translate('auto.components.sidebar.manualSortSwitch.title', 'Sort changed to Manual'),
+    {
+      id: MANUAL_SORT_SWITCH_TOAST_ID,
+      description: translate(
+        'auto.components.sidebar.manualSortSwitch.description',
+        'Manual keeps workspaces where you drop them.'
+      ),
+      duration: 8000,
+      onDismiss: retire,
+      onAutoClose: retire,
+      action: previousLabel
+        ? {
+            label: translate(
+              'auto.components.sidebar.manualSortSwitch.restore',
+              'Back to {{label}}',
+              {
+                label: previousLabel
+              }
+            ),
+            // The sortBy change retires the toast through the subscription above.
+            onClick: () => {
+              if (!retired) {
+                setSortBy(previousSortBy)
+              }
+            }
+          }
+        : undefined
+    }
+  )
+}
diff --git a/src/renderer/src/components/sidebar/use-delete-worktree-status-hydration.ts b/src/renderer/src/components/sidebar/use-delete-worktree-status-hydration.ts
index 475f0f0d1de..5ed3fd6efd0 100644
--- a/src/renderer/src/components/sidebar/use-delete-worktree-status-hydration.ts
+++ b/src/renderer/src/components/sidebar/use-delete-worktree-status-hydration.ts
@@ -12,7 +12,7 @@ import { getWorktreeHostIdentity } from '../../../../shared/worktree/host-qualif
 import { isFolderWorkspaceDelete } from './delete-worktree-dialog-copy'
 import { orderDeleteWorktreeStatusHydrationTargets } from './delete-worktree-dirty-change-counts'
 
-const EMPTY_STATUS_BY_IDENTITY = new Map<string, GitStatusResult['entries']>()
+const EMPTY_STATUS_BY_IDENTITY = new Map<string, GitStatusResult['entries'] | null>()
 
 export function useDeleteWorktreeStatusHydration({
   isOpen,
@@ -24,14 +24,14 @@ export function useDeleteWorktreeStatusHydration({
   deleteTargets: readonly Worktree[]
   visibleTargets: readonly Worktree[]
   repoMap: ReadonlyMap<string, Repo>
-}): ReadonlyMap<string, GitStatusResult['entries']> {
+}): ReadonlyMap<string, GitStatusResult['entries'] | null> {
   const repos = useAppStore((state) => state.repos)
   const settings = useAppStore((state) => state.settings)
   const generation = isOpen ? deleteTargets.map(getWorktreeHostIdentity).join('\n') : ''
   const generationRef = useRef(generation)
-  const [statusByIdentity, setStatusByIdentity] = useState<Map<string, GitStatusResult['entries']>>(
-    () => new Map()
-  )
+  const [statusByIdentity, setStatusByIdentity] = useState<
+    Map<string, GitStatusResult['entries'] | null>
+  >(() => new Map())
   const currentStatusByIdentity =
     generationRef.current === generation ? statusByIdentity : EMPTY_STATUS_BY_IDENTITY
 
@@ -89,7 +89,9 @@ export function useDeleteWorktreeStatusHydration({
           }
         })
         .catch(() => {
-          // Best effort only; deletion performs the authoritative backend check.
+          if (!controller.signal.aborted && generationRef.current === generation) {
+            setStatusByIdentity((current) => new Map(current).set(identity, null))
+          }
         })
     }
     return () => {
diff --git a/src/renderer/src/components/sidebar/use-workspace-kanban-worktree-actions.ts b/src/renderer/src/components/sidebar/use-workspace-kanban-worktree-actions.ts
index 96647d65763..b0efb012b8d 100644
--- a/src/renderer/src/components/sidebar/use-workspace-kanban-worktree-actions.ts
+++ b/src/renderer/src/components/sidebar/use-workspace-kanban-worktree-actions.ts
@@ -1,6 +1,7 @@
 import { useCallback } from 'react'
 import { useAppStore } from '@/store'
 import { getWorkspaceStatus } from './workspace-status'
+import { switchSortToManualAfterDrop } from './manual-sort-switch-toast'
 import { resolveFullLaneDropIndex } from './workspace-kanban-filtered-drop-index'
 import {
   buildManualOrderUpdatesForGroupDrop,
@@ -19,7 +20,6 @@ export function useWorkspaceKanbanWorktreeActions(args: {
   laneFullWorktreeIds: ReadonlyMap<string, readonly string[]>
   laneViews: ReadonlyMap<string, LaneView>
   maybeSyncTaskStatuses: (worktreeIds: readonly string[], status: WorkspaceStatus) => void
-  setSortBy: ReturnType<typeof useAppStore.getState>['setSortBy']
   sortBy: ReturnType<typeof useAppStore.getState>['sortBy']
   updateWorktreeMeta: ReturnType<typeof useAppStore.getState>['updateWorktreeMeta']
   updateWorktreesMeta: ReturnType<typeof useAppStore.getState>['updateWorktreesMeta']
@@ -145,7 +145,7 @@ export function useWorkspaceKanbanWorktreeActions(args: {
         return
       }
       if (writeManualOrder && order.changed) {
-        args.setSortBy('manual')
+        switchSortToManualAfterDrop()
       }
       recordInteraction()
       void args.updateWorktreesMeta(changed)
diff --git a/src/renderer/src/components/sidebar/useSidebarProjectDrop.ts b/src/renderer/src/components/sidebar/useSidebarProjectDrop.ts
index f44048aea87..90f40d0f8f2 100644
--- a/src/renderer/src/components/sidebar/useSidebarProjectDrop.ts
+++ b/src/renderer/src/components/sidebar/useSidebarProjectDrop.ts
@@ -12,6 +12,7 @@ import {
   resolveSidebarProjectDropPath
 } from './sidebar-project-drop'
 import { translate } from '@/i18n/i18n'
+import { userNamedFileAccess } from '@/lib/local-file-access'
 
 type SidebarProjectDropHandlers = {
   onDragEnter: (event: React.DragEvent<HTMLElement>) => void
@@ -79,8 +80,10 @@ export function useSidebarProjectDrop(): {
 
       setIsHandlingDrop(true)
       try {
-        await window.api.fs.authorizeExternalPath({ targetPath: pathResolution.path })
-        const stat = await window.api.fs.stat({ filePath: pathResolution.path })
+        const stat = await window.api.fs.stat({
+          filePath: pathResolution.path,
+          access: userNamedFileAccess()
+        })
         if (!mountedRef.current) {
           return
         }
diff --git a/src/renderer/src/components/sidebar/visible-worktree-options-from-state.ts b/src/renderer/src/components/sidebar/visible-worktree-options-from-state.ts
index d9a09639cdf..9ab318e26a3 100644
--- a/src/renderer/src/components/sidebar/visible-worktree-options-from-state.ts
+++ b/src/renderer/src/components/sidebar/visible-worktree-options-from-state.ts
@@ -48,6 +48,7 @@ export function buildVisibleWorktreeOptionsFromState(
     workspaceHostScope: state.workspaceHostScope,
     visibleWorkspaceHostIds: state.visibleWorkspaceHostIds,
     defaultHostId: getSettingsFocusedExecutionHostId(state.settings),
-    worktreeLineageById: state.worktreeLineageById
+    worktreeLineageById: state.worktreeLineageById,
+    preserveLineageParentOrder: state.sortBy === 'manual'
   }
 }
diff --git a/src/renderer/src/components/sidebar/visible-worktrees-manual-lineage-order.test.ts b/src/renderer/src/components/sidebar/visible-worktrees-manual-lineage-order.test.ts
new file mode 100644
index 00000000000..743f4acc7be
--- /dev/null
+++ b/src/renderer/src/components/sidebar/visible-worktrees-manual-lineage-order.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest'
+import type { ExecutionHostId } from '../../../../shared/execution-host'
+import type { WorktreeLineage } from '../../../../shared/worktree/lineage-types'
+import { worktree, repoMap } from './worktree-list-groups-test-fixtures'
+import { computeVisibleWorktrees, type VisibleWorktreeOptions } from './visible-worktrees'
+import { buildRows } from './worktree-list/grouping/build-rows'
+
+function scenario(hostId: ExecutionHostId) {
+  const parent = { ...worktree, id: 'parent', instanceId: 'parent-instance', hostId }
+  const child = { ...worktree, id: 'child', instanceId: 'child-instance', hostId }
+  const sibling = { ...worktree, id: 'sibling', instanceId: 'sibling-instance', hostId }
+  const lineage: WorktreeLineage = {
+    worktreeId: child.id,
+    worktreeInstanceId: child.instanceId,
+    parentWorktreeId: parent.id,
+    parentWorktreeInstanceId: parent.instanceId,
+    origin: 'manual',
+    capture: { source: 'manual-action', confidence: 'explicit' },
+    createdAt: 1
+  }
+  const options: VisibleWorktreeOptions = {
+    filterRepoIds: [],
+    showSleepingWorkspaces: true,
+    tabsByWorktree: {},
+    ptyIdsByTabId: {},
+    worktreeIdsWithLiveAgent: new Set(),
+    hideDefaultBranchWorkspace: false,
+    hideAutomationGeneratedWorkspaces: false,
+    hideCliCreatedWorkspaces: false,
+    hideDetachedHeadWorkspaces: false,
+    hideWorkspacesFromOtherDevices: false,
+    pairedDeviceIdsByEnvironment: new Map(),
+    repoMap,
+    workspaceHostScope: 'all',
+    defaultHostId: 'local',
+    worktreeLineageById: { [child.id]: lineage }
+  }
+  const worktreesByRepo = { [worktree.repoId]: [parent, child, sibling] }
+  const sortedIds = [child.id, sibling.id, parent.id]
+  function renderedIds(overrides: Partial<VisibleWorktreeOptions> = {}): string[] {
+    const visible = computeVisibleWorktrees(worktreesByRepo, sortedIds, {
+      ...options,
+      ...overrides
+    })
+    return buildRows(
+      'none',
+      visible,
+      repoMap,
+      {},
+      new Set(),
+      new Map(),
+      [],
+      undefined,
+      options.worktreeLineageById,
+      new Map([parent, child, sibling].map((row) => [row.id, row])),
+      true
+    ).flatMap((row) => (row.type === 'item' ? [row.worktree.id] : []))
+  }
+  return { renderedIds }
+}
+
+describe.each(['local', 'ssh:remote'] as const)('manual lineage order on %s', (hostId) => {
+  it('keeps a parent below its neighbor despite higher-ranked children', () => {
+    expect(scenario(hostId).renderedIds({ preserveLineageParentOrder: true })).toEqual([
+      'sibling',
+      'parent',
+      'child'
+    ])
+  })
+
+  it('keeps a filtered structural parent in its manual position', () => {
+    expect(
+      scenario(hostId).renderedIds({
+        preserveLineageParentOrder: true,
+        showSleepingWorkspaces: false,
+        worktreeIdsWithLiveAgent: new Set(['child', 'sibling'])
+      })
+    ).toEqual(['sibling', 'parent', 'child'])
+  })
+
+  it('continues promoting a parent with its children for automatic sorts', () => {
+    expect(scenario(hostId).renderedIds()).toEqual(['parent', 'child', 'sibling'])
+  })
+})
diff --git a/src/renderer/src/components/sidebar/visible-worktrees.ts b/src/renderer/src/components/sidebar/visible-worktrees.ts
index 37fb31890fb..581f2e1fef2 100644
--- a/src/renderer/src/components/sidebar/visible-worktrees.ts
+++ b/src/renderer/src/components/sidebar/visible-worktrees.ts
@@ -85,6 +85,7 @@ export type VisibleWorktreeOptions = {
   defaultHostId: ExecutionHostId
   worktreeLineageById: Record<string, WorktreeLineage>
   injectLineageAncestors?: boolean
+  preserveLineageParentOrder?: boolean
   forcedVisibleWorktreeIds?: readonly string[]
 }
 
@@ -175,6 +176,10 @@ export function computeVisibleWorktrees(
 
   // Apply cached sort order. Items not yet in the cache (e.g. brand-new
   // worktrees before the next sortEpoch bump) are appended at the end.
+  // Manual placement belongs to the parent, even when a hidden child has a higher rank.
+  if (opts.injectLineageAncestors !== false && opts.preserveLineageParentOrder) {
+    all = addVisibleLineageAncestors(all, lineageAncestorById, opts.worktreeLineageById)
+  }
   const orderIndex = getSortedWorktreeRankIndex(sortedIds)
   all.sort((a, b) => {
     const ai = orderIndex.get(a.id) ?? Infinity
@@ -182,7 +187,7 @@ export function computeVisibleWorktrees(
     return ai - bi
   })
 
-  return opts.injectLineageAncestors === false
+  return opts.injectLineageAncestors === false || opts.preserveLineageParentOrder
     ? all
     : addVisibleLineageAncestors(all, lineageAncestorById, opts.worktreeLineageById)
 }
diff --git a/src/renderer/src/components/sidebar/worktree-comment-textarea-sizing.ts b/src/renderer/src/components/sidebar/worktree-comment-textarea-sizing.ts
new file mode 100644
index 00000000000..16ca227d72c
--- /dev/null
+++ b/src/renderer/src/components/sidebar/worktree-comment-textarea-sizing.ts
@@ -0,0 +1,4 @@
+export function resizeCommentTextarea(textarea: HTMLTextAreaElement): void {
+  textarea.style.height = 'auto'
+  textarea.style.height = `${textarea.scrollHeight}px`
+}
diff --git a/src/renderer/src/components/sidebar/worktree-list/drag/use-status-mutations.ts b/src/renderer/src/components/sidebar/worktree-list/drag/use-status-mutations.ts
index 6243f34cf02..249c2ef3b3a 100644
--- a/src/renderer/src/components/sidebar/worktree-list/drag/use-status-mutations.ts
+++ b/src/renderer/src/components/sidebar/worktree-list/drag/use-status-mutations.ts
@@ -16,6 +16,7 @@ import {
 } from '../../worktree-manual-order'
 import { buildWorkspaceKanbanSidebarDropUpdates } from '../../workspace-kanban-sidebar-drop'
 import type { SortBy } from '../../smart-sort'
+import { switchSortToManualAfterDrop } from '../../manual-sort-switch-toast'
 import type { WorktreeStatusDropAtIndexArgs } from './drop-commit-context'
 import type { WorktreeManualOrderCatalog } from '../../worktree-manual-order-catalog'
 
@@ -29,7 +30,6 @@ export function useWorktreeStatusMutations(args: {
   const { manualOrderCatalog, worktreeMap, workspaceStatuses, sortBy } = args
   const updateWorktreeMeta = useAppStore((s) => s.updateWorktreeMeta)
   const updateWorktreesMeta = useAppStore((s) => s.updateWorktreesMeta)
-  const setSortBy = useAppStore((s) => s.setSortBy)
   const setWorktreesPinnedAndReveal = useAppStore((s) => s.setWorktreesPinnedAndReveal)
 
   const moveWorktreeToStatus = useCallback(
@@ -111,11 +111,11 @@ export function useWorktreeStatusMutations(args: {
       }
       // Why: the insertion line promises exact placement, so persist manual order on a cross-status drop.
       if (order.changed) {
-        setSortBy('manual')
+        switchSortToManualAfterDrop()
       }
       void updateWorktreesMeta([...updates.values()])
     },
-    [manualOrderCatalog, setSortBy, updateWorktreesMeta, worktreeMap, workspaceStatuses]
+    [manualOrderCatalog, updateWorktreesMeta, worktreeMap, workspaceStatuses]
   )
 
   const pinWorktree = useCallback(
@@ -146,7 +146,7 @@ export function useWorktreeStatusMutations(args: {
         allWorktreeIds: manualOrderCatalog.orderedIds
       })
       if (result.changed) {
-        setSortBy('manual')
+        switchSortToManualAfterDrop()
       }
       void updateWorktreesMeta(
         [...result.updates].map(([worktreeId, updates]) => ({
@@ -156,7 +156,7 @@ export function useWorktreeStatusMutations(args: {
         }))
       )
     },
-    [manualOrderCatalog, setSortBy, updateWorktreesMeta, worktreeMap]
+    [manualOrderCatalog, updateWorktreesMeta, worktreeMap]
   )
 
   const shouldShowWorkspaceBoardDropIndicator = useCallback(
@@ -190,12 +190,12 @@ export function useWorktreeStatusMutations(args: {
       }
       // Why: switch to Manual when the drop changes order so the placement stays visible.
       if (result.shouldSwitchToManual) {
-        setSortBy('manual')
+        switchSortToManualAfterDrop()
       }
       useAppStore.getState().recordFeatureInteraction('workspace-board-actions')
       void updateWorktreesMeta(result.updates)
     },
-    [manualOrderCatalog, setSortBy, sortBy, updateWorktreesMeta, worktreeMap, workspaceStatuses]
+    [manualOrderCatalog, sortBy, updateWorktreesMeta, worktreeMap, workspaceStatuses]
   )
 
   return {
diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/use-sort-order.test.tsx b/src/renderer/src/components/sidebar/worktree-list/listing/use-sort-order.test.tsx
new file mode 100644
index 00000000000..116cee843fd
--- /dev/null
+++ b/src/renderer/src/components/sidebar/worktree-list/listing/use-sort-order.test.tsx
@@ -0,0 +1,311 @@
+// @vitest-environment happy-dom
+
+import { StrictMode, createElement } from 'react'
+import { flushSync } from 'react-dom'
+import { createRoot } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, renderHook } from '@testing-library/react'
+import { useAppStore } from '@/store'
+import type { Worktree } from '../../../../../../shared/worktree/types'
+import { makeRepo, makeWorktree } from '../../../worktree-jump-palette-test-fixtures'
+import type { SortBy } from '../../smart-sort'
+import { useSidebarWorktreeSortOrder } from './use-sort-order'
+
+const initialState = useAppStore.getInitialState()
+const repo = makeRepo()
+const repoMap = new Map([[repo.id, repo]])
+
+// Why a settled bump: the store's add/remove baseline is the row count at the last sortEpoch change.
+function seed(worktrees: Worktree[], sortBy: SortBy): void {
+  useAppStore.setState({
+    sortBy,
+    sortEpoch: 1,
+    settledSortEpoch: 1,
+    worktreesByRepo: { [repo.id]: worktrees }
+  })
+}
+
+function bumpSortEpoch(): void {
+  useAppStore.setState((s) => ({ sortEpoch: s.sortEpoch + 1 }))
+}
+
+function replaceWorktrees(worktrees: Worktree[]): void {
+  useAppStore.setState((s) => ({
+    worktreesByRepo: { [repo.id]: worktrees },
+    sortEpoch: s.sortEpoch + 1
+  }))
+}
+
+function renderSortOrder(options?: { strict?: boolean }) {
+  const renders = { count: 0 }
+  const hook = renderHook(
+    () => {
+      renders.count += 1
+      const sortBy = useAppStore((s) => s.sortBy)
+      return useSidebarWorktreeSortOrder({ repoMap, sortBy })
+    },
+    { wrapper: options?.strict ? StrictMode : undefined }
+  )
+  return { ...hook, renders }
+}
+
+function renderSortOrderOutsideAct(sortBy: SortBy) {
+  const errors: unknown[] = []
+  const latest: { ids: string[] } = { ids: [] }
+  const previousActEnvironment = globalThis.IS_REACT_ACT_ENVIRONMENT
+  globalThis.IS_REACT_ACT_ENVIRONMENT = false
+  const root = createRoot(document.createElement('div'), {
+    onUncaughtError: (error) => errors.push(error),
+    onCaughtError: (error) => errors.push(error)
+  })
+  function Probe(): null {
+    latest.ids = useSidebarWorktreeSortOrder({ repoMap, sortBy })
+    return null
+  }
+  flushSync(() => root.render(createElement(Probe)))
+  return {
+    errors,
+    latest,
+    unmount: () => {
+      root.unmount()
+      globalThis.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment
+    }
+  }
+}
+
+describe('useSidebarWorktreeSortOrder', () => {
+  beforeEach(() => {
+    useAppStore.setState(initialState, true)
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.useRealTimers()
+    useAppStore.setState(initialState, true)
+  })
+
+  it('renders once per sortEpoch bump in Manual (no hook-initiated re-render)', () => {
+    seed(
+      [makeWorktree('a', 'A', { manualOrder: 2 }), makeWorktree('b', 'B', { manualOrder: 1 })],
+      'manual'
+    )
+    const { renders } = renderSortOrder()
+    const before = renders.count
+    for (let i = 0; i < 10; i++) {
+      act(() => bumpSortEpoch())
+    }
+    expect(renders.count - before).toBe(10)
+  })
+
+  it('applies a Manual reorder in the same commit as the bump', () => {
+    seed(
+      [makeWorktree('a', 'A', { manualOrder: 2 }), makeWorktree('b', 'B', { manualOrder: 1 })],
+      'manual'
+    )
+    const { result } = renderSortOrder({ strict: true })
+    expect(result.current).toEqual(['a', 'b'])
+    act(() =>
+      replaceWorktrees([
+        makeWorktree('a', 'A', { manualOrder: 2 }),
+        makeWorktree('b', 'B', { manualOrder: 3 })
+      ])
+    )
+    expect(result.current).toEqual(['b', 'a'])
+  })
+
+  it('survives a burst of synchronous store bumps in Manual', () => {
+    seed(
+      [makeWorktree('a', 'A', { manualOrder: 2 }), makeWorktree('b', 'B', { manualOrder: 1 })],
+      'manual'
+    )
+    const view = renderSortOrderOutsideAct('manual')
+    try {
+      for (let i = 0; i < 80; i++) {
+        flushSync(() => bumpSortEpoch())
+      }
+      expect(view.errors).toEqual([])
+    } finally {
+      view.unmount()
+    }
+  })
+
+  it('survives 80 synchronous bumps in Recent while worktrees are added, then settles in order', () => {
+    vi.useFakeTimers()
+    let worktrees = [makeWorktree('w0', 'W0', { lastActivityAt: 0 })]
+    seed(worktrees, 'recent')
+    const view = renderSortOrderOutsideAct('recent')
+    try {
+      for (let i = 1; i <= 80; i++) {
+        if (i % 4 === 1) {
+          // Why newest activity: a structural add must land at its sorted position (first) immediately.
+          worktrees = [...worktrees, makeWorktree(`w${i}`, `W${i}`, { lastActivityAt: i * 100 })]
+          flushSync(() => replaceWorktrees(worktrees))
+          expect(view.latest.ids[0]).toBe(`w${i}`)
+        } else {
+          // Why reversed activity: these bumps reorder rows, so only the settle may apply them.
+          worktrees = worktrees.map((w, index) => ({ ...w, lastActivityAt: i * 100 - index }))
+          flushSync(() => replaceWorktrees(worktrees))
+          flushSync(() => bumpSortEpoch())
+        }
+      }
+      expect(view.latest.ids[0]).toBe('w77')
+      expect(view.errors).toEqual([])
+      flushSync(() => vi.advanceTimersByTime(3_000))
+      expect(view.errors).toEqual([])
+      const expected = [...useAppStore.getState().worktreesByRepo[repo.id]]
+        .sort((a, b) => b.lastActivityAt - a.lastActivityAt)
+        .map((w) => w.id)
+      expect(view.latest.ids).toEqual(expected)
+      expect(view.latest.ids[0]).toBe('w0')
+      expect(vi.getTimerCount()).toBe(0)
+    } finally {
+      view.unmount()
+    }
+  })
+
+  it('debounces Recent re-sorts until the settle window passes', () => {
+    vi.useFakeTimers()
+    seed(
+      [
+        makeWorktree('a', 'A', { lastActivityAt: 2_000 }),
+        makeWorktree('b', 'B', { lastActivityAt: 1_000 })
+      ],
+      'recent'
+    )
+    const { result } = renderSortOrder()
+    expect(result.current).toEqual(['a', 'b'])
+    act(() =>
+      replaceWorktrees([
+        makeWorktree('a', 'A', { lastActivityAt: 2_000 }),
+        makeWorktree('b', 'B', { lastActivityAt: 3_000 })
+      ])
+    )
+    expect(result.current).toEqual(['a', 'b'])
+    act(() => vi.advanceTimersByTime(3_000))
+    expect(result.current).toEqual(['b', 'a'])
+  })
+
+  it('applies an added worktree immediately in debounced modes', () => {
+    vi.useFakeTimers()
+    seed([makeWorktree('a', 'A')], 'name')
+    const { result } = renderSortOrder()
+    act(() => replaceWorktrees([makeWorktree('a', 'A'), makeWorktree('0', '0 first')]))
+    expect(result.current).toEqual(['0', 'a'])
+  })
+
+  it('re-sorts on Manual -> Recent and stays put at settle', () => {
+    vi.useFakeTimers()
+    seed(
+      [
+        makeWorktree('a', 'A', { manualOrder: 2, lastActivityAt: 1_000 }),
+        makeWorktree('b', 'B', { manualOrder: 1, lastActivityAt: 2_000 })
+      ],
+      'manual'
+    )
+    const { result } = renderSortOrder()
+    for (let i = 0; i < 5; i++) {
+      act(() => bumpSortEpoch())
+    }
+    expect(result.current).toEqual(['a', 'b'])
+    act(() => useAppStore.getState().setSortBy('recent'))
+    expect(result.current).toEqual(['b', 'a'])
+    const afterSwitch = result.current
+    act(() => vi.advanceTimersByTime(3_000))
+    expect(result.current).toBe(afterSwitch)
+  })
+
+  it('restarts the settle window on every bump in a burst', () => {
+    vi.useFakeTimers()
+    seed(
+      [
+        makeWorktree('a', 'A', { lastActivityAt: 2_000 }),
+        makeWorktree('b', 'B', { lastActivityAt: 1_000 })
+      ],
+      'recent'
+    )
+    const { result } = renderSortOrder()
+    act(() =>
+      replaceWorktrees([
+        makeWorktree('a', 'A', { lastActivityAt: 2_000 }),
+        makeWorktree('b', 'B', { lastActivityAt: 3_000 })
+      ])
+    )
+    act(() => vi.advanceTimersByTime(2_000))
+    act(() => bumpSortEpoch())
+    act(() => vi.advanceTimersByTime(2_000))
+    expect(result.current).toEqual(['a', 'b'])
+    act(() => vi.advanceTimersByTime(1_000))
+    expect(result.current).toEqual(['b', 'a'])
+  })
+
+  it('applies a removed worktree immediately in debounced modes', () => {
+    vi.useFakeTimers()
+    seed(
+      [
+        makeWorktree('a', 'A', { lastActivityAt: 3_000 }),
+        makeWorktree('b', 'B', { lastActivityAt: 2_000 }),
+        makeWorktree('c', 'C', { lastActivityAt: 1_000 })
+      ],
+      'recent'
+    )
+    const { result } = renderSortOrder()
+    act(() =>
+      replaceWorktrees([
+        makeWorktree('b', 'B', { lastActivityAt: 2_000 }),
+        makeWorktree('c', 'C', { lastActivityAt: 4_000 })
+      ])
+    )
+    expect(result.current).toEqual(['c', 'b'])
+  })
+
+  it('does not re-sort when rows change without a sortEpoch bump', () => {
+    vi.useFakeTimers()
+    seed(
+      [
+        makeWorktree('a', 'A', { lastActivityAt: 2_000 }),
+        makeWorktree('b', 'B', { lastActivityAt: 1_000 })
+      ],
+      'recent'
+    )
+    const { result } = renderSortOrder()
+    const before = result.current
+    // Same shape as a stale-host purge that drops/changes rows without bumping sortEpoch.
+    act(() =>
+      useAppStore.setState({
+        worktreesByRepo: {
+          [repo.id]: [
+            makeWorktree('a', 'A', { lastActivityAt: 2_000 }),
+            makeWorktree('b', 'B', { lastActivityAt: 3_000 }),
+            makeWorktree('c', 'C', { lastActivityAt: 4_000 })
+          ]
+        }
+      })
+    )
+    act(() => vi.advanceTimersByTime(3_000))
+    expect(result.current).toBe(before)
+    expect(vi.getTimerCount()).toBe(0)
+  })
+
+  it('switching sort mode cancels a pending settle and re-sorts right away', () => {
+    vi.useFakeTimers()
+    seed(
+      [
+        makeWorktree('a', 'Zeta', { lastActivityAt: 2_000 }),
+        makeWorktree('b', 'Alpha', { lastActivityAt: 1_000 })
+      ],
+      'recent'
+    )
+    const { result } = renderSortOrder()
+    act(() =>
+      replaceWorktrees([
+        makeWorktree('a', 'Zeta', { lastActivityAt: 2_000 }),
+        makeWorktree('b', 'Alpha', { lastActivityAt: 3_000 })
+      ])
+    )
+    expect(vi.getTimerCount()).toBe(1)
+    act(() => useAppStore.getState().setSortBy('name'))
+    expect(result.current).toEqual(['b', 'a'])
+    expect(useAppStore.getState().settledSortEpoch).toBe(useAppStore.getState().sortEpoch)
+    expect(vi.getTimerCount()).toBe(0)
+  })
+})
diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/use-sort-order.ts b/src/renderer/src/components/sidebar/worktree-list/listing/use-sort-order.ts
index 815e66da55d..78d5fce41a3 100644
--- a/src/renderer/src/components/sidebar/worktree-list/listing/use-sort-order.ts
+++ b/src/renderer/src/components/sidebar/worktree-list/listing/use-sort-order.ts
@@ -1,11 +1,10 @@
-import { useEffect, useMemo, useRef, useState } from 'react'
+import { useEffect, useMemo, useRef } from 'react'
 import { useAppStore } from '@/store'
 import { getAllWorktreesFromState } from '@/store/selectors'
 import { track } from '@/lib/telemetry'
 import { tabHasLivePty } from '@/lib/tab-has-live-pty'
 import { persistWorktreeSortOrderByHost } from '@/lib/worktree-sort-order-persistence'
 import type { Repo } from '../../../../../../shared/repo-types'
-import type { Worktree } from '../../../../../../shared/worktree/types'
 import {
   buildWorktreeComparator,
   buildWorktreeSortLabels,
@@ -20,9 +19,6 @@ import {
 } from '../../smart-attention'
 import { useReusedArrayIdentity } from './use-reused-array-identity'
 
-// Debounce re-sort after a sortEpoch bump so background score changes don't jar row positions.
-const SORT_SETTLE_MS = 3_000
-
 function trackSmartClassDistribution(attention: ReadonlyMap<string, WorktreeAttention>): void {
   let class1 = 0
   let class2 = 0
@@ -52,52 +48,16 @@ function trackSmartClassDistribution(attention: ReadonlyMap<string, WorktreeAtte
   })
 }
 
-// Why debounce: scores are time-decaying, so recomputing on every sortEpoch bump makes worktrees jump; settle to coalesce.
-// Structural changes (add/remove) bypass the debounce so a new worktree appears at its sorted position immediately.
-function useDebouncedSortEpoch(worktreeCount: number, sortBy: SortBy): number {
-  const sortEpoch = useAppStore((s) => s.sortEpoch)
-  const [debouncedSortEpoch, setDebouncedSortEpoch] = useState(sortEpoch)
-  const prevWorktreeCountRef = useRef(worktreeCount)
-  useEffect(() => {
-    if (debouncedSortEpoch === sortEpoch) {
-      return
-    }
-
-    const structuralChange = worktreeCount !== prevWorktreeCountRef.current
-    prevWorktreeCountRef.current = worktreeCount
-
-    // Why: manual drag/drop is direct manipulation; the settle-window delay would make a successful drop look broken.
-    if (structuralChange || sortBy === 'manual') {
-      setDebouncedSortEpoch(sortEpoch)
-      return
-    }
-
-    const timer = setTimeout(() => setDebouncedSortEpoch(sortEpoch), SORT_SETTLE_MS)
-    return () => clearTimeout(timer)
-  }, [sortEpoch, debouncedSortEpoch, worktreeCount, sortBy])
-  return debouncedSortEpoch
-}
-
 // ── Stable sort order ──────────────────────────────────────────
 // Why sortEpoch (not selection): selection side-effects (clearing isUnread, PR-cache refresh) must not reorder the sidebar under the user.
 // Why useMemo not useEffect: order must be computed synchronously before the worktrees memo reads it.
 export function useSidebarWorktreeSortOrder(args: {
-  allWorktrees: readonly Worktree[]
   repoMap: Map<string, Repo>
   sortBy: SortBy
 }): string[] {
-  const { allWorktrees, repoMap, sortBy } = args
-  // Non-archived count — detects structural changes (add/remove) so the debounce below can apply immediately.
-  const worktreeCount = useMemo(() => {
-    let count = 0
-    for (const worktree of allWorktrees) {
-      if (!worktree.isArchived) {
-        count++
-      }
-    }
-    return count
-  }, [allWorktrees])
-  const debouncedSortEpoch = useDebouncedSortEpoch(worktreeCount, sortBy)
+  const { repoMap, sortBy } = args
+  // Why settled (not live): the store coalesces bump bursts so rows don't jump (store/settled-sort-epoch.ts).
+  const settledSortEpoch = useAppStore((s) => s.settledSortEpoch)
 
   // Why a latching ref: a live signal makes Smart authoritative for the session, even after that activity ends.
   const sessionHasHadLiveSmartSignal = useRef(false)
@@ -157,9 +117,9 @@ export function useSidebarWorktreeSortOrder(args: {
       attentionByWorktree: sortBy === 'smart' ? attentionByWorktree : null,
       detectedLiveSmartSignal
     }
-    // debouncedSortEpoch is an intentional trigger not read in the memo; its change (debounced) signals a recompute.
+    // settledSortEpoch is an intentional trigger not read in the memo; its change signals a recompute.
     // oxlint-disable-next-line react-hooks/exhaustive-deps
-  }, [debouncedSortEpoch, repoMap, sortBy])
+  }, [settledSortEpoch, repoMap, sortBy])
   // Why: stable ID order prevents rank-only refreshes from echoing an unchanged snapshot.
   const sortedIds = useReusedArrayIdentity(recomputedSort.sortedIds)
 
diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts b/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts
index 1990fad3606..6b42ea04b22 100644
--- a/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts
+++ b/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts
@@ -106,6 +106,7 @@ export function useVisibleSidebarWorktrees(args: {
       visibleWorkspaceHostIds,
       defaultHostId,
       worktreeLineageById,
+      preserveLineageParentOrder: sortBy === 'manual',
       forcedVisibleWorktreeIds: args.agentSendTargetWorktreeId
         ? [args.agentSendTargetWorktreeId]
         : undefined
@@ -130,6 +131,7 @@ export function useVisibleSidebarWorktrees(args: {
     ptyIdsByTabId,
     browserTabsByWorktree,
     sortedIds,
+    sortBy,
     worktreeLineageById,
     worktreesByRepo,
     pairedDeviceIdsByEnvironment,
diff --git a/src/renderer/src/components/sidebar/worktree-manual-order-store-write.test.ts b/src/renderer/src/components/sidebar/worktree-manual-order-store-write.test.ts
index 6789c95df1b..97ff803fd0f 100644
--- a/src/renderer/src/components/sidebar/worktree-manual-order-store-write.test.ts
+++ b/src/renderer/src/components/sidebar/worktree-manual-order-store-write.test.ts
@@ -8,6 +8,9 @@ import { makeWorktree } from '../worktree-jump-palette-test-fixtures'
 import { buildWorktreeManualOrderCatalog } from './worktree-manual-order-catalog'
 import { useWorktreeStatusMutations } from './worktree-list/drag/use-status-mutations'
 
+const toastInfo = vi.hoisted(() => vi.fn())
+vi.mock('sonner', () => ({ toast: { info: toastInfo, dismiss: vi.fn() } }))
+
 /**
  * The sidebar drop only reorders if the payload `reorderWorktrees` builds is the
  * one `updateWorktreesMeta` consumes. The e2e that covered this replaced the store
@@ -61,6 +64,7 @@ describe('sidebar manual-order drop', () => {
   beforeEach(() => {
     useAppStore.setState(initialState, true)
     updateMeta.mockClear()
+    toastInfo.mockClear()
     Object.assign(window, { api: { worktrees: { updateMeta } } })
   })
 
@@ -85,6 +89,7 @@ describe('sidebar manual-order drop', () => {
 
     expect(manualOrderedIds()).toEqual([ids[1], ids[0], ids[2]])
     expect(useAppStore.getState().sortBy).toBe('manual')
+    expect(toastInfo).toHaveBeenCalledTimes(1)
     expect(updateMeta).toHaveBeenCalledWith({
       worktreeId: ids[0],
       executionHostId: 'local',
@@ -111,5 +116,25 @@ describe('sidebar manual-order drop', () => {
     expect(useAppStore.getState().sortBy).toBe('smart')
     expect(useAppStore.getState().sortEpoch).toBe(epochBeforeDrop)
     expect(updateMeta).not.toHaveBeenCalled()
+    expect(toastInfo).not.toHaveBeenCalled()
+  })
+
+  it('reorders silently when Manual is already the sort', async () => {
+    const worktrees = seedManualOrderedRows(3)
+    useAppStore.setState({ sortBy: 'manual' })
+    const ids = worktrees.map((worktree) => worktree.id)
+    const reorder = renderReorder(worktrees)
+
+    await act(async () => {
+      reorder.current.reorderWorktrees({
+        groups: [{ key: GROUP_KEY, worktreeIds: ids }],
+        sourceGroupKey: GROUP_KEY,
+        draggedIds: [ids[0]!],
+        dropIndex: 2
+      })
+    })
+
+    expect(manualOrderedIds()).toEqual([ids[1], ids[0], ids[2]])
+    expect(toastInfo).not.toHaveBeenCalled()
   })
 })
diff --git a/src/renderer/src/components/skills/SkillShareReleaseNotesField.tsx b/src/renderer/src/components/skills/SkillShareReleaseNotesField.tsx
index 7b2a540e8c8..e351260e13a 100644
--- a/src/renderer/src/components/skills/SkillShareReleaseNotesField.tsx
+++ b/src/renderer/src/components/skills/SkillShareReleaseNotesField.tsx
@@ -1,3 +1,4 @@
+import { ImeTextarea } from '@/lib/ime-text-field'
 import { Collapsible, CollapsibleContent } from '@/components/ui/collapsible'
 import { Label } from '@/components/ui/label'
 import { translate } from '@/i18n/i18n'
@@ -35,7 +36,7 @@ export function SkillShareReleaseNotesField({
         <Label htmlFor="skill-release-notes" className="sr-only">
           {translate('auto.components.skills.SkillShareReviewContent.f0c0411549', 'Release notes')}
         </Label>
-        <textarea
+        <ImeTextarea
           id="skill-release-notes"
           value={value}
           onChange={(event) => onChange(event.target.value)}
diff --git a/src/renderer/src/components/status-bar/CaffeinateStatusSegment.localization.test.tsx b/src/renderer/src/components/status-bar/CaffeinateStatusSegment.localization.test.tsx
index c7caec6cdf9..1b375a52ced 100644
--- a/src/renderer/src/components/status-bar/CaffeinateStatusSegment.localization.test.tsx
+++ b/src/renderer/src/components/status-bar/CaffeinateStatusSegment.localization.test.tsx
@@ -4,7 +4,11 @@ import type { ReactNode } from 'react'
 import { cleanup, render, screen, waitFor, within } from '@testing-library/react'
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 import { i18n, translate } from '@/i18n/i18n'
-import { getAgentAwakeModeLabel, getAgentAwakeTitle } from '../settings/agent-awake-copy'
+import {
+  getAgentAwakeLidNote,
+  getAgentAwakeModeLabel,
+  getAgentAwakeTitle
+} from '../settings/agent-awake-copy'
 import { CaffeinateStatusSegment } from './CaffeinateStatusSegment'
 
 const storeMocks = vi.hoisted(() => ({
@@ -197,6 +201,7 @@ describe('keep-awake copy under non-English UI languages', () => {
       name: '防止电脑休眠，智能体 · 生效中'
     })
     expect(trigger.textContent).toContain('智能体')
+    expect(screen.getByRole('tooltip').textContent).toContain(getAgentAwakeLidNote())
 
     const menu = screen.getByRole('menu')
     await waitFor(() => expect(menu.textContent).toContain('防止电脑休眠'))
diff --git a/src/renderer/src/components/status-bar/CaffeinateStatusSegment.tsx b/src/renderer/src/components/status-bar/CaffeinateStatusSegment.tsx
index 89c6f0266bb..150a2f01dad 100644
--- a/src/renderer/src/components/status-bar/CaffeinateStatusSegment.tsx
+++ b/src/renderer/src/components/status-bar/CaffeinateStatusSegment.tsx
@@ -13,7 +13,11 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip
 import { useAppStore } from '@/store'
 import { isPairedWebClientWindow } from '@/lib/desktop-window-chrome'
 import { translate } from '@/i18n/i18n'
-import { getAgentAwakeModeLabel, getAgentAwakeTitle } from '../settings/agent-awake-copy'
+import {
+  getAgentAwakeLidNote,
+  getAgentAwakeModeLabel,
+  getAgentAwakeTitle
+} from '../settings/agent-awake-copy'
 import {
   computerAwakeSettingsForMode,
   normalizeComputerAwakeMode,
@@ -110,7 +114,7 @@ export function CaffeinateStatusSegment({
           </DropdownMenuTrigger>
         </TooltipTrigger>
         <TooltipContent side="top" sideOffset={6}>
-          {ariaLabel}
+          {ariaLabel}. {getAgentAwakeLidNote()}
         </TooltipContent>
       </Tooltip>
       <DropdownMenuContent
diff --git a/src/renderer/src/components/status-bar/StatusBarProviderSegment.tsx b/src/renderer/src/components/status-bar/StatusBarProviderSegment.tsx
index a0be19112c7..f9a484ede41 100644
--- a/src/renderer/src/components/status-bar/StatusBarProviderSegment.tsx
+++ b/src/renderer/src/components/status-bar/StatusBarProviderSegment.tsx
@@ -6,6 +6,8 @@ import {
   type UsagePercentageDisplay
 } from '../../../../shared/usage-percentage-display'
 import type { StatusBarUsageMode } from '../../../../shared/status-bar-usage-mode'
+import { formatCurrencyAmount } from '../../../../shared/currency-format'
+import { formatCreditCount } from '../../../../shared/credit-count-format'
 import {
   ProviderIcon,
   USAGE_URGENT_PERCENT,
@@ -262,6 +264,43 @@ function VerboseProviderUsage({
   )
 }
 
+// A plan spends into its overage balance only once an included window is
+// exhausted. Treat ~100% as capped to tolerate provider rounding.
+const CAP_THRESHOLD_PERCENT = 99.5
+
+// Why: only reveal the compact balance once a capped window can spend it.
+function isExtraUsageActive(p: ProviderRateLimits): boolean {
+  if (
+    !p.extraUsage ||
+    !p.extraUsage.enabled ||
+    (p.extraUsage.unit === 'currency' &&
+      (p.extraUsage.balance === null || p.extraUsage.balance <= 0))
+  ) {
+    return false
+  }
+  return [p.session, p.weekly, p.monthly, p.fableWeekly].some(
+    (w) => w != null && clampUsedPercent(w.usedPercent) >= CAP_THRESHOLD_PERCENT
+  )
+}
+
+function formatCompactExtraUsage(balance: ProviderRateLimits['extraUsage']): string {
+  if (!balance) {
+    return ''
+  }
+  if (balance.unit === 'credits') {
+    return balance.unlimited
+      ? translate('auto.components.status.bar.StatusBar.4025a6f62f', 'Unlimited')
+      : translate('auto.components.status.bar.StatusBar.a95969101f', '{{value0}} credits', {
+          value0: formatCreditCount(balance.balance)
+        })
+  }
+  return balance.balance === null
+    ? ''
+    : translate('auto.components.status.bar.StatusBar.4fba7dc1e7', '{{value0}} bal', {
+        value0: formatCurrencyAmount(balance.balance, balance.currencyCode)
+      })
+}
+
 export function ProviderSegment({
   p,
   compact,
@@ -320,6 +359,7 @@ export function ProviderSegment({
 
   // Has data (ok, fetching with stale data, or error with stale data)
   const isStale = p.status === 'error'
+  const showBalance = isExtraUsageActive(p)
 
   return (
     <span className="inline-flex items-center gap-1.5">
@@ -339,6 +379,12 @@ export function ProviderSegment({
           showLabel={!compact}
         />
       ) : null}
+      {showBalance && p.extraUsage ? (
+        <>
+          <span className="text-muted-foreground">·</span>
+          <span className="tabular-nums">{formatCompactExtraUsage(p.extraUsage)}</span>
+        </>
+      ) : null}
       {isStale && <AlertTriangle size={11} className="text-muted-foreground/80" />}
     </span>
   )
diff --git a/src/renderer/src/components/status-bar/provider-extra-usage-section.tsx b/src/renderer/src/components/status-bar/provider-extra-usage-section.tsx
new file mode 100644
index 00000000000..3eabad4bb5e
--- /dev/null
+++ b/src/renderer/src/components/status-bar/provider-extra-usage-section.tsx
@@ -0,0 +1,158 @@
+import type { ExtraUsageBalance, ProviderRateLimits } from '../../../../shared/rate-limit-types'
+import type { UsagePercentageDisplay } from '../../../../shared/usage-percentage-display'
+import { clampUsedPercent } from '../../../../shared/usage-percentage-display'
+import { formatCreditCount } from '../../../../shared/credit-count-format'
+import { formatCurrencyAmount } from '../../../../shared/currency-format'
+import { translate } from '@/i18n/i18n'
+import { formatUsagePercentageLabel } from './usage-percentage-label'
+
+export const USAGE_WARNING_PERCENT = 60
+export const USAGE_URGENT_PERCENT = 80
+
+export function barColor(usedPct: number): string {
+  if (usedPct < USAGE_WARNING_PERCENT) {
+    return 'bg-muted-foreground/40'
+  }
+  if (usedPct < USAGE_URGENT_PERCENT) {
+    return 'bg-yellow-500'
+  }
+  return 'bg-red-500'
+}
+
+export function getExtraUsageLabel(provider: ProviderRateLimits['provider']): string {
+  if (provider === 'claude') {
+    return translate('auto.components.status.bar.tooltip.7404abbece', 'Usage credits')
+  }
+  if (provider === 'opencode-go') {
+    return translate('auto.components.status.bar.tooltip.fbc80d8be2', 'Zen balance')
+  }
+  if (provider === 'codex') {
+    return translate('auto.components.status.bar.tooltip.f21b2ba897', 'Credits')
+  }
+  return translate('auto.components.status.bar.tooltip.c03c61f53f', 'Balance')
+}
+
+function renderUncappedBalanceLine(balance: ExtraUsageBalance): string {
+  if (balance.unit === 'credits') {
+    if (balance.unlimited) {
+      return translate('auto.components.status.bar.tooltip.56c0d70577', 'Unlimited')
+    }
+    return translate(
+      'auto.components.status.bar.tooltip.87b5bda4d3',
+      '{{value0}} credits available',
+      { value0: formatCreditCount(balance.balance) }
+    )
+  }
+  if (balance.balance === null) {
+    return ''
+  }
+  const currencyText = formatCurrencyAmount(balance.balance, balance.currencyCode)
+  return translate('auto.components.status.bar.tooltip.f6a27a3c0a', '{{value0}} available', {
+    value0: currencyText
+  })
+}
+
+export function ProviderExtraUsageSection({
+  balance,
+  provider,
+  textClass,
+  mutedClass,
+  faintClass,
+  emptyBarClass,
+  usagePercentageDisplay
+}: {
+  balance: ExtraUsageBalance
+  provider: ProviderRateLimits['provider']
+  textClass: string
+  mutedClass: string
+  faintClass: string
+  emptyBarClass: string
+  usagePercentageDisplay: UsagePercentageDisplay
+}): React.JSX.Element | null {
+  const label = getExtraUsageLabel(provider)
+  if (balance.unit === 'credits') {
+    return (
+      <div className="space-y-1">
+        <div className={`font-medium ${textClass}`}>{label}</div>
+        <div className={mutedClass}>{renderUncappedBalanceLine(balance)}</div>
+      </div>
+    )
+  }
+
+  if (provider === 'opencode-go' && balance.balance === null) {
+    const status =
+      balance.disabledReason === 'refresh-failed'
+        ? translate('auto.components.status.bar.tooltip.e740f92596', 'Refresh failed')
+        : translate('auto.components.status.bar.tooltip.1292d4f2ee', 'Unavailable')
+    return (
+      <div className="space-y-1">
+        <div className={`font-medium ${textClass}`}>{label}</div>
+        <div className={mutedClass}>{status}</div>
+        {balance.disabledReason === 'api-key-source' ? (
+          <div className={faintClass}>
+            {translate(
+              'auto.components.status.bar.provider.extra.usage.section.apiKeyBalanceUnavailable',
+              'Balance is not included in this usage response.'
+            )}
+          </div>
+        ) : null}
+      </div>
+    )
+  }
+
+  const capped =
+    balance.spendLimit !== null && balance.spentPercent !== null && balance.spent !== null
+  const balanceText =
+    balance.balance === null ? null : formatCurrencyAmount(balance.balance, balance.currencyCode)
+  if (!capped) {
+    const limitText =
+      balance.spendLimit === null
+        ? null
+        : formatCurrencyAmount(balance.spendLimit, balance.currencyCode)
+    const limitLabel =
+      limitText === null
+        ? null
+        : translate(
+            'auto.components.status.bar.provider.extra.usage.section.135d51c19f',
+            'Limit {{value0}}',
+            { value0: limitText }
+          )
+    if (balanceText === null && limitLabel === null) {
+      return null
+    }
+    return (
+      <div className="space-y-1">
+        <div className={`font-medium ${textClass}`}>{label}</div>
+        <div className={mutedClass}>
+          {balanceText === null ? limitLabel : renderUncappedBalanceLine(balance)}
+        </div>
+      </div>
+    )
+  }
+
+  const spentPct = clampUsedPercent(balance.spentPercent ?? 0)
+  const spent = formatCurrencyAmount(balance.spent ?? 0, balance.currencyCode)
+  const limit = formatCurrencyAmount(balance.spendLimit ?? 0, balance.currencyCode)
+  return (
+    <div className="space-y-1">
+      <div className={`font-medium ${textClass}`}>{label}</div>
+      <div className={`h-[6px] w-full overflow-hidden rounded-full ${emptyBarClass}`}>
+        <div
+          className={`h-full rounded-full ${barColor(spentPct)} transition-all duration-300`}
+          style={{ width: `${spentPct}%` }}
+        />
+      </div>
+      <div className={`flex justify-between ${mutedClass}`}>
+        <span>{`${spent} / ${limit}`}</span>
+        <span>{formatUsagePercentageLabel(spentPct, usagePercentageDisplay)}</span>
+      </div>
+      {balanceText !== null ? (
+        <div className={faintClass}>
+          {translate('auto.components.status.bar.tooltip.473d45cd0f', 'Balance {{value0}}', {
+            value0: balanceText
+          })}
+        </div>
+      ) : null}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/status-bar/provider-segment-balance.test.tsx b/src/renderer/src/components/status-bar/provider-segment-balance.test.tsx
new file mode 100644
index 00000000000..e176ca44987
--- /dev/null
+++ b/src/renderer/src/components/status-bar/provider-segment-balance.test.tsx
@@ -0,0 +1,212 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { ProviderRateLimits } from '../../../../shared/rate-limit-types'
+
+const compactMessages = vi.hoisted(() => ({ balance: '' }))
+
+afterEach(() => {
+  compactMessages.balance = ''
+})
+
+vi.mock('@/i18n/i18n', () => ({
+  i18n: { language: 'en' },
+  translate: (_key: string, fallback: string, values?: Record<string, string>) => {
+    let result =
+      _key === 'auto.components.status.bar.StatusBar.4fba7dc1e7' && compactMessages.balance
+        ? compactMessages.balance
+        : fallback
+    for (const [key, value] of Object.entries(values ?? {})) {
+      result = result.replace(`{{${key}}}`, value)
+    }
+    return result
+  }
+}))
+
+vi.mock('@/lib/agent-catalog', () => ({
+  AgentIcon: () => null
+}))
+
+vi.mock('../../store', () => ({
+  useAppStore: (selector: (state: { usagePercentageDisplay: 'used' | 'remaining' }) => unknown) =>
+    selector({ usagePercentageDisplay: 'used' })
+}))
+
+function openCodeGo(sessionUsedPercent: number, balance = 12.4): ProviderRateLimits {
+  return {
+    provider: 'opencode-go',
+    session: {
+      usedPercent: sessionUsedPercent,
+      windowMinutes: 300,
+      resetsAt: null,
+      resetDescription: null
+    },
+    weekly: { usedPercent: 40, windowMinutes: 10080, resetsAt: null, resetDescription: null },
+    extraUsage: {
+      balance,
+      unit: 'currency',
+      currencyCode: 'USD',
+      enabled: true,
+      disabledReason: null,
+      spent: null,
+      spendLimit: null,
+      spentPercent: null,
+      resetsAt: null
+    },
+    updatedAt: Date.now(),
+    error: null,
+    status: 'ok'
+  }
+}
+
+function claudeUnknownBalance(): ProviderRateLimits {
+  return {
+    provider: 'claude',
+    session: { usedPercent: 100, windowMinutes: 300, resetsAt: null, resetDescription: null },
+    weekly: { usedPercent: 40, windowMinutes: 10080, resetsAt: null, resetDescription: null },
+    extraUsage: {
+      balance: null,
+      unit: 'currency',
+      currencyCode: 'EUR',
+      enabled: true,
+      disabledReason: null,
+      spent: 50,
+      spendLimit: 2000,
+      spentPercent: 2.5,
+      resetsAt: null
+    },
+    updatedAt: Date.now(),
+    error: null,
+    status: 'ok'
+  }
+}
+
+function codexCredits(sessionUsedPercent: number): ProviderRateLimits {
+  return {
+    provider: 'codex',
+    session: {
+      usedPercent: sessionUsedPercent,
+      windowMinutes: 300,
+      resetsAt: null,
+      resetDescription: null
+    },
+    weekly: { usedPercent: 40, windowMinutes: 10080, resetsAt: null, resetDescription: null },
+    extraUsage: {
+      balance: 500,
+      unit: 'credits',
+      unlimited: false,
+      enabled: true,
+      disabledReason: null,
+      resetsAt: null
+    },
+    updatedAt: Date.now(),
+    error: null,
+    status: 'ok'
+  }
+}
+
+function claudeDisabledCredits(): ProviderRateLimits {
+  return {
+    provider: 'claude',
+    session: { usedPercent: 100, windowMinutes: 300, resetsAt: null, resetDescription: null },
+    weekly: { usedPercent: 80, windowMinutes: 10080, resetsAt: null, resetDescription: null },
+    extraUsage: {
+      balance: 0,
+      unit: 'currency',
+      currencyCode: 'EUR',
+      enabled: false,
+      disabledReason: 'out_of_credits',
+      spent: 0,
+      spendLimit: 2000,
+      spentPercent: 0,
+      resetsAt: null
+    },
+    updatedAt: Date.now(),
+    error: null,
+    status: 'ok'
+  }
+}
+
+describe('ProviderSegment extra-usage balance token', () => {
+  it.each([
+    ['Spanish', 'saldo {{value0}}', 'saldo $12.40'],
+    ['French', 'solde {{value0}}', 'solde $12.40']
+  ])('lets %s put the balance label before its amount', async (_locale, message, expected) => {
+    compactMessages.balance = message
+    const { ProviderSegment } = await import('./StatusBar')
+    const markup = renderToStaticMarkup(
+      <ProviderSegment p={openCodeGo(100)} compact={false} display="used" />
+    )
+    expect(markup).toContain(expected)
+    expect(markup).not.toContain('{{value0}}')
+  })
+
+  it('reveals the remaining balance once a plan window is capped', async () => {
+    const { ProviderSegment } = await import('./StatusBar')
+
+    const markup = renderToStaticMarkup(
+      <ProviderSegment p={openCodeGo(100)} compact={false} display="used" />
+    )
+
+    expect(markup).toContain('$12.40')
+    expect(markup).toContain('bal')
+  })
+
+  it.each([0, -1.25])(
+    'hides a depleted currency balance of %s from the compact segment',
+    async (balance) => {
+      const { ProviderSegment } = await import('./StatusBar')
+
+      const markup = renderToStaticMarkup(
+        <ProviderSegment p={openCodeGo(100, balance)} compact={false} display="used" />
+      )
+
+      expect(markup).not.toContain('bal')
+      expect(markup).not.toContain('$0.00')
+      expect(markup).not.toContain('-$1.25')
+    }
+  )
+
+  it('hides the balance while plan windows still have headroom', async () => {
+    const { ProviderSegment } = await import('./StatusBar')
+
+    const markup = renderToStaticMarkup(
+      <ProviderSegment p={openCodeGo(20)} compact={false} display="used" />
+    )
+
+    expect(markup).not.toContain('$12.40')
+    expect(markup).not.toContain('bal')
+  })
+
+  it('does not reveal an unavailable balance as zero when a window is capped', async () => {
+    const { ProviderSegment } = await import('./StatusBar')
+
+    const markup = renderToStaticMarkup(
+      <ProviderSegment p={claudeUnknownBalance()} compact={false} display="used" />
+    )
+
+    expect(markup).not.toContain('€0.00')
+    expect(markup).not.toContain('bal')
+  })
+
+  it('does not reveal a disabled balance even when a window is capped', async () => {
+    const { ProviderSegment } = await import('./StatusBar')
+
+    const markup = renderToStaticMarkup(
+      <ProviderSegment p={claudeDisabledCredits()} compact={false} display="used" />
+    )
+
+    expect(markup).not.toContain('bal')
+  })
+
+  it('reveals a Codex credit count (not a currency amount) when a window caps', async () => {
+    const { ProviderSegment } = await import('./StatusBar')
+
+    const markup = renderToStaticMarkup(
+      <ProviderSegment p={codexCredits(100)} compact={false} display="used" />
+    )
+
+    expect(markup).toContain('500 credits')
+    expect(markup).not.toContain('$500')
+    expect(markup).not.toContain('bal')
+  })
+})
diff --git a/src/renderer/src/components/status-bar/tooltip.test.ts b/src/renderer/src/components/status-bar/tooltip.test.ts
index f08f1e4a1eb..6f928745dbb 100644
--- a/src/renderer/src/components/status-bar/tooltip.test.ts
+++ b/src/renderer/src/components/status-bar/tooltip.test.ts
@@ -28,6 +28,7 @@ import {
   formatResetCreditExpiry,
   formatResetCountdown,
   getProviderUsageErrorMessage,
+  getExtraUsageLabel,
   getProviderUsageStatusLabel,
   getWindowSections,
   ProviderIcon,
@@ -461,6 +462,277 @@ describe('getWindowSections', () => {
   })
 })
 
+describe('getExtraUsageLabel', () => {
+  it('names the balance per provider', () => {
+    expect(getExtraUsageLabel('claude')).toBe('Usage credits')
+    expect(getExtraUsageLabel('opencode-go')).toBe('Zen balance')
+    expect(getExtraUsageLabel('codex')).toBe('Credits')
+    expect(getExtraUsageLabel('gemini')).toBe('Balance')
+  })
+})
+
+describe('ProviderPanel extra-usage rendering', () => {
+  it('renders the Claude usage-credits cap as a spent/limit meter plus balance', () => {
+    const p = provider({
+      status: 'ok',
+      session: { usedPercent: 100, windowMinutes: 300, resetsAt: null, resetDescription: null },
+      extraUsage: {
+        balance: 10,
+        unit: 'currency',
+        currencyCode: 'EUR',
+        enabled: true,
+        disabledReason: null,
+        spent: 50,
+        spendLimit: 2000,
+        spentPercent: 2.5,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Usage credits')
+    expect(markup).toContain('€2,000.00')
+    expect(markup).toContain('€50.00')
+    expect(markup).toContain('% used')
+    expect(markup).toContain('Balance €10.00')
+  })
+
+  it('renders a legacy spend cap without presenting an unavailable balance as zero', () => {
+    const p = provider({
+      status: 'ok',
+      session: { usedPercent: 100, windowMinutes: 300, resetsAt: null, resetDescription: null },
+      extraUsage: {
+        balance: null,
+        unit: 'currency',
+        currencyCode: 'EUR',
+        enabled: true,
+        disabledReason: null,
+        spent: 50,
+        spendLimit: 2000,
+        spentPercent: 2.5,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Usage credits')
+    expect(markup).toContain('€50.00 / €2,000.00')
+    expect(markup).not.toContain('Balance €0.00')
+  })
+
+  it('renders a known legacy cap without inventing spend, percent, balance, or a meter', () => {
+    const p = provider({
+      status: 'ok',
+      extraUsage: {
+        balance: null,
+        unit: 'currency',
+        currencyCode: 'EUR',
+        enabled: true,
+        disabledReason: null,
+        spent: null,
+        spendLimit: 2000,
+        spentPercent: null,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Usage credits')
+    expect(markup).toContain('Limit €2,000.00')
+    expect(markup).not.toContain('€0.00')
+    expect(markup).not.toContain('% used')
+    expect(markup).not.toContain('h-[6px]')
+  })
+
+  it('keeps a known cap as a caption when spend is unknown even if a percentage is present', () => {
+    const p = provider({
+      status: 'ok',
+      extraUsage: {
+        balance: null,
+        unit: 'currency',
+        currencyCode: 'EUR',
+        enabled: true,
+        disabledReason: null,
+        spent: null,
+        spendLimit: 2000,
+        spentPercent: 10,
+        resetsAt: null
+      }
+    })
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+    expect(markup).toContain('Limit €2,000.00')
+    expect(markup).not.toContain('€0.00')
+    expect(markup).not.toContain('% used')
+    expect(markup).not.toContain('h-[6px]')
+  })
+
+  it('renders a disabled, out-of-credits cap with a zero balance', () => {
+    const p = provider({
+      status: 'ok',
+      session: { usedPercent: 100, windowMinutes: 300, resetsAt: null, resetDescription: null },
+      extraUsage: {
+        balance: 0,
+        unit: 'currency',
+        currencyCode: 'EUR',
+        enabled: false,
+        disabledReason: 'out_of_credits',
+        spent: 0,
+        spendLimit: 2000,
+        spentPercent: 0,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Usage credits')
+    expect(markup).toContain('€0.00 / €2,000.00')
+    expect(markup).toContain('Balance €0.00')
+  })
+
+  it('renders an uncapped OpenCode Go balance as a plain available amount', () => {
+    const p = provider({
+      provider: 'opencode-go',
+      status: 'ok',
+      session: { usedPercent: 20, windowMinutes: 300, resetsAt: null, resetDescription: null },
+      extraUsage: {
+        balance: 12.4,
+        unit: 'currency',
+        currencyCode: 'USD',
+        enabled: true,
+        disabledReason: null,
+        spent: null,
+        spendLimit: null,
+        spentPercent: null,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Zen balance')
+    expect(markup).toContain('$12.40')
+    expect(markup).toContain('available')
+  })
+
+  it.each([
+    [0, '$0.00'],
+    [-1.25, '-$1.25']
+  ])('keeps a depleted Zen balance of %s visible in the popover', (balance, formatted) => {
+    const p = provider({
+      provider: 'opencode-go',
+      status: 'ok',
+      session: { usedPercent: 100, windowMinutes: 300, resetsAt: null, resetDescription: null },
+      extraUsage: {
+        balance,
+        unit: 'currency',
+        currencyCode: 'USD',
+        enabled: true,
+        disabledReason: null,
+        spent: null,
+        spendLimit: null,
+        spentPercent: null,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Zen balance')
+    expect(markup).toContain(formatted)
+    expect(markup).toContain('available')
+  })
+
+  it.each([
+    ['refresh-failed', 'Refresh failed'],
+    ['billing-unavailable', 'Unavailable'],
+    ['api-key-source', 'Balance is not included in this usage response.']
+  ])('shows an unknown Zen balance honestly for %s', (disabledReason, message) => {
+    const p = provider({
+      provider: 'opencode-go',
+      status: 'ok',
+      session: { usedPercent: 20, windowMinutes: 300, resetsAt: null, resetDescription: null },
+      extraUsage: {
+        balance: null,
+        unit: 'currency',
+        currencyCode: 'USD',
+        enabled: false,
+        disabledReason,
+        spent: null,
+        spendLimit: null,
+        spentPercent: null,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Zen balance')
+    expect(markup).toContain(message)
+    expect(markup).toContain('Session')
+    expect(markup).not.toContain('$0.00')
+    expect(markup).not.toMatch(/\$[\d,.]+ available/)
+  })
+
+  it('renders a Codex credit count as a plain "N credits available" line', () => {
+    const p = provider({
+      provider: 'codex',
+      status: 'ok',
+      session: { usedPercent: 20, windowMinutes: 300, resetsAt: null, resetDescription: null },
+      extraUsage: {
+        balance: 500,
+        unit: 'credits',
+        unlimited: false,
+        enabled: true,
+        disabledReason: null,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Credits')
+    expect(markup).toContain('500 credits available')
+    // A credit count is not a currency amount.
+    expect(markup).not.toContain('$500')
+  })
+
+  it('renders unlimited Codex credits as "Unlimited"', () => {
+    const p = provider({
+      provider: 'codex',
+      status: 'ok',
+      session: { usedPercent: 20, windowMinutes: 300, resetsAt: null, resetDescription: null },
+      extraUsage: {
+        balance: 0,
+        unit: 'credits',
+        unlimited: true,
+        enabled: true,
+        disabledReason: null,
+        resetsAt: null
+      }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).toContain('Unlimited')
+  })
+
+  it('omits the balance row when no extra usage is reported', () => {
+    const p = provider({
+      status: 'ok',
+      session: { usedPercent: 40, windowMinutes: 300, resetsAt: null, resetDescription: null }
+    })
+
+    const markup = renderToStaticMarkup(createElement(ProviderPanel, { p }))
+
+    expect(markup).not.toContain('Usage credits')
+    expect(markup).not.toContain('Zen balance')
+  })
+})
+
 describe('ProviderPanel reset rendering', () => {
   it('renders the Fable reset countdown when Claude reports a reset timestamp', () => {
     vi.useFakeTimers()
@@ -594,7 +866,7 @@ describe('barColor', () => {
 
 describe('ProviderIcon', () => {
   it('renders the Antigravity agent icon for the antigravity provider', () => {
-    const markup = renderToStaticMarkup(ProviderIcon({ provider: 'antigravity' }))
+    const markup = renderToStaticMarkup(createElement(ProviderIcon, { provider: 'antigravity' }))
     expect(markup).toContain('data-agent-icon="antigravity"')
   })
 
@@ -602,7 +874,7 @@ describe('ProviderIcon', () => {
     // Why: the icon must travel to the status bar / tooltip unchanged so the
     // user recognises the brand. We pin it to an <img> with a non-empty
     // resource URL and aria-hidden so the icon stays purely decorative.
-    const markup = renderToStaticMarkup(ProviderIcon({ provider: 'minimax' }))
+    const markup = renderToStaticMarkup(createElement(ProviderIcon, { provider: 'minimax' }))
     expect(markup.startsWith('<img')).toBe(true)
     expect(markup).toContain('aria-hidden="true"')
     expect(markup).toMatch(/src="[^"]+"/)
diff --git a/src/renderer/src/components/status-bar/tooltip.tsx b/src/renderer/src/components/status-bar/tooltip.tsx
index 735452c9e26..d871f8943eb 100644
--- a/src/renderer/src/components/status-bar/tooltip.tsx
+++ b/src/renderer/src/components/status-bar/tooltip.tsx
@@ -18,6 +18,14 @@ import {
 } from '../../../../shared/usage-percentage-display'
 import { formatUsagePercentageLabel } from './usage-percentage-label'
 import { useResetCountdownClock } from '@/hooks/useResetCountdownClock'
+import { barColor, ProviderExtraUsageSection } from './provider-extra-usage-section'
+
+export {
+  barColor,
+  getExtraUsageLabel,
+  USAGE_URGENT_PERCENT,
+  USAGE_WARNING_PERCENT
+} from './provider-extra-usage-section'
 
 // Re-exported from its shared home so status-bar callers keep a single import.
 export { clampUsedPercent }
@@ -208,21 +216,6 @@ export function getWindowSections(
 // `text-background` for primary text and `text-background/50` for secondary
 // to stay readable inside the inverted tooltip container.
 
-// Why: urgency color tracks % used even when fill represents % remaining;
-// low usage stays neutral so persistent chrome stays quiet.
-export const USAGE_WARNING_PERCENT = 60
-export const USAGE_URGENT_PERCENT = 80
-
-export function barColor(usedPct: number): string {
-  if (usedPct < USAGE_WARNING_PERCENT) {
-    return 'bg-muted-foreground/40'
-  }
-  if (usedPct < USAGE_URGENT_PERCENT) {
-    return 'bg-yellow-500'
-  }
-  return 'bg-red-500'
-}
-
 function ProviderRateLimitWindowSection({
   window,
   label,
@@ -378,6 +371,18 @@ export function ProviderPanel({
         />
       ))}
 
+      {p.extraUsage ? (
+        <ProviderExtraUsageSection
+          balance={p.extraUsage}
+          provider={p.provider}
+          textClass={textClass}
+          mutedClass={mutedClass}
+          faintClass={faintClass}
+          emptyBarClass={emptyBarClass}
+          usagePercentageDisplay={usagePercentageDisplay}
+        />
+      ) : null}
+
       {p.error ? (
         <ErrorMessage
           message={p.error}
diff --git a/src/renderer/src/components/tab-bar/EditorFileTab.test.tsx b/src/renderer/src/components/tab-bar/EditorFileTab.test.tsx
index f8d930b044c..592c9579568 100644
--- a/src/renderer/src/components/tab-bar/EditorFileTab.test.tsx
+++ b/src/renderer/src/components/tab-bar/EditorFileTab.test.tsx
@@ -462,7 +462,8 @@ describe('EditorFileTab rename menu', () => {
       oldPath: '/repo/untitled-5.md',
       newName: '日本語.md',
       worktreeId: 'wt-1',
-      worktreePath: '/repo'
+      worktreePath: '/repo',
+      documentScoped: false
     })
   })
 
diff --git a/src/renderer/src/components/tab-bar/EditorFileTab.tsx b/src/renderer/src/components/tab-bar/EditorFileTab.tsx
index 34d173c246a..9a651ab75f2 100644
--- a/src/renderer/src/components/tab-bar/EditorFileTab.tsx
+++ b/src/renderer/src/components/tab-bar/EditorFileTab.tsx
@@ -32,6 +32,7 @@ import { TAB_LABEL_WIDTH_CLASSES } from './tab-width-rules'
 import { useTabStripSlotProps } from './use-tab-strip-slot-props'
 import { EditorFileTabCloseButton } from './EditorFileTabCloseButton'
 import { useTabStripPointerActivation } from './tab-strip-pointer-activation'
+import { editorTabDocumentFolderAccess } from '@/lib/local-file-access'
 
 export default function EditorFileTab({
   file,
@@ -162,7 +163,9 @@ export default function EditorFileTab({
       oldPath: file.filePath,
       newName,
       worktreeId: file.worktreeId,
-      worktreePath
+      worktreePath,
+      // Why: a file opened outside every project may be renamed to any path, wherever it lives.
+      documentScoped: editorTabDocumentFolderAccess(useAppStore.getState(), file) !== undefined
     })
   }
 
diff --git a/src/renderer/src/components/tab-bar/QuickLaunchButton.launch-status.test.tsx b/src/renderer/src/components/tab-bar/QuickLaunchButton.launch-status.test.tsx
new file mode 100644
index 00000000000..370ca704b87
--- /dev/null
+++ b/src/renderer/src/components/tab-bar/QuickLaunchButton.launch-status.test.tsx
@@ -0,0 +1,213 @@
+// @vitest-environment happy-dom
+
+import type { ReactNode } from 'react'
+import { cleanup, fireEvent, render } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { StructuredLaunchState } from '@/lib/structured-agent-session-launch-registry'
+import type { StructuredLaunchAttempt } from '@/lib/structured-agent-session-launch-request'
+
+vi.mock('@/hooks/useDetectedAgents', () => ({
+  useDetectedAgents: () => ({ detectedIds: ['claude', 'codex'] })
+}))
+vi.mock('@/hooks/useShortcutLabel', () => ({ useOptionalShortcutLabel: () => null }))
+vi.mock('@/store', () => {
+  const state = {
+    settings: { defaultTuiAgent: 'codex', disabledTuiAgents: [] },
+    worktreesByRepo: {},
+    repos: [],
+    openSettingsPage: vi.fn(),
+    openSettingsTarget: vi.fn()
+  }
+  const useAppStore = Object.assign((selector: (s: typeof state) => unknown) => selector(state), {
+    getState: () => state
+  })
+  return { useAppStore }
+})
+vi.mock('@/lib/agent-catalog', () => ({
+  getAgentCatalog: () => [
+    { id: 'claude', label: 'Claude' },
+    { id: 'codex', label: 'Codex' }
+  ],
+  AgentIcon: ({ agent }: { agent: string }) => <span>{agent}</span>
+}))
+vi.mock('@/components/ui/dropdown-menu', () => ({
+  DropdownMenuItem: ({
+    children,
+    disabled,
+    title,
+    onSelect
+  }: { children: ReactNode } & DivProps) => (
+    <div aria-disabled={disabled ? 'true' : 'false'} title={title} onClick={onSelect}>
+      {children}
+    </div>
+  ),
+  DropdownMenuShortcut: ({ children }: { children: ReactNode }) => <span>{children}</span>
+}))
+vi.mock('@/i18n/i18n', () => ({
+  translate: (_key: string, fallback: string, values?: Record<string, string>) =>
+    fallback.replace('{{value0}}', values?.value0 ?? '')
+}))
+const launchMock = vi.hoisted(() => vi.fn())
+vi.mock('@/lib/launch-agent-in-new-tab', () => ({ launchAgentInNewTab: launchMock }))
+
+type DivProps = { disabled?: boolean; title?: string; onSelect?: () => void }
+
+import { QuickLaunchAgentMenuItems } from './QuickLaunchButton'
+import {
+  resetStructuredAgentLaunchRegistryForTests,
+  setStructuredLaunchState
+} from '@/lib/structured-agent-session-launch-registry'
+
+const WORKTREE_ID = 'worktree-1'
+
+function registerLaunch(
+  agent: 'claude' | 'codex',
+  outcome: 'pending' | 'failed',
+  attempt: StructuredLaunchAttempt = {
+    kind: 'first',
+    requestId: `${agent}-pick`,
+    blank: true,
+    stagedEntry: null
+  }
+): void {
+  const sessionId = `${agent}-session`
+  setStructuredLaunchState({
+    identity: `${agent}:${WORKTREE_ID}`,
+    intent: {
+      worktreeId: WORKTREE_ID,
+      sessionId,
+      executionHostId: 'local',
+      target: { kind: 'local' },
+      agent,
+      params: {
+        envelope: {
+          sessionId,
+          clientOperationId: `operation-${sessionId}`,
+          expectedRuntimeFence: null,
+          payloadFingerprint: `fingerprint-${sessionId}`
+        },
+        worktree: `id:${WORKTREE_ID}`,
+        agent
+      }
+    },
+    promptDelivery: undefined,
+    callers: {
+      outcome,
+      attempt,
+      entries: new Set(),
+      promptDeliveryResults: new Set(),
+      onSettled: () => undefined
+    },
+    promise: new Promise(() => undefined),
+    visibilityUnknown: false,
+    cancelled: false,
+    selection: { held: {} }
+  } satisfies StructuredLaunchState)
+}
+
+function agentRowDisabled(label: string): string | null | undefined {
+  return document
+    .querySelector(`[title="Launch ${label} in a new terminal"]`)
+    ?.getAttribute('aria-disabled')
+}
+
+describe('QuickLaunchAgentMenuItems launches', () => {
+  beforeEach(() => {
+    localStorage.clear()
+    resetStructuredAgentLaunchRegistryForTests()
+  })
+  afterEach(cleanup)
+
+  // Each pick is its own request, so a chat starting, failing or retrying never blocks one.
+  it('keeps every agent launchable while chats start, fail or retry', () => {
+    registerLaunch('claude', 'pending')
+    registerLaunch('codex', 'failed')
+
+    render(
+      <QuickLaunchAgentMenuItems
+        worktreeId={WORKTREE_ID}
+        groupId="group-1"
+        onFocusTerminal={vi.fn()}
+      />
+    )
+    expect(agentRowDisabled('Claude')).toBe('false')
+    expect(agentRowDisabled('Codex')).toBe('false')
+    cleanup()
+
+    registerLaunch('codex', 'pending', { kind: 'retry' })
+    render(
+      <QuickLaunchAgentMenuItems
+        worktreeId={WORKTREE_ID}
+        groupId="group-1"
+        onFocusTerminal={vi.fn()}
+        prompt="review notes"
+      />
+    )
+    expect(agentRowDisabled('Codex')).toBe('false')
+  })
+
+  it('gives each pick its own request, so a second pick opens its own chat', () => {
+    launchMock.mockReset()
+    launchMock.mockReturnValue({
+      surface: { kind: 'local-agent-session', tabId: 'tab-1', sessionId: 'codex-session' }
+    })
+    render(
+      <QuickLaunchAgentMenuItems
+        worktreeId={WORKTREE_ID}
+        groupId="group-1"
+        onFocusTerminal={vi.fn()}
+        prompt="review notes"
+      />
+    )
+    const codexRow = document.querySelector('[title="Launch Codex in a new terminal"]')!
+    fireEvent.click(codexRow)
+    fireEvent.click(codexRow)
+
+    const requestIds = launchMock.mock.calls.map(([args]) => args.requestId)
+    expect(requestIds).toHaveLength(2)
+    expect(requestIds[0]).toEqual(expect.any(String))
+    expect(requestIds[1]).not.toBe(requestIds[0])
+  })
+
+  // Why: the notes menu holds what it sent until this result, so a second send leaves them out.
+  it("hands the launch's own delivery outcome to the notes menu", async () => {
+    const delivery = Promise.resolve({ delivered: true, failureNotified: false })
+    launchMock.mockReturnValue({
+      surface: { kind: 'local-agent-session', tabId: 'tab-1', sessionId: 'codex-session' },
+      promptDeliveryResult: delivery
+    })
+    const onPromptHandedOff = vi.fn()
+
+    render(
+      <QuickLaunchAgentMenuItems
+        worktreeId={WORKTREE_ID}
+        groupId="group-1"
+        onFocusTerminal={vi.fn()}
+        prompt="review notes"
+        promptDelivery="submit-after-ready"
+        onPromptHandedOff={onPromptHandedOff}
+      />
+    )
+    fireEvent.click(document.querySelector('[title="Launch Codex in a new terminal"]')!)
+
+    expect(onPromptHandedOff).toHaveBeenCalledOnce()
+    await expect(onPromptHandedOff.mock.calls[0][0]).resolves.toEqual({ delivered: true })
+  })
+
+  it('starts no agent when the menu has nothing left to send', () => {
+    launchMock.mockClear()
+    render(
+      <QuickLaunchAgentMenuItems
+        worktreeId={WORKTREE_ID}
+        groupId="group-1"
+        onFocusTerminal={vi.fn()}
+        prompt=""
+        disabled
+      />
+    )
+
+    expect(agentRowDisabled('Codex')).toBe('true')
+    fireEvent.click(document.querySelector('[title="Launch Codex in a new terminal"]')!)
+    expect(launchMock).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/components/tab-bar/QuickLaunchButton.tsx b/src/renderer/src/components/tab-bar/QuickLaunchButton.tsx
index 026944575c8..3f15fe43418 100644
--- a/src/renderer/src/components/tab-bar/QuickLaunchButton.tsx
+++ b/src/renderer/src/components/tab-bar/QuickLaunchButton.tsx
@@ -1,5 +1,5 @@
 import React, { useCallback } from 'react'
-import { Loader2, Settings as SettingsIcon } from 'lucide-react'
+import { Settings as SettingsIcon } from 'lucide-react'
 import { toast } from 'sonner'
 import { DropdownMenuItem, DropdownMenuShortcut } from '@/components/ui/dropdown-menu'
 import { getAgentCatalog, AgentIcon } from '@/lib/agent-catalog'
@@ -8,7 +8,7 @@ import { useAgentDetectionTargetForWorktree } from '@/hooks/useAgentDetectionTar
 import { useDetectedAgents } from '@/hooks/useDetectedAgents'
 import { useOptionalShortcutLabel } from '@/hooks/useShortcutLabel'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
-import { isAgentSessionHandleProvider } from '../../../../shared/agent-session-provider-handle'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import type { TuiAgent } from '../../../../shared/tui-agent'
 import type { LaunchSource } from '../../../../shared/telemetry-events'
 import {
@@ -16,7 +16,7 @@ import {
   filterEnabledTuiAgents
 } from '../../../../shared/tui-agent-selection'
 import { translate } from '@/i18n/i18n'
-import { useStructuredAgentLaunchStatus } from '@/lib/structured-agent-session-launch'
+import { newAgentPromptOutcome } from '@/lib/new-agent-prompt-outcome'
 
 export type QuickLaunchAgentMenuItemsProps = {
   worktreeId: string
@@ -37,6 +37,10 @@ export type QuickLaunchAgentMenuItemsProps = {
   launchSource?: LaunchSource
   /** Called after a prompt is queued into the agent, or immediately for argv prompt launches. */
   onPromptDelivered?: () => void
+  /** Given the launch's own delivery result while the prompt is still on its way. */
+  onPromptHandedOff?: (delivered: Promise<unknown>) => void
+  /** Nothing to send: e.g. every note is already on its way, so no agent is started. */
+  disabled?: boolean
 }
 
 function getCatalogEntry(agent: TuiAgent): { id: TuiAgent; label: string } | null {
@@ -103,7 +107,9 @@ function QuickLaunchAgentMenuItemsInner({
   prompt,
   promptDelivery,
   launchSource,
-  onPromptDelivered
+  onPromptDelivered,
+  onPromptHandedOff,
+  disabled = false
 }: QuickLaunchAgentMenuItemsProps): React.JSX.Element | null {
   // Why: resolving only the SSH connectionId here made paired-runtime
   // worktrees fall back to LOCAL detection, listing the client's agents
@@ -118,12 +124,6 @@ function QuickLaunchAgentMenuItemsInner({
   const openSettingsPage = useAppStore((s) => s.openSettingsPage)
   const openSettingsTarget = useAppStore((s) => s.openSettingsTarget)
   const newAgentShortcut = useOptionalShortcutLabel('tab.newAgent')
-  // One hook per structured provider: the launch registry is keyed by agent, and hooks cannot run
-  // inside the agent list's render loop.
-  const structuredLaunchStatusByAgent = {
-    claude: useStructuredAgentLaunchStatus(worktreeId, 'claude'),
-    codex: useStructuredAgentLaunchStatus(worktreeId, 'codex')
-  }
 
   const openAgentSettings = useCallback(() => {
     openSettingsTarget({ pane: 'agents', repoId: null })
@@ -132,9 +132,13 @@ function QuickLaunchAgentMenuItemsInner({
 
   const runLaunch = useCallback(
     (agent: TuiAgent) => {
+      if (disabled) {
+        return
+      }
       const entry = getCatalogEntry(agent)
       const label = entry?.label ?? agent
       const result = launchAgentInNewTab({
+        requestId: newAgentLaunchRequestId(),
         agent,
         worktreeId,
         groupId,
@@ -153,6 +157,17 @@ function QuickLaunchAgentMenuItemsInner({
         )
         return
       }
+      if (onPromptHandedOff && result.promptDeliveryResult) {
+        onPromptHandedOff(
+          newAgentPromptOutcome({
+            prompt: prompt ?? '',
+            ...(result.surface.kind === 'local-agent-session'
+              ? { sessionId: result.surface.sessionId }
+              : {}),
+            delivery: result.promptDeliveryResult
+          })
+        )
+      }
       if (result.surface.kind !== 'local-terminal') {
         return
       }
@@ -179,7 +194,17 @@ function QuickLaunchAgentMenuItemsInner({
         toast.message(getLaunchWatchdogTimeoutMessage(label))
       })
     },
-    [worktreeId, groupId, onFocusTerminal, prompt, promptDelivery, launchSource, onPromptDelivered]
+    [
+      worktreeId,
+      groupId,
+      onFocusTerminal,
+      prompt,
+      promptDelivery,
+      launchSource,
+      onPromptDelivered,
+      onPromptHandedOff,
+      disabled
+    ]
   )
 
   const enabledDetectedIds = detectedIds ? filterEnabledTuiAgents(detectedIds, disabledAgents) : []
@@ -203,14 +228,12 @@ function QuickLaunchAgentMenuItemsInner({
       {agents.map((agent) => {
         const entry = getCatalogEntry(agent)
         const label = entry?.label ?? agent
-        const isStructuredLaunchPending =
-          isAgentSessionHandleProvider(agent) && structuredLaunchStatusByAgent[agent] === 'pending'
         const showsDefaultAgentShortcut =
           newAgentShortcut !== null && defaultAgent !== 'blank' && agent === defaultAgent
         return (
           <DropdownMenuItem
             key={agent}
-            disabled={isStructuredLaunchPending}
+            disabled={disabled}
             onSelect={() => runLaunch(agent)}
             className="gap-2 rounded-[7px] px-2 py-1.5 text-[12px] leading-5 font-medium"
             title={translate(
@@ -219,11 +242,7 @@ function QuickLaunchAgentMenuItemsInner({
               { value0: label }
             )}
           >
-            {isStructuredLaunchPending ? (
-              <Loader2 className="size-3.5 shrink-0 animate-spin" aria-hidden="true" />
-            ) : (
-              <AgentIcon agent={agent} size={14} />
-            )}
+            <AgentIcon agent={agent} size={14} />
             <span className="flex-1">{label}</span>
             {showsDefaultAgentShortcut ? (
               <DropdownMenuShortcut>{newAgentShortcut}</DropdownMenuShortcut>
diff --git a/src/renderer/src/components/tab-bar/TabBarCreateEntry.keyboard.test.tsx b/src/renderer/src/components/tab-bar/TabBarCreateEntry.keyboard.test.tsx
index 8eab22f3c8c..035cba0c0c1 100644
--- a/src/renderer/src/components/tab-bar/TabBarCreateEntry.keyboard.test.tsx
+++ b/src/renderer/src/components/tab-bar/TabBarCreateEntry.keyboard.test.tsx
@@ -18,9 +18,6 @@ import type { AppState } from '@/store/types'
 // Why: the real entry-action module pulls in runtime IPC + the app store; the
 // keyboard behavior under test only needs a controllable option list.
 const entryOptionsMock = vi.hoisted(() => ({ options: [] as TabEntryOption[] }))
-const structuredLaunchMock = vi.hoisted(() => ({
-  status: 'idle' as 'idle' | 'pending' | 'unknown'
-}))
 vi.mock('./tab-create-entry-action', () => ({
   getTabEntryOptions: () => entryOptionsMock.options,
   createTabEntryAllowAbsolutePathsSelector: () => () => true,
@@ -38,9 +35,6 @@ vi.mock('@/lib/agent-catalog', () => ({
   getAgentCatalog: () => [],
   AgentIcon: () => null
 }))
-vi.mock('@/lib/structured-agent-session-launch', () => ({
-  useStructuredAgentLaunchStatus: () => structuredLaunchMock.status
-}))
 
 import TabBarCreateEntry from './TabBarCreateEntry'
 
@@ -176,7 +170,6 @@ afterEach(() => {
   act(() => root.unmount())
   container.remove()
   vi.clearAllMocks()
-  structuredLaunchMock.status = 'idle'
 })
 
 describe('TabBarCreateEntry keyboard navigation', () => {
@@ -267,29 +260,6 @@ describe('TabBarCreateEntry keyboard navigation', () => {
     expect(onLaunchAgent).toHaveBeenCalledWith('gemini')
   })
 
-  it('does not relaunch Codex when a structured launch is already pending', () => {
-    structuredLaunchMock.status = 'pending'
-    const agentOptions: TabAgentLaunchOption[] = [
-      { agent: 'codex', aliases: ['codex'], label: 'Codex' }
-    ]
-    const onLaunchAgent = vi.fn()
-    mount(
-      <TabBarCreateEntry
-        worktreeId="wt"
-        groupId="g"
-        menuOpen
-        agentOptions={agentOptions}
-        onOpenEntry={vi.fn().mockResolvedValue(undefined)}
-        onLaunchAgent={onLaunchAgent}
-      />
-    )
-
-    setQuery('cod')
-    submitForm()
-
-    expect(onLaunchAgent).not.toHaveBeenCalled()
-  })
-
   it('exposes the highlighted row to assistive tech via aria-activedescendant', () => {
     entryOptionsMock.options = [fileOption('a.ts'), fileOption('b.ts'), fileOption('c.ts')]
     mount(
diff --git a/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx b/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx
index d0766a7b1cf..0c1562513b8 100644
--- a/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx
+++ b/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx
@@ -33,9 +33,6 @@ import {
   getTabEntryOmniboxPlaceholder
 } from './tab-create-entry-copy'
 import { EMPTY_AGENT_OPTIONS, EMPTY_MENU_OPTIONS } from './tab-create-entry-empty-options'
-import { useStructuredAgentLaunchStatus } from '@/lib/structured-agent-session-launch'
-import { isAgentSessionHandleProvider } from '../../../../shared/agent-session-provider-handle'
-import type { TuiAgent } from '../../../../shared/tui-agent'
 import type { TabEntryActionClassification } from './tab-create-entry-classifier'
 import type { TabBarCreateEntryProps } from './tab-create-entry-props'
 
@@ -62,14 +59,6 @@ function TabBarCreateEntrySession({
   const [error, setError] = useState<string | null>(null)
   const [switchError, setSwitchError] = useState<string | null>(null)
   const [selectionGuidance, setSelectionGuidance] = useState<string | null>(null)
-  // One hook per structured provider: the launch registry is keyed by agent, and hooks cannot run
-  // inside the option render loop.
-  const structuredLaunchStatusByAgent = {
-    claude: useStructuredAgentLaunchStatus(worktreeId, 'claude'),
-    codex: useStructuredAgentLaunchStatus(worktreeId, 'codex')
-  }
-  const isStructuredLaunchPending = (agent: TuiAgent): boolean =>
-    isAgentSessionHandleProvider(agent) && structuredLaunchStatusByAgent[agent] === 'pending'
   // null = follow ranking (deferred tabs can prepend); set on arrow keys only.
   const [pinnedOptionId, setPinnedOptionId] = useState<string | null>(null)
   const inputRef = useRef<HTMLInputElement>(null)
@@ -238,9 +227,6 @@ function TabBarCreateEntrySession({
       return
     }
     if (selectedOption.kind === 'agent') {
-      if (isStructuredLaunchPending(selectedOption.option.agent)) {
-        return
-      }
       onLaunchAgent?.(selectedOption.option.agent)
       onDidOpenEntry?.()
       return
@@ -389,15 +375,8 @@ function TabBarCreateEntrySession({
                 id={resultOptionDomId(index)}
                 option={option}
                 selected={index === activeSelectedIndex}
-                disabled={
-                  disabled ||
-                  pending ||
-                  (option.kind === 'agent' && isStructuredLaunchPending(option.option.agent))
-                }
-                loading={
-                  (pending && index === activeSelectedIndex) ||
-                  (option.kind === 'agent' && isStructuredLaunchPending(option.option.agent))
-                }
+                disabled={disabled || pending}
+                loading={pending && index === activeSelectedIndex}
                 onClick={() => {
                   setSelectionGuidance(null)
                   submitOption(option)
diff --git a/src/renderer/src/components/tab-bar/TabBarQuickCommandsMenu.tsx b/src/renderer/src/components/tab-bar/TabBarQuickCommandsMenu.tsx
index 02b6cd4ec50..e8ab06dfe70 100644
--- a/src/renderer/src/components/tab-bar/TabBarQuickCommandsMenu.tsx
+++ b/src/renderer/src/components/tab-bar/TabBarQuickCommandsMenu.tsx
@@ -326,11 +326,7 @@ export function TabBarQuickCommandsMenu({
                   setCommandValueOverride(null)
                   setQuery(nextQuery)
                 }}
-                onCompositionStart={searchInput.onCompositionStart}
-                onCompositionEnd={searchInput.onCompositionEnd}
                 onKeyDown={searchInput.onKeyDown}
-                onKeyUp={searchInput.onKeyUp}
-                onBlur={searchInput.onBlur}
                 className="h-9 py-2 text-[12px]"
                 wrapperClassName="border-b border-border/50 px-2"
                 iconClassName="h-3.5 w-3.5"
diff --git a/src/renderer/src/components/tab-bar/tab-create-entry-absolute-file.ts b/src/renderer/src/components/tab-bar/tab-create-entry-absolute-file.ts
index 2b60d1d2506..7e201f7fc6c 100644
--- a/src/renderer/src/components/tab-bar/tab-create-entry-absolute-file.ts
+++ b/src/renderer/src/components/tab-bar/tab-create-entry-absolute-file.ts
@@ -1,20 +1,20 @@
 import { detectLanguage } from '@/lib/language-detect'
 import { toWorktreeRelativePath } from '@/lib/terminal-links'
-import type { RuntimeFileOperationArgs, statRuntimePath } from '@/runtime/runtime-file-client'
+import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
 import type { OpenFile } from '@/store/slices/editor'
 import {
   validateNewTabEntryAbsolutePath,
   type TabEntryLocalPlatform
 } from './tab-create-entry-path-validation'
+import type { statUserOpenedPath, UserOpenedPathStat } from '@/lib/user-opened-local-path'
 
 type AbsoluteFileOperations = {
   assertAbsolutePathAllowed: () => void
-  authorizeExternalPath: (args: { targetPath: string }) => Promise<void>
   openFile: (
     file: Omit<OpenFile, 'id' | 'isDirty'>,
     options?: { preview?: boolean; targetGroupId?: string }
   ) => void
-  statRuntimePath: typeof statRuntimePath
+  statUserOpenedPath: typeof statUserOpenedPath
 }
 
 export async function openAbsoluteTabEntryFile(args: {
@@ -28,11 +28,9 @@ export async function openAbsoluteTabEntryFile(args: {
 }): Promise<void> {
   const filePath = validateNewTabEntryAbsolutePath(args.filePath, args.localPlatform)
   args.operations.assertAbsolutePathAllowed()
-  await args.operations.authorizeExternalPath({ targetPath: filePath })
-  args.operations.assertAbsolutePathAllowed()
-  let stat: Awaited<ReturnType<typeof statRuntimePath>>
+  let stat: UserOpenedPathStat
   try {
-    stat = await args.operations.statRuntimePath(args.context, filePath)
+    stat = await args.operations.statUserOpenedPath(args.context, filePath)
   } catch {
     throw new Error(`File not found: ${filePath}`)
   }
@@ -44,7 +42,10 @@ export async function openAbsoluteTabEntryFile(args: {
   args.operations.openFile(
     {
       filePath,
-      relativePath: toWorktreeRelativePath(filePath, args.worktreePath) || filePath,
+      // Why: a project link out of the project keeps its absolute path, so it reads as user-named.
+      relativePath: stat.escapesWorktree
+        ? filePath
+        : toWorktreeRelativePath(filePath, args.worktreePath) || filePath,
       worktreeId: args.worktreeId,
       language: detectLanguage(filePath),
       mode: 'edit'
diff --git a/src/renderer/src/components/tab-bar/tab-create-entry-action.test.ts b/src/renderer/src/components/tab-bar/tab-create-entry-action.test.ts
index 880bb561db4..93d007adf31 100644
--- a/src/renderer/src/components/tab-bar/tab-create-entry-action.test.ts
+++ b/src/renderer/src/components/tab-bar/tab-create-entry-action.test.ts
@@ -14,7 +14,7 @@ describe('openTabEntryWithOperations', () => {
       openWorkspaceBrowserTab: vi.fn().mockResolvedValue(undefined),
       openFile: vi.fn(),
       statRuntimePath: vi.fn().mockResolvedValue({ size: 1, isDirectory: false, mtime: 1 }),
-      authorizeExternalPath: vi.fn().mockResolvedValue(undefined),
+      statUserOpenedPath: vi.fn().mockResolvedValue({ isDirectory: false, escapesWorktree: false }),
       assertAbsolutePathAllowed: vi.fn(),
       ...overrides
     }
@@ -254,7 +254,7 @@ describe('openTabEntryWithOperations', () => {
     })
   })
 
-  it('authorizes and opens absolute local files in the target group', async () => {
+  it('opens absolute local files as user-named in the target group', async () => {
     const operations = makeOperations()
 
     await openTabEntryWithOperations({
@@ -264,8 +264,7 @@ describe('openTabEntryWithOperations', () => {
       operations
     })
 
-    expect(operations.authorizeExternalPath).toHaveBeenCalledWith({ targetPath: '/tmp/notes.md' })
-    expect(operations.statRuntimePath).toHaveBeenCalledWith(
+    expect(operations.statUserOpenedPath).toHaveBeenCalledWith(
       baseArgs.runtimeContext,
       '/tmp/notes.md'
     )
@@ -298,6 +297,27 @@ describe('openTabEntryWithOperations', () => {
     )
   })
 
+  it('opens a typed project link that leads out of the project by its absolute path', async () => {
+    const operations = makeOperations({
+      statUserOpenedPath: vi.fn().mockResolvedValue({ isDirectory: false, escapesWorktree: true })
+    })
+
+    await openTabEntryWithOperations({
+      ...baseArgs,
+      classification: { kind: 'absolute-file', filePath: '/repo/docs-link/secret.md' },
+      query: '/repo/docs-link/secret.md',
+      operations
+    })
+
+    expect(operations.openFile).toHaveBeenCalledWith(
+      expect.objectContaining({
+        filePath: '/repo/docs-link/secret.md',
+        relativePath: '/repo/docs-link/secret.md'
+      }),
+      { preview: false, targetGroupId: 'group-1' }
+    )
+  })
+
   it('rejects absolute paths when remote workspaces disallow them', async () => {
     const operations = makeOperations()
 
@@ -311,13 +331,12 @@ describe('openTabEntryWithOperations', () => {
       })
     ).rejects.toThrow(TAB_ENTRY_ABSOLUTE_PATH_REMOTE_BLOCKED_MESSAGE)
 
-    expect(operations.authorizeExternalPath).not.toHaveBeenCalled()
-    expect(operations.statRuntimePath).not.toHaveBeenCalled()
+    expect(operations.statUserOpenedPath).not.toHaveBeenCalled()
     expect(operations.createRuntimePath).not.toHaveBeenCalled()
     expect(operations.openFile).not.toHaveBeenCalled()
   })
 
-  it('rejects Windows path syntax before native POSIX authorization', async () => {
+  it('rejects Windows path syntax before touching a native POSIX path', async () => {
     const operations = makeOperations()
 
     await expect(
@@ -329,8 +348,7 @@ describe('openTabEntryWithOperations', () => {
       })
     ).rejects.toThrow('Enter an absolute path for this computer.')
 
-    expect(operations.authorizeExternalPath).not.toHaveBeenCalled()
-    expect(operations.statRuntimePath).not.toHaveBeenCalled()
+    expect(operations.statUserOpenedPath).not.toHaveBeenCalled()
     expect(operations.openFile).not.toHaveBeenCalled()
   })
 
@@ -346,23 +364,22 @@ describe('openTabEntryWithOperations', () => {
       operations
     })
 
-    expect(operations.authorizeExternalPath).toHaveBeenCalledWith({
-      targetPath: 'C:/tmp/notes.md'
-    })
-    expect(operations.statRuntimePath).toHaveBeenCalledWith(
+    expect(operations.statUserOpenedPath).toHaveBeenCalledWith(
       baseArgs.runtimeContext,
       'C:/tmp/notes.md'
     )
   })
 
-  it('stops after authorization when ownership becomes remote or ambiguous', async () => {
-    let releaseAuthorization: (() => void) | undefined
-    const authorization = new Promise<void>((resolve) => {
-      releaseAuthorization = resolve
-    })
+  it('stops after the file check when ownership becomes remote or ambiguous', async () => {
+    let releaseStat: (() => void) | undefined
+    const statResult = new Promise<{ isDirectory: boolean; escapesWorktree: boolean }>(
+      (resolve) => {
+        releaseStat = () => resolve({ isDirectory: false, escapesWorktree: false })
+      }
+    )
     let allowed = true
     const operations = makeOperations({
-      authorizeExternalPath: vi.fn(() => authorization),
+      statUserOpenedPath: vi.fn(() => statResult),
       assertAbsolutePathAllowed: vi.fn(() => {
         if (!allowed) {
           throw new Error(TAB_ENTRY_ABSOLUTE_PATH_REMOTE_BLOCKED_MESSAGE)
@@ -376,15 +393,14 @@ describe('openTabEntryWithOperations', () => {
       query: '/tmp/notes.md',
       operations
     })
-    await vi.waitFor(() => expect(operations.authorizeExternalPath).toHaveBeenCalledTimes(1))
+    await vi.waitFor(() => expect(operations.statUserOpenedPath).toHaveBeenCalledTimes(1))
     const rejection = expect(opening).rejects.toThrow(
       TAB_ENTRY_ABSOLUTE_PATH_REMOTE_BLOCKED_MESSAGE
     )
     allowed = false
-    releaseAuthorization?.()
+    releaseStat?.()
     await rejection
 
-    expect(operations.statRuntimePath).not.toHaveBeenCalled()
     expect(operations.openFile).not.toHaveBeenCalled()
   })
 })
diff --git a/src/renderer/src/components/tab-bar/tab-create-entry-action.ts b/src/renderer/src/components/tab-bar/tab-create-entry-action.ts
index 6c7ec6bbdb5..4fedc19935b 100644
--- a/src/renderer/src/components/tab-bar/tab-create-entry-action.ts
+++ b/src/renderer/src/components/tab-bar/tab-create-entry-action.ts
@@ -49,6 +49,7 @@ export {
   getTabEntryAllowAbsolutePaths,
   isTabEntryAbsolutePathAllowed
 } from './tab-create-entry-local-path'
+import { statUserOpenedPath } from '@/lib/user-opened-local-path'
 
 export type TabCreateEntryArgs = {
   classification?: TabEntryActionClassification
@@ -66,7 +67,7 @@ export type TabEntryOperations = {
     options?: { preview?: boolean; targetGroupId?: string }
   ) => void
   statRuntimePath: typeof statRuntimePath
-  authorizeExternalPath: (args: { targetPath: string }) => Promise<void>
+  statUserOpenedPath: typeof statUserOpenedPath
   assertAbsolutePathAllowed: () => void
 }
 
@@ -290,7 +291,7 @@ export async function openTabBarEntry(args: TabCreateEntryArgs): Promise<void> {
       openWorkspaceBrowserTab,
       openFile: state.openFile,
       statRuntimePath,
-      authorizeExternalPath: window.api.fs.authorizeExternalPath,
+      statUserOpenedPath,
       assertAbsolutePathAllowed: () => {
         if (!getTabEntryAllowAbsolutePaths(useAppStore.getState(), args.worktreeId)) {
           throw new Error(TAB_ENTRY_ABSOLUTE_PATH_REMOTE_BLOCKED_MESSAGE)
diff --git a/src/renderer/src/components/tab-bar/use-tab-bar-create-menu-controller.ts b/src/renderer/src/components/tab-bar/use-tab-bar-create-menu-controller.ts
index 9b688008b99..dcbc45df788 100644
--- a/src/renderer/src/components/tab-bar/use-tab-bar-create-menu-controller.ts
+++ b/src/renderer/src/components/tab-bar/use-tab-bar-create-menu-controller.ts
@@ -7,6 +7,7 @@ import {
   launchAgentInNewTab,
   shouldQueueTerminalFocusAfterMenuClose
 } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import type { WindowsTerminalCapabilities } from '@/lib/windows-terminal-capabilities'
 import { useAppStore } from '../../store'
 import type { TabAgentLaunchOption } from './tab-agent-launch-options'
@@ -223,6 +224,7 @@ export function useTabBarCreateMenuController({
   const launchAgentFromNewTabEntry = (agent: TuiAgent): void => {
     const option = agentLaunchOptions.find((candidate) => candidate.agent === agent)
     const result = launchAgentInNewTab({
+      requestId: newAgentLaunchRequestId(),
       agent,
       worktreeId,
       groupId: resolvedGroupId,
diff --git a/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.test.ts b/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.test.ts
deleted file mode 100644
index 1883cadde2c..00000000000
--- a/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.test.ts
+++ /dev/null
@@ -1,132 +0,0 @@
-// @vitest-environment happy-dom
-import { createRef } from 'react'
-import { renderHook } from '@testing-library/react'
-import { describe, expect, it, vi } from 'vitest'
-
-import { useTabBarQuickCommandSearchInput } from './use-tab-bar-quick-command-search-input'
-import type { TerminalQuickCommand } from '../../../../shared/terminal-quick-command-types'
-
-const command = { id: 'cmd-1', label: 'Run tests' } as unknown as TerminalQuickCommand
-
-function setup(onRun = vi.fn()): {
-  onRun: ReturnType<typeof vi.fn>
-  result: ReturnType<typeof renderHook<ReturnType<typeof useTabBarQuickCommandSearchInput>, void>>
-} {
-  const result = renderHook(() =>
-    useTabBarQuickCommandSearchInput({
-      commandListRef: createRef<HTMLDivElement>(),
-      commandValue: command.id,
-      filteredCommands: [command],
-      getCommandId: (item) => item.id,
-      onCommandValueChange: () => {},
-      onRun,
-      selectedCommand: command
-    })
-  )
-  return { onRun, result }
-}
-
-function keyEvent(init: {
-  key: string
-  keyCode: number
-  ctrlKey?: boolean
-  metaKey?: boolean
-  shiftKey?: boolean
-  altKey?: boolean
-  isComposing?: boolean
-  preventDefault?: () => void
-  stopPropagation?: () => void
-}): never {
-  return {
-    key: init.key,
-    keyCode: init.keyCode,
-    ctrlKey: init.ctrlKey ?? false,
-    altKey: init.altKey ?? false,
-    metaKey: init.metaKey ?? false,
-    shiftKey: init.shiftKey ?? false,
-    nativeEvent: { isComposing: init.isComposing ?? false },
-    preventDefault: init.preventDefault ?? (() => {}),
-    stopPropagation: init.stopPropagation ?? (() => {})
-  } as never
-}
-
-// Why: Enter here RUNS a terminal command, so a stray Enter is not recoverable.
-describe('useTabBarQuickCommandSearchInput IME Enter ownership', () => {
-  it('navigates hosted commands by the caller-provided composite key', () => {
-    const entries = [{ key: 'local\0shared' }, { key: 'runtime:build\0shared' }]
-    const onCommandValueChange = vi.fn()
-    const { result } = renderHook(() =>
-      useTabBarQuickCommandSearchInput({
-        commandListRef: createRef<HTMLDivElement>(),
-        commandValue: entries[0].key,
-        filteredCommands: entries,
-        getCommandId: (entry) => entry.key,
-        onCommandValueChange,
-        onRun: vi.fn(),
-        selectedCommand: entries[0]
-      })
-    )
-
-    result.current.onKeyDown(keyEvent({ key: 'ArrowDown', keyCode: 40 }))
-
-    expect(onCommandValueChange).toHaveBeenCalledWith(entries[1].key)
-  })
-
-  it('lets the native select-all behavior run in the search input', () => {
-    const { result } = setup()
-    const stopPropagation = vi.fn()
-    const preventDefault = vi.fn()
-
-    result.result.current.onKeyDown(
-      keyEvent({
-        key: 'a',
-        keyCode: 65,
-        ctrlKey: true,
-        stopPropagation,
-        preventDefault
-      })
-    )
-
-    expect(stopPropagation).toHaveBeenCalledOnce()
-    expect(preventDefault).not.toHaveBeenCalled()
-  })
-
-  it('does not run the command on the bare redispatch after a confirm', () => {
-    const { onRun, result } = setup()
-    result.result.current.onCompositionStart()
-    result.result.current.onKeyDown(keyEvent({ key: 'Process', keyCode: 229, isComposing: true }))
-    result.result.current.onCompositionEnd()
-    result.result.current.onKeyDown(keyEvent({ key: 'Enter', keyCode: 13 }))
-
-    expect(onRun).not.toHaveBeenCalled()
-  })
-
-  it('does not run the command on an Enter pressed during composition', () => {
-    const { onRun, result } = setup()
-    result.result.current.onCompositionStart()
-    result.result.current.onKeyDown(keyEvent({ key: 'Enter', keyCode: 13, isComposing: true }))
-
-    expect(onRun).not.toHaveBeenCalled()
-  })
-
-  // Regression: the carry token owned any modifier-carrying Enter, so a modifier held
-  // through the confirm silently dropped the run. Ctrl, not Cmd: happy-dom is non-Mac.
-  it('runs the command when a modifier is held through the confirm redispatch', () => {
-    const { onRun, result } = setup()
-    result.result.current.onCompositionStart()
-    result.result.current.onKeyDown(
-      keyEvent({ key: 'Enter', keyCode: 13, isComposing: true, ctrlKey: true })
-    )
-    result.result.current.onCompositionEnd()
-    result.result.current.onKeyDown(keyEvent({ key: 'Enter', keyCode: 13, ctrlKey: true }))
-
-    expect(onRun).toHaveBeenCalledWith(command)
-  })
-
-  it('runs the command on an ordinary Enter', () => {
-    const { onRun, result } = setup()
-    result.result.current.onKeyDown(keyEvent({ key: 'Enter', keyCode: 13 }))
-
-    expect(onRun).toHaveBeenCalledWith(command)
-  })
-})
diff --git a/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.test.tsx b/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.test.tsx
new file mode 100644
index 00000000000..99f40b66a10
--- /dev/null
+++ b/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.test.tsx
@@ -0,0 +1,80 @@
+// @vitest-environment happy-dom
+import { createRef } from 'react'
+import { cleanup, fireEvent, render } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { Command, CommandInput } from '@/components/ui/command'
+import { useTabBarQuickCommandSearchInput } from './use-tab-bar-quick-command-search-input'
+
+const commands = [
+  { id: 'local\0shared', label: 'Run tests' },
+  { id: 'runtime:build\0shared', label: 'Build' }
+]
+afterEach(cleanup)
+
+function setup() {
+  const onRun = vi.fn(),
+    onCommandValueChange = vi.fn()
+  function Search() {
+    const props = useTabBarQuickCommandSearchInput({
+      commandListRef: createRef<HTMLDivElement>(),
+      commandValue: commands[0].id,
+      filteredCommands: commands,
+      getCommandId: (item) => item.id,
+      onCommandValueChange,
+      onRun,
+      selectedCommand: commands[0]
+    })
+    return (
+      <Command>
+        <CommandInput {...props} />
+      </Command>
+    )
+  }
+  const { getByRole } = render(<Search />)
+  return { input: getByRole('combobox'), onRun, onCommandValueChange }
+}
+
+// Enter executes a terminal command, so exercise the actual guarded search field.
+describe('quick command search IME ownership', () => {
+  it('navigates hosted commands by the caller-provided composite key', () => {
+    const { input, onCommandValueChange } = setup()
+    fireEvent.keyDown(input, { key: 'ArrowDown', keyCode: 40 })
+    expect(onCommandValueChange).toHaveBeenCalledWith(commands[1].id)
+  })
+
+  it('leaves native select-all available', () => {
+    const { input } = setup()
+    expect(fireEvent.keyDown(input, { key: 'a', ctrlKey: true })).toBe(true)
+  })
+
+  it('does not run a command on the bare redispatch after a confirmation', () => {
+    const { input, onRun } = setup()
+    fireEvent.compositionStart(input)
+    fireEvent.keyDown(input, { key: 'Process', keyCode: 229, isComposing: true })
+    fireEvent.compositionEnd(input)
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+    expect(onRun).not.toHaveBeenCalled()
+  })
+
+  it('does not run a command during composition', () => {
+    const { input, onRun } = setup()
+    fireEvent.compositionStart(input)
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, isComposing: true })
+    expect(onRun).not.toHaveBeenCalled()
+  })
+
+  it('runs a command when a modifier is held through the confirmation redispatch', () => {
+    const { input, onRun } = setup()
+    fireEvent.compositionStart(input)
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, isComposing: true, ctrlKey: true })
+    fireEvent.compositionEnd(input)
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, ctrlKey: true })
+    expect(onRun).toHaveBeenCalledExactlyOnceWith(commands[0])
+  })
+
+  it('runs a command on ordinary Enter', () => {
+    const { input, onRun } = setup()
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+    expect(onRun).toHaveBeenCalledExactlyOnceWith(commands[0])
+  })
+})
diff --git a/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.ts b/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.ts
index e0beabace4f..906fca92633 100644
--- a/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.ts
+++ b/src/renderer/src/components/tab-bar/use-tab-bar-quick-command-search-input.ts
@@ -1,6 +1,5 @@
 import { useCallback, type KeyboardEvent, type RefObject } from 'react'
 
-import { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
 import { isSelectAllShortcut } from '@/lib/editable-target'
 
 type SearchInputOptions<TCommand> = {
@@ -22,18 +21,10 @@ export function useTabBarQuickCommandSearchInput<TCommand>({
   onRun,
   selectedCommand
 }: SearchInputOptions<TCommand>): {
-  onBlur: () => void
-  onCompositionEnd: () => void
-  onCompositionStart: () => void
   onKeyDown: (event: KeyboardEvent<HTMLInputElement>) => void
-  onKeyUp: ReturnType<typeof useImeEnterGestureOwnership>['onKeyUp']
 } {
-  const imeEnter = useImeEnterGestureOwnership()
   const onKeyDown = useCallback(
     (event: KeyboardEvent<HTMLInputElement>) => {
-      if (imeEnter.ownsKeyDown(event)) {
-        return
-      }
       if (isSelectAllShortcut(event)) {
         event.stopPropagation()
         return
@@ -71,7 +62,6 @@ export function useTabBarQuickCommandSearchInput<TCommand>({
       commandValue,
       filteredCommands,
       getCommandId,
-      imeEnter,
       onCommandValueChange,
       onRun,
       selectedCommand
@@ -79,10 +69,6 @@ export function useTabBarQuickCommandSearchInput<TCommand>({
   )
 
   return {
-    onBlur: imeEnter.reset,
-    onCompositionEnd: () => imeEnter.setComposing(false),
-    onCompositionStart: () => imeEnter.setComposing(true),
-    onKeyDown,
-    onKeyUp: imeEnter.onKeyUp
+    onKeyDown
   }
 }
diff --git a/src/renderer/src/components/task-page-jira-create-fields.test.ts b/src/renderer/src/components/task-page-jira-create-fields.test.ts
index 76707e54a0d..18fcfc918c7 100644
--- a/src/renderer/src/components/task-page-jira-create-fields.test.ts
+++ b/src/renderer/src/components/task-page-jira-create-fields.test.ts
@@ -3,10 +3,12 @@ import { describe, expect, it } from 'vitest'
 import {
   buildJiraCreateCustomFields,
   buildJiraCreateFieldValue,
+  buildJiraCreateSubmission,
   findJiraCreateAllowedValue,
   getJiraCreateAllowedValueLabel,
   getJiraCreateOptionPayload,
   getJiraUserCreateFieldKeys,
+  hasJiraAssigneeCreateField,
   isJiraScalarUserCreateField,
   isJiraUserCreateField,
   isVisibleJiraCreateField
@@ -25,6 +27,8 @@ describe('isVisibleJiraCreateField', () => {
     { key: 'issuetype', required: true, expected: false },
     { key: 'summary', required: true, expected: false },
     { key: 'description', required: true, expected: false },
+    // the dialog renders a dedicated assignee picker, so the generic field must not show
+    { key: 'assignee', required: true, expected: false },
     // characterization: current behavior — the system-field filter is exact-match
     // and case-sensitive, so a differently-cased key stays visible.
     { key: 'Summary', required: true, expected: true }
@@ -222,3 +226,55 @@ describe('buildJiraCreateCustomFields', () => {
     expect(buildJiraCreateCustomFields([field({ key: 'a' })], { other: 'x' })).toBeUndefined()
   })
 })
+
+describe('hasJiraAssigneeCreateField', () => {
+  it('detects whether the create screen accepts an assignee', () => {
+    expect(hasJiraAssigneeCreateField([field({ key: 'assignee', required: false })])).toBe(true)
+    expect(hasJiraAssigneeCreateField([field({ key: 'reporter' })])).toBe(false)
+    expect(hasJiraAssigneeCreateField([])).toBe(false)
+  })
+})
+
+describe('buildJiraCreateSubmission', () => {
+  const userField = field({ key: 'customfield_9', schema: { type: 'user' } })
+
+  it('omits assignee and userFieldKeys for the Automatic default', () => {
+    expect(buildJiraCreateSubmission([field({ key: 'a' })], { a: 'one' }, null)).toEqual({
+      customFields: { a: 'one' },
+      userFieldKeys: undefined
+    })
+    expect(buildJiraCreateSubmission([], {}, undefined)).toEqual({
+      customFields: undefined,
+      userFieldKeys: undefined
+    })
+  })
+
+  it('adds the picked assignee to customFields and names it as a user field', () => {
+    expect(buildJiraCreateSubmission([], {}, 'acc-1')).toEqual({
+      customFields: { assignee: 'acc-1' },
+      userFieldKeys: ['assignee']
+    })
+  })
+
+  it('names only the user-typed fields that carry a value', () => {
+    expect(
+      buildJiraCreateSubmission(
+        [userField, field({ key: 'customfield_8', schema: { type: 'user' } })],
+        { customfield_9: 'acc-9' },
+        'acc-1'
+      )
+    ).toEqual({
+      customFields: { customfield_9: 'acc-9', assignee: 'acc-1' },
+      userFieldKeys: ['customfield_9', 'assignee']
+    })
+  })
+
+  it('keeps userFieldKeys absent when user fields exist but are blank', () => {
+    // Why it matters: a non-empty key list trips the remote user-fields
+    // capability gate, which older hosts fail even with nothing to shape.
+    expect(buildJiraCreateSubmission([userField], {}, null)).toEqual({
+      customFields: undefined,
+      userFieldKeys: undefined
+    })
+  })
+})
diff --git a/src/renderer/src/components/task-page-jira-create-fields.ts b/src/renderer/src/components/task-page-jira-create-fields.ts
index 958cda620ea..07d929555f6 100644
--- a/src/renderer/src/components/task-page-jira-create-fields.ts
+++ b/src/renderer/src/components/task-page-jira-create-fields.ts
@@ -1,11 +1,25 @@
 import { buildJiraCreateTextAdf } from '@/components/jira-create-adf'
 import type { JiraCreateField } from '../../../shared/jira-types'
 
-const JIRA_CREATE_SYSTEM_FIELD_KEYS = new Set(['project', 'issuetype', 'summary', 'description'])
+// 'assignee' is system here because the dialog renders a dedicated picker for it.
+const JIRA_CREATE_SYSTEM_FIELD_KEYS = new Set([
+  'project',
+  'issuetype',
+  'summary',
+  'description',
+  'assignee'
+])
 
 /** Jira's own create screen defaults only this field to the authenticated user. */
 export const JIRA_REPORTER_FIELD_KEY = 'reporter'
 
+export const JIRA_ASSIGNEE_FIELD_KEY = 'assignee'
+
+// Jira rejects fields absent from the create screen.
+export function hasJiraAssigneeCreateField(fields: readonly JiraCreateField[]): boolean {
+  return fields.some((field) => field.key === JIRA_ASSIGNEE_FIELD_KEY)
+}
+
 /** True for required create fields the dialog must render (system fields excluded). */
 export function isVisibleJiraCreateField(field: JiraCreateField): boolean {
   return field.required && !JIRA_CREATE_SYSTEM_FIELD_KEYS.has(field.key)
@@ -110,3 +124,25 @@ export function buildJiraCreateCustomFields(
   }
   return Object.keys(customFields).length > 0 ? customFields : undefined
 }
+
+// Only populated user fields require the remote user-field capability.
+export function buildJiraCreateSubmission(
+  fields: readonly JiraCreateField[],
+  values: Record<string, string>,
+  assigneeAccountId?: string | null
+): { customFields?: Record<string, unknown>; userFieldKeys?: string[] } {
+  const customFields = { ...buildJiraCreateCustomFields(fields, values) }
+  if (assigneeAccountId) {
+    customFields[JIRA_ASSIGNEE_FIELD_KEY] = assigneeAccountId
+  }
+  const userFieldKeys = getJiraUserCreateFieldKeys(fields).filter(
+    (key) => customFields[key] !== undefined
+  )
+  if (assigneeAccountId) {
+    userFieldKeys.push(JIRA_ASSIGNEE_FIELD_KEY)
+  }
+  return {
+    customFields: Object.keys(customFields).length > 0 ? customFields : undefined,
+    userFieldKeys: userFieldKeys.length > 0 ? userFieldKeys : undefined
+  }
+}
diff --git a/src/renderer/src/components/task-page/jira/IssueAssigneeField.test.tsx b/src/renderer/src/components/task-page/jira/IssueAssigneeField.test.tsx
new file mode 100644
index 00000000000..3bff2e62614
--- /dev/null
+++ b/src/renderer/src/components/task-page/jira/IssueAssigneeField.test.tsx
@@ -0,0 +1,61 @@
+// @vitest-environment happy-dom
+import type { ComponentProps } from 'react'
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, expect, it, vi } from 'vitest'
+import { TaskPageJiraIssueAssigneeField } from './IssueAssigneeField'
+
+const search = vi.hoisted(() => vi.fn())
+vi.mock('@/runtime/runtime-jira-client', () => ({ jiraListAssignableUsersForProject: search }))
+afterEach(cleanup)
+
+it('drops old provider candidates before another host with identical project IDs can select them', async () => {
+  const onSelect = vi.fn()
+  const model: ComponentProps<typeof TaskPageJiraIssueAssigneeField>['model'] = {
+    settings: null,
+    jiraTaskSourceContext: null,
+    jiraStatusCurrent: true,
+    jiraStatus: {
+      connected: true,
+      activeSiteId: 'same-site',
+      viewer: { accountId: 'local-me', displayName: 'Local me', email: null }
+    },
+    jiraCreateFields: [{ key: 'assignee', name: 'Assignee', required: false }],
+    newJiraIssueTargetProject: { id: '100', key: 'PRJ', name: 'Project', siteId: 'same-site' },
+    newJiraIssueAssignee: null,
+    setNewJiraIssueAssignee: onSelect,
+    newJiraIssueSubmitting: false,
+    providerRuntimeContextKey: 'local'
+  }
+  search.mockResolvedValueOnce([{ accountId: 'local-user', displayName: 'Local user' }])
+  const { rerender } = render(<TaskPageJiraIssueAssigneeField model={model} />)
+  fireEvent.click(screen.getByRole('button', { name: 'Assignee' }))
+  await screen.findByRole('button', { name: 'Local user' })
+  expect(screen.getByRole('button', { name: 'Assign to me (Local me)' })).toBeTruthy()
+  expect(search).toHaveBeenCalledWith(null, 'PRJ', '', 'same-site')
+
+  search.mockReturnValueOnce(new Promise(() => {}))
+  rerender(
+    <TaskPageJiraIssueAssigneeField
+      model={{ ...model, providerRuntimeContextKey: 'runtime:remote', jiraStatusCurrent: false }}
+    />
+  )
+  expect(screen.queryByRole('button', { name: 'Local user' })).toBeNull()
+  fireEvent.click(screen.getByRole('button', { name: 'Assignee' }))
+  await waitFor(() => expect(search).toHaveBeenCalledTimes(2))
+  expect(screen.queryByRole('button', { name: 'Local user' })).toBeNull()
+  expect(screen.queryByRole('button', { name: 'Assign to me (Local me)' })).toBeNull()
+  rerender(
+    <TaskPageJiraIssueAssigneeField
+      model={{
+        ...model,
+        providerRuntimeContextKey: 'runtime:remote',
+        jiraStatus: {
+          ...model.jiraStatus,
+          viewer: { accountId: 'remote-me', displayName: 'Remote me', email: null }
+        }
+      }}
+    />
+  )
+  fireEvent.click(screen.getByRole('button', { name: 'Assign to me (Remote me)' }))
+  expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({ accountId: 'remote-me' }))
+})
diff --git a/src/renderer/src/components/task-page/jira/IssueAssigneeField.tsx b/src/renderer/src/components/task-page/jira/IssueAssigneeField.tsx
new file mode 100644
index 00000000000..f5091cfe142
--- /dev/null
+++ b/src/renderer/src/components/task-page/jira/IssueAssigneeField.tsx
@@ -0,0 +1,100 @@
+import { useCallback } from 'react'
+import type { TaskPageComposerActionsModel } from '../../use-task-page-composer-actions'
+import { getJiraSelfUser } from '@/components/jira-self-user'
+import { JiraUserPicker, type JiraUserPickerFixedOption } from '@/components/jira-user-picker'
+import { hasJiraAssigneeCreateField } from '@/components/task-page-jira-create-fields'
+import { getJiraProjectSelectionKey } from '@/components/task-page-jira-project-selection'
+import { jiraListAssignableUsersForProject } from '@/runtime/runtime-jira-client'
+import { translate } from '@/i18n/i18n'
+
+export function TaskPageJiraIssueAssigneeField({
+  model
+}: {
+  model: Pick<
+    TaskPageComposerActionsModel,
+    | 'settings'
+    | 'jiraTaskSourceContext'
+    | 'jiraStatus'
+    | 'jiraStatusCurrent'
+    | 'jiraCreateFields'
+    | 'newJiraIssueTargetProject'
+    | 'newJiraIssueAssignee'
+    | 'setNewJiraIssueAssignee'
+    | 'newJiraIssueSubmitting'
+    | 'providerRuntimeContextKey'
+  >
+}): React.JSX.Element | null {
+  const {
+    settings,
+    jiraTaskSourceContext,
+    jiraStatus,
+    jiraCreateFields,
+    newJiraIssueTargetProject,
+    newJiraIssueAssignee,
+    setNewJiraIssueAssignee,
+    newJiraIssueSubmitting
+  } = model
+  const providerSettings = jiraTaskSourceContext ?? settings
+  const projectKey = newJiraIssueTargetProject?.key
+  const projectSiteId = newJiraIssueTargetProject?.siteId
+  const searchAssignableUsers = useCallback(
+    (query: string) =>
+      projectKey
+        ? jiraListAssignableUsersForProject(providerSettings, projectKey, query, projectSiteId)
+        : Promise.resolve([]),
+    [projectKey, projectSiteId, providerSettings]
+  )
+  if (!hasJiraAssigneeCreateField(jiraCreateFields)) {
+    return null
+  }
+  const selfUser = model.jiraStatusCurrent
+    ? getJiraSelfUser(jiraStatus, projectSiteId ?? null)
+    : null
+  const assigneeLabel = translate('components.jiraIssueAssigneeField.label', 'Assignee')
+  const automaticLabel = translate('components.jiraIssueAssigneeField.automatic', 'Automatic')
+  const fixedOptions: JiraUserPickerFixedOption[] = [
+    {
+      key: 'automatic',
+      label: automaticLabel,
+      onSelect: () => setNewJiraIssueAssignee(null)
+    },
+    ...(selfUser
+      ? [
+          {
+            key: 'self',
+            label: translate(
+              'components.jiraIssueAssigneeField.assignToMe',
+              'Assign to me ({{name}})',
+              { name: selfUser.displayName }
+            ),
+            onSelect: () => setNewJiraIssueAssignee(selfUser)
+          }
+        ]
+      : [])
+  ]
+  return (
+    <div className="grid gap-3 sm:grid-cols-2">
+      <div className="flex min-w-0 flex-col gap-1">
+        <label className="text-[11px] font-medium text-muted-foreground">{assigneeLabel}</label>
+        <JiraUserPicker
+          // Cached candidates belong to one provider, project, and site.
+          key={JSON.stringify([
+            model.providerRuntimeContextKey,
+            newJiraIssueTargetProject
+              ? getJiraProjectSelectionKey(newJiraIssueTargetProject)
+              : 'no-project'
+          ])}
+          providerSettings={providerSettings}
+          siteId={projectSiteId ?? undefined}
+          value={newJiraIssueAssignee ? newJiraIssueAssignee.accountId : automaticLabel}
+          selectedUser={newJiraIssueAssignee}
+          onSelect={(user) => setNewJiraIssueAssignee(user)}
+          disabled={newJiraIssueSubmitting}
+          label={assigneeLabel}
+          fixedOptions={fixedOptions}
+          searchUsers={searchAssignableUsers}
+        />
+      </div>
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/task-page/jira/IssueDialog.tsx b/src/renderer/src/components/task-page/jira/IssueDialog.tsx
index b58f806d572..f39beb86078 100644
--- a/src/renderer/src/components/task-page/jira/IssueDialog.tsx
+++ b/src/renderer/src/components/task-page/jira/IssueDialog.tsx
@@ -31,6 +31,7 @@ import {
 } from '@/components/ui/select'
 import { Input } from '@/components/ui/input'
 import { getJiraCreateAllowedValueLabel } from '@/components/task-page-jira-create-fields'
+import { TaskPageJiraIssueAssigneeField } from './IssueAssigneeField'
 export function TaskPageJiraIssueDialog({
   model
 }: {
@@ -260,6 +261,7 @@ export function TaskPageJiraIssueDialog({
               className="w-full min-w-0 rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-xs transition-[color,box-shadow] outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 resize-none max-h-60 overflow-y-auto scrollbar-sleek"
             />
           </div>
+          <TaskPageJiraIssueAssigneeField model={model} />
           {jiraCreateFieldsLoading ? (
             <div className="flex items-center gap-2 rounded-md border border-border/50 bg-muted/30 px-3 py-2 text-xs text-muted-foreground">
               <LoaderCircle className="size-3.5 animate-spin" />
diff --git a/src/renderer/src/components/task-page/linear/IssueDialog.tsx b/src/renderer/src/components/task-page/linear/IssueDialog.tsx
index 92ea19fd536..b6da48daaaf 100644
--- a/src/renderer/src/components/task-page/linear/IssueDialog.tsx
+++ b/src/renderer/src/components/task-page/linear/IssueDialog.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import type { TaskPageComposerActionsModel } from '../../use-task-page-composer-actions'
 import { Dialog, DialogContent } from '@/components/ui/dialog'
 import { isScreenSubmitShortcut } from '@/lib/screen-submit-shortcut'
@@ -105,7 +106,7 @@ export function TaskPageLinearIssueDialog({
         {/* Form Content */}
         <div className="flex flex-col px-6 py-4 gap-3">
           {/* Title */}
-          <input
+          <ImeInput
             autoFocus
             value={newLinearIssueTitle}
             onChange={(e) => setNewLinearIssueTitle(e.target.value)}
diff --git a/src/renderer/src/components/task-page/linear/ProjectFields.tsx b/src/renderer/src/components/task-page/linear/ProjectFields.tsx
index fcf7fb44708..20683773123 100644
--- a/src/renderer/src/components/task-page/linear/ProjectFields.tsx
+++ b/src/renderer/src/components/task-page/linear/ProjectFields.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import type { TaskPageComposerActionsModel } from '../../use-task-page-composer-actions'
 import { translate } from '@/i18n/i18n'
 import { Popover, PopoverTrigger, PopoverContent } from '@/components/ui/popover'
@@ -37,7 +38,7 @@ export function TaskPageLinearProjectFields({
   } = model
   return (
     <div className="flex min-h-0 flex-1 flex-col gap-4 overflow-y-auto px-6 py-5 scrollbar-sleek">
-      <input
+      <ImeInput
         autoFocus
         value={newLinearProjectName}
         onChange={(event) => setNewLinearProjectName(event.target.value)}
diff --git a/src/renderer/src/components/terminal-pane/MobileDriverOverlay.test.tsx b/src/renderer/src/components/terminal-pane/MobileDriverOverlay.test.tsx
index 99a11a48351..dea8f870679 100644
--- a/src/renderer/src/components/terminal-pane/MobileDriverOverlay.test.tsx
+++ b/src/renderer/src/components/terminal-pane/MobileDriverOverlay.test.tsx
@@ -113,8 +113,8 @@ describe('MobileDriverOverlay', () => {
       onAllAction: vi.fn()
     }) as OverlayElement
 
-    expect(overlay.props.actionLabel).toBe('Restore this terminal')
-    expect(overlay.props.allActionLabel).toBe('Restore all terminals')
+    expect(overlay.props.actionLabel).toBe('Restore')
+    expect(overlay.props.allActionLabel).toBe('Restore all')
   })
 
   it('exposes an all-terminals restore action when provided', async () => {
@@ -123,8 +123,8 @@ describe('MobileDriverOverlay', () => {
 
     const overlay = renderOverlay(onAction, onAllAction)
 
-    expect(overlay.props.actionLabel).toBe('Take back this terminal')
-    expect(overlay.props.allActionLabel).toBe('Take back all terminals')
+    expect(overlay.props.actionLabel).toBe('Take back')
+    expect(overlay.props.allActionLabel).toBe('Take back all')
     expect(overlay.props.allActionPending).toBe(false)
     await overlay.props.onAllAction?.()
 
diff --git a/src/renderer/src/components/terminal-pane/MobileDriverOverlay.tsx b/src/renderer/src/components/terminal-pane/MobileDriverOverlay.tsx
index e9d55155227..bd51f067bac 100644
--- a/src/renderer/src/components/terminal-pane/MobileDriverOverlay.tsx
+++ b/src/renderer/src/components/terminal-pane/MobileDriverOverlay.tsx
@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useId, useRef, useState, type ReactElement } from 'react'
-import { Smartphone } from 'lucide-react'
+import { Minimize2, Smartphone } from 'lucide-react'
 import { Button } from '@/components/ui/button'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
 import { cn } from '@/lib/utils'
 import type { DriverState } from '@/lib/pane-manager/mobile-driver-state'
 import { shouldFocusMobileDriverAction } from './mobile-driver-overlay-focus'
@@ -92,26 +93,22 @@ export function MobileDriverOverlay({
   if (isHeldAtPhoneFit) {
     return (
       <LoudOverlay
-        eyebrow={translate(
-          'auto.components.terminal.pane.MobileDriverOverlay.f2a8b9c1d3',
-          'From your phone'
-        )}
         title={translate(
-          'auto.components.terminal.pane.MobileDriverOverlay.faa367dc74',
-          'Your phone left this at phone size'
+          'auto.components.terminal.pane.MobileDriverOverlay.4b7e1c9a20',
+          'Still sized for your phone'
         )}
         body={translate(
-          'auto.components.terminal.pane.MobileDriverOverlay.a6b1d8f3e2',
-          'Your phone session ended. Restore to desktop size for this terminal, or for all terminals your phone left at phone size.'
+          'auto.components.terminal.pane.MobileDriverOverlay.9d2f6a3e58',
+          'Your phone session ended. Restore to fit this window.'
         )}
         actionLabel={translate(
-          'auto.components.terminal.pane.MobileDriverOverlay.b3d8e1f42a',
-          'Restore this terminal'
+          'auto.components.terminal.pane.MobileDriverOverlay.1e5c8b7d43',
+          'Restore'
         )}
         actionPending={actionPending}
         allActionLabel={translate(
-          'auto.components.terminal.pane.MobileDriverOverlay.e8c4f2a91b',
-          'Restore all terminals'
+          'auto.components.terminal.pane.MobileDriverOverlay.6a3d9f2c71',
+          'Restore all'
         )}
         allActionPending={allActionPending}
         onAction={handleAction}
@@ -137,26 +134,22 @@ export function MobileDriverOverlay({
 
   return (
     <LoudOverlay
-      eyebrow={translate(
-        'auto.components.terminal.pane.MobileDriverOverlay.f2a8b9c1d3',
-        'From your phone'
-      )}
       title={translate(
         'auto.components.terminal.pane.MobileDriverOverlay.c7e4a2b8f1',
         'Your phone is in control'
       )}
       body={translate(
-        'auto.components.terminal.pane.MobileDriverOverlay.d9f3c6e2a4',
-        'Desktop keyboard is paused. Take back this terminal to type here, take back all terminals your phone controls, or collapse to keep watching.'
+        'auto.components.terminal.pane.MobileDriverOverlay.8c1a5e9f36',
+        'Desktop typing is paused. Output keeps streaming.'
       )}
       actionLabel={translate(
-        'auto.components.terminal.pane.MobileDriverOverlay.c8f2e1a4b9',
-        'Take back this terminal'
+        'auto.components.terminal.pane.MobileDriverOverlay.c6460cf584',
+        'Take back'
       )}
       actionPending={actionPending}
       allActionLabel={translate(
-        'auto.components.terminal.pane.MobileDriverOverlay.54f7d6f69d',
-        'Take back all terminals'
+        'auto.components.terminal.pane.MobileDriverOverlay.2f7b4d1e95',
+        'Take back all'
       )}
       allActionPending={allActionPending}
       onAction={handleAction}
@@ -170,7 +163,6 @@ export function MobileDriverOverlay({
 }
 
 type LoudOverlayProps = {
-  eyebrow: string
   title: string
   body: string
   actionLabel: string
@@ -186,7 +178,6 @@ type LoudOverlayProps = {
 }
 
 function LoudOverlay({
-  eyebrow,
   title,
   body,
   actionLabel,
@@ -201,6 +192,10 @@ function LoudOverlay({
   rootClassName
 }: LoudOverlayProps): ReactElement {
   const titleId = useId()
+  const collapseLabel = translate(
+    'auto.components.terminal.pane.MobileDriverOverlay.3a9c5f7e12',
+    'Minimize'
+  )
   const bodyId = useId()
   const rootRef = useRef<HTMLDivElement>(null)
   const actionRef = useRef<HTMLButtonElement>(null)
@@ -236,68 +231,67 @@ function LoudOverlay({
         rootClassName
       )}
     >
-      <div className="pointer-events-auto flex w-full max-w-[30rem] flex-col gap-3 rounded-lg border border-border bg-card p-6 pb-5 text-card-foreground shadow-xs">
-        <div className="flex items-start gap-3">
-          <div
-            className={cn(
-              'flex size-10 shrink-0 items-center justify-center rounded-full border border-border',
-              tone === 'driving' ? 'bg-muted' : 'bg-muted/60'
-            )}
-          >
-            <Smartphone className="size-5 text-foreground" aria-hidden="true" />
-          </div>
-          <div className="flex min-w-0 flex-1 flex-col gap-1">
-            <div
-              className={cn(
-                'flex items-center gap-1.5 text-xs font-medium uppercase tracking-wide',
-                tone === 'driving' ? 'text-foreground' : 'text-muted-foreground'
-              )}
-            >
-              {tone === 'driving' ? (
-                <span aria-hidden="true" className="size-1.5 rounded-full bg-foreground" />
-              ) : null}
-              <span>{eyebrow}</span>
-            </div>
-            <div id={titleId} className="text-base font-semibold leading-tight">
-              {title}
-            </div>
-          </div>
+      <div className="pointer-events-auto relative flex w-full max-w-sm gap-3 rounded-lg border border-border bg-card p-4 text-card-foreground shadow-floating">
+        <div className="relative mt-0.5 shrink-0">
+          <Smartphone className="size-4 text-muted-foreground" aria-hidden="true" />
+          {tone === 'driving' ? (
+            <span
+              aria-hidden="true"
+              className="absolute -right-0.5 -top-0.5 size-1.5 animate-pulse rounded-full bg-foreground ring-2 ring-card"
+            />
+          ) : null}
         </div>
-        <div id={bodyId} className="text-sm leading-relaxed text-muted-foreground">
-          {body}
-        </div>
-        <div className="mt-1 flex flex-wrap justify-end gap-2">
-          {onCollapse && (
-            <Button type="button" variant="outline" size="sm" onClick={onCollapse}>
-              {translate(
-                'auto.components.terminal.pane.MobileDriverOverlay.7cffad954c',
-                'Collapse'
-              )}
-            </Button>
-          )}
-          {onAllAction && allActionLabel ? (
+        <div className="flex min-w-0 flex-1 flex-col">
+          <div id={titleId} className="pr-6 text-sm font-semibold leading-5">
+            {title}
+          </div>
+          <div id={bodyId} className="mt-0.5 text-sm text-muted-foreground">
+            {body}
+          </div>
+          <div className="mt-3 flex flex-wrap justify-end gap-1.5">
+            {onAllAction && allActionLabel ? (
+              <Button
+                type="button"
+                variant="ghost"
+                size="sm"
+                onClick={onAllAction}
+                disabled={actionPending || allActionPending}
+              >
+                {allActionLabel}
+              </Button>
+            ) : null}
+            {/* Focus is moved to this button only when no user input is active; see effect above. */}
             <Button
+              ref={actionRef}
               type="button"
-              variant="outline"
+              variant="default"
               size="sm"
-              onClick={onAllAction}
+              onClick={onAction}
               disabled={actionPending || allActionPending}
             >
-              {allActionLabel}
+              {actionLabel}
             </Button>
-          ) : null}
-          {/* Focus is moved to this button only when no user input is active; see effect above. */}
-          <Button
-            ref={actionRef}
-            type="button"
-            variant="default"
-            size="sm"
-            onClick={onAction}
-            disabled={actionPending || allActionPending}
-          >
-            {actionLabel}
-          </Button>
+          </div>
         </div>
+        {onCollapse && (
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <Button
+                type="button"
+                variant="ghost"
+                size="icon-xs"
+                className="absolute right-2 top-2"
+                aria-label={collapseLabel}
+                onClick={onCollapse}
+              >
+                <Minimize2 />
+              </Button>
+            </TooltipTrigger>
+            <TooltipContent side="top" sideOffset={4}>
+              {collapseLabel}
+            </TooltipContent>
+          </Tooltip>
+        )}
       </div>
     </div>
   )
diff --git a/src/renderer/src/components/terminal-pane/TerminalPaneHeaderOverlay.tsx b/src/renderer/src/components/terminal-pane/TerminalPaneHeaderOverlay.tsx
index cebeabd9bb7..0640f194627 100644
--- a/src/renderer/src/components/terminal-pane/TerminalPaneHeaderOverlay.tsx
+++ b/src/renderer/src/components/terminal-pane/TerminalPaneHeaderOverlay.tsx
@@ -1,3 +1,4 @@
+import { ImeInput } from '@/lib/ime-text-field'
 import type { CSSProperties, RefObject } from 'react'
 import {
   MessageSquare,
@@ -198,7 +199,7 @@ export default function TerminalPaneHeaderOverlay({
             }}
           >
             {isEditing ? (
-              <input
+              <ImeInput
                 ref={renameInputRef}
                 className="pane-title-input"
                 aria-label={translate(
diff --git a/src/renderer/src/components/terminal-pane/codex-detached-pane-restart.ts b/src/renderer/src/components/terminal-pane/codex-detached-pane-restart.ts
index 1578a09fc24..6c3228ae10b 100644
--- a/src/renderer/src/components/terminal-pane/codex-detached-pane-restart.ts
+++ b/src/renderer/src/components/terminal-pane/codex-detached-pane-restart.ts
@@ -16,6 +16,7 @@ import { useAppStore } from '@/store'
 import { getWorktreeMapFromState } from '@/store/selectors'
 import { singlePaneLayoutSnapshot } from '@/store/slices/terminal-helpers'
 import { hasRegisteredRuntimeTerminalTab } from '@/runtime/sync-runtime-graph'
+import { buildCodexAccountRestartStartup } from '@/lib/codex-account-restart-startup'
 import { CODEX_ACCOUNT_RESTART_STARTUP } from '@/lib/codex-session-restart'
 import { isForeignMachineCodexPtyId } from '@/lib/codex-pane-selection-lane'
 import { getLocalProjectExecutionRuntimeContext } from '@/lib/local-preflight-context'
@@ -127,13 +128,10 @@ function locateCodexPane(state: AppState, ptyId: string): LocatedCodexPane | nul
 
 function getWorkspacePath(state: AppState, worktreeId: string): string | null {
   const parsed = parseWorkspaceKey(worktreeId)
-  if (parsed?.type === 'folder') {
-    return (
-      (state.folderWorkspaces ?? []).find((workspace) => workspace.id === parsed.folderWorkspaceId)
-        ?.folderPath ?? null
-    )
-  }
-  return getWorktreeMapFromState(state).get(worktreeId)?.path ?? null
+  return parsed?.type === 'folder'
+    ? (state.folderWorkspaces.find((workspace) => workspace.id === parsed.folderWorkspaceId)
+        ?.folderPath ?? null)
+    : (getWorktreeMapFromState(state).get(worktreeId)?.path ?? null)
 }
 
 function buildPaneIdentityEnv(
@@ -183,6 +181,12 @@ async function executeDetachedCodexPaneRestart(
     return
   }
   const { worktreeId, tab, leafId } = located
+  const startup = buildCodexAccountRestartStartup({
+    worktreeId,
+    tabId: tab.id,
+    leafId,
+    shellOverride: tab.shellOverride
+  })
 
   const workspacePath = getWorkspacePath(state, worktreeId)
   const cwd = tab.startupCwd ?? workspacePath ?? undefined
@@ -214,10 +218,8 @@ async function executeDetachedCodexPaneRestart(
     rows: 24,
     ...(cwd ? { cwd } : {}),
     cwdFallback: 'worktree',
-    env: buildPaneIdentityEnv(state, worktreeId, tab.id, leafId),
-    command: CODEX_ACCOUNT_RESTART_STARTUP.command,
-    startupCommandDelivery: CODEX_ACCOUNT_RESTART_STARTUP.startupCommandDelivery,
-    launchAgent: CODEX_ACCOUNT_RESTART_STARTUP.launchAgent,
+    ...startup,
+    env: { ...startup.env, ...buildPaneIdentityEnv(state, worktreeId, tab.id, leafId) },
     worktreeId,
     tabId: tab.id,
     leafId,
diff --git a/src/renderer/src/components/terminal-pane/ipc-pty-opencode-model.test.ts b/src/renderer/src/components/terminal-pane/ipc-pty-opencode-model.test.ts
new file mode 100644
index 00000000000..631d965b91b
--- /dev/null
+++ b/src/renderer/src/components/terminal-pane/ipc-pty-opencode-model.test.ts
@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { z } from 'zod'
+import { callRuntimeRpc } from '../../runtime/runtime-rpc-client'
+import { spawnIpcPty } from './ipc-pty-spawn-request'
+import type { IpcPtyTransportOptions } from './pty-transport-types'
+
+vi.mock('../../runtime/runtime-rpc-client', async () => ({
+  callRuntimeRpc: vi.fn(),
+  RuntimeRpcCallError: (await import('../../runtime/runtime-rpc-result')).RuntimeRpcCallError
+}))
+const spawn = vi.fn(async () => ({ id: 'pty_host', isReattach: true }))
+const options = (): IpcPtyTransportOptions => ({
+  worktreeId: 'folder:private',
+  tabId: 'tab_private',
+  leafId: 'leaf_private',
+  launchAgent: 'opencode',
+  command: 'opencode --model private-proof/model-b',
+  agentPrompt: 'Read only',
+  agentPromptDelivery: 'auto-submit',
+  agentLaunchPreferences: { model: 'private-proof/model-b' }
+})
+const connect = { url: 'ipc://private', callbacks: {}, cols: 80, rows: 24 }
+
+describe('local OpenCode model launch authority', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.stubGlobal('window', { api: { pty: { spawn } } })
+    spawn.mockResolvedValue({ id: 'pty_host', isReattach: true })
+    vi.mocked(callRuntimeRpc).mockResolvedValue({
+      terminal: { ptyId: 'pty_host' },
+      disposition: 'created'
+    })
+  })
+  afterEach(() => vi.unstubAllGlobals())
+
+  it('sends preferences to the execution host and attaches only to its returned PTY', async () => {
+    const claimReplacedPtyId = vi.fn(() => 'pty_previous')
+    expect(await spawnIpcPty(options(), { ...connect, claimReplacedPtyId })).toMatchObject({
+      id: 'pty_host'
+    })
+    expect(callRuntimeRpc).toHaveBeenCalledWith(
+      { kind: 'local' },
+      'terminal.createAgentSession',
+      expect.objectContaining({
+        agent: 'opencode',
+        launchPreferences: { model: 'private-proof/model-b' },
+        prompt: 'Read only',
+        promptDelivery: 'auto-submit',
+        placement: { tabId: 'tab_private', leafId: 'leaf_private' }
+      })
+    )
+    expect(spawn).toHaveBeenCalledWith(
+      expect.objectContaining({ sessionId: 'pty_host', command: undefined })
+    )
+    expect(claimReplacedPtyId).not.toHaveBeenCalled()
+  })
+
+  it('preserves one operation ID across a lost reply and reconnect', async () => {
+    const transport = options()
+    vi.mocked(callRuntimeRpc).mockRejectedValueOnce(new Error('reply lost'))
+    await spawnIpcPty(transport, connect)
+    await spawnIpcPty(transport, connect)
+    const operationRequest = z.object({ clientOperationId: z.string() })
+    const ids = vi
+      .mocked(callRuntimeRpc)
+      .mock.calls.map((call) => operationRequest.parse(call[2]).clientOperationId)
+    expect(ids).toHaveLength(3)
+    expect(new Set(ids).size).toBe(1)
+    expect(ids[0]).toMatch(/^\d{13}-[0-9a-f]{32}$/)
+  })
+
+  it('does not issue raw spawn or replacement effects after the host refuses', async () => {
+    vi.mocked(callRuntimeRpc).mockRejectedValue(new Error('capability_unsupported'))
+    const claimReplacedPtyId = vi.fn(() => 'pty_previous')
+    await expect(spawnIpcPty(options(), { ...connect, claimReplacedPtyId })).rejects.toThrow(
+      'capability_unsupported'
+    )
+    expect(spawn).not.toHaveBeenCalled()
+    expect(claimReplacedPtyId).not.toHaveBeenCalled()
+  })
+
+  it.each([
+    { connectionId: 'ssh_private' },
+    { resumeProviderSession: { key: 'session_id' as const, id: 'old' } }
+  ])('refuses unsupported placement before host or raw spawn', async (extra) => {
+    await expect(spawnIpcPty({ ...options(), ...extra }, connect)).rejects.toThrow(
+      'capability_unsupported'
+    )
+    expect(callRuntimeRpc).not.toHaveBeenCalled()
+    expect(spawn).not.toHaveBeenCalled()
+  })
+
+  it('preserves ordinary raw startup and captured-session attachment', async () => {
+    const ordinary = { ...options(), agentLaunchPreferences: undefined }
+    await spawnIpcPty(ordinary, connect)
+    expect(spawn).toHaveBeenCalledWith(expect.objectContaining({ command: ordinary.command }))
+    await spawnIpcPty(options(), connect, 'pty_existing')
+    expect(callRuntimeRpc).not.toHaveBeenCalled()
+    expect(spawn).toHaveBeenLastCalledWith(expect.objectContaining({ sessionId: 'pty_existing' }))
+  })
+})
diff --git a/src/renderer/src/components/terminal-pane/ipc-pty-spawn-request.ts b/src/renderer/src/components/terminal-pane/ipc-pty-spawn-request.ts
index ff69ba35a86..667865deb7e 100644
--- a/src/renderer/src/components/terminal-pane/ipc-pty-spawn-request.ts
+++ b/src/renderer/src/components/terminal-pane/ipc-pty-spawn-request.ts
@@ -1,6 +1,14 @@
 import type { IpcPtyTransportOptions, PtyConnectResult, PtyTransport } from './pty-transport-types'
+import type { RuntimeCreateAgentSessionResult } from '../../../../shared/agent-session-host-authority'
+import {
+  createAgentSessionCreateOperation,
+  type AgentSessionCreateOperation
+} from '../../runtime/agent-session-create-operation'
+import { callRuntimeRpc } from '../../runtime/runtime-rpc-client'
+import { toRuntimeTerminalWorktreeSelector } from '../../runtime/runtime-worktree-selector'
 
 type PtyConnectOptions = Parameters<PtyTransport['connect']>[0]
+const modelLaunchOperations = new WeakMap<IpcPtyTransportOptions, AgentSessionCreateOperation>()
 
 /** `incarnationId` names which lifetime of the returned id this spawn owns; absent when the
  *  execution host predates the field. It is deliberately NOT on `PtyConnectResult` — only the
@@ -15,6 +23,52 @@ export async function spawnIpcPty(
   connectOptions: PtyConnectOptions,
   admittedSessionId?: string
 ): Promise<IpcPtySpawnResponse> {
+  if (
+    !admittedSessionId &&
+    transportOptions.launchAgent === 'opencode' &&
+    Object.values(transportOptions.agentLaunchPreferences ?? {}).some(
+      (value) => value !== undefined
+    )
+  ) {
+    const { worktreeId, tabId, leafId, connectionId, resumeProviderSession } = transportOptions
+    if (!worktreeId || !tabId || !leafId || connectionId || resumeProviderSession) {
+      throw new Error('capability_unsupported')
+    }
+    let operation = modelLaunchOperations.get(transportOptions)
+    if (!operation) {
+      operation = createAgentSessionCreateOperation()
+      modelLaunchOperations.set(transportOptions, operation)
+    }
+    const created = await operation.run((clientOperationId) =>
+      callRuntimeRpc<RuntimeCreateAgentSessionResult>(
+        { kind: 'local' },
+        'terminal.createAgentSession',
+        {
+          clientOperationId,
+          worktree: toRuntimeTerminalWorktreeSelector(worktreeId),
+          agent: 'opencode',
+          prompt: transportOptions.agentPrompt,
+          promptDelivery: transportOptions.agentPromptDelivery,
+          agentArgs: transportOptions.agentArgsOverride,
+          launchPreferences: transportOptions.agentLaunchPreferences,
+          startupCwd: transportOptions.cwd,
+          placement: { tabId, leafId },
+          presentation: 'background',
+          ...(transportOptions.terminalKittyKeyboardProtocol === true
+            ? { terminalKittyKeyboardProtocol: true }
+            : {})
+        }
+      )
+    )
+    if (!created.terminal.ptyId) {
+      throw new Error('agent_session_operation_unknown')
+    }
+    return spawnIpcPty(
+      { ...transportOptions, command: undefined, launchConfig: undefined },
+      { ...connectOptions, command: undefined, launchConfig: undefined },
+      created.terminal.ptyId
+    )
+  }
   const {
     cwd,
     cwdFallback,
diff --git a/src/renderer/src/components/terminal-pane/pty-connection-reattach-mode-reset.test.ts b/src/renderer/src/components/terminal-pane/pty-connection-reattach-mode-reset.test.ts
index d5722b214a5..c57c1bd9e9d 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection-reattach-mode-reset.test.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection-reattach-mode-reset.test.ts
@@ -254,6 +254,30 @@ describe('connectPanePty', () => {
     expect(resetWriteCall as number).toBeLessThan(tailWriteCall as number)
   })
 
+  it('answers cursor queries while an account notice blocks user input', async () => {
+    const { connectPanePty } = await import('./pty-connection')
+    const transport = createMockTransport('pty-live')
+    transportFactoryQueue.push(transport)
+    mockStoreState.codexRestartNoticeByPtyId = {
+      'pty-live': { previousAccountLabel: 'A', nextAccountLabel: 'B' }
+    }
+    const pane = createPane(1)
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: fixtures implement the connection's pane, manager and dependency contract.
+    const args = [pane, createManager(1), createDeps()] as unknown as Parameters<
+      typeof connectPanePty
+    >
+    const binding = connectPanePty(...args)
+    transport.getPtyId.mockReturnValue('pty-live')
+    mockStoreState.codexRestartNoticeByPtyId = {
+      'pty-live': { previousAccountLabel: 'A', nextAccountLabel: 'B' }
+    }
+    sendTerminalInputThroughPane(pane, '\x1b[1;1R')
+    sendTerminalInputThroughPane(pane, 'do work\r')
+    expect(transport.sendInputImmediate).toHaveBeenCalledWith('\x1b[1;1R')
+    expect(transport.sendInput).not.toHaveBeenCalledWith('do work\r', expect.anything())
+    binding.dispose()
+  })
+
   it('routes native onData query replies through sendInputImmediate, typed input through sendInput (#7329)', async () => {
     // Why this test: the mock aliases sendInputImmediate to sendInput, so other tests can't tell them apart; this pins the routing decision.
     const { connectPanePty } = await import('./pty-connection')
diff --git a/src/renderer/src/components/terminal-pane/pty-connection-test-pane-fixtures.ts b/src/renderer/src/components/terminal-pane/pty-connection-test-pane-fixtures.ts
index 302efe743bb..0959c996bfd 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection-test-pane-fixtures.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection-test-pane-fixtures.ts
@@ -1,5 +1,6 @@
 import { vi } from 'vitest'
 import type { Mock } from 'vitest'
+import type { PtyReplayDataMeta } from './pty-transport-types'
 
 export const LEAF_1 = '11111111-1111-4111-8111-111111111111' as const
 export const LEAF_2 = '22222222-2222-4222-8222-222222222222' as const
@@ -16,7 +17,7 @@ export type ConnectCallbacks = {
     data: string,
     meta?: { seq?: number; rawLength?: number; background?: boolean; droppedOutput?: boolean }
   ) => void
-  onReplayData?: (data: string, meta?: { clearBeforeReplay?: boolean }) => void
+  onReplayData?: (data: string, meta?: PtyReplayDataMeta) => void
   onError?: (msg: string) => void
   onErrorCleared?: (msg: string) => void
   onWriteUnavailable?: () => void
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/deferred-cold-restore-and-snapshot.ts b/src/renderer/src/components/terminal-pane/pty-connection/deferred-cold-restore-and-snapshot.ts
index f2a91feb98c..24c89af5181 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/deferred-cold-restore-and-snapshot.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/deferred-cold-restore-and-snapshot.ts
@@ -159,7 +159,8 @@ export function bindDeferredColdRestoreAndSnapshot(session: ConnectPanePtySessio
       ...(meta.alternateScreen !== undefined ? { alternateScreen: meta.alternateScreen } : {}),
       ...(meta.snapshotCols !== undefined && meta.snapshotRows !== undefined
         ? { snapshotCols: meta.snapshotCols, snapshotRows: meta.snapshotRows }
-        : {})
+        : {}),
+      ...(meta.carriesNormalBuffer ? { carriesNormalBuffer: true } : {})
     }
     session.scheduleReplayDataDrain()
   }
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/deferred-session-reattach-choice.ts b/src/renderer/src/components/terminal-pane/pty-connection/deferred-session-reattach-choice.ts
index 6d045232a36..7ee801dddfb 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/deferred-session-reattach-choice.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/deferred-session-reattach-choice.ts
@@ -18,6 +18,11 @@ import { startDeferredSessionReattach } from './deferred-session-reattach-connec
 import type { ConnectPanePtySession } from './connect-pane-pty-session'
 
 export function runDeferredSessionReattachChoice(session: ConnectPanePtySession): void {
+  // An explicit replacement owns its startup; saved recovery state must not substitute another agent.
+  if (session.pendingReplacedPtyId) {
+    session.startFreshSpawn()
+    return
+  }
   // Why: re-read session IDs here rather than at connect scheduling — cleanup during the caller's one-frame gap could otherwise reattach a dead session.
   const restoredPtyId =
     session.deps.restoredLeafId && session.deps.restoredPtyIdByLeafId
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/hidden-output-restore-snapshot.ts b/src/renderer/src/components/terminal-pane/pty-connection/hidden-output-restore-snapshot.ts
index e895128b280..a64209a71cd 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/hidden-output-restore-snapshot.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/hidden-output-restore-snapshot.ts
@@ -61,6 +61,7 @@ export function bindHiddenOutputRestoreSnapshot(session: ConnectPanePtySession):
     pendingDeliveryStartSeq?: number
     alternateScreen?: boolean
     scrollbackAnsi?: string
+    carriesNormalBuffer?: boolean
     pendingEscapeTailAnsi?: string
     kittyKeyboardFlags?: number
     terminalOwner?: 'shell'
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/pty-input-forward.ts b/src/renderer/src/components/terminal-pane/pty-connection/pty-input-forward.ts
index aad2384bb27..cbaf010940c 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/pty-input-forward.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/pty-input-forward.ts
@@ -46,6 +46,11 @@ export function installPtyInputForward(session: ConnectPanePtySession): void {
       return
     }
     const currentPtyId = session.transport.getPtyId()
+    // Protocol replies keep the TUI responsive while an account notice blocks typing.
+    if (isTerminalQueryReply(data)) {
+      session.sendDesktopQueryReplyImmediate(data)
+      return
+    }
     // Why: after a Codex account switch, the runtime auth has already moved to
     // the newly selected account. Stale panes must not keep sending input until
     // they restart, or work can execute under the wrong account while the UI
@@ -78,19 +83,6 @@ export function installPtyInputForward(session: ConnectPanePtySession): void {
       // disabling the mode would permanently silence focus events on resume.
       return
     }
-    // Why: xterm answers CPR/DSR/DA queries natively through this same onData
-    // stream (mixed with keystrokes). Those replies are latency-critical — a
-    // querying program reads them in raw mode with a short timeout — so send
-    // them immediately, skipping the remote input debounce that would corrupt
-    // them (#7329). They are not user input, so they bypass intent inference and
-    // activity recording below. No pending-intent guard: the only intents are
-    // plain-escape (`\x1b`) and ctrl-c (`\x03`), neither of which can satisfy
-    // isTerminalQueryReply (it requires length >= 3 and a full reply grammar),
-    // so a real keystroke never reaches this branch.
-    if (isTerminalQueryReply(data)) {
-      session.sendDesktopQueryReplyImmediate(data)
-      return
-    }
     // Why after the query-reply branch: device replies are not user input and
     // must always reach the shell, or a program querying during reattach hangs.
     // Why at all: a replaced endpoint reattaches to a fresh shell, so the tail
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/replay-data-drain.ts b/src/renderer/src/components/terminal-pane/pty-connection/replay-data-drain.ts
index 693ee4be67a..f748de0ea73 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/replay-data-drain.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/replay-data-drain.ts
@@ -3,7 +3,10 @@ import { waitForTerminalOutputParsed } from '@/lib/pane-manager/pane-terminal-ou
 import { safeFit, safeFitAndThen } from '@/lib/pane-manager/pane-tree-ops'
 import { getFitOverrideForPty } from '@/lib/pane-manager/mobile-fit-overrides'
 
-import { resolvePositiveTerminalDimensions } from '../terminal-snapshot-replay-paint'
+import {
+  buildFoldedImageReplayWrites,
+  resolvePositiveTerminalDimensions
+} from '../terminal-snapshot-replay-paint'
 
 import {
   CURSOR_SHOW_SEQUENCE,
@@ -101,7 +104,8 @@ export function bindReplayDataDrain(session: ConnectPanePtySession): void {
         alternateScreen,
         terminalOwner,
         snapshotCols,
-        snapshotRows
+        snapshotRows,
+        carriesNormalBuffer
       } = payload
       session.pendingReplayData = null
       const isCurrentPayload = (): boolean =>
@@ -115,15 +119,28 @@ export function bindReplayDataDrain(session: ConnectPanePtySession): void {
       // Relay replay buffers may overlap with content already rendered in
       // xterm. Local eager replay decides this earlier so metadata-only frames
       // can keep restored scrollback while still using the replay guard.
-      // Why ahead of the source-grid resize: the clear is grid-independent, so
-      // dropping the scrollback first spares a reflow of history the very next
+      // Why ahead of the source-grid resize: the clear is grid-independent, so a
+      // clear that drops the scrollback spares a reflow of history the very next
       // sequence discards (see use-terminal-container-fit-sync.ts on its cost).
+      let replayPayload = data
       if (clearBeforeReplay) {
-        // RELEASE_SYNCHRONIZED_OUTPUT: a reconnect is exactly the event that severs a
-        // frame mid-flight, so this xterm may hold an open 2026 latch — and \x1b[2J does
-        // not clear it, so the pane would stay frozen on its last painted frame and the
-        // whole replay would go unseen until xterm's 1s timeout.
-        await session.writeReplayDataAsync(`${RELEASE_SYNCHRONIZED_OUTPUT}\x1b[2J\x1b[3J\x1b[H`)
+        if (carriesNormalBuffer) {
+          // Why after queued output parses: a TUI's own ?1049h may still be
+          // queued, and a stale read would paint the image into the wrong buffer.
+          await waitForTerminalOutputParsed(session.pane.terminal)
+          if (!isCurrentPayload()) {
+            continue
+          }
+          const image = buildFoldedImageReplayWrites(data, session.isPaneOnAlternateScreen())
+          replayPayload = image.payload
+          await session.writeReplayDataAsync(image.preamble)
+        } else {
+          // RELEASE_SYNCHRONIZED_OUTPUT: a reconnect is exactly the event that severs a
+          // frame mid-flight, so this xterm may hold an open 2026 latch — and \x1b[2J does
+          // not clear it, so the pane would stay frozen on its last painted frame and the
+          // whole replay would go unseen until xterm's 1s timeout.
+          await session.writeReplayDataAsync(`${RELEASE_SYNCHRONIZED_OUTPUT}\x1b[2J\x1b[3J\x1b[H`)
+        }
         if (!isCurrentPayload()) {
           continue
         }
@@ -158,7 +175,7 @@ export function bindReplayDataDrain(session: ConnectPanePtySession): void {
       // semantics: relay reconnects redeliver the same window, so pushes
       // apply as sets to keep the mirrored stack from accumulating frames.
       session.applySnapshotKittyKeyboardModes(data, payload)
-      await session.writeReplayDataAsync(data)
+      await session.writeReplayDataAsync(replayPayload)
       if (!isCurrentPayload()) {
         continue
       }
diff --git a/src/renderer/src/components/terminal-pane/pty-output-processor.ts b/src/renderer/src/components/terminal-pane/pty-output-processor.ts
index d80f8e1cb7f..8903348ee16 100644
--- a/src/renderer/src/components/terminal-pane/pty-output-processor.ts
+++ b/src/renderer/src/components/terminal-pane/pty-output-processor.ts
@@ -40,6 +40,7 @@ export type ProcessPtyOutputOptions = {
   terminalOwner?: 'shell'
   snapshotCols?: number
   snapshotRows?: number
+  carriesNormalBuffer?: boolean
 }
 
 function removeSuppressedCursorNativeTitles(
@@ -228,7 +229,8 @@ export function createPtyOutputProcessor({
         ...(options.terminalOwner ? { terminalOwner: options.terminalOwner } : {}),
         ...(options.snapshotCols !== undefined && options.snapshotRows !== undefined
           ? { snapshotCols: options.snapshotCols, snapshotRows: options.snapshotRows }
-          : {})
+          : {}),
+        ...(options.carriesNormalBuffer ? { carriesNormalBuffer: true } : {})
       }
       if (Object.keys(replayMeta).length > 0) {
         callbacks.onReplayData(data, replayMeta)
diff --git a/src/renderer/src/components/terminal-pane/pty-transport-types.ts b/src/renderer/src/components/terminal-pane/pty-transport-types.ts
index dce25fd547c..39f1c7962ef 100644
--- a/src/renderer/src/components/terminal-pane/pty-transport-types.ts
+++ b/src/renderer/src/components/terminal-pane/pty-transport-types.ts
@@ -38,6 +38,9 @@ export type PtyBufferSnapshot = {
   alternateScreen?: boolean
   /** Authoritative normal buffer paired with an alternate-screen frame. */
   scrollbackAnsi?: string
+  /** `data` starts on the normal buffer and enters alt itself (remote images fold
+   *  their normal buffer in rather than splitting it into `scrollbackAnsi`). */
+  carriesNormalBuffer?: boolean
   /** Trailing incomplete escape sequence main's emulator ingested (a PTY read
    *  ended mid-escape). Must be written LAST — after post-replay resets, right
    *  before post-snapshot live chunks — so the continuation completes it
@@ -65,6 +68,9 @@ export type PtyReplayDataMeta = {
    *  it; the drain replays there and fits back to the pane afterwards. */
   snapshotCols?: number
   snapshotRows?: number
+  /** An image that starts on the normal buffer and enters alt itself; absent for
+   *  raw byte replays such as an SSH relay's ring buffer. */
+  carriesNormalBuffer?: boolean
 }
 
 export type LocalPtySessionMetadata = {
diff --git a/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport-host-session-launch.test.ts b/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport-host-session-launch.test.ts
index f5861cbc810..4ad4e950c81 100644
--- a/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport-host-session-launch.test.ts
+++ b/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport-host-session-launch.test.ts
@@ -191,7 +191,7 @@ describe('createRemoteRuntimePtyTransport', () => {
       })
     )
 
-    expect(onReplayData).toHaveBeenCalledWith('hello')
+    expect(onReplayData).toHaveBeenCalledWith('hello', { carriesNormalBuffer: true })
     expect(onConnect).toHaveBeenCalled()
     expect(onData).toHaveBeenCalledWith(' world', expect.objectContaining({ seq: 4 }))
   })
diff --git a/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport-snapshot-replay.test.ts b/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport-snapshot-replay.test.ts
index b6fc15f6413..2ee83ace72b 100644
--- a/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport-snapshot-replay.test.ts
+++ b/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport-snapshot-replay.test.ts
@@ -59,7 +59,9 @@ describe('createRemoteRuntimePtyTransport', () => {
       'before\x1b]9999;{"state":"working","prompt":"old","agentType":"codex"}\x07after\x1b]0;Remote title\x07\x07'
     )
 
-    expect(onReplayData).toHaveBeenCalledWith('beforeafter\x1b]0;Remote title\x07\x07')
+    expect(onReplayData).toHaveBeenCalledWith('beforeafter\x1b]0;Remote title\x07\x07', {
+      carriesNormalBuffer: true
+    })
     await vi.waitFor(() =>
       expect(onTitleChange).toHaveBeenCalledWith('Remote title', 'Remote title')
     )
@@ -89,12 +91,36 @@ describe('createRemoteRuntimePtyTransport', () => {
       'before\x1b]9999;{"state":"working","prompt":"old","agentType":"codex"}\x07after'
     )
 
-    expect(onReplayData).toHaveBeenCalledWith('beforeafter')
+    expect(onReplayData).toHaveBeenCalledWith('beforeafter', { carriesNormalBuffer: true })
     expect(onAgentStatus).not.toHaveBeenCalled()
     expect(onBell).not.toHaveBeenCalled()
     expect(onConnect).toHaveBeenCalled()
   })
 
+  // Why: a push buffered during a cancelled shutdown is the same folded image and must
+  // keep its flag when the rollback replays it.
+  it('flags a pushed snapshot replayed after a cancelled shutdown', async () => {
+    const { createRemoteRuntimePtyTransport } = await import('./remote-runtime-pty-transport')
+    const { unregisterPtyDataHandlers, restorePtyDataHandlersAfterFailedShutdown } =
+      await import('./pty-shutdown-data-suspension')
+    const onReplayData = vi.fn()
+    const transport = createRemoteRuntimePtyTransport('env-1', { worktreeId: 'wt-1' })
+
+    await transport.connect({ url: '', callbacks: { onReplayData } })
+    await vi.waitFor(() => expect(subscriptionSendBinary).toHaveBeenCalled())
+    const { streamId } = latestSubscribePayload()
+    const ptyId = transport.getPtyId()
+    expect(ptyId).toBeTruthy()
+    const shutdown = unregisterPtyDataHandlers([ptyId ?? ''])
+    emitSnapshot(streamId, 'buffered image')
+    expect(onReplayData).not.toHaveBeenCalled()
+    restorePtyDataHandlersAfterFailedShutdown(shutdown)
+
+    await vi.waitFor(() =>
+      expect(onReplayData).toHaveBeenCalledWith('buffered image', { carriesNormalBuffer: true })
+    )
+  })
+
   it('paints a nonempty lossy initial snapshot once before resuming live output', async () => {
     const { createRemoteRuntimePtyTransport } = await import('./remote-runtime-pty-transport')
     const terminal = new Terminal({ cols: 80, rows: 24 })
@@ -157,7 +183,7 @@ describe('createRemoteRuntimePtyTransport', () => {
     await vi.waitFor(() => expect(subscriptionSendBinary).toHaveBeenCalled())
     const { streamId } = latestSubscribePayload()
     emitSnapshot(streamId, 'initial')
-    expect(onReplayData).toHaveBeenCalledWith('initial')
+    expect(onReplayData).toHaveBeenCalledWith('initial', { carriesNormalBuffer: true })
     expect(onConnect).toHaveBeenCalled()
 
     const snapshotPromise = transport.serializeBuffer?.({ scrollbackRows: 5000 })
@@ -197,7 +223,8 @@ describe('createRemoteRuntimePtyTransport', () => {
       cols: 132,
       rows: 43,
       seq: 17,
-      source: 'headless'
+      source: 'headless',
+      carriesNormalBuffer: true
     })
     expect(onReplayData).toHaveBeenCalledTimes(1)
     expect(onData).not.toHaveBeenCalledWith('requested snapshot', expect.anything())
@@ -254,7 +281,7 @@ describe('createRemoteRuntimePtyTransport', () => {
     expect(latestFrameForOpcode(TerminalStreamOpcode.SnapshotRequest)).toBeUndefined()
 
     emitSnapshot(streamId, 'initial replay')
-    expect(onReplayData).toHaveBeenCalledWith('initial replay')
+    expect(onReplayData).toHaveBeenCalledWith('initial replay', { carriesNormalBuffer: true })
     expect(onConnect).toHaveBeenCalled()
 
     await vi.waitFor(() =>
@@ -288,7 +315,8 @@ describe('createRemoteRuntimePtyTransport', () => {
       cols: 100,
       rows: 20,
       seq: undefined,
-      source: undefined
+      source: undefined,
+      carriesNormalBuffer: true
     })
     expect(onReplayData).toHaveBeenCalledTimes(1)
   })
diff --git a/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport.ts b/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport.ts
index cb78db75e9e..1b6cca61767 100644
--- a/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport.ts
+++ b/src/renderer/src/components/terminal-pane/remote-runtime-pty-transport.ts
@@ -423,10 +423,12 @@ export function createRemoteRuntimePtyTransport(
   ): void => {
     outputProcessor.processData(data, storedCallbacks, undefined, meta)
   }
+  // Why flagged: only pushed snapshots are buffered for this pty during a shutdown.
   const shutdownReplayHandler = (data: string): void => {
     outputProcessor.processData(data, storedCallbacks, {
       replayingBufferedData: true,
-      suppressAttentionEvents: true
+      suppressAttentionEvents: true,
+      carriesNormalBuffer: true
     })
   }
   const shutdownLifecycle = {
@@ -2019,7 +2021,8 @@ export function createRemoteRuntimePtyTransport(
               // host dimensions. Absent/zero degrades to the pane's own grid.
               ...(meta?.cols !== undefined && meta.rows !== undefined
                 ? { snapshotCols: meta.cols, snapshotRows: meta.rows }
-                : {})
+                : {}),
+              carriesNormalBuffer: true
             })
           }
         },
diff --git a/src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-host-chain.test.ts b/src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-host-chain.test.ts
new file mode 100644
index 00000000000..d5ed2ff5f49
--- /dev/null
+++ b/src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-host-chain.test.ts
@@ -0,0 +1,398 @@
+import type * as React from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { Terminal } from '@xterm/headless'
+import {
+  TerminalStreamOpcode,
+  decodeTerminalStreamFrame,
+  decodeTerminalStreamJson,
+  encodeTerminalStreamFrame
+} from '../../../../shared/terminal-stream-protocol'
+import { flushAsyncTicks, writeHeadlessTerminal } from './pty-connection-test-async'
+import { createMockTransport, createPane, createManager } from './pty-connection-test-pane-fixtures'
+import type { ConnectCallbacks, MockTransport } from './pty-connection-test-pane-fixtures'
+import type { PtyReplayDataMeta } from './pty-transport-types'
+import { buildPaneConnectionDeps } from './pty-connection-test-deps'
+import { createInitialStoreState } from './pty-connection-test-store-fixtures'
+import type { StoreState } from './pty-connection-test-store-state'
+import {
+  installTerminalTestGlobals,
+  restoreTerminalTestGlobals
+} from './pty-connection-test-environment'
+
+// Why this suite: remote-snapshot-alt-screen-replay.test.ts hand-writes the replay meta, and
+// once fed a shape the host never sends. Here every input is produced by the real code:
+// the host runtime's headless model and shell-ownership proof, its ack-recovery publisher,
+// the wire codec, the client multiplexer, and the remote transport. Only the hand-off from
+// the transport's onReplayData into the pane's callback is wired by the test.
+
+const { scheduleRuntimeGraphSync, shouldSeedCacheTimerOnInitialTitle, toastInfo } = vi.hoisted(
+  () => ({
+    scheduleRuntimeGraphSync: vi.fn(),
+    shouldSeedCacheTimerOnInitialTitle: vi.fn(() => false),
+    toastInfo: vi.fn()
+  })
+)
+
+let mockStoreState: StoreState
+let transportFactoryQueue: MockTransport[] = []
+let storeSubscribers: ((state: StoreState) => void)[] = []
+
+vi.mock('@/runtime/sync-runtime-graph', () => ({ scheduleRuntimeGraphSync }))
+
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => mockStoreState,
+    subscribe: (listener: (state: StoreState) => void) => {
+      storeSubscribers.push(listener)
+      return () => {
+        storeSubscribers = storeSubscribers.filter((candidate) => candidate !== listener)
+      }
+    }
+  }
+}))
+
+vi.mock('@/lib/agent-status', async (importOriginal) => {
+  const { buildAgentStatusModuleMock } = await import('./pty-connection-test-environment')
+  return buildAgentStatusModuleMock(await importOriginal<Record<string, unknown>>())
+})
+
+vi.mock('./cache-timer-seeding', () => ({ shouldSeedCacheTimerOnInitialTitle }))
+
+vi.mock('sonner', () => ({ toast: { info: toastInfo } }))
+
+vi.mock('react', async (importOriginal) => {
+  const actual = await importOriginal<typeof React>()
+  return {
+    ...actual,
+    useCallback: <T extends (...args: unknown[]) => unknown>(fn: T): T => fn
+  }
+})
+
+vi.mock('./pty-transport', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  createIpcPtyTransport: vi.fn(() => {
+    const nextTransport = transportFactoryQueue.shift()
+    if (!nextTransport) {
+      throw new Error('No mock transport queued')
+    }
+    return nextTransport
+  })
+}))
+
+// Host-only surfaces, typed here so the renderer typecheck never walks the main graph.
+type HostSnapshot = {
+  data: string
+  cols: number
+  rows: number
+  seq?: number
+  source?: string
+  alternateScreen?: boolean
+  terminalOwner?: 'shell'
+}
+type HostRuntime = {
+  setPtyController(controller: {
+    write: () => boolean
+    kill: () => boolean
+    getForegroundProcess: () => Promise<null>
+    getSize: () => { cols: number; rows: number }
+    confirmShellForeground: () => Promise<boolean>
+  }): void
+  registerPty(ptyId: string, worktreeId: string): void
+  onPtyData(ptyId: string, data: string, at: number): number
+}
+type HostSendFrame = (opcode: number, payload?: Uint8Array<ArrayBufferLike>) => boolean
+type HostStream = {
+  streamId: number
+  ptyId: string
+  outputPaused: boolean
+  ackRecoverySnapshotInFlight: boolean
+  ackOutputSourceRanges: boolean
+  ackPendingOutput: unknown[]
+  ackPendingOutputBytes: number
+  ackPendingOutputOverflowed: boolean
+}
+type HostConnection = {
+  runtime: HostRuntime
+  streams: Map<number, HostStream>
+  closed: boolean
+  sendFrame: (streamId: number, opcode: number, payload?: Uint8Array<ArrayBufferLike>) => boolean
+  sendStreamError: (streamId: number, message: string) => void
+  sendAckRecoverySnapshot?: (stream: HostStream) => Promise<void>
+}
+
+const COLS = 40
+const ROWS = 6
+const PTY_ID = 'host-pty'
+const COMMAND_START = '\x1b]133;C\x07'
+// A setup script's output, then an agent TUI entering the alt screen over it.
+const LIVE_PANE = `${Array.from({ length: 10 }, (_, i) => `SETUP-OUTPUT-${i}`).join('\r\n')}\r\n$ claude${COMMAND_START}\x1b[?1049h\x1b[2J\x1b[HOLD-AGENT-FRAME`
+// Output the client missed before the host's recovery push.
+const AGENT_FRAME = '\x1b[H\x1b[2;1HNo\x1b[1Cnotice\x1b[1Ctoday'
+const AGENT_EXIT = `${AGENT_FRAME}\x1b[?1049lResume with claude --resume\r\n\x1b]133;D;0\x07\x1b]133;A\x07$ `
+
+type PaneEvent = string | { cols: number; rows: number }
+
+function bufferLines(term: Terminal, which: 'normal' | 'alternate'): string[] {
+  const buffer = which === 'normal' ? term.buffer.normal : term.buffer.alternate
+  return Array.from(
+    { length: buffer.length },
+    (_, row) => buffer.getLine(row)?.translateToString(true) ?? ''
+  )
+}
+
+function viewport(term: Terminal, which: 'normal' | 'alternate'): string[] {
+  return bufferLines(term, which).slice(-term.rows)
+}
+
+async function render(events: PaneEvent[]): Promise<Terminal> {
+  const term = new Terminal({ cols: COLS, rows: ROWS, scrollback: 100, allowProposedApi: true })
+  for (const event of events) {
+    if (typeof event === 'string') {
+      await writeHeadlessTerminal(term, event)
+    } else {
+      term.resize(event.cols, event.rows)
+    }
+  }
+  return term
+}
+
+/** Real host + client chain: returns what the remote transport hands the pane for the push. */
+async function publishHostRecovery(
+  missed: string
+): Promise<{ data: string; meta: PtyReplayDataMeta; published: HostSnapshot }> {
+  const { OrcaRuntimeService } = await vi.importActual<{
+    OrcaRuntimeService: new (store: null) => HostRuntime
+  }>('../../../../main/runtime/orca-runtime')
+  const { sendSnapshotFrames, serializeBudgetedRequestedSnapshot } = await vi.importActual<{
+    sendSnapshotFrames: (send: HostSendFrame, options: Record<string, unknown>) => unknown
+    serializeBudgetedRequestedSnapshot: (
+      runtime: HostRuntime,
+      ptyId: string,
+      scrollbackRows: number
+    ) => Promise<HostSnapshot | null>
+  }>('../../../../main/runtime/rpc/methods/terminal/terminal-snapshot-publication')
+  const { installMultiplexFlowControl } = await vi.importActual<{
+    installMultiplexFlowControl: (build: HostConnection) => void
+  }>('../../../../main/runtime/rpc/methods/terminal/terminal-multiplex-flow-control')
+
+  const host = new OrcaRuntimeService(null)
+  host.setPtyController({
+    write: () => true,
+    kill: () => true,
+    getForegroundProcess: async () => null,
+    getSize: () => ({ cols: COLS, rows: ROWS }),
+    // The host has verified the shell is back in the foreground at the exit marker.
+    confirmShellForeground: async () => true
+  })
+  host.registerPty(PTY_ID, 'wt-1')
+  host.onPtyData(PTY_ID, LIVE_PANE, Date.now())
+
+  const runtimeSubscribe = vi.fn()
+  const sendBinary = vi.fn()
+  let toClient: ((bytes: Uint8Array<ArrayBufferLike>) => void) | undefined
+  runtimeSubscribe.mockImplementation(
+    async (
+      _args: unknown,
+      callbacks: {
+        onResponse: (response: unknown) => void
+        onBinary?: (bytes: Uint8Array<ArrayBufferLike>) => void
+      }
+    ) => {
+      toClient = callbacks.onBinary
+      queueMicrotask(() => callbacks.onResponse({ ok: true, result: { type: 'ready' } }))
+      return { unsubscribe: vi.fn(), sendBinary }
+    }
+  )
+  const runtimeCall = vi.fn().mockResolvedValue({
+    ok: true,
+    result: {
+      terminal: { handle: 'terminal-1', tabId: 'tab-1', leafId: 'pane:1', worktreeId: 'wt-1' }
+    }
+  })
+  Object.assign(window.api, {
+    runtimeEnvironments: { call: runtimeCall, subscribe: runtimeSubscribe }
+  })
+
+  const { createRemoteRuntimePtyTransport } = await import('./remote-runtime-pty-transport')
+  const transport = createRemoteRuntimePtyTransport('env-1', {
+    worktreeId: 'wt-1',
+    tabId: 'tab-1',
+    leafId: 'pane:1'
+  })
+  const onReplayData = vi.fn<(data: string, meta?: PtyReplayDataMeta) => void>()
+  transport.attach({
+    existingPtyId: 'remote:env-1@@terminal-1',
+    cols: COLS,
+    rows: ROWS,
+    callbacks: { onReplayData }
+  })
+  await expect
+    .poll(() =>
+      sendBinary.mock.calls.some(
+        ([bytes]) => decodeTerminalStreamFrame(bytes)?.opcode === TerminalStreamOpcode.Subscribe
+      )
+    )
+    .toBe(true)
+  const subscribe = sendBinary.mock.calls
+    .map(([bytes]) => decodeTerminalStreamFrame(bytes))
+    .find((frame) => frame?.opcode === TerminalStreamOpcode.Subscribe)
+  const streamId = decodeTerminalStreamJson<{ streamId: number }>(subscribe!.payload)!.streamId
+  const sendFrame = (
+    id: number,
+    opcode: number,
+    payload?: Uint8Array<ArrayBufferLike>
+  ): boolean => {
+    toClient?.(
+      encodeTerminalStreamFrame({
+        opcode,
+        streamId: id,
+        seq: 0,
+        payload: payload ?? new Uint8Array()
+      })
+    )
+    return true
+  }
+
+  // The initial push only opens the stream; the pane below already parsed these bytes live.
+  const initial = await serializeBudgetedRequestedSnapshot(host, PTY_ID, 0)
+  sendSnapshotFrames((opcode, payload) => sendFrame(streamId, opcode, payload), {
+    kind: 'scrollback',
+    cols: initial!.cols,
+    rows: initial!.rows,
+    seq: initial!.seq,
+    source: initial!.source,
+    data: initial!.data
+  })
+  await expect.poll(() => onReplayData.mock.calls.length).toBe(1)
+
+  host.onPtyData(PTY_ID, missed, Date.now())
+  const stream: HostStream = {
+    streamId,
+    ptyId: PTY_ID,
+    outputPaused: false,
+    ackRecoverySnapshotInFlight: false,
+    ackOutputSourceRanges: false,
+    ackPendingOutput: [],
+    ackPendingOutputBytes: 0,
+    ackPendingOutputOverflowed: false
+  }
+  const connection: HostConnection = {
+    runtime: host,
+    streams: new Map([[streamId, stream]]),
+    closed: false,
+    sendFrame,
+    sendStreamError: (_id, message) => {
+      throw new Error(message)
+    }
+  }
+  const published = await serializeBudgetedRequestedSnapshot(host, PTY_ID, 0)
+  installMultiplexFlowControl(connection)
+  await connection.sendAckRecoverySnapshot?.(stream)
+  await expect.poll(() => onReplayData.mock.calls.length).toBe(2)
+  transport.destroy?.()
+  const [data, meta] = onReplayData.mock.calls[1]!
+  return { data, meta: meta ?? {}, published: published! }
+}
+
+describe('host-published recovery snapshot onto a live alt screen', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.clearAllMocks()
+    transportFactoryQueue = []
+    storeSubscribers = []
+    mockStoreState = createInitialStoreState(() => mockStoreState)
+    installTerminalTestGlobals()
+  })
+
+  afterEach(async () => {
+    await restoreTerminalTestGlobals()
+  })
+
+  /** The pane's writes and grid changes, in order, ending back at the pane's own grid. */
+  async function drainOntoLiveAltScreen(
+    data: string,
+    meta: PtyReplayDataMeta
+  ): Promise<PaneEvent[]> {
+    const { connectPanePty } = await import('./pty-connection')
+    const transport = createMockTransport('agent-pty')
+    const replay: { current: ConnectCallbacks['onReplayData'] | null } = { current: null }
+    transport.connect.mockImplementation(async ({ callbacks }: { callbacks: ConnectCallbacks }) => {
+      replay.current = callbacks.onReplayData ?? null
+      return 'agent-pty'
+    })
+    transportFactoryQueue.push(transport)
+    const pane = createPane(1)
+    const events: PaneEvent[] = []
+    const parseCallbacks: (() => void)[] = []
+    pane.terminal.write.mockImplementation((chunk: string, callback?: () => void) => {
+      if (chunk.length > 0) {
+        events.push(chunk)
+      }
+      if (callback) {
+        parseCallbacks.push(callback)
+      }
+    })
+    pane.terminal.resize.mockImplementation((cols: number, rows: number) => {
+      pane.terminal.cols = cols
+      pane.terminal.rows = rows
+      events.push({ cols, rows })
+    })
+    const deps = buildPaneConnectionDeps(() => mockStoreState)
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixtures implement the pane, manager and deps members connectPanePty reads.
+    const binding = connectPanePty(pane as never, createManager(1) as never, deps as never)
+    await flushAsyncTicks(8)
+    pane.terminal.cols = COLS
+    pane.terminal.rows = ROWS
+    pane.terminal.buffer.active.type = 'alternate'
+    replay.current?.(data, meta)
+    for (let index = 0; index < 12; index += 1) {
+      await flushAsyncTicks(4)
+      parseCallbacks.shift()?.()
+    }
+    await flushAsyncTicks(8)
+    binding.dispose()
+    expect(
+      events.some((event) => typeof event === 'string' && event.length > 0 && data.endsWith(event))
+    ).toBe(true)
+    return [...events, { cols: COLS, rows: ROWS }]
+  }
+
+  // Why: while the TUI lives, the host publishes no owner, so the alt flag never reaches
+  // the client; the pane must keep the setup history the TUI's alt screen covers.
+  it('keeps the covered history for a live TUI exactly as the host holds it', async () => {
+    const { data, meta, published } = await publishHostRecovery(AGENT_FRAME)
+    expect(published.alternateScreen).toBe(true)
+    expect(meta.terminalOwner).toBeUndefined()
+    expect(meta.alternateScreen).toBeUndefined()
+    const client = await render([LIVE_PANE, ...(await drainOntoLiveAltScreen(data, meta))])
+    const host = await render([LIVE_PANE, AGENT_FRAME])
+    try {
+      expect(client.buffer.active.type).toBe('alternate')
+      expect(viewport(client, 'alternate')).toEqual(viewport(host, 'alternate'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(host, 'normal'))
+    } finally {
+      client.dispose()
+      host.dispose()
+    }
+  })
+
+  // Why: once the host's TUI exits, its image no longer enters alt; the pane must leave
+  // alt and show the host's normal screen.
+  it('repaints from the normal buffer once the host TUI has exited', async () => {
+    const { data, meta } = await publishHostRecovery(AGENT_EXIT)
+    expect(meta.terminalOwner).toBe('shell')
+    expect(meta.alternateScreen).toBe(false)
+    const client = await render([LIVE_PANE, ...(await drainOntoLiveAltScreen(data, meta))])
+    const host = await render([LIVE_PANE, AGENT_EXIT])
+    const fresh = await render([data])
+    try {
+      expect(client.buffer.active.type).toBe('normal')
+      expect(viewport(client, 'normal')).toEqual(viewport(host, 'normal'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(fresh, 'normal'))
+    } finally {
+      client.dispose()
+      host.dispose()
+      fresh.dispose()
+    }
+  })
+})
diff --git a/src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-replay.test.ts b/src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-replay.test.ts
new file mode 100644
index 00000000000..016abf75a0d
--- /dev/null
+++ b/src/renderer/src/components/terminal-pane/remote-snapshot-alt-screen-replay.test.ts
@@ -0,0 +1,370 @@
+import type * as React from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { Terminal } from '@xterm/headless'
+import { flushAsyncTicks, writeHeadlessTerminal } from './pty-connection-test-async'
+import { buildMainModelSnapshotReplayWrites } from './terminal-snapshot-replay-paint'
+import { createMockTransport, createPane, createManager } from './pty-connection-test-pane-fixtures'
+import type { ConnectCallbacks, MockTransport } from './pty-connection-test-pane-fixtures'
+import type { PtyReplayDataMeta } from './pty-transport-types'
+import { buildPaneConnectionDeps } from './pty-connection-test-deps'
+import { createInitialStoreState } from './pty-connection-test-store-fixtures'
+import type { StoreState } from './pty-connection-test-store-state'
+import {
+  installTerminalTestGlobals,
+  restoreTerminalTestGlobals
+} from './pty-connection-test-environment'
+
+const { scheduleRuntimeGraphSync, shouldSeedCacheTimerOnInitialTitle, toastInfo } = vi.hoisted(
+  () => ({
+    scheduleRuntimeGraphSync: vi.fn(),
+    shouldSeedCacheTimerOnInitialTitle: vi.fn(() => false),
+    toastInfo: vi.fn()
+  })
+)
+
+let mockStoreState: StoreState
+let transportFactoryQueue: MockTransport[] = []
+let storeSubscribers: ((state: StoreState) => void)[] = []
+
+vi.mock('@/runtime/sync-runtime-graph', () => ({ scheduleRuntimeGraphSync }))
+
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => mockStoreState,
+    subscribe: (listener: (state: StoreState) => void) => {
+      storeSubscribers.push(listener)
+      return () => {
+        storeSubscribers = storeSubscribers.filter((candidate) => candidate !== listener)
+      }
+    }
+  }
+}))
+
+vi.mock('@/lib/agent-status', async (importOriginal) => {
+  const { buildAgentStatusModuleMock } = await import('./pty-connection-test-environment')
+  return buildAgentStatusModuleMock(await importOriginal<Record<string, unknown>>())
+})
+
+vi.mock('./cache-timer-seeding', () => ({ shouldSeedCacheTimerOnInitialTitle }))
+
+vi.mock('sonner', () => ({ toast: { info: toastInfo } }))
+
+vi.mock('react', async (importOriginal) => {
+  const actual = await importOriginal<typeof React>()
+  return {
+    ...actual,
+    useCallback: <T extends (...args: unknown[]) => unknown>(fn: T): T => fn
+  }
+})
+
+vi.mock('./pty-transport', () => ({
+  createIpcPtyTransport: vi.fn(() => {
+    const nextTransport = transportFactoryQueue.shift()
+    if (!nextTransport) {
+      throw new Error('No mock transport queued')
+    }
+    return nextTransport
+  })
+}))
+
+const COLS = 40
+const ROWS = 6
+// A setup script's output, then an agent TUI that entered the alt screen over it. Under a
+// live TUI the normal buffer is frozen, so host and pane hold the same one.
+const NORMAL_LINES = [...Array.from({ length: 10 }, (_, i) => `SETUP-OUTPUT-${i}`), '$ claude']
+const LIVE_PANE = `${NORMAL_LINES.join('\r\n')}\x1b[?1049h\x1b[2J\x1b[HOLD-AGENT-FRAME`
+// Agent frames jump the cursor over cells they expect blank instead of writing spaces.
+const AGENT_FRAME = '\x1b[H\x1b[2;1HNo\x1b[1Cnotice\x1b[1Ctoday'
+const ENTER_AGENT_FRAME = `\x1b[0m\x1b[?1049h${AGENT_FRAME}`
+
+// Remote image shapes: the normal buffer folded in, then the image enters alt itself.
+// Pushes carry only the host's screen; requested snapshots also carry history.
+function pushedImage(hostRows: number): string {
+  return `${NORMAL_LINES.slice(-hostRows).join('\r\n')}${ENTER_AGENT_FRAME}`
+}
+// What the multiplexer hands the pane for a recovery push (its own screen clear first).
+function recoveryPayload(hostRows: number): string {
+  return `\x1b[?2026l\x1b[2J\x1b[3J\x1b[H${pushedImage(hostRows)}`
+}
+const REQUESTED_IMAGE = `${NORMAL_LINES.join('\r\n')}${ENTER_AGENT_FRAME}`
+
+type PaneEvent = string | { cols: number; rows: number }
+
+function bufferLines(term: Terminal, which: 'normal' | 'alternate'): string[] {
+  const buffer = which === 'normal' ? term.buffer.normal : term.buffer.alternate
+  return Array.from(
+    { length: buffer.length },
+    (_, row) => buffer.getLine(row)?.translateToString(true) ?? ''
+  )
+}
+
+function viewport(term: Terminal, which: 'normal' | 'alternate'): string[] {
+  return bufferLines(term, which).slice(-term.rows)
+}
+
+async function render(events: PaneEvent[], rows = ROWS): Promise<Terminal> {
+  const term = new Terminal({ cols: COLS, rows, scrollback: 100, allowProposedApi: true })
+  for (const event of events) {
+    if (typeof event === 'string') {
+      await writeHeadlessTerminal(term, event)
+    } else {
+      term.resize(event.cols, event.rows)
+    }
+  }
+  return term
+}
+
+/** The live pane's own buffers carried through the drain's grid changes and nothing else. */
+function untouchedPane(events: PaneEvent[]): Promise<Terminal> {
+  return render([LIVE_PANE, ...events.filter((event) => typeof event !== 'string')])
+}
+
+describe('remote snapshot replay onto a live alt screen', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.clearAllMocks()
+    transportFactoryQueue = []
+    storeSubscribers = []
+    mockStoreState = createInitialStoreState(() => mockStoreState)
+    installTerminalTestGlobals()
+  })
+
+  afterEach(async () => {
+    await restoreTerminalTestGlobals()
+  })
+
+  /** The pane's writes and grid changes, in order, ending back at the pane's own grid. */
+  async function drainOntoLiveAltScreen(
+    data: string,
+    meta: PtyReplayDataMeta,
+    // 'alternate-queued': the TUI's ?1049h is still queued and parses with the first write.
+    paneBuffer: 'normal' | 'alternate' | 'alternate-queued' = 'alternate'
+  ): Promise<PaneEvent[]> {
+    const { connectPanePty } = await import('./pty-connection')
+    const transport = createMockTransport('agent-pty')
+    const replay: { current: ConnectCallbacks['onReplayData'] | null } = { current: null }
+    transport.connect.mockImplementation(async ({ callbacks }: { callbacks: ConnectCallbacks }) => {
+      replay.current = callbacks.onReplayData ?? null
+      return 'agent-pty'
+    })
+    transportFactoryQueue.push(transport)
+    const pane = createPane(1)
+    const events: PaneEvent[] = []
+    const parseCallbacks: (() => void)[] = []
+    pane.terminal.write.mockImplementation((chunk: string, callback?: () => void) => {
+      if (chunk.length > 0) {
+        events.push(chunk)
+      }
+      if (callback) {
+        parseCallbacks.push(() => {
+          pane.terminal.buffer.active.type = paneBuffer === 'normal' ? 'normal' : 'alternate'
+          callback()
+        })
+      }
+    })
+    pane.terminal.resize.mockImplementation((cols: number, rows: number) => {
+      pane.terminal.cols = cols
+      pane.terminal.rows = rows
+      events.push({ cols, rows })
+    })
+    const deps = buildPaneConnectionDeps(() => mockStoreState)
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixtures implement the pane, manager and deps members connectPanePty reads.
+    const binding = connectPanePty(pane as never, createManager(1) as never, deps as never)
+    await flushAsyncTicks(8)
+    pane.terminal.cols = COLS
+    pane.terminal.rows = ROWS
+    pane.terminal.buffer.active.type = paneBuffer === 'alternate' ? 'alternate' : 'normal'
+    replay.current?.(data, meta)
+    for (let index = 0; index < 12; index += 1) {
+      await flushAsyncTicks(4)
+      parseCallbacks.shift()?.()
+    }
+    await flushAsyncTicks(8)
+    binding.dispose()
+    expect(
+      events.some((event) => typeof event === 'string' && event.length > 0 && data.endsWith(event))
+    ).toBe(true)
+    return [...events, { cols: COLS, rows: ROWS }]
+  }
+
+  // Why: a revisited remote tab running an agent TUI gets a pushed snapshot while xterm
+  // is on the agent's alt screen. Cleared in place, the image's normal screen (old setup
+  // output) painted into the agent's screen, under its next paints.
+  it('repaints a pushed image exactly and keeps the history the TUI covers', async () => {
+    const payload = recoveryPayload(ROWS)
+    const client = await render([
+      LIVE_PANE,
+      ...(await drainOntoLiveAltScreen(payload, {
+        carriesNormalBuffer: true,
+        snapshotCols: COLS,
+        snapshotRows: ROWS
+      }))
+    ])
+    const host = await render([LIVE_PANE])
+    const fresh = await render([pushedImage(ROWS)])
+    try {
+      expect(client.buffer.active.type).toBe('alternate')
+      expect(viewport(client, 'alternate')).toEqual(viewport(fresh, 'alternate'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(host, 'normal'))
+    } finally {
+      client.dispose()
+      host.dispose()
+      fresh.dispose()
+    }
+  })
+
+  // Why: the pane's normal buffer froze with the host's when the TUI entered alt, so a
+  // pushed image repaints only the alt frame, whatever grid the host serialized it at.
+  it("keeps the pane's history when the host screen has another grid", async () => {
+    const hostRows = 10
+    const events = await drainOntoLiveAltScreen(recoveryPayload(hostRows), {
+      carriesNormalBuffer: true,
+      snapshotCols: COLS,
+      snapshotRows: hostRows
+    })
+    const client = await render([LIVE_PANE, ...events])
+    const untouched = await untouchedPane(events)
+    const fresh = await render([pushedImage(hostRows), { cols: COLS, rows: ROWS }], hostRows)
+    try {
+      expect(viewport(client, 'alternate')).toEqual(viewport(fresh, 'alternate'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(untouched, 'normal'))
+    } finally {
+      client.dispose()
+      untouched.dispose()
+      fresh.dispose()
+    }
+  })
+
+  // Why: a push can reuse a concurrent requested capture that folds history in too;
+  // painting that history over the kept one would duplicate it in scrollback.
+  it('keeps history unduplicated when a pushed image also carries history', async () => {
+    const client = await render([
+      LIVE_PANE,
+      ...(await drainOntoLiveAltScreen(`\x1b[?2026l\x1b[2J\x1b[3J\x1b[H${REQUESTED_IMAGE}`, {
+        carriesNormalBuffer: true,
+        snapshotCols: COLS,
+        snapshotRows: ROWS
+      }))
+    ])
+    const host = await render([LIVE_PANE])
+    const fresh = await render([REQUESTED_IMAGE])
+    try {
+      expect(viewport(client, 'alternate')).toEqual(viewport(fresh, 'alternate'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(host, 'normal'))
+    } finally {
+      client.dispose()
+      host.dispose()
+      fresh.dispose()
+    }
+  })
+
+  // Why: the pane's buffer is read only after queued output parses; read early, a
+  // still-queued ?1049h makes the image paint its normal part into the TUI.
+  it('reads the pane buffer after a queued alt-screen entry parses', async () => {
+    const client = await render([
+      LIVE_PANE,
+      ...(await drainOntoLiveAltScreen(
+        recoveryPayload(ROWS),
+        { carriesNormalBuffer: true, snapshotCols: COLS, snapshotRows: ROWS },
+        'alternate-queued'
+      ))
+    ])
+    const host = await render([LIVE_PANE])
+    const fresh = await render([pushedImage(ROWS)])
+    try {
+      expect(viewport(client, 'alternate')).toEqual(viewport(fresh, 'alternate'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(host, 'normal'))
+    } finally {
+      client.dispose()
+      host.dispose()
+      fresh.dispose()
+    }
+  })
+
+  // Why: a TUI that started while the tab was hidden left the pane on the normal
+  // buffer; the image must rebuild that buffer and enter alt itself.
+  it('paints the whole image when the TUI started while hidden', async () => {
+    const client = await render([
+      NORMAL_LINES.join('\r\n'),
+      ...(await drainOntoLiveAltScreen(
+        recoveryPayload(ROWS),
+        { carriesNormalBuffer: true, snapshotCols: COLS, snapshotRows: ROWS },
+        'normal'
+      ))
+    ])
+    const fresh = await render([pushedImage(ROWS)])
+    try {
+      expect(client.buffer.active.type).toBe('alternate')
+      expect(viewport(client, 'alternate')).toEqual(viewport(fresh, 'alternate'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(fresh, 'normal'))
+    } finally {
+      client.dispose()
+      fresh.dispose()
+    }
+  })
+
+  // Why: once the host's TUI exits, its image no longer enters alt; the pane must leave
+  // alt and show the host's normal screen.
+  it('repaints from the normal buffer once the host TUI has exited', async () => {
+    const hostScreen = [...NORMAL_LINES, 'Resume with claude --resume', '$ ']
+      .slice(-ROWS)
+      .join('\r\n')
+    const client = await render([
+      LIVE_PANE,
+      ...(await drainOntoLiveAltScreen(`\x1b[?2026l\x1b[2J\x1b[3J\x1b[H${hostScreen}`, {
+        carriesNormalBuffer: true,
+        terminalOwner: 'shell',
+        alternateScreen: false,
+        snapshotCols: COLS,
+        snapshotRows: ROWS
+      }))
+    ])
+    const fresh = await render([hostScreen])
+    try {
+      expect(client.buffer.active.type).toBe('normal')
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(fresh, 'normal'))
+    } finally {
+      client.dispose()
+      fresh.dispose()
+    }
+  })
+
+  // Why: an SSH relay replays a raw byte window, not an image; it continues the TUI on
+  // the alt screen and must leave the normal buffer alone.
+  it('clears a raw byte replay in place on the alt screen', async () => {
+    const client = await render([LIVE_PANE, ...(await drainOntoLiveAltScreen(AGENT_FRAME, {}))])
+    const expected = await render([LIVE_PANE, `\x1b[2J${AGENT_FRAME}`])
+    try {
+      expect(client.buffer.active.type).toBe('alternate')
+      expect(viewport(client, 'alternate')).toEqual(viewport(expected, 'alternate'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(expected, 'normal'))
+    } finally {
+      client.dispose()
+      expected.dispose()
+    }
+  })
+
+  // Why: a requested image flags alt only once the host's TUI exited (shell owner); one
+  // that exited without leaving alt must still paint from the normal buffer.
+  it('paints a requested image from an exited TUI exactly over an alt screen', async () => {
+    const client = await render([
+      LIVE_PANE,
+      ...buildMainModelSnapshotReplayWrites(
+        {
+          data: REQUESTED_IMAGE,
+          alternateScreen: true,
+          carriesNormalBuffer: true
+        },
+        { paneOnAlternateScreen: true }
+      )
+    ])
+    const fresh = await render([REQUESTED_IMAGE])
+    try {
+      expect(viewport(client, 'alternate')).toEqual(viewport(fresh, 'alternate'))
+      expect(bufferLines(client, 'normal')).toEqual(bufferLines(fresh, 'normal'))
+    } finally {
+      client.dispose()
+      fresh.dispose()
+    }
+  })
+})
diff --git a/src/renderer/src/components/terminal-pane/terminal-agent-session-fork.ts b/src/renderer/src/components/terminal-pane/terminal-agent-session-fork.ts
index 3c0d33a14d6..d9a4deb4807 100644
--- a/src/renderer/src/components/terminal-pane/terminal-agent-session-fork.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-agent-session-fork.ts
@@ -16,6 +16,7 @@ import type { TuiAgent } from '../../../../shared/tui-agent'
 import { getLocalProjectExecutionRuntimeContext } from '@/lib/local-preflight-context'
 import { translate } from '@/i18n/i18n'
 import { planAgentSessionLaunch } from '@/lib/agent-session-launch-plan'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 
 type ForkAgentSessionFromPaneArgs = {
   pane: ManagedPane
@@ -230,6 +231,7 @@ export async function startAgentSessionFork(fork: PreparedAgentSessionFork): Pro
     return copyAgentSessionForkContext(fork)
   }
   const agentSessionLaunchPlan = planAgentSessionLaunch(useAppStore.getState(), {
+    requestId: newAgentLaunchRequestId(),
     agent: fork.agent,
     workspace: { kind: 'git-worktree', worktreeId: forkWorktreeId },
     prompt: fork.prompt,
diff --git a/src/renderer/src/components/terminal-pane/terminal-file-open-routing.ts b/src/renderer/src/components/terminal-pane/terminal-file-open-routing.ts
index 21bb89d39aa..9680392f5ee 100644
--- a/src/renderer/src/components/terminal-pane/terminal-file-open-routing.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-file-open-routing.ts
@@ -10,7 +10,6 @@ import {
 } from '@/lib/workspace-file-host-routing'
 import {
   isMissingRuntimePathError,
-  statRuntimePath,
   type RuntimeFileOperationArgs
 } from '@/runtime/runtime-file-client'
 import { useAppStore } from '@/store'
@@ -23,6 +22,7 @@ import {
   toSshExecutionHostId,
   type ExecutionHostId
 } from '../../../../shared/execution-host'
+import { statUserOpenedPath } from '@/lib/user-opened-local-path'
 
 export type FileOpenFailure = {
   /** `missing` is a verified absence; `unverifiable` means the host could not answer (dropped SSH, timeout, denied path). */
@@ -173,11 +173,7 @@ export function openDetectedFilePath(
     }
 
     try {
-      // Why: remote paths don't need local auth — the relay/runtime is the security boundary.
-      if (canOpenWithSystemDefault) {
-        await window.api.fs.authorizeExternalPath({ targetPath: mappedFilePath })
-      }
-      statResult = await statRuntimePath(fileContext, mappedFilePath)
+      statResult = await statUserOpenedPath(fileContext, mappedFilePath)
     } catch (error) {
       if (requestId === latestOpenDetectedFilePathRequestId && deps.onOpenFailure) {
         // Why: loss of contact with the host is not evidence the file is gone.
@@ -239,7 +235,9 @@ export function openDetectedFilePath(
     let relativePath = mappedFilePath
     if (worktreePath && isPathInsideWorktree(mappedFilePath, worktreePath)) {
       const maybeRelative = toWorktreeRelativePath(mappedFilePath, worktreePath)
-      if (maybeRelative !== null && maybeRelative.length > 0) {
+      // Why: a link out of the project keeps its absolute path, so the tab reads it as the file
+      // the user named, before and after a restart, instead of being refused as a project file.
+      if (maybeRelative !== null && maybeRelative.length > 0 && !statResult.escapesWorktree) {
         relativePath = maybeRelative
       }
     } else if (
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-click-fallback.test.ts b/src/renderer/src/components/terminal-pane/terminal-link-click-fallback.test.ts
index f7c92a460bc..7ded98221b3 100644
--- a/src/renderer/src/components/terminal-pane/terminal-link-click-fallback.test.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-link-click-fallback.test.ts
@@ -106,7 +106,9 @@ describe('createFilePathLinkProvider range bounds', () => {
 
     expect(opened).toBe(true)
     expect(statMock).toHaveBeenCalledWith({
-      filePath: '\\\\wsl.localhost\\Ubuntu\\root\\workspace\\myrepo\\README.md'
+      filePath: '\\\\wsl.localhost\\Ubuntu\\root\\workspace\\myrepo\\README.md',
+      connectionId: undefined,
+      access: { kind: 'user-file' }
     })
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-escaping-file-open.test.ts b/src/renderer/src/components/terminal-pane/terminal-link-escaping-file-open.test.ts
new file mode 100644
index 00000000000..6c5815564fb
--- /dev/null
+++ b/src/renderer/src/components/terminal-pane/terminal-link-escaping-file-open.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it, vi } from 'vitest'
+import { openDetectedFilePath } from './terminal-link-handlers'
+import { createTerminalLinkTestDoubles } from './terminal-link-handlers-test-fixtures'
+import {
+  flushAsyncWork,
+  installTerminalLinkTestEnvironment,
+  setPlatform
+} from './terminal-link-handlers-test-harness'
+
+const doubles = createTerminalLinkTestDoubles()
+const { storeState, deps, openFileMock, statMock } = doubles
+
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => storeState
+  }
+}))
+
+vi.mock('@/lib/worktree-activation', () => ({
+  activateAndRevealWorkspace: vi.fn(),
+  activateAndRevealWorktree: vi.fn()
+}))
+
+vi.mock('@/lib/connection-context', () => ({
+  getConnectionId: vi.fn(() => null)
+}))
+
+installTerminalLinkTestEnvironment(doubles)
+
+/** Main's answer for a project link to outside: refused inside the root, readable as user-named. */
+function linkLeadsOutOfProject(): void {
+  statMock.mockImplementation(async ({ access }: { access?: { kind: string } }) => {
+    if (access?.kind !== 'user-file') {
+      throw new Error('Access denied: path resolves outside allowed directories')
+    }
+    return { size: 1, isDirectory: false, mtime: 1 }
+  })
+}
+
+describe('Cmd-click on a project file that links out of the project', () => {
+  it('opens it by its absolute path so it reads the same after a restart', async () => {
+    setPlatform('Macintosh')
+    linkLeadsOutOfProject()
+
+    openDetectedFilePath('/tmp/docs/link.md', null, null, deps)
+    await flushAsyncWork()
+
+    expect(openFileMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        filePath: '/tmp/docs/link.md',
+        relativePath: '/tmp/docs/link.md',
+        worktreeId: 'wt-1'
+      }),
+      expect.anything()
+    )
+  })
+
+  it('keeps an ordinary project file as a project tab', async () => {
+    setPlatform('Macintosh')
+    statMock.mockReset().mockResolvedValue({ size: 1, isDirectory: false, mtime: 1 })
+
+    openDetectedFilePath('/tmp/docs/plain.md', null, null, deps)
+    await flushAsyncWork()
+
+    expect(statMock).toHaveBeenCalledExactlyOnceWith({
+      filePath: '/tmp/docs/plain.md',
+      connectionId: undefined
+    })
+    expect(openFileMock).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: '/tmp/docs/plain.md', relativePath: 'docs/plain.md' }),
+      expect.anything()
+    )
+  })
+})
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-handlers-test-fixtures.ts b/src/renderer/src/components/terminal-pane/terminal-link-handlers-test-fixtures.ts
index 12751c02373..f609b05aaa6 100644
--- a/src/renderer/src/components/terminal-pane/terminal-link-handlers-test-fixtures.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-link-handlers-test-fixtures.ts
@@ -24,7 +24,6 @@ export type TerminalLinkTestDoubles = {
   openFileUriMock: Mock
   openFilePathMock: Mock
   openFileMock: Mock
-  authorizeExternalPathMock: Mock
   statMock: Mock
   fsPathExistsMock: Mock
   runtimeEnvironmentCallMock: Mock
@@ -43,7 +42,6 @@ export function createTerminalLinkTestDoubles(): TerminalLinkTestDoubles {
   const openFileUriMock = vi.fn()
   const openFilePathMock = vi.fn()
   const openFileMock = vi.fn()
-  const authorizeExternalPathMock = vi.fn()
   const statMock = vi.fn().mockResolvedValue({ isDirectory: false })
   const fsPathExistsMock = vi.fn().mockResolvedValue(true)
   const runtimeEnvironmentCallMock = vi.fn()
@@ -72,7 +70,6 @@ export function createTerminalLinkTestDoubles(): TerminalLinkTestDoubles {
     openFileUriMock,
     openFilePathMock,
     openFileMock,
-    authorizeExternalPathMock,
     statMock,
     fsPathExistsMock,
     runtimeEnvironmentCallMock,
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-handlers-test-harness.ts b/src/renderer/src/components/terminal-pane/terminal-link-handlers-test-harness.ts
index 5230fa00ed2..43fd7a05a6d 100644
--- a/src/renderer/src/components/terminal-pane/terminal-link-handlers-test-harness.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-link-handlers-test-harness.ts
@@ -35,7 +35,6 @@ export function installTerminalLinkTestEnvironment(doubles: TerminalLinkTestDoub
     openUrlMock,
     openFileUriMock,
     openFilePathMock,
-    authorizeExternalPathMock,
     statMock,
     fsPathExistsMock,
     runtimeEnvironmentCallMock,
@@ -71,7 +70,6 @@ export function installTerminalLinkTestEnvironment(doubles: TerminalLinkTestDoub
           pathExists: vi.fn().mockResolvedValue(true)
         },
         fs: {
-          authorizeExternalPath: authorizeExternalPathMock,
           pathExists: fsPathExistsMock,
           stat: statMock
         },
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-missing-file-open.test.ts b/src/renderer/src/components/terminal-pane/terminal-link-missing-file-open.test.ts
index 500975a29b8..6f91f728650 100644
--- a/src/renderer/src/components/terminal-pane/terminal-link-missing-file-open.test.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-link-missing-file-open.test.ts
@@ -9,7 +9,7 @@ import {
 } from './terminal-link-handlers-test-harness'
 
 const doubles = createTerminalLinkTestDoubles()
-const { storeState, deps, openFileMock, statMock, authorizeExternalPathMock } = doubles
+const { storeState, deps, openFileMock, statMock } = doubles
 
 vi.mock('@/store', () => ({
   useAppStore: {
@@ -34,7 +34,8 @@ describe('openDetectedFilePath on a path it cannot verify', () => {
   it('reports a verified miss', async () => {
     setPlatform('Macintosh')
     const error = new Error("Error invoking remote method 'fs:stat': Error: ENOENT: no such file")
-    statMock.mockRejectedValueOnce(error)
+    // A missing file fails both the project check and the user-named one.
+    statMock.mockRejectedValue(error)
     const onOpenFailure = vi.fn<OnOpenFailure>()
 
     openDetectedFilePath('/tmp/src/gone.md', null, null, { ...deps, onOpenFailure })
@@ -48,7 +49,7 @@ describe('openDetectedFilePath on a path it cannot verify', () => {
   it('reports a host that could not answer as unverifiable, not missing', async () => {
     setPlatform('Macintosh')
     const error = new Error('SSH connection closed')
-    statMock.mockRejectedValueOnce(error)
+    statMock.mockRejectedValue(error)
     const onOpenFailure = vi.fn<OnOpenFailure>()
 
     openDetectedFilePath('/tmp/src/present.md', null, null, { ...deps, onOpenFailure })
@@ -58,19 +59,6 @@ describe('openDetectedFilePath on a path it cannot verify', () => {
     expect(onOpenFailure.mock.calls[0][0]).toEqual({ verdict: 'unverifiable', error })
   })
 
-  it('reports a refused path authorization as unverifiable', async () => {
-    setPlatform('Macintosh')
-    const error = new Error('Path is outside the allowed roots')
-    authorizeExternalPathMock.mockRejectedValueOnce(error)
-    const onOpenFailure = vi.fn<OnOpenFailure>()
-
-    openDetectedFilePath('/tmp/src/denied.md', null, null, { ...deps, onOpenFailure })
-    await flushAsyncWork()
-
-    expect(statMock).not.toHaveBeenCalled()
-    expect(onOpenFailure.mock.calls[0][0]).toEqual({ verdict: 'unverifiable', error })
-  })
-
   it('skips the callback when a later click superseded the failing one', async () => {
     setPlatform('Macintosh')
     let rejectFirstStat!: (error: Error) => void
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-osc-file-targets.test.ts b/src/renderer/src/components/terminal-pane/terminal-link-osc-file-targets.test.ts
index c537d57ba0f..2c59fd08101 100644
--- a/src/renderer/src/components/terminal-pane/terminal-link-osc-file-targets.test.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-link-osc-file-targets.test.ts
@@ -9,14 +9,8 @@ import {
 } from './terminal-link-handlers-test-harness'
 
 const doubles = createTerminalLinkTestDoubles()
-const {
-  storeState,
-  deps,
-  authorizeExternalPathMock,
-  openFileMock,
-  openFilePathMock,
-  setPendingEditorRevealMock
-} = doubles
+const { storeState, deps, openFileMock, openFilePathMock, setPendingEditorRevealMock, statMock } =
+  doubles
 
 vi.mock('@/store', () => ({
   useAppStore: {
@@ -49,7 +43,6 @@ describe('handleOscLink', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 0))
 
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(openFileMock).not.toHaveBeenCalled()
     expect(openFilePathMock).not.toHaveBeenCalled()
   })
@@ -65,7 +58,7 @@ describe('handleOscLink', () => {
     // before asserting on positive behavior.
     await new Promise((resolve) => setTimeout(resolve, 0))
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({ targetPath: '/tmp/test.txt' })
+    expect(statMock).toHaveBeenCalledWith(expect.objectContaining({ filePath: '/tmp/test.txt' }))
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({ filePath: '/tmp/test.txt' }),
       { forceContentReload: true }
@@ -88,9 +81,9 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
     await flushDoubleRaf()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: 'C:/repo/src/index.ts'
-    })
+    expect(statMock).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: 'C:/repo/src/index.ts' })
+    )
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({ filePath: 'C:/repo/src/index.ts' }),
       { forceContentReload: true }
@@ -118,9 +111,9 @@ describe('handleOscLink', () => {
     )
     await flushAsyncWork()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: '//server/share/repo/test.txt'
-    })
+    expect(statMock).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: '//server/share/repo/test.txt' })
+    )
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({ filePath: '//server/share/repo/test.txt' }),
       { forceContentReload: true }
@@ -140,7 +133,6 @@ describe('handleOscLink', () => {
     )
     await flushAsyncWork()
 
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(openFileMock).not.toHaveBeenCalled()
   })
 
@@ -151,7 +143,7 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
     await flushDoubleRaf()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({ targetPath: '/tmp/test.txt' })
+    expect(statMock).toHaveBeenCalledWith(expect.objectContaining({ filePath: '/tmp/test.txt' }))
     expect(openFilePathMock).not.toHaveBeenCalled()
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({ filePath: '/tmp/test.txt' }),
@@ -177,7 +169,7 @@ describe('handleOscLink', () => {
     )
     await flushAsyncWork()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({ targetPath: '/tmp/test.txt' })
+    expect(statMock).toHaveBeenCalledWith(expect.objectContaining({ filePath: '/tmp/test.txt' }))
     expect(openFilePathMock).toHaveBeenCalledWith('/tmp/test.txt')
     expect(openFileMock).not.toHaveBeenCalled()
     expect(setPendingEditorRevealMock).not.toHaveBeenCalled()
@@ -195,7 +187,7 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
     await flushDoubleRaf()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({ targetPath: '/tmp/test.txt' })
+    expect(statMock).toHaveBeenCalledWith(expect.objectContaining({ filePath: '/tmp/test.txt' }))
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({ filePath: '/tmp/test.txt' }),
       { forceContentReload: true }
@@ -224,9 +216,9 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
     await flushDoubleRaf()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: '//server/Share/Repo/src/app.ts'
-    })
+    expect(statMock).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: '//server/Share/Repo/src/app.ts' })
+    )
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({
         filePath: '//server/Share/Repo/src/app.ts',
@@ -258,9 +250,9 @@ describe('handleOscLink', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 0))
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: '/tmp/project/docs/README.md'
-    })
+    expect(statMock).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: '/tmp/project/docs/README.md' })
+    )
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({
         filePath: '/tmp/project/docs/README.md',
@@ -287,9 +279,11 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
     await flushDoubleRaf()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: '\\\\wsl.localhost\\Ubuntu\\root\\workspace\\myrepo\\README.md'
-    })
+    expect(statMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        filePath: '\\\\wsl.localhost\\Ubuntu\\root\\workspace\\myrepo\\README.md'
+      })
+    )
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({
         filePath: '\\\\wsl.localhost\\Ubuntu\\root\\workspace\\myrepo\\README.md'
@@ -320,9 +314,11 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
     await flushDoubleRaf()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: '\\\\wsl.localhost\\Ubuntu\\root\\workspace\\myrepo\\README.md'
-    })
+    expect(statMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        filePath: '\\\\wsl.localhost\\Ubuntu\\root\\workspace\\myrepo\\README.md'
+      })
+    )
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({
         filePath: '\\\\wsl.localhost\\Ubuntu\\root\\workspace\\myrepo\\README.md'
@@ -353,9 +349,9 @@ describe('handleOscLink', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 0))
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: '/home/alice/file.ts'
-    })
+    expect(statMock).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: '/home/alice/file.ts' })
+    )
     expect(openFileMock).toHaveBeenCalledWith(
       expect.objectContaining({
         filePath: '/home/alice/file.ts'
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-remote-runtime-ssh-open.test.ts b/src/renderer/src/components/terminal-pane/terminal-link-remote-runtime-ssh-open.test.ts
index 67562aec052..2df62eb3e99 100644
--- a/src/renderer/src/components/terminal-pane/terminal-link-remote-runtime-ssh-open.test.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-link-remote-runtime-ssh-open.test.ts
@@ -15,7 +15,6 @@ const doubles = createTerminalLinkTestDoubles()
 const {
   storeState,
   deps,
-  authorizeExternalPathMock,
   statMock,
   openFileMock,
   openFilePathMock,
@@ -67,7 +66,6 @@ describe('handleOscLink', () => {
     openDetectedFilePath('/tmp/src/main.ts', null, null, deps)
     await new Promise((resolve) => setTimeout(resolve, 0))
 
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).not.toHaveBeenCalled()
     await vi.waitFor(() => {
       expect(runtimeEnvironmentCallMock).toHaveBeenCalledWith({
@@ -130,7 +128,6 @@ describe('handleOscLink', () => {
     })
     await new Promise((resolve) => setTimeout(resolve, 0))
 
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).toHaveBeenCalledWith({
       filePath: '/home/me/repo/src/main.ts',
       connectionId: 'ssh-1'
@@ -172,7 +169,6 @@ describe('handleOscLink', () => {
     })
     await flushAsyncWork()
 
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).toHaveBeenCalledWith({
       filePath: '/tmp/ssh-preview.png',
       connectionId: 'ssh-1'
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-worktree-root-activation.test.ts b/src/renderer/src/components/terminal-pane/terminal-link-worktree-root-activation.test.ts
index 1920afc3643..66ece84e48c 100644
--- a/src/renderer/src/components/terminal-pane/terminal-link-worktree-root-activation.test.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-link-worktree-root-activation.test.ts
@@ -16,8 +16,7 @@ import {
 } from './terminal-link-handlers-test-harness'
 
 const doubles = createTerminalLinkTestDoubles()
-const { storeState, deps, authorizeExternalPathMock, statMock, openFileMock, openFilePathMock } =
-  doubles
+const { storeState, deps, statMock, openFileMock, openFilePathMock } = doubles
 
 vi.mock('@/store', () => ({
   useAppStore: {
@@ -55,7 +54,6 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
 
     expect(activateAndRevealWorktree).toHaveBeenCalledWith('wt-2')
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).not.toHaveBeenCalled()
     expect(openFilePathMock).not.toHaveBeenCalled()
     expect(openFileMock).not.toHaveBeenCalled()
@@ -73,7 +71,6 @@ describe('handleOscLink', () => {
 
     expect(activateAndRevealWorktree).toHaveBeenCalledTimes(1)
     expect(activateAndRevealWorktree).toHaveBeenCalledWith('wt-2')
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).not.toHaveBeenCalled()
   })
 
@@ -90,9 +87,9 @@ describe('handleOscLink', () => {
     })
     await flushAsyncWork()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: '/tmp/other-worktree'
-    })
+    expect(statMock).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: '/tmp/other-worktree' })
+    )
     expect(statMock).toHaveBeenCalled()
     expect(openFilePathMock).toHaveBeenCalledWith('/tmp/other-worktree')
     expect(activateAndRevealWorktree).not.toHaveBeenCalled()
@@ -113,7 +110,6 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
 
     expect(activateAndRevealWorktree).toHaveBeenCalledWith('wt-2')
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).not.toHaveBeenCalled()
     expect(openFilePathMock).not.toHaveBeenCalled()
   })
@@ -131,7 +127,6 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
 
     expect(activateAndRevealWorktree).toHaveBeenCalledWith('wt-win')
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).not.toHaveBeenCalled()
     expect(openFilePathMock).not.toHaveBeenCalled()
   })
@@ -147,7 +142,6 @@ describe('handleOscLink', () => {
     await flushAsyncWork()
 
     expect(activateAndRevealWorktree).toHaveBeenCalledWith('wt-2')
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).not.toHaveBeenCalled()
     expect(openFilePathMock).not.toHaveBeenCalled()
     expect(openFileMock).not.toHaveBeenCalled()
@@ -254,7 +248,6 @@ describe('createFilePathLinkProvider range bounds', () => {
 
     expect(opened).toBe(true)
     expect(activateAndRevealWorktree).toHaveBeenCalledWith('wt-2')
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(statMock).not.toHaveBeenCalled()
     expect(openFilePathMock).not.toHaveBeenCalled()
     expect(openFileMock).not.toHaveBeenCalled()
diff --git a/src/renderer/src/components/terminal-pane/terminal-link-wsl-path-mapping.test.ts b/src/renderer/src/components/terminal-pane/terminal-link-wsl-path-mapping.test.ts
index 5ef937f9ed2..744cd12f988 100644
--- a/src/renderer/src/components/terminal-pane/terminal-link-wsl-path-mapping.test.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-link-wsl-path-mapping.test.ts
@@ -11,13 +11,7 @@ import {
 } from './terminal-link-handlers-test-harness'
 
 const doubles = createTerminalLinkTestDoubles()
-const {
-  storeState,
-  authorizeExternalPathMock,
-  statMock,
-  openFileMock,
-  setPendingEditorRevealMock
-} = doubles
+const { storeState, statMock, openFileMock, setPendingEditorRevealMock } = doubles
 
 vi.mock('@/store', () => ({
   useAppStore: {
@@ -70,7 +64,11 @@ describe('createFilePathLinkProvider range bounds', () => {
     await flushAsyncWork()
     await flushDoubleRaf()
 
-    expect(statMock).toHaveBeenCalledWith({ filePath: mappedPath })
+    expect(statMock).toHaveBeenCalledWith({
+      filePath: mappedPath,
+      connectionId: undefined,
+      access: { kind: 'user-file' }
+    })
     expect(openFileMock).toHaveBeenCalledWith(expect.objectContaining({ filePath: mappedPath }), {
       forceContentReload: true
     })
@@ -183,14 +181,16 @@ describe('createFilePathLinkProvider range bounds', () => {
 
     openDetectedFilePath('/home/alice/notes.md', null, null, {
       worktreeId: 'wt-1',
-      worktreePath: 'C:\\repo',
+      worktreePath: '/home/alice',
       wslDistro: 'Ubuntu',
       runtimeEnvironmentId: 'env-1'
     })
     await flushAsyncWork()
 
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({
-      targetPath: '/home/alice/notes.md'
-    })
+    // An unmapped POSIX path stays inside the runtime worktree and is asked of its host.
+    expect(JSON.stringify(doubles.runtimeEnvironmentTransportCallMock.mock.calls)).toContain(
+      '"relativePath":"notes.md"'
+    )
+    expect(statMock).not.toHaveBeenCalled()
   })
 })
diff --git a/src/renderer/src/components/terminal-pane/terminal-snapshot-replay-paint.ts b/src/renderer/src/components/terminal-pane/terminal-snapshot-replay-paint.ts
index fd5da6ae20b..ef534946ef1 100644
--- a/src/renderer/src/components/terminal-pane/terminal-snapshot-replay-paint.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-snapshot-replay-paint.ts
@@ -4,12 +4,7 @@ import {
   ABORT_TRUNCATED_CONTROL_STRING,
   buildSnapshotReplayPrologue
 } from '../../../../shared/terminal-mode-reset-profiles'
-
-// Once only: CAN must precede the first ESC of the replay, but the split branch
-// builds two prologues and later writes follow well-formed payloads.
-function abortGapBeforeFirstWrite(writes: string[]): string[] {
-  return [`${ABORT_TRUNCATED_CONTROL_STRING}${writes[0]}`, ...writes.slice(1)]
-}
+import { splitAtAlternateScreenEntry } from '../../../../shared/terminal-alternate-screen-split'
 
 /**
  * Shared guards and write choreography for painting a main-model snapshot into
@@ -67,6 +62,39 @@ export function shouldSkipAltFrameForWidthMismatch(
   return snapshotCols > targetCols
 }
 
+/** First write of a snapshot replay; CAN aborts a control string the gap truncated. */
+export function buildSnapshotReplayPreamble(
+  args: Parameters<typeof buildSnapshotReplayPrologue>[0]
+): string {
+  return `${ABORT_TRUNCATED_CONTROL_STRING}${buildSnapshotReplayPrologue(args)}`
+}
+
+/**
+ * Writes for a remote image, which folds its normal buffer in ahead of its alt
+ * entry. Over a pane already on alt, an image that ends on alt repaints only its
+ * alt payload, so the pane's normal buffer and history stay as they are; any
+ * other image paints from the normal buffer.
+ */
+export function buildFoldedImageReplayWrites(
+  data: string,
+  paneOnAlternateScreen: boolean
+): { preamble: string; payload: string } {
+  const split = paneOnAlternateScreen ? splitAtAlternateScreenEntry(data) : null
+  if (split) {
+    return {
+      preamble: buildSnapshotReplayPreamble({
+        targetAlternateScreen: true,
+        paneOnAlternateScreen: true
+      }),
+      payload: split.alternateAnsi
+    }
+  }
+  return {
+    preamble: buildSnapshotReplayPreamble({ targetAlternateScreen: false, paneOnAlternateScreen }),
+    payload: data
+  }
+}
+
 /**
  * Ordered replay writes for a main-model snapshot, including the alt-screen
  * choreography: main strips the `?1049h` marker when splitting scrollbackAnsi
@@ -85,14 +113,11 @@ export function buildMainModelSnapshotReplayWrites(
     frameRestoreAnsi?: string
     alternateScreen?: boolean
     scrollbackAnsi?: string
+    carriesNormalBuffer?: boolean
   },
   options: { skipAltFrame?: boolean; paneOnAlternateScreen: boolean }
 ): string[] {
   const { paneOnAlternateScreen } = options
-  const normalPrologue = buildSnapshotReplayPrologue({
-    targetAlternateScreen: false,
-    paneOnAlternateScreen
-  })
   // The alt payload always follows a hop through the normal buffer in the split
   // branch, so its own switch is judged from there, not from where we started.
   const altPrologue = (fromAlternateScreen: boolean): string =>
@@ -100,12 +125,17 @@ export function buildMainModelSnapshotReplayWrites(
       targetAlternateScreen: true,
       paneOnAlternateScreen: fromAlternateScreen
     })
-  if (!snapshot.alternateScreen) {
-    // Why the switch can be needed here: the gap can eat the TUI's own exit
-    // sequence, leaving the renderer on alt while the model moved to normal —
-    // the restored history would paint into the alt buffer, looking right while
-    // scrollback stays empty (STA-4042).
-    return abortGapBeforeFirstWrite([normalPrologue, snapshot.data])
+  // Why the switch can be needed here: the gap can eat the TUI's own exit
+  // sequence, leaving the renderer on alt while the model moved to normal —
+  // the restored history would paint into the alt buffer, looking right while
+  // scrollback stays empty (STA-4042). An image carrying its normal buffer
+  // enters alt itself, so it needs the same start.
+  const normalPreamble = buildSnapshotReplayPreamble({
+    targetAlternateScreen: false,
+    paneOnAlternateScreen
+  })
+  if (!snapshot.alternateScreen || snapshot.carriesNormalBuffer) {
+    return [normalPreamble, snapshot.data]
   }
   // Older snapshot producers do not expose the mode/frame boundary. Keep their
   // composed data rather than dropping terminal modes together with the frame.
@@ -117,14 +147,12 @@ export function buildMainModelSnapshotReplayWrites(
     // Why a prologue per payload: main serializes the buffers separately and
     // each is diffed against the baseline. scrollbackAnsi used to replay before
     // any reset at all, so the history inherited the stale state (STA-4042).
-    return abortGapBeforeFirstWrite([
-      normalPrologue,
-      snapshot.scrollbackAnsi,
-      altPrologue(false),
-      ...altFrame
-    ])
+    return [normalPreamble, snapshot.scrollbackAnsi, altPrologue(false), ...altFrame]
   }
   // Why the prologue clears: `?1049h` does not clear the alt buffer, so the
   // pre-hide frame would bleed through the snapshot's blank cells.
-  return abortGapBeforeFirstWrite([altPrologue(paneOnAlternateScreen), ...altFrame])
+  return [
+    buildSnapshotReplayPreamble({ targetAlternateScreen: true, paneOnAlternateScreen }),
+    ...altFrame
+  ]
 }
diff --git a/src/renderer/src/components/terminal-pane/use-terminal-pane-process-exit-actions.ts b/src/renderer/src/components/terminal-pane/use-terminal-pane-process-exit-actions.ts
index 0d3a8c5f382..f8c105bf971 100644
--- a/src/renderer/src/components/terminal-pane/use-terminal-pane-process-exit-actions.ts
+++ b/src/renderer/src/components/terminal-pane/use-terminal-pane-process-exit-actions.ts
@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useLayoutEffect } from 'react'
 import { useAppStore } from '../../store'
-import { CODEX_ACCOUNT_RESTART_STARTUP } from '@/lib/codex-session-restart'
+import { buildCodexAccountRestartStartup } from '@/lib/codex-account-restart-startup'
 import { makePaneKey } from '../../../../shared/stable-pane-id'
 import { connectPanePty } from './pty-connection'
 import { bindPanePtyId } from '@/lib/pane-manager/mobile-fit-overrides'
@@ -59,15 +59,22 @@ export function useTerminalPaneProcessExitActions(controller: TerminalPaneCloseC
   } = controller
 
   const handleRestartCodexPane = useCallback(
-    (
-      paneId: number,
-      restartStartup: PtyConnectionDeps['startup'] = CODEX_ACCOUNT_RESTART_STARTUP
-    ) => {
+    (paneId: number, restartStartup?: PtyConnectionDeps['startup']) => {
       const manager = managerRef.current
       const pane = manager?.getPanes().find((candidate) => candidate.id === paneId)
       if (!manager || !pane) {
         return
       }
+      const startup =
+        restartStartup ??
+        buildCodexAccountRestartStartup({
+          tabId,
+          worktreeId,
+          leafId: pane.leafId,
+          shellOverride: useAppStore
+            .getState()
+            .tabsByWorktree[worktreeId]?.find((tab) => tab.id === tabId)?.shellOverride
+        })
       const transport = paneTransportsRef.current.get(paneId)
       const panePtyBinding = panePtyBindingsRef.current.get(paneId)
       const existingPtyId = transport?.getPtyId()
@@ -88,7 +95,7 @@ export function useTerminalPaneProcessExitActions(controller: TerminalPaneCloseC
         tabId,
         worktreeId,
         cwd,
-        startup: restartStartup,
+        startup,
         ...(replacesPtyId ? { replacesPtyId } : {}),
         mountFollowsTerminalPark: false,
         paneTransportsRef,
diff --git a/src/renderer/src/components/ui/command.tsx b/src/renderer/src/components/ui/command.tsx
index 77b9946bed6..36a4898edef 100644
--- a/src/renderer/src/components/ui/command.tsx
+++ b/src/renderer/src/components/ui/command.tsx
@@ -7,6 +7,8 @@ import { SearchIcon } from 'lucide-react'
 import { Dialog as DialogPrimitive } from 'radix-ui'
 
 import { cn } from '@/lib/utils'
+import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
+import { useImeTextFieldProps } from '@/lib/ime-text-field'
 
 function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>) {
   return (
@@ -66,6 +68,7 @@ function CommandDialog({
             'fixed top-[20%] left-[50%] z-50 w-[660px] max-w-[90vw] translate-x-[-50%] rounded-lg border border-black/14 bg-background/96 text-foreground shadow-[0_20px_60px_rgba(0,0,0,0.28),inset_0_1px_0_rgba(255,255,255,0.08)] backdrop-blur-2xl outline-none dark:border-white/14 dark:bg-[rgba(23,23,23,0.96)] dark:shadow-[0_24px_72px_rgba(0,0,0,0.55),inset_0_1px_0_rgba(255,255,255,0.06)] data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95',
             contentClassName
           )}
+          onEscapeKeyDown={(event) => handleImeOverlayEscape(event)}
           onOpenAutoFocus={onOpenAutoFocus}
           onCloseAutoFocus={onCloseAutoFocus}
         >
@@ -102,6 +105,7 @@ function CommandInput({
   /** Rendered after the field, inside the input frame (e.g. a filter control). */
   trailing?: React.ReactNode
 }) {
+  const imeProps = useImeTextFieldProps<HTMLInputElement>(props)
   return (
     <div
       className={cn(
@@ -119,6 +123,7 @@ function CommandInput({
           className
         )}
         {...props}
+        {...imeProps}
       />
       {trailing}
     </div>
diff --git a/src/renderer/src/components/ui/context-menu.tsx b/src/renderer/src/components/ui/context-menu.tsx
index 5c574db1797..40fc7dd7bea 100644
--- a/src/renderer/src/components/ui/context-menu.tsx
+++ b/src/renderer/src/components/ui/context-menu.tsx
@@ -3,6 +3,7 @@ import { ChevronRightIcon, CircleIcon } from 'lucide-react'
 import { ContextMenu as ContextMenuPrimitive } from 'radix-ui'
 
 import { cn } from '@/lib/utils'
+import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
 
 function ContextMenu({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Root>) {
   return <ContextMenuPrimitive.Root data-slot="context-menu" modal={false} {...props} />
@@ -65,6 +66,7 @@ function ContextMenuSubContent({
         // overflow clipping does not hide the cascade on click/hover.
         style={{ ...style, WebkitAppRegion: 'no-drag' } as React.CSSProperties}
         {...props}
+        onEscapeKeyDown={(event) => handleImeOverlayEscape(event, props.onEscapeKeyDown)}
       />
     </ContextMenuPrimitive.Portal>
   )
@@ -87,6 +89,7 @@ function ContextMenuContent({
         // capture clicks at the OS level when menus overlap them.
         style={{ ...style, WebkitAppRegion: 'no-drag' } as React.CSSProperties}
         {...props}
+        onEscapeKeyDown={(event) => handleImeOverlayEscape(event, props.onEscapeKeyDown)}
       />
     </ContextMenuPrimitive.Portal>
   )
diff --git a/src/renderer/src/components/ui/dialog.tsx b/src/renderer/src/components/ui/dialog.tsx
index f4e85276b51..f996d91b1b6 100644
--- a/src/renderer/src/components/ui/dialog.tsx
+++ b/src/renderer/src/components/ui/dialog.tsx
@@ -5,6 +5,7 @@ import { XIcon } from 'lucide-react'
 import { Dialog as DialogPrimitive } from 'radix-ui'
 
 import { cn } from '@/lib/utils'
+import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
 import { Button } from '@/components/ui/button'
 import { translate } from '@/i18n/i18n'
 
@@ -71,6 +72,7 @@ function DialogContent({
           className
         )}
         {...props}
+        onEscapeKeyDown={(event) => handleImeOverlayEscape(event, props.onEscapeKeyDown)}
       >
         {children}
         {showCloseButton && (
diff --git a/src/renderer/src/components/ui/dropdown-menu.tsx b/src/renderer/src/components/ui/dropdown-menu.tsx
index b0e1d67a77c..7026c397c04 100644
--- a/src/renderer/src/components/ui/dropdown-menu.tsx
+++ b/src/renderer/src/components/ui/dropdown-menu.tsx
@@ -3,6 +3,7 @@ import { CheckIcon, ChevronRightIcon, CircleIcon } from 'lucide-react'
 import { DropdownMenu as DropdownMenuPrimitive } from 'radix-ui'
 
 import { cn } from '@/lib/utils'
+import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
 
 function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>) {
   return <DropdownMenuPrimitive.Root data-slot="dropdown-menu" {...props} />
@@ -40,6 +41,7 @@ function DropdownMenuContent({
         // dropdown menus that visually overlap the titlebar are unclickable.
         style={{ ...style, WebkitAppRegion: 'no-drag' } as React.CSSProperties}
         {...props}
+        onEscapeKeyDown={(event) => handleImeOverlayEscape(event, props.onEscapeKeyDown)}
       />
     </DropdownMenuPrimitive.Portal>
   )
@@ -218,6 +220,7 @@ function DropdownMenuSubContent({
         // would otherwise capture clicks when submenu overlaps it.
         style={{ ...style, WebkitAppRegion: 'no-drag' } as React.CSSProperties}
         {...props}
+        onEscapeKeyDown={(event) => handleImeOverlayEscape(event, props.onEscapeKeyDown)}
       />
     </DropdownMenuPrimitive.Portal>
   )
diff --git a/src/renderer/src/components/ui/input.tsx b/src/renderer/src/components/ui/input.tsx
index 1d2d7b5dcfb..3acf54323d6 100644
--- a/src/renderer/src/components/ui/input.tsx
+++ b/src/renderer/src/components/ui/input.tsx
@@ -1,11 +1,12 @@
 import * as React from 'react'
 
 import { cn } from '@/lib/utils'
+import { ImeInput } from '@/lib/ime-text-field'
 
 const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<'input'>>(
   ({ className, type, ...props }, ref) => {
     return (
-      <input
+      <ImeInput
         ref={ref}
         type={type}
         data-slot="input"
diff --git a/src/renderer/src/components/ui/popover.tsx b/src/renderer/src/components/ui/popover.tsx
index 0362e7c63ab..1652805a59b 100644
--- a/src/renderer/src/components/ui/popover.tsx
+++ b/src/renderer/src/components/ui/popover.tsx
@@ -4,6 +4,7 @@ import * as React from 'react'
 import { Popover as PopoverPrimitive } from 'radix-ui'
 
 import { cn } from '@/lib/utils'
+import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
 
 // React delegates wheel passively, so native defaultPrevented may not reflect synthetic cancellation.
 const consumerPreventedWheelEvents = new WeakSet<WheelEvent>()
@@ -187,6 +188,7 @@ function PopoverContent({
         onWheel={handleConsumerWheel}
         onWheelCapture={handleConsumerWheelCapture}
         {...props}
+        onEscapeKeyDown={(event) => handleImeOverlayEscape(event, props.onEscapeKeyDown)}
       />
     </PopoverPrimitive.Portal>
   )
diff --git a/src/renderer/src/components/ui/sheet.tsx b/src/renderer/src/components/ui/sheet.tsx
index 24f5dfcebe5..26199a56a33 100644
--- a/src/renderer/src/components/ui/sheet.tsx
+++ b/src/renderer/src/components/ui/sheet.tsx
@@ -6,6 +6,7 @@ import { Dialog as SheetPrimitive } from 'radix-ui'
 import { cva, type VariantProps } from 'class-variance-authority'
 
 import { cn } from '@/lib/utils'
+import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
 import { translate } from '@/i18n/i18n'
 
 function Sheet({ ...props }: React.ComponentProps<typeof SheetPrimitive.Root>) {
@@ -92,6 +93,7 @@ function SheetContent({
         // document root and its header overlaps the titlebar drag strip.
         style={{ ...style, WebkitAppRegion: 'no-drag' } as React.CSSProperties}
         {...props}
+        onEscapeKeyDown={(event) => handleImeOverlayEscape(event, props.onEscapeKeyDown)}
       >
         {children}
         {showCloseButton && (
diff --git a/src/renderer/src/components/ui/textarea.tsx b/src/renderer/src/components/ui/textarea.tsx
index 10344a85248..18014b3fd76 100644
--- a/src/renderer/src/components/ui/textarea.tsx
+++ b/src/renderer/src/components/ui/textarea.tsx
@@ -2,9 +2,16 @@ import * as React from 'react'
 import { cva, type VariantProps } from 'class-variance-authority'
 
 import { cn } from '@/lib/utils'
+import { ImeTextarea } from '@/lib/ime-text-field'
 
 const textareaVariants = cva('', {
-  variants: { variant: { default: '', code: 'font-mono' } },
+  variants: {
+    variant: {
+      default: '',
+      code: 'font-mono',
+      cell: 'h-full min-h-0 resize-none rounded-none border-0 px-2 py-0 font-mono text-xs shadow-none md:text-xs focus-visible:ring-1 focus-visible:ring-inset'
+    }
+  },
   defaultVariants: { variant: 'default' }
 })
 
@@ -13,7 +20,7 @@ const Textarea = React.forwardRef<
   React.ComponentProps<'textarea'> & VariantProps<typeof textareaVariants>
 >(({ className, variant, ...props }, ref) => {
   return (
-    <textarea
+    <ImeTextarea
       ref={ref}
       data-slot="textarea"
       // Why scrollbar-sleek here: a textarea scrolls without an overflow class,
diff --git a/src/renderer/src/components/use-jira-create-assignee.test.tsx b/src/renderer/src/components/use-jira-create-assignee.test.tsx
new file mode 100644
index 00000000000..aa67a7d46ab
--- /dev/null
+++ b/src/renderer/src/components/use-jira-create-assignee.test.tsx
@@ -0,0 +1,42 @@
+// @vitest-environment happy-dom
+import { act, renderHook } from '@testing-library/react'
+import { describe, expect, it } from 'vitest'
+import { useJiraCreateAssignee } from './use-jira-create-assignee'
+
+const user = { accountId: 'account-a', displayName: 'Ada' }
+
+describe('useJiraCreateAssignee', () => {
+  it('clears the selection when a site filter implicitly changes the target project', () => {
+    const { result, rerender } = renderHook(
+      ({ project }) => useJiraCreateAssignee('local', project),
+      { initialProps: { project: 'site-a::100' } }
+    )
+    act(() => result.current.setNewJiraIssueAssignee(user))
+    const staleSelect = result.current.setNewJiraIssueAssignee
+    rerender({ project: 'site-b::100' })
+    expect(result.current.newJiraIssueAssignee).toBeNull()
+    act(() => staleSelect(user))
+    expect(result.current.newJiraIssueAssignee).toBeNull()
+    rerender({ project: 'site-a::100' })
+    expect(result.current.newJiraIssueAssignee).toBeNull()
+  })
+
+  it('clears across providers even when the dialog was closed', () => {
+    const { result, rerender } = renderHook(
+      ({ provider }) => useJiraCreateAssignee(provider, 'site-a::100'),
+      { initialProps: { provider: 'local' } }
+    )
+    act(() => result.current.setNewJiraIssueAssignee(user))
+    rerender({ provider: 'runtime:remote' })
+    expect(result.current.newJiraIssueAssignee).toBeNull()
+  })
+
+  it('retains the assignee across unrelated renders and supports Automatic', () => {
+    const { result, rerender } = renderHook(() => useJiraCreateAssignee('local', 'site-a::100'))
+    act(() => result.current.setNewJiraIssueAssignee(user))
+    rerender()
+    expect(result.current.newJiraIssueAssignee).toEqual(user)
+    act(() => result.current.setNewJiraIssueAssignee(null))
+    expect(result.current.newJiraIssueAssignee).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/use-jira-create-assignee.ts b/src/renderer/src/components/use-jira-create-assignee.ts
new file mode 100644
index 00000000000..e7565fe2709
--- /dev/null
+++ b/src/renderer/src/components/use-jira-create-assignee.ts
@@ -0,0 +1,23 @@
+import { useCallback, useState } from 'react'
+import type { JiraUser } from '../../../shared/jira-types'
+
+export function useJiraCreateAssignee(providerKey: string, projectKey: string) {
+  const scope = JSON.stringify([providerKey, projectKey])
+  const [selection, setSelection] = useState<{ scope: string; user: JiraUser | null }>({
+    scope,
+    user: null
+  })
+  // Reset during render so an implicit project change cannot submit the previous site's user.
+  if (selection.scope !== scope) {
+    setSelection({ scope, user: null })
+  }
+  const setNewJiraIssueAssignee = useCallback(
+    (user: JiraUser | null) =>
+      setSelection((current) => (current.scope === scope ? { scope, user } : current)),
+    [scope]
+  )
+  return {
+    newJiraIssueAssignee: selection.scope === scope ? selection.user : null,
+    setNewJiraIssueAssignee
+  }
+}
diff --git a/src/renderer/src/components/use-task-page-jira-creation-projects.ts b/src/renderer/src/components/use-task-page-jira-creation-projects.ts
index 1e8ac8992a7..8c4a6522ba7 100644
--- a/src/renderer/src/components/use-task-page-jira-creation-projects.ts
+++ b/src/renderer/src/components/use-task-page-jira-creation-projects.ts
@@ -1,3 +1,4 @@
+import { useJiraCreateAssignee } from './use-jira-create-assignee'
 import React, { useCallback, useEffect, useMemo } from 'react'
 
 import { filterJiraProjectPickerProjects } from '@/components/jira-project-picker-filter'
@@ -54,6 +55,10 @@ export function useTaskPageJiraCreationProjects(model: TaskPageJiraCreationState
   const newJiraIssueTargetProjectSelectionKey = newJiraIssueTargetProject
     ? getJiraProjectSelectionKey(newJiraIssueTargetProject)
     : ''
+  const { newJiraIssueAssignee, setNewJiraIssueAssignee } = useJiraCreateAssignee(
+    model.providerRuntimeContextKey,
+    newJiraIssueTargetProjectSelectionKey
+  )
   const newJiraIssueTargetType = useMemo(
     () =>
       availableJiraIssueTypes.find((issueType) => issueType.id === newJiraIssueTypeId) ??
@@ -173,7 +178,7 @@ export function useTaskPageJiraCreationProjects(model: TaskPageJiraCreationState
     handleNewJiraIssueProjectComboboxOpenChange
   nextModel.handleNewJiraIssueProjectSelect = handleNewJiraIssueProjectSelect
   nextModel.handleNewJiraIssueProjectTriggerKeyDown = handleNewJiraIssueProjectTriggerKeyDown
-  return nextModel
+  return Object.assign(nextModel, { newJiraIssueAssignee, setNewJiraIssueAssignee })
 }
 
 export type TaskPageJiraCreationProjectsModel = ReturnType<typeof useTaskPageJiraCreationProjects>
diff --git a/src/renderer/src/components/use-task-page-jira-issue-creation.ts b/src/renderer/src/components/use-task-page-jira-issue-creation.ts
index c1760e1c11d..af8ce0f7156 100644
--- a/src/renderer/src/components/use-task-page-jira-issue-creation.ts
+++ b/src/renderer/src/components/use-task-page-jira-issue-creation.ts
@@ -1,6 +1,9 @@
 import type { TaskPageLinearIssueCreationModel } from './use-task-page-linear-issue-creation'
 import { useCallback } from 'react'
-import { buildJiraCreateCustomFields } from '@/components/task-page-jira-create-fields'
+import {
+  buildJiraCreateSubmission,
+  hasJiraAssigneeCreateField
+} from '@/components/task-page-jira-create-fields'
 import { jiraCreateIssue, jiraGetIssue } from '@/runtime/runtime-jira-client'
 import { toast } from 'sonner'
 import { translate } from '@/i18n/i18n'
@@ -20,9 +23,12 @@ export function useTaskPageJiraIssueCreation(model: TaskPageLinearIssueCreationM
     setNewJiraIssueBody,
     newJiraIssueSubmitting,
     setNewJiraIssueSubmitting,
+    jiraCreateFields,
     jiraCreateFieldsLoading,
     newJiraIssueCustomFieldValues,
     setNewJiraIssueCustomFieldValues,
+    newJiraIssueAssignee,
+    setNewJiraIssueAssignee,
     discardNewJiraIssueDraft,
     newJiraIssueTargetProject,
     newJiraIssueTargetType,
@@ -37,9 +43,12 @@ export function useTaskPageJiraIssueCreation(model: TaskPageLinearIssueCreationM
     if (!title || newJiraIssueSubmitting || hasMissingJiraCreateField || jiraCreateFieldsLoading) {
       return
     }
-    const customFields = buildJiraCreateCustomFields(
+    const { customFields, userFieldKeys } = buildJiraCreateSubmission(
       visibleJiraCreateFields,
-      newJiraIssueCustomFieldValues
+      newJiraIssueCustomFieldValues,
+      // Why: Jira rejects creates that set a field absent from the create
+      // screen, so a picked assignee only ships when the screen accepts one.
+      hasJiraAssigneeCreateField(jiraCreateFields) ? newJiraIssueAssignee?.accountId : undefined
     )
     setNewJiraIssueSubmitting(true)
     const submitProviderRuntimeContextKey = providerRuntimeContextKey
@@ -50,7 +59,8 @@ export function useTaskPageJiraIssueCreation(model: TaskPageLinearIssueCreationM
         issueTypeId: newJiraIssueTargetType.id,
         title,
         description: newJiraIssueBody || undefined,
-        customFields
+        customFields,
+        userFieldKeys
       })
       if (submitProviderRuntimeContextKey !== providerRuntimeContextKeyRef.current) {
         return
@@ -80,6 +90,7 @@ export function useTaskPageJiraIssueCreation(model: TaskPageLinearIssueCreationM
       setNewJiraIssueTitle('')
       setNewJiraIssueBody('')
       setNewJiraIssueCustomFieldValues({})
+      setNewJiraIssueAssignee(null)
       setJiraRefreshNonce((n) => n + 1)
       void jiraGetIssue(
         jiraTaskSourceContext ?? settings,
@@ -112,7 +123,9 @@ export function useTaskPageJiraIssueCreation(model: TaskPageLinearIssueCreationM
     }
   }, [
     hasMissingJiraCreateField,
+    jiraCreateFields,
     jiraCreateFieldsLoading,
+    newJiraIssueAssignee,
     newJiraIssueBody,
     newJiraIssueCustomFieldValues,
     newJiraIssueSubmitting,
@@ -132,6 +145,7 @@ export function useTaskPageJiraIssueCreation(model: TaskPageLinearIssueCreationM
     setNewJiraIssueTitle,
     setNewJiraIssueBody,
     setNewJiraIssueCustomFieldValues,
+    setNewJiraIssueAssignee,
     setNewJiraIssueSubmitting
   ])
   const nextModel = model as typeof model & {
diff --git a/src/renderer/src/components/use-terminal-create-actions.ts b/src/renderer/src/components/use-terminal-create-actions.ts
index c67f7a664f3..43b0cada390 100644
--- a/src/renderer/src/components/use-terminal-create-actions.ts
+++ b/src/renderer/src/components/use-terminal-create-actions.ts
@@ -10,6 +10,7 @@ import {
 } from '@/runtime/web-runtime-session'
 import { openMobileEmulatorTab } from '@/lib/open-mobile-emulator-tab'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { buildDuplicatedBrowserTabOptions } from '@/lib/duplicate-browser-tab-options'
 import { browserWorkspaceHasRemoteOwner } from '@/runtime/remote-browser-tab-ownership'
 import { getClientCreationActionPolicy } from '@/lib/client-creation-action-policy'
@@ -96,6 +97,7 @@ export function useTerminalCreateActions(controller: TerminalColdActivationContr
         state.activeGroupIdByWorktree[activeWorktreeId] ??
         state.groupsByWorktree[activeWorktreeId]?.[0]?.id
       const result = launchAgentInNewTab({
+        requestId: newAgentLaunchRequestId(),
         agent,
         worktreeId: activeWorktreeId,
         groupId: targetGroupId,
diff --git a/src/renderer/src/hooks/composer-state/attachment-drop-failure.test.tsx b/src/renderer/src/hooks/composer-state/attachment-drop-failure.test.tsx
index 9b72a3d0dba..31900f8202d 100644
--- a/src/renderer/src/hooks/composer-state/attachment-drop-failure.test.tsx
+++ b/src/renderer/src/hooks/composer-state/attachment-drop-failure.test.tsx
@@ -31,7 +31,6 @@ function installFsApi(): void {
   Object.assign(window, {
     api: {
       fs: {
-        authorizeExternalPath: vi.fn(async () => {}),
         stat: vi.fn(async ({ filePath }: { filePath: string }) => {
           if (FAILING_PATHS.has(filePath)) {
             throw new Error(
diff --git a/src/renderer/src/hooks/composer-state/attachment-drop-lifetime.test.tsx b/src/renderer/src/hooks/composer-state/attachment-drop-lifetime.test.tsx
index 577d7c1fdf1..6709b5e76f3 100644
--- a/src/renderer/src/hooks/composer-state/attachment-drop-lifetime.test.tsx
+++ b/src/renderer/src/hooks/composer-state/attachment-drop-lifetime.test.tsx
@@ -12,7 +12,6 @@ vi.mock('@/store', () => ({ useAppStore: { getState: () => ({}) } }))
 vi.mock('@/runtime/runtime-file-client', () => ({ importExternalPathsToRuntime: vi.fn() }))
 
 const listeners = new Set<(data: NativeFileDropPayload) => void>()
-const authorize = vi.fn(async (_input: { targetPath: string }) => {})
 const stat = vi.fn(async (_input: { filePath: string }) => ({ isDirectory: false }))
 let originalApi: PropertyDescriptor | undefined
 
@@ -45,13 +44,12 @@ function nativeDrop(paths: string[]): void {
 
 beforeEach(() => {
   vi.clearAllMocks()
-  authorize.mockReset().mockResolvedValue(undefined)
   stat.mockReset().mockResolvedValue({ isDirectory: false })
   originalApi = Object.getOwnPropertyDescriptor(window, 'api')
   Object.defineProperty(window, 'api', {
     configurable: true,
     value: {
-      fs: { authorizeExternalPath: authorize, stat },
+      fs: { stat },
       ui: {
         onFileDrop: (listener: (data: NativeFileDropPayload) => void) => {
           listeners.add(listener)
@@ -72,61 +70,45 @@ afterEach(() => {
   }
 })
 
+function holdStat(gate: Promise<void>): void {
+  stat.mockImplementationOnce(async () => {
+    await gate
+    return { isDirectory: false }
+  })
+}
+
 describe('local composer drop lifetime', () => {
-  it.each(['authorize', 'stat'] as const)(
-    'stops a large batch after unmount during %s',
-    async (phase) => {
-      const gate = Promise.withResolvers<void>()
-      if (phase === 'authorize') {
-        authorize.mockImplementationOnce(() => gate.promise)
-      } else {
-        stat.mockImplementationOnce(async () => {
-          await gate.promise
-          return { isDirectory: false }
-        })
-      }
-      const hook = renderDrop()
-      const paths = Array.from({ length: 1000 }, (_, index) => `/drop/item-${index}`)
-      const pending = hook.result.current.applyLocalComposerDrop(paths)
-      await vi.waitFor(() =>
-        expect(phase === 'authorize' ? authorize : stat).toHaveBeenCalledOnce()
-      )
-      hook.unmount()
-      gate.resolve()
-      await pending
+  it('stops a large batch after unmount during a file check', async () => {
+    const gate = Promise.withResolvers<void>()
+    holdStat(gate.promise)
+    const hook = renderDrop()
+    const paths = Array.from({ length: 1000 }, (_, index) => `/drop/item-${index}`)
+    const pending = hook.result.current.applyLocalComposerDrop(paths)
+    await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
+    hook.unmount()
+    gate.resolve()
+    await pending
 
-      expect(authorize).toHaveBeenCalledOnce()
-      expect(stat).toHaveBeenCalledTimes(phase === 'authorize' ? 0 : 1)
-      expect(hook.attach).not.toHaveBeenCalled()
-      expect(hook.prompt).not.toHaveBeenCalled()
-      expect(mocks.toastError).not.toHaveBeenCalled()
-    }
-  )
+    expect(stat).toHaveBeenCalledOnce()
+    expect(hook.attach).not.toHaveBeenCalled()
+    expect(hook.prompt).not.toHaveBeenCalled()
+    expect(mocks.toastError).not.toHaveBeenCalled()
+  })
 
-  it.each(['authorize', 'stat'] as const)(
-    'stops silently when a held %s fails after unmount',
-    async (phase) => {
-      const gate = Promise.withResolvers<never>()
-      if (phase === 'authorize') {
-        authorize.mockImplementationOnce(() => gate.promise)
-      } else {
-        stat.mockImplementationOnce(() => gate.promise)
-      }
-      const hook = renderDrop()
-      const pending = hook.result.current.applyLocalComposerDrop(['/drop/one', '/drop/two'])
-      await vi.waitFor(() =>
-        expect(phase === 'authorize' ? authorize : stat).toHaveBeenCalledOnce()
-      )
-      hook.unmount()
-      gate.reject(new Error('EACCES: no access'))
-      await pending
+  it('stops silently when a held file check fails after unmount', async () => {
+    const gate = Promise.withResolvers<never>()
+    stat.mockImplementationOnce(() => gate.promise)
+    const hook = renderDrop()
+    const pending = hook.result.current.applyLocalComposerDrop(['/drop/one', '/drop/two'])
+    await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
+    hook.unmount()
+    gate.reject(new Error('EACCES: no access'))
+    await pending
 
-      expect(authorize).toHaveBeenCalledOnce()
-      expect(stat).toHaveBeenCalledTimes(phase === 'authorize' ? 0 : 1)
-      expect(hook.attach).not.toHaveBeenCalled()
-      expect(mocks.toastError).not.toHaveBeenCalled()
-    }
-  )
+    expect(stat).toHaveBeenCalledOnce()
+    expect(hook.attach).not.toHaveBeenCalled()
+    expect(mocks.toastError).not.toHaveBeenCalled()
+  })
 
   it('does no work through a callback saved before unmount', async () => {
     const hook = renderDrop()
@@ -134,18 +116,14 @@ describe('local composer drop lifetime', () => {
     hook.unmount()
     await applyDrop(['/drop/late'])
 
-    expect(authorize).not.toHaveBeenCalled()
     expect(stat).not.toHaveBeenCalled()
     expect(hook.attach).not.toHaveBeenCalled()
   })
 
-  it('preserves mixed results, order, duplicate filtering and one failure report', async () => {
+  it('checks each dropped path as user-named, keeping results, order and one failure report', async () => {
     const order: string[] = []
-    authorize.mockImplementation(async ({ targetPath }) => {
-      order.push(`authorize:${targetPath}`)
-    })
     stat.mockImplementation(async ({ filePath }) => {
-      order.push(`stat:${filePath}`)
+      order.push(filePath)
       if (filePath === '/drop/missing') {
         throw new Error('ENOENT: missing')
       }
@@ -155,7 +133,8 @@ describe('local composer drop lifetime', () => {
     const paths = ['/drop/one', '/drop/folder', '/drop/missing', '/drop/two', '/drop/one']
     await hook.result.current.applyLocalComposerDrop(paths)
 
-    expect(order).toEqual(paths.flatMap((path) => [`authorize:${path}`, `stat:${path}`]))
+    expect(order).toEqual(paths)
+    expect(stat).toHaveBeenCalledWith({ filePath: '/drop/one', access: { kind: 'user-file' } })
     expect(hook.attach).toHaveBeenCalledOnce()
     expect(hook.attach.mock.calls[0]?.[0](['/existing'])).toEqual([
       '/existing',
@@ -175,16 +154,15 @@ describe('native composer ownership during a local drop', () => {
     'stops after actual listener cleanup (Strict Mode: %s)',
     async (strict) => {
       const gate = Promise.withResolvers<void>()
-      authorize.mockImplementationOnce(() => gate.promise)
+      holdStat(gate.promise)
       const hook = renderDrop(strict)
       act(() => nativeDrop(['/drop/one', '/drop/two']))
-      await vi.waitFor(() => expect(authorize).toHaveBeenCalledOnce())
+      await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
       hook.unmount()
       expect(listeners.size).toBe(0)
       await act(async () => gate.resolve())
 
-      expect(authorize).toHaveBeenCalledOnce()
-      expect(stat).not.toHaveBeenCalled()
+      expect(stat).toHaveBeenCalledOnce()
       expect(hook.attach).not.toHaveBeenCalled()
     }
   )
@@ -192,16 +170,14 @@ describe('native composer ownership during a local drop', () => {
   it('continues while temporarily covered and applies if ownership returns', async () => {
     const first = Promise.withResolvers<void>()
     const second = Promise.withResolvers<void>()
-    authorize
-      .mockImplementationOnce(() => first.promise)
-      .mockImplementationOnce(() => second.promise)
+    holdStat(first.promise)
+    holdStat(second.promise)
     const older = renderDrop()
     act(() => nativeDrop(['/drop/one', '/drop/two']))
-    await vi.waitFor(() => expect(authorize).toHaveBeenCalledOnce())
+    await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
     const newer = renderDrop()
     await act(async () => first.resolve())
-    expect(authorize).toHaveBeenCalledTimes(2)
-    expect(stat).toHaveBeenCalledOnce()
+    expect(stat).toHaveBeenCalledTimes(2)
     expect(older.attach).not.toHaveBeenCalled()
     newer.unmount()
     await act(async () => second.resolve())
@@ -212,14 +188,13 @@ describe('native composer ownership during a local drop', () => {
 
   it('withholds a completed drop while a newer owner remains mounted', async () => {
     const gate = Promise.withResolvers<void>()
-    authorize.mockImplementationOnce(() => gate.promise)
+    holdStat(gate.promise)
     const older = renderDrop()
     act(() => nativeDrop(['/drop/one', '/drop/two']))
-    await vi.waitFor(() => expect(authorize).toHaveBeenCalledOnce())
+    await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
     const newer = renderDrop()
     await act(async () => gate.resolve())
 
-    expect(authorize).toHaveBeenCalledTimes(2)
     expect(stat).toHaveBeenCalledTimes(2)
     expect(older.attach).not.toHaveBeenCalled()
     expect(newer.attach).not.toHaveBeenCalled()
@@ -227,10 +202,10 @@ describe('native composer ownership during a local drop', () => {
 
   it('does not revive an old batch when another composer mounts', async () => {
     const gate = Promise.withResolvers<void>()
-    authorize.mockImplementationOnce(() => gate.promise)
+    holdStat(gate.promise)
     const older = renderDrop()
     act(() => nativeDrop(['/drop/old-one', '/drop/old-two']))
-    await vi.waitFor(() => expect(authorize).toHaveBeenCalledOnce())
+    await vi.waitFor(() => expect(stat).toHaveBeenCalledOnce())
     older.unmount()
     const newer = renderDrop()
     await act(async () => {
@@ -238,11 +213,7 @@ describe('native composer ownership during a local drop', () => {
       gate.resolve()
     })
 
-    expect(authorize.mock.calls.map(([input]) => input.targetPath)).toEqual([
-      '/drop/old-one',
-      '/drop/new'
-    ])
-    expect(stat.mock.calls.map(([input]) => input.filePath)).toEqual(['/drop/new'])
+    expect(stat.mock.calls.map(([input]) => input.filePath)).toEqual(['/drop/old-one', '/drop/new'])
     expect(older.attach).not.toHaveBeenCalled()
     expect(newer.attach).toHaveBeenCalledOnce()
   })
diff --git a/src/renderer/src/hooks/composer-state/attachment-drop-state.ts b/src/renderer/src/hooks/composer-state/attachment-drop-state.ts
index 03d1f15dc24..3358a7e028e 100644
--- a/src/renderer/src/hooks/composer-state/attachment-drop-state.ts
+++ b/src/renderer/src/hooks/composer-state/attachment-drop-state.ts
@@ -30,6 +30,7 @@ import {
 import { applyComposerNativeFileDrop } from '../composer-native-file-drop'
 import { useMountedRef } from '../useMountedRef'
 import { useComposerDropListener } from './composer-drop-listener'
+import { userNamedFileAccess } from '@/lib/local-file-access'
 
 // Local drops bypass the runtime importer's skip classification.
 function localDropFailure(detail: string | undefined): ComposerDropFailure {
@@ -220,11 +221,7 @@ export function useAttachmentDropState(input: AttachmentDropStateInput) {
           return
         }
         try {
-          await window.api.fs.authorizeExternalPath({ targetPath: filePath })
-          if (!mountedRef.current) {
-            return
-          }
-          const stat = await window.api.fs.stat({ filePath })
+          const stat = await window.api.fs.stat({ filePath, access: userNamedFileAccess() })
           results.push({
             status: 'imported',
             destPath: filePath,
diff --git a/src/renderer/src/hooks/composer-state/composer-submit-model.ts b/src/renderer/src/hooks/composer-state/composer-submit-model.ts
index 9ae5fcf6826..7d75d60782d 100644
--- a/src/renderer/src/hooks/composer-state/composer-submit-model.ts
+++ b/src/renderer/src/hooks/composer-state/composer-submit-model.ts
@@ -66,7 +66,7 @@ export type QuickSubmitSource = {
 
 export type PreparedQuickSubmit = QuickSubmitSource & {
   effectiveSetupDecision: SetupDecision
-  issueCommand: WorktreeCreationRequest['issueCommand']
+  hookPreparation: WorktreeCreationRequest['hookPreparation']
   linkedLinearIssue: string | undefined
   linkedLinearIssueWorkspaceId: string | undefined
   linkedLinearIssueOrganizationUrlKey: string | undefined
diff --git a/src/renderer/src/hooks/composer-state/composer-submit-orchestration.ts b/src/renderer/src/hooks/composer-state/composer-submit-orchestration.ts
index 83fd13e7811..13cf2c225f2 100644
--- a/src/renderer/src/hooks/composer-state/composer-submit-orchestration.ts
+++ b/src/renderer/src/hooks/composer-state/composer-submit-orchestration.ts
@@ -181,7 +181,6 @@ export function useComposerSubmitOrchestration(
     selectedRepoHookContextKey: target.runtimeTargetSelection.selectedRepoHookContextKey,
     selectedRepoIsGit: target.runtimeTargetSelection.selectedRepoIsGit,
     setAdvancedOpen: target.asyncComposerState.setAdvancedOpen,
-    setLoadedIssueCommand: target.asyncComposerState.setLoadedIssueCommand,
     settings: target.composerTargetStore.settings,
     setupConfig: target.derivedComposerState.setupConfig,
     setupDecision: target.asyncComposerState.setupDecision,
diff --git a/src/renderer/src/hooks/composer-state/full-creation-execution.ts b/src/renderer/src/hooks/composer-state/full-creation-execution.ts
index 14230fde43a..53e632dbb0a 100644
--- a/src/renderer/src/hooks/composer-state/full-creation-execution.ts
+++ b/src/renderer/src/hooks/composer-state/full-creation-execution.ts
@@ -38,6 +38,7 @@ import { seedNativeChatAppliedSessionOptions } from '@/components/native-chat/na
 import { queueWorkspaceActivationTerminalFocus } from '@/lib/workspace-activation-terminal-focus'
 import { useAppStore } from '@/store'
 import { planAgentSessionLaunch } from '@/lib/agent-session-launch-plan'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { beginFullCreationStructuredLaunch } from './full-creation-structured-launch'
 import { finalizeFullCreation } from './full-creation-finalization'
 import { buildFullCreationIssueCommand } from './full-creation-issue-command'
@@ -130,6 +131,7 @@ export function useFullCreationExecution(input: FullCreationExecutionInput) {
       }
 
       const launchPlan = planAgentSessionLaunch(useAppStore.getState(), {
+        requestId: newAgentLaunchRequestId(),
         agent: tuiAgent,
         workspace: {
           kind: selectedRepoIsGit ? 'git-worktree' : 'folder',
diff --git a/src/renderer/src/hooks/composer-state/quick-creation-execution.ts b/src/renderer/src/hooks/composer-state/quick-creation-execution.ts
index 324bf694025..554571dc631 100644
--- a/src/renderer/src/hooks/composer-state/quick-creation-execution.ts
+++ b/src/renderer/src/hooks/composer-state/quick-creation-execution.ts
@@ -38,7 +38,6 @@ import type { TuiAgent } from '../../../../shared/tui-agent'
 import type { WorktreeCreationRequest } from '@/lib/pending-worktree-creation'
 import { useAppStore } from '@/store'
 import { settleComposerSubmit } from '@/lib/composer-submit-cancellation'
-import { ensureHooksConfirmed } from '@/lib/ensure-hooks-confirmed'
 import { getActiveRuntimeTarget } from '@/runtime/runtime-rpc-client'
 import { runBackgroundWorktreeCreation } from '@/lib/worktree-creation-flow'
 import { translate } from '@/i18n/i18n'
@@ -46,7 +45,7 @@ import { resolveQuickCreateLinkedWorkItemPrompt } from '@/lib/linked-work-item-c
 import { buildQuickComposerStartup } from './quick-startup-plan'
 import { buildQuickCreationRequest } from './quick-creation-request'
 import type { PendingSmartGitHubSubmitResolution } from './source-selection-decisions'
-import { planAgentSessionLaunch } from '@/lib/agent-session-launch-plan'
+import { resolveAgentSessionLaunchRoute } from '@/lib/agent-session-launch-plan'
 
 export function useQuickCreationExecution(input: QuickCreationExecutionInput) {
   const {
@@ -110,7 +109,7 @@ export function useQuickCreationExecution(input: QuickCreationExecutionInput) {
         submitCompareBaseRef,
         submitPushTarget,
         effectiveSetupDecision,
-        issueCommand,
+        hookPreparation,
         linkedLinearIssue,
         linkedLinearIssueWorkspaceId,
         linkedLinearIssueOrganizationUrlKey,
@@ -165,24 +164,6 @@ export function useQuickCreationExecution(input: QuickCreationExecutionInput) {
       const activeEphemeralVmRecipeId = ephemeralVmsEnabled ? selectedEphemeralVmRecipeId : null
 
       if (activeEphemeralVmRecipeId && selectedWorkspaceTarget.status === 'ready') {
-        const vmRecipeTrustSettlement = await settleComposerSubmit(
-          ensureHooksConfirmed(
-            useAppStore.getState(),
-            repoId,
-            'vmRecipe',
-            selectedRepoExecutionHostId ?? undefined,
-            undefined,
-            isSubmissionCancelled
-          ),
-          isSubmissionCancelled
-        )
-        if (vmRecipeTrustSettlement.status === 'cancelled') {
-          return
-        }
-        const vmRecipeTrustDecision = vmRecipeTrustSettlement.value
-        if (vmRecipeTrustDecision === 'skip') {
-          return
-        }
         const selectedRecipe = ephemeralVmRecipes.find(
           (recipe) => recipe.id === activeEphemeralVmRecipeId
         )
@@ -197,7 +178,7 @@ export function useQuickCreationExecution(input: QuickCreationExecutionInput) {
       const promptDelivery = quickDraftPrompt ? 'draft' : 'auto-submit'
       // Why: the verdict is persisted on the request as data and re-entered once the worktree exists.
       const agentLaunchRoute = agent
-        ? planAgentSessionLaunch(useAppStore.getState(), {
+        ? resolveAgentSessionLaunchRoute(useAppStore.getState(), {
             agent,
             workspace: {
               kind: selectedRepoIsGit ? 'git-worktree' : 'folder',
@@ -209,7 +190,7 @@ export function useQuickCreationExecution(input: QuickCreationExecutionInput) {
             prompt: quickDraftPrompt ?? quickPrompt,
             promptDelivery,
             initialSessionOptions: startupPlan?.sessionOptions
-          }).route
+          })
         : 'terminal-tui'
       const structuredLaunch = agentLaunchRoute === 'structured-native-chat'
 
@@ -248,7 +229,13 @@ export function useQuickCreationExecution(input: QuickCreationExecutionInput) {
         linkedGitLabIssue,
         includeGitLabLinks: smartGitHubResolution.kind === 'none',
         startup: structuredLaunch ? undefined : backendStartup,
-        issueCommand,
+        hookPreparation: ephemeralVmRecipe
+          ? {
+              ...hookPreparation,
+              executionHostId: selectedRepoExecutionHostId ?? undefined,
+              confirmVmRecipe: true
+            }
+          : hookPreparation,
         pendingFirstAgentMessageRename,
         note: trimmedNote,
         startupPlan,
diff --git a/src/renderer/src/hooks/composer-state/quick-creation-request.ts b/src/renderer/src/hooks/composer-state/quick-creation-request.ts
index da7fa8cec11..73ecb8a0f71 100644
--- a/src/renderer/src/hooks/composer-state/quick-creation-request.ts
+++ b/src/renderer/src/hooks/composer-state/quick-creation-request.ts
@@ -41,7 +41,8 @@ export type QuickCreationRequestInput = {
   linkedGitLabIssue: number | null
   includeGitLabLinks: boolean
   startup: WorktreeCreationRequest['startup']
-  issueCommand: WorktreeCreationRequest['issueCommand']
+  issueCommand?: WorktreeCreationRequest['issueCommand']
+  hookPreparation?: WorktreeCreationRequest['hookPreparation']
   pendingFirstAgentMessageRename: boolean
   note: string
   startupPlan: AgentStartupPlan | null
@@ -103,6 +104,7 @@ export function buildQuickCreationRequest(
       ? { linkedGitLabIssue: input.linkedGitLabIssue }
       : {}),
     ...(input.startup ? { startup: input.startup } : {}),
+    ...(input.hookPreparation ? { hookPreparation: input.hookPreparation } : {}),
     ...(input.issueCommand ? { issueCommand: input.issueCommand } : {}),
     pendingFirstAgentMessageRename: input.pendingFirstAgentMessageRename,
     note: input.note,
diff --git a/src/renderer/src/hooks/composer-state/quick-submit-input-contract.ts b/src/renderer/src/hooks/composer-state/quick-submit-input-contract.ts
index b924fccce07..d9bd86d8106 100644
--- a/src/renderer/src/hooks/composer-state/quick-submit-input-contract.ts
+++ b/src/renderer/src/hooks/composer-state/quick-submit-input-contract.ts
@@ -19,7 +19,6 @@ export type QuickSubmitPreparationInput = Pick<
   | 'selectedRepoHookContextKey'
   | 'selectedRepoIsGit'
   | 'setAdvancedOpen'
-  | 'setLoadedIssueCommand'
   | 'settings'
   | 'setupConfig'
   | 'setupDecision'
diff --git a/src/renderer/src/hooks/composer-state/quick-submit-preparation.ts b/src/renderer/src/hooks/composer-state/quick-submit-preparation.ts
index 39976157830..2f7753ed650 100644
--- a/src/renderer/src/hooks/composer-state/quick-submit-preparation.ts
+++ b/src/renderer/src/hooks/composer-state/quick-submit-preparation.ts
@@ -8,13 +8,8 @@ import {
   getLinkedWorkItemProvider,
   canUseIssueCommandForLinkedItemProvider
 } from '@/lib/new-workspace'
-import {
-  ensureHooksConfirmed,
-  readAndConfirmRuntimeIssueCommand
-} from '@/lib/ensure-hooks-confirmed'
-import { useAppStore } from '@/store'
 import type { SetupDecision } from '../../../../shared/worktree/create-types'
-import { buildTrustedComposerIssueCommand } from '@/lib/composer-issue-command'
+import type { WorktreeCreationRequest } from '@/lib/pending-worktree-creation'
 import { resolveComposerBranchNameOverrideForCreate } from '../composer-branch-selection'
 import { resolveWorktreeCreateBaseBranch } from '@/runtime/worktree-create-base'
 import type { TuiAgent } from '../../../../shared/tui-agent'
@@ -39,7 +34,6 @@ export function useQuickSubmitPreparation(input: QuickSubmitPreparationInput) {
     selectedRepoHookContextKey,
     selectedRepoIsGit,
     setAdvancedOpen,
-    setLoadedIssueCommand,
     settings,
     setupConfig,
     setupDecision,
@@ -79,6 +73,7 @@ export function useQuickSubmitPreparation(input: QuickSubmitPreparationInput) {
 
       if (
         selectedRepoIsGit &&
+        setupPolicy === 'ask' &&
         selectedRepoHookContextKey &&
         checkedHooksContextKey !== selectedRepoHookContextKey
       ) {
@@ -113,84 +108,29 @@ export function useQuickSubmitPreparation(input: QuickSubmitPreparationInput) {
         return null
       }
 
-      const setupTrustSettlement = await settleComposerSubmit(
-        selectedRepoIsGit
-          ? ensureHooksConfirmed(
-              useAppStore.getState(),
-              repoId,
-              'setup',
-              selectedRepoExecutionHostId ?? undefined,
-              undefined,
-              isSubmissionCancelled
-            )
-          : Promise.resolve<'skip'>('skip'),
-        isSubmissionCancelled
-      )
-
-      if (setupTrustSettlement.status === 'cancelled') {
-        return null
-      }
-
-      const trustDecision = setupTrustSettlement.value
-
-      const effectiveSetupDecision: SetupDecision =
-        trustDecision === 'skip'
-          ? 'skip'
-          : ((submitResolvedSetupDecision ?? 'inherit') as SetupDecision)
-
+      const effectiveSetupDecision: SetupDecision = selectedRepoIsGit
+        ? (submitResolvedSetupDecision ?? 'inherit')
+        : 'skip'
       const submitLinkedWorkItemProvider = submitLinkedWorkItem
         ? getLinkedWorkItemProvider(submitLinkedWorkItem)
         : null
-
-      const shouldReadIssueCommand =
-        enableIssueAutomation &&
-        selectedRepoIsGit &&
-        submitLinkedIssueNumber !== null &&
-        canUseIssueCommandForLinkedItemProvider(submitLinkedWorkItemProvider)
-
-      let submitIssueCommandTemplate = ''
-
-      let issueCommandTrustDecision: 'run' | 'skip' = 'skip'
-
-      if (
-        shouldReadIssueCommand &&
-        trustDecision !== 'skip' &&
-        selectedRepoExecutionHostId &&
-        selectedRepoHookContextKey
-      ) {
-        const issueCommandSettlement = await settleComposerSubmit(
-          readAndConfirmRuntimeIssueCommand(
-            useAppStore.getState(),
-            repoId,
-            selectedRepoExecutionHostId,
-            isSubmissionCancelled
-          ),
-          isSubmissionCancelled
-        )
-        if (issueCommandSettlement.status === 'cancelled') {
-          return null
-        }
-        const confirmedIssueCommand = issueCommandSettlement.value
-        submitIssueCommandTemplate = confirmedIssueCommand.template
-        issueCommandTrustDecision = confirmedIssueCommand.trustDecision
-        setLoadedIssueCommand({
-          contextKey: selectedRepoHookContextKey,
-          result: confirmedIssueCommand.result
-        })
-      }
-
-      const issueCommandInput = {
-        enabled: enableIssueAutomation && selectedRepoIsGit,
-        provider: submitLinkedWorkItemProvider,
-        issueNumber: submitLinkedIssueNumber,
-        template: submitIssueCommandTemplate,
-        artifactUrl: submitLinkedWorkItem?.url ?? null
-      }
-
-      const issueCommand = buildTrustedComposerIssueCommand({
-        ...issueCommandInput,
-        trustDecision: issueCommandTrustDecision
-      })
+      const hookPreparation: WorktreeCreationRequest['hookPreparation'] = selectedRepoIsGit
+        ? {
+            executionHostId: selectedRepoExecutionHostId ?? undefined,
+            issueCommand:
+              enableIssueAutomation &&
+              submitLinkedIssueNumber !== null &&
+              canUseIssueCommandForLinkedItemProvider(submitLinkedWorkItemProvider) &&
+              selectedRepoExecutionHostId &&
+              selectedRepoHookContextKey
+                ? {
+                    provider: submitLinkedWorkItemProvider,
+                    issueNumber: submitLinkedIssueNumber,
+                    artifactUrl: submitLinkedWorkItem?.url ?? null
+                  }
+                : undefined
+          }
+        : undefined
 
       const linkedLinearIssue =
         submitLinkedWorkItem && submitLinkedWorkItemProvider === 'linear'
@@ -249,7 +189,7 @@ export function useQuickSubmitPreparation(input: QuickSubmitPreparationInput) {
 
       return Object.assign(source, {
         effectiveSetupDecision,
-        issueCommand,
+        hookPreparation,
         linkedLinearIssue,
         linkedLinearIssueWorkspaceId,
         linkedLinearIssueOrganizationUrlKey,
@@ -277,7 +217,6 @@ export function useQuickSubmitPreparation(input: QuickSubmitPreparationInput) {
       selectedRepoHookContextKey,
       selectedRepoIsGit,
       setAdvancedOpen,
-      setLoadedIssueCommand,
       settings,
       setupConfig,
       setupDecision,
diff --git a/src/renderer/src/hooks/useGlobalFileDrop.escaping-link.test.tsx b/src/renderer/src/hooks/useGlobalFileDrop.escaping-link.test.tsx
new file mode 100644
index 00000000000..c03f7a44146
--- /dev/null
+++ b/src/renderer/src/hooks/useGlobalFileDrop.escaping-link.test.tsx
@@ -0,0 +1,87 @@
+// @vitest-environment happy-dom
+
+import { cleanup, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { NativeFileDropPayload } from '../../../shared/native-file-drop'
+
+const mocks = vi.hoisted(() => ({
+  statUserOpenedPath: vi.fn(),
+  openFile: vi.fn(),
+  setActiveTabType: vi.fn()
+}))
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn() } }))
+vi.mock('@/lib/connection-context', () => ({ getConnectionId: () => null }))
+vi.mock('@/lib/ssh-mutation-expectation', () => ({
+  captureWorktreeSshMutationExpectation: () => ({})
+}))
+vi.mock('@/lib/worktree-runtime-owner', () => ({
+  getRuntimeEnvironmentIdForWorktree: () => null
+}))
+vi.mock('@/lib/user-opened-local-path', () => ({ statUserOpenedPath: mocks.statUserOpenedPath }))
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({
+      settings: {},
+      activeWorktreeId: 'wt-1',
+      getKnownWorktreeById: () => ({ id: 'wt-1', path: '/repo' }),
+      setActiveTabType: mocks.setActiveTabType,
+      openFile: mocks.openFile
+    })
+  }
+}))
+
+import { useGlobalFileDrop } from './useGlobalFileDrop'
+
+let dropListener: ((data: NativeFileDropPayload) => void) | null = null
+
+beforeEach(() => {
+  mocks.statUserOpenedPath.mockReset()
+  mocks.openFile.mockReset()
+  vi.stubGlobal('api', {
+    ui: {
+      onFileDrop: (listener: (data: NativeFileDropPayload) => void) => {
+        dropListener = listener
+        return () => {
+          dropListener = null
+        }
+      }
+    }
+  })
+})
+
+afterEach(() => {
+  cleanup()
+  vi.unstubAllGlobals()
+})
+
+async function dropOnTabStrip(path: string): Promise<void> {
+  renderHook(() => useGlobalFileDrop())
+  dropListener?.({ target: 'editor', paths: [path] })
+  await vi.waitFor(() => expect(mocks.openFile).toHaveBeenCalledTimes(1))
+}
+
+describe('dropping a project file on the tab strip', () => {
+  it('opens a link that leads out of the project by its absolute path', async () => {
+    mocks.statUserOpenedPath.mockResolvedValue({ isDirectory: false, escapesWorktree: true })
+
+    await dropOnTabStrip('/repo/docs-link/secret.md')
+
+    expect(mocks.openFile).toHaveBeenCalledWith(
+      expect.objectContaining({
+        filePath: '/repo/docs-link/secret.md',
+        relativePath: '/repo/docs-link/secret.md'
+      })
+    )
+  })
+
+  it('keeps an ordinary project file project-relative', async () => {
+    mocks.statUserOpenedPath.mockResolvedValue({ isDirectory: false, escapesWorktree: false })
+
+    await dropOnTabStrip('/repo/docs/plain.md')
+
+    expect(mocks.openFile).toHaveBeenCalledWith(
+      expect.objectContaining({ filePath: '/repo/docs/plain.md', relativePath: 'docs/plain.md' })
+    )
+  })
+})
diff --git a/src/renderer/src/hooks/useGlobalFileDrop.ts b/src/renderer/src/hooks/useGlobalFileDrop.ts
index e201893088b..18f01ad0ff7 100644
--- a/src/renderer/src/hooks/useGlobalFileDrop.ts
+++ b/src/renderer/src/hooks/useGlobalFileDrop.ts
@@ -8,8 +8,6 @@ import { joinPath } from '@/lib/path'
 import { getRuntimeEnvironmentIdForWorktree } from '@/lib/worktree-runtime-owner'
 import {
   importExternalPathsToRuntime,
-  isRemoteRuntimeFileOperation,
-  statRuntimePath,
   type RuntimeFileOperationArgs
 } from '@/runtime/runtime-file-client'
 import type { GlobalSettings } from '../../../shared/global-settings-types'
@@ -21,6 +19,7 @@ import {
 } from '../../../shared/native-file-drop'
 import { captureWorktreeSshMutationExpectation } from '@/lib/ssh-mutation-expectation'
 import { describeDropTempCopyFailure } from '@/lib/drop-temp-copy-failure-copy'
+import { statUserOpenedPath } from '@/lib/user-opened-local-path'
 
 export function getEditorFileDropSettingsForWorktree(
   store: WorktreeRuntimeOwnerState,
@@ -160,18 +159,19 @@ export function useGlobalFileDrop(): void {
       for (const filePath of data.paths) {
         void (async () => {
           try {
-            const isRemoteRuntimePath = isRemoteRuntimeFileOperation(fileContext, filePath)
-            // Why: remote paths don't need local auth — the relay/runtime is the security boundary.
-            if (!connectionId && !isRemoteRuntimePath) {
-              await window.api.fs.authorizeExternalPath({ targetPath: filePath })
-            }
-            const stat = await statRuntimePath(fileContext, filePath)
+            const stat = await statUserOpenedPath(fileContext, filePath)
             if (stat.isDirectory) {
               return
             }
 
             let relativePath = filePath
-            if (worktreePath && isPathInsideWorktree(filePath, worktreePath)) {
+            // Why: a project link out of the project keeps its absolute path, so it reads as
+            // user-named instead of being refused as a project file.
+            if (
+              worktreePath &&
+              !stat.escapesWorktree &&
+              isPathInsideWorktree(filePath, worktreePath)
+            ) {
               const maybeRelative = toWorktreeRelativePath(filePath, worktreePath)
               if (maybeRelative !== null && maybeRelative.length > 0) {
                 relativePath = maybeRelative
@@ -191,7 +191,7 @@ export function useGlobalFileDrop(): void {
               mode: 'edit'
             })
           } catch {
-            // Ignore files that cannot be authorized or stat'd.
+            // Ignore files that cannot be stat'd.
           }
         })()
       }
diff --git a/src/renderer/src/i18n/en-runtime-required.json b/src/renderer/src/i18n/en-runtime-required.json
index b20c7037d55..cc4ab94202a 100644
--- a/src/renderer/src/i18n/en-runtime-required.json
+++ b/src/renderer/src/i18n/en-runtime-required.json
@@ -1580,6 +1580,7 @@
           "a42f6fbdd8": "Keeps this computer and display awake while agents are working. Orca also asks this device to stay awake when the lid is closed, subject to its power policy.",
           "e5995ce268": "Keep computer awake while agents are working",
           "modeDescriptionDefault": "Choose On, Agent, or Off. Agent mode stays awake while agents are working. Orca also asks this device to stay awake when the lid is closed, subject to its power policy.",
+          "modeDescriptionMac": "Choose On, Agent, or Off. Agent mode prevents idle sleep while agents work, so long runs finish with the lid open. Closing the lid still puts this Mac to sleep.",
           "modeDescriptionWindows": "Choose On, Agent, or Off. Agent mode stays awake while agents are working; lid-close behavior follows this device's power settings.",
           "modeTitle": "Keep computer awake"
         },
@@ -1884,6 +1885,9 @@
         "CacheTimer": {
           "07729cc155": "expired"
         },
+        "DeleteWorktreeDirtyChangeHint": {
+          "8e2994ce28": "Deleting this workspace permanently removes these changes from disk."
+        },
         "FolderWorkspaceComposerDialog": {
           "chooseSourceProject": "Choose task source",
           "connectFailed": "Failed to connect to project.",
@@ -2882,7 +2886,6 @@
         "openCurrentConversation": "Open the current conversation to continue.",
         "optionRejected": "The agent didn't accept this setting.",
         "outcomeUnknown": "Orca couldn't confirm what happened. Check the chat.",
-        "sendOutcomeLost": "Orca couldn't confirm your message reached the agent. Check the chat, then send it again if needed.",
         "ownerUnproven": "The previous agent in this chat may still be running.",
         "promptPending": "The agent is waiting for an answer to a question or approval.",
         "questionChanged": "This question was already answered or has changed.",
@@ -2892,6 +2895,7 @@
         "reopenChat": "Reopen the chat to check again.",
         "restartFailed": "The agent couldn't restart.",
         "savedByNewerOrca": "Chats were saved by a newer Orca.",
+        "sendOutcomeLost": "Orca couldn't confirm your message reached the agent. Check the chat, then send it again if needed.",
         "settleEarlierMessage": "Wait for your earlier message to go through, or retry it.",
         "startNewChat": "Start a new chat to continue.",
         "terminalAgentHoldsChat": "This chat is still open in a terminal agent.",
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index cb7b6f4607f..4456d126c93 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -1,4 +1,37 @@
 {
+  "csv": {
+    "detectingDelimiter": "Detecting delimiter…",
+    "indexProgress": "Indexing CSV… {{percent}}%",
+    "loadingCell": "Loading…",
+    "nextRows": "Next rows",
+    "previousRows": "Previous rows",
+    "readOnlyPreview": "Large file preview · Read-only",
+    "resizeColumn": "Resize column {{column}}",
+    "rowWindow": "Rows {{first}}–{{last}}",
+    "editor": "CSV editor",
+    "editCell": "Edit row {{row}}, column {{column}}",
+    "filterRows": "Filter rows",
+    "edit": "Edit cell",
+    "copy": "Copy",
+    "paste": "Paste",
+    "rows": "Rows",
+    "insertRowAbove": "Insert row above",
+    "insertRowBelow": "Insert row below",
+    "deleteRows": "Delete selected rows",
+    "columns": "Columns",
+    "newColumn": "Column {{column}}",
+    "insertColumnBefore": "Insert column before",
+    "insertColumnAfter": "Insert column after",
+    "moveColumnLeft": "Move column left",
+    "moveColumnRight": "Move column right",
+    "deleteColumns": "Delete selected columns",
+    "sort": "Sort",
+    "sortAscending": "Sort selected column ascending",
+    "sortDescending": "Sort selected column descending",
+    "originalOrder": "Original row order",
+    "save": "Save",
+    "inspectionOnly": "Inspection only · File row order unchanged"
+  },
   "osDocumentOpen": {
     "failed": "Failed to open the file."
   },
@@ -3218,18 +3251,16 @@
           },
           "MobileDriverOverlay": {
             "c6460cf584": "Take back",
-            "c8f2e1a4b9": "Take back this terminal",
             "c44659e09f": "Phone driving",
-            "7cffad954c": "Collapse",
             "3eed73394f": "Your keyboard is paused",
-            "faa367dc74": "Your phone left this at phone size",
-            "54f7d6f69d": "Take back all terminals",
-            "b3d8e1f42a": "Restore this terminal",
-            "e8c4f2a91b": "Restore all terminals",
-            "f2a8b9c1d3": "From your phone",
             "c7e4a2b8f1": "Your phone is in control",
-            "d9f3c6e2a4": "Desktop keyboard is paused. Take back this terminal to type here, take back all terminals your phone controls, or collapse to keep watching.",
-            "a6b1d8f3e2": "Your phone session ended. Restore to desktop size for this terminal, or for all terminals your phone left at phone size."
+            "4b7e1c9a20": "Still sized for your phone",
+            "9d2f6a3e58": "Your phone session ended. Restore to fit this window.",
+            "1e5c8b7d43": "Restore",
+            "6a3d9f2c71": "Restore all",
+            "8c1a5e9f36": "Desktop typing is paused. Output keeps streaming.",
+            "2f7b4d1e95": "Take back all",
+            "3a9c5f7e12": "Minimize"
           },
           "TerminalAgentSessionForkDialog": {
             "17fc841e59": "Copy context",
@@ -3874,6 +3905,9 @@
             "grokUsageAria": "Open Grok usage details",
             "grokUsageMenu": "Grok Usage",
             "floatingTerminalNewActivity": "{{label}}, new activity",
+            "4fba7dc1e7": "{{value0}} bal",
+            "4025a6f62f": "Unlimited",
+            "a95969101f": "{{value0}} credits",
             "codexSignInSuccess": "Signed in to Codex",
             "codexSignInError": "Codex sign-in failed. Please try again.",
             "cursorUsageMenu": "Cursor Usage",
@@ -4024,6 +4058,16 @@
               }
             }
           },
+          "provider": {
+            "extra": {
+              "usage": {
+                "section": {
+                  "135d51c19f": "Limit {{value0}}",
+                  "apiKeyBalanceUnavailable": "Balance is not included in this usage response."
+                }
+              }
+            }
+          },
           "tooltip": {
             "zcode": {
               "mcp": "MCP"
@@ -4061,6 +4105,14 @@
             "d1b7f509ac": "Run grok in a terminal on the computer running Orca and wait for it to start. If prompted, complete sign-in, then retry usage. You do not need to send a chat message.",
             "f90b3d7a16": "Run Kimi to refresh",
             "a37e8c15d4": "Run kimi in a terminal on the computer running Orca and wait for it to start, then retry usage.",
+            "fbc80d8be2": "Zen balance",
+            "c03c61f53f": "Balance",
+            "f6a27a3c0a": "{{value0}} available",
+            "7404abbece": "Usage credits",
+            "473d45cd0f": "Balance {{value0}}",
+            "f21b2ba897": "Credits",
+            "56c0d70577": "Unlimited",
+            "87b5bda4d3": "{{value0}} credits available",
             "minimax": {
               "expired": {
                 "label": "Sign-in expired",
@@ -6507,6 +6559,11 @@
           "copied": "Command copied",
           "retry": "Retry now",
           "restored": "Git is working again. Worktrees refreshed."
+        },
+        "manualSortSwitch": {
+          "title": "Sort changed to Manual",
+          "description": "Manual keeps workspaces where you drop them.",
+          "restore": "Back to {{label}}"
         }
       },
       "shared": {
@@ -7787,7 +7844,6 @@
         },
         "MobilePane": {
           "dd3cd78d04": "Scan with Orca Mobile",
-          "35100bca5d": "While you're using a terminal on your phone, Orca shrinks it to fit your phone screen. When you close the app or switch away, this controls whether it stays at phone size (so interactive CLI tools don't reflow) or resizes back to your desktop. You can always use Restore this terminal or Restore all terminals on the banner to resize manually.",
           "ee56f1c7e4": "When you leave the mobile app",
           "3939fd062c": "Revoking a device disconnects it immediately.",
           "254a6d09e4": "Paired",
@@ -7812,7 +7868,8 @@
           "pairingCodeReady": "Pairing code ready",
           "copyPairingCode": "Copy pairing code",
           "diagnosticsCopied": "Diagnostics copied",
-          "diagnosticsCopyFailed": "Failed to copy diagnostics"
+          "diagnosticsCopyFailed": "Failed to copy diagnostics",
+          "5e2c7a1f84": "While you're using a terminal on your phone, Orca shrinks it to fit your phone screen. When you close the app or switch away, this controls whether it stays at phone size (so interactive CLI tools don't reflow) or resizes back to your desktop. You can always use Restore or Restore all on the banner to resize manually."
         },
         "MobileSettingsPane": {
           "9a3c280e49": "GitHub Releases",
@@ -8912,7 +8969,38 @@
             "fastDescription": "Extra multiplier while scrolling with a modifier key.",
             "tui": "TUI",
             "tuiDescription": "Discrete wheel reports for full-screen terminal apps."
-          }
+          },
+          "8dbe0bc942": "Shell arguments, one per line",
+          "f58cb71f53": "--rcfile\n/path/to/rcfile",
+          "48b91a3ed2": "Custom args",
+          "7bd83fc1d0": "-l (default)",
+          "5ffc4777b6": "Shell argument mode",
+          "578ec79449": "Enter one argument per line. Leave it empty to pass no arguments.",
+          "884a006065": "Starts the shell as a login shell with -l.",
+          "01c600daff": "Shell arguments",
+          "e3ae5aed18": ". Switch to System shell or choose an executable on this host.",
+          "59573d0b33": "Enter a shell name on PATH or an executable path. Orca starts it as a login shell.",
+          "5e06e87730": "Custom shell executable",
+          "c2bf02ce2f": "fish, nu, or /bin/zsh",
+          "f51cc79784": "Custom shell",
+          "dd3f4c35da": "System shell ({{value0}})",
+          "fd05fb109c": "Terminal shell",
+          "69724e8f0c": "Choose what Orca opens for new local terminal panes.",
+          "c2ddb189e7": "rcfile",
+          "73c211e979": "wrapper",
+          "4faf688f78": "login",
+          "44f8a56f66": "args",
+          "af893aa433": "arguments",
+          "ddc72a4860": "default",
+          "d469840b75": "nushell",
+          "17ad899ba4": "bash",
+          "c9bc93d343": "zsh",
+          "0cbe5ad727": "fish",
+          "81694f1584": "terminal",
+          "a909136b3f": "shell",
+          "1c29734248": "Shell used for new terminal panes",
+          "9589abc009": "Default shell",
+          "5a5eac2f44": "Shell not found: {{value0}}"
         },
         "TerminalSettingsPreview": {
           "a63953a48a": "Preview {{value0}} theme",
@@ -10877,7 +10965,19 @@
               "statusline": "statusline",
               "dim": "dim",
               "colors": "colors"
-            }
+            },
+            "d31ed1ac1c": "rcfile",
+            "d9e29543a1": "wrapper",
+            "50ba80b6dd": "login",
+            "36ba1a1357": "args",
+            "5304b12d5c": "arguments",
+            "7c3ede6f12": "nushell",
+            "bf09070e31": "bash",
+            "d26257a80d": "zsh",
+            "454df22a5e": "fish",
+            "ddd5efe113": "shell",
+            "3de504994c": "Shell and arguments used for new local interactive terminal panes",
+            "1733ccd3e9": "Terminal shell"
           },
           "windows": {
             "search": {
@@ -10986,7 +11086,11 @@
           "a42f6fbdd8": "Keeps this computer and display awake while agents are working. Orca also asks this device to stay awake when the lid is closed, subject to its power policy.",
           "modeTitle": "Keep computer awake",
           "modeDescriptionWindows": "Choose On, Agent, or Off. Agent mode stays awake while agents are working; lid-close behavior follows this device's power settings.",
-          "modeDescriptionDefault": "Choose On, Agent, or Off. Agent mode stays awake while agents are working. Orca also asks this device to stay awake when the lid is closed, subject to its power policy."
+          "modeDescriptionMac": "Choose On, Agent, or Off. Agent mode prevents idle sleep while agents work, so long runs finish with the lid open. Closing the lid still puts this Mac to sleep.",
+          "modeDescriptionDefault": "Choose On, Agent, or Off. Agent mode stays awake while agents are working. Orca also asks this device to stay awake when the lid is closed, subject to its power policy.",
+          "lidNoteWindows": "Lid-close behavior follows this device's power settings.",
+          "lidNoteMac": "Prevents idle sleep with the lid open; closing the lid still puts this Mac to sleep.",
+          "lidNoteDefault": "Orca also asks this device to stay awake when the lid is closed, subject to its power policy."
         },
         "agent-status-hooks-copy": {
           "7707c15abb": "Agent status hooks",
@@ -13490,7 +13594,8 @@
             "fca915a67a": "Remote items are permanently deleted and cannot be undone. Local items move to the {{value0}}."
           },
           "useFileExplorerHandlers": {
-            "32cd9fd991": "Cannot open symlink target"
+            "32cd9fd991": "Cannot open symlink target",
+            "folderLinksOutsideProject": "This folder links outside the project, so it can't be opened here."
           },
           "useFileExplorerImport": {
             "25919b2050": "Skipped {{value0}} {{value1}}.",
@@ -13758,7 +13863,6 @@
           },
           "aiVaultSessionLogOpen": {
             "workspaceGone": "Couldn't open log — workspace is no longer available.",
-            "notAuthorized": "Couldn't open log — path not authorized.",
             "alreadyEditable": "Log is already open for editing."
           },
           "github": {
@@ -15663,7 +15767,9 @@
           }
         },
         "richMarkdownLargeTextPaste": {
-          "tooLarge": "Paste is too large."
+          "tooLarge": "Paste is too large.",
+          "stopped": "Large paste stopped before it finished.",
+          "cancelled": "Large paste cancelled because its original target changed."
         },
         "ExternalFileChangeBanner": {
           "7c41e90d12": "This file changed on disk while you have unsaved edits. Saving will overwrite the newer disk content.",
@@ -15764,6 +15870,10 @@
           "a0af0198aa": "Large diffs are not rendered by default.",
           "c3d9f4a712": "This diff's size isn't known yet, so it loads on request.",
           "f7fa7a40d0": "Load diff"
+        },
+        "richMarkdownImageInsertionFeedback": {
+          "importedFileKept": "Image insertion canceled because the destination changed. The imported file was kept.",
+          "destinationChanged": "Image insertion canceled because the destination changed. Try again."
         }
       },
       "diff": {
@@ -17584,6 +17694,11 @@
         }
       }
     },
+    "jiraIssueAssigneeField": {
+      "label": "Assignee",
+      "automatic": "Automatic",
+      "assignToMe": "Assign to me ({{name}})"
+    },
     "jiraUserPicker": {
       "select": "Select {{value0}}",
       "search": "Search users",
@@ -18060,6 +18175,7 @@
       "dismissDeliveryNotice": "Dismiss",
       "messageNotSent": "Message not sent",
       "deliveryUnconfirmed": "Delivery unconfirmed — check chat before retrying",
+      "messageSending": "Sending…",
       "queuedMessages": {
         "behindReturnedHold": "Waiting — a message ahead needs attention",
         "awaitingAnswerHold": "Waiting for your answer",
@@ -18346,6 +18462,16 @@
         "workspaceReadyToast": "Workspace {{name}} is ready",
         "goToWorktree": "Go to worktree",
         "goToWorkspace": "Go to workspace"
+      },
+      "delete": {
+        "changes": {
+          "permanentLoss": "Any uncommitted or untracked changes in Git workspaces will be permanently deleted.",
+          "clean": "No uncommitted or untracked changes",
+          "unavailable": "Changes could not be checked",
+          "checking": "Checking for changes…",
+          "checkingDetails": "Checking…",
+          "unavailableDetails": "Details unavailable"
+        }
       }
     },
     "agentSessionContinuation": {
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index 3f8a1e2f703..4f002551643 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -41,11 +41,72 @@
         "portsToggleDescription": "Muestra los puertos activos de los espacios de trabajo. Haz clic para ver los puertos de cada espacio de trabajo y los puertos externos.",
         "antigravityToggleDescription": "Muestra el uso de suscripción de Antigravity para el espacio de trabajo activo.",
         "grokToggleDescription": "Muestra el uso de créditos de suscripción de Grok cuando has iniciado sesión con Grok CLI.",
-        "cursorToggleDescription": "Muestra el uso del plan de Cursor cuando inicias sesión con cursor-agent o el IDE de Cursor."
+        "cursorToggleDescription": "Muestra el uso del plan de Cursor cuando inicias sesión con cursor-agent o el IDE de Cursor.",
+        "zcodeToggleDescription": "Mostrar el uso de la cuota del plan de codificación ZCode."
       },
       "menuBarIcon": {
         "title": "Mostrar icono en la barra de menús",
-        "description": "Mantén un acceso directo de Orca e indicador de actividad en la barra de menús de macOS."
+        "description": "Mantén un acceso directo de Orca e indicador de actividad en la barra de menús de macOS.",
+        "keyword": {
+          "menuBar": "barra de menús",
+          "statusItem": "elemento de estado",
+          "activity": "actividad"
+        }
+      }
+    },
+    "browser": {
+      "clientHostedRemote": {
+        "title": "Hospeda páginas de navegadores remotos en este dispositivo",
+        "description": "Renderizar páginas de espacio de trabajo remoto en este escritorio; el tráfico de red todavía pasa por el host remoto. Se aplica solo a páginas nuevas.",
+        "optionDevice": "Este dispositivo",
+        "optionDeviceTooltip": "Las páginas se representan en este escritorio, por lo que la entrada y las ventanas emergentes se comportan de forma nativa.",
+        "optionServer": "Servidor (transmitido)",
+        "optionServerTooltip": "Las páginas se renderizan en el servidor remoto y se transmiten a este dispositivo.",
+        "rowTitle": "Espacios de trabajo de servidores remotos",
+        "rowDescription": "Donde se renderizan las páginas. El tráfico siempre pasa por el servidor remoto. Se aplica solo a páginas nuevas."
+      },
+      "sshWorkspaceRouting": {
+        "title": "Navega a través de los anfitriones del espacio de trabajo SSH",
+        "description": "Las páginas del navegador en los espacios de trabajo SSH envían su tráfico a través del host SSH del espacio de trabajo, con el DNS resuelto allí. Off significa que las páginas navegan desde esta máquina.",
+        "disabledHosts": "En su lugar, los anfitriones navegan desde este dispositivo:",
+        "enableHost": "Redireccionar chat",
+        "optionHost": "Anfitrión SSH",
+        "optionHostTooltip": "El tráfico y el DNS pasan por el host SSH del espacio de trabajo.",
+        "optionDevice": "Este dispositivo",
+        "optionDeviceTooltip": "Las páginas navegan desde la red de esta máquina.",
+        "rowTitle": "Espacios de trabajo SSH",
+        "rowDescription": "De dónde sale el tráfico del navegador. Las páginas siempre se renderizan en este dispositivo.",
+        "useHost": "Usar host SSH",
+        "probeSkippedHosts": "Anfitriones enrutados sin la comprobación de conexión (inténtalo de todos modos):",
+        "probeAgain": "Verificar de nuevo"
+      },
+      "remoteBrowsing": {
+        "heading": "Navegación remota",
+        "headingDescription": "Dónde se representan las páginas del espacio de trabajo remoto y desde dónde sale su tráfico de red."
+      },
+      "userAgent": {
+        "title": "Identidad del navegador",
+        "description": "Elija el agente de usuario para cada perfil y página del navegador. El modo nativo deshabilita el inicio de sesión de Google. Los cambios surten efecto después de un reinicio.",
+        "remoteUnsupported": "Gestiona la identidad del navegador en el host remoto con la CLI de Orca.",
+        "loading": "Cargando…",
+        "resetRequired": "Los datos de identidad deben restablecerse explícitamente antes de que se puedan cambiar.",
+        "resetRequiredCommand": "Restablecerlo desde la línea de comandos: orca browser identity set --mode <mode> --reset",
+        "optionClean": "Limpio",
+        "optionCleanTooltip": "Elimina los tokens Orca y Electron para que coincidan con las sesiones de Chrome importadas.",
+        "optionNative": "Nativo",
+        "optionNativeTooltip": "Mantiene la identidad incorporada de Electron para los sitios que rechazan la identidad limpiada. El inicio de sesión de Google no está disponible en modo nativo.",
+        "restartRequired": "Se requiere un reinicio",
+        "unavailable": "La identidad del navegador no está disponible."
+      }
+    },
+    "agents": {
+      "codexTerminalServerIsolation": {
+        "title": "Ejecutar cada terminal del Codex en su propio servidor",
+        "description": "Mantiene el estado de Orca y las pestañas de cierre funcionando correctamente. Desactivar para utilizar el servidor compartido de Codex y la descripción general de sus agentes. Se aplica a terminales nuevos."
+      },
+      "codexSharedServerWarning": {
+        "title": "Avisar cuando una pestaña de Codex comparte un servidor",
+        "description": "Muestra un aviso en un Codex que usted mismo inició cuando comparte un servidor con otras pestañas, porque su estado de agente puede ser incorrecto."
       }
     }
   },
@@ -94,7 +155,9 @@
       "issue": "Issue",
       "mr": "MR",
       "port": "Puerto",
-      "pr": "PR"
+      "pr": "PR",
+      "task": "Tarea",
+      "automation": "Corrida"
     },
     "filter": {
       "emptyTitle": "Ningún resultado coincide con el filtro activo",
@@ -122,6 +185,19 @@
       "back": "Atrás",
       "ariaActive": "Filtro: {{value0}} activos.",
       "scopedTo": "Ámbito:"
+    },
+    "linearIssue": {
+      "createLabel": "Crear árbol de trabajo a partir de un problema Linear __{{value0}} __: {{value1}}",
+      "pendingLabel": "Crear árbol de trabajo a partir de la emisión Linear {{value0}}",
+      "loadingLabel": "Cargando problema Linear {{value0}}",
+      "createHint": "Crear árbol de trabajo a partir de un problema Linear",
+      "loadingHint": "Cargando problema Linear..."
+    },
+    "renderCapOverflow": "{{value0}} más",
+    "seeMore": "Ver más",
+    "taskUrl": {
+      "loadingHint": "Cargando {{value0}}…",
+      "createHint": "Crear árbol de trabajo a partir de {{value0}}"
     }
   },
   "auto": {
@@ -192,7 +268,8 @@
         "runtimeEnvironmentManuallyDisconnected": "El entorno de ejecución se ha desconectado manualmente.",
         "loopbackPairingBlocked": "Este enlace de acceso apunta de nuevo a este dispositivo.",
         "remotePairingUnreachable": "No se puede acceder a Orca en {{endpoint}}.",
-        "remotePairingInvalidDetails": "Este enlace de acceso contiene datos de conexión no válidos."
+        "remotePairingInvalidDetails": "Este enlace de acceso contiene datos de conexión no válidos.",
+        "remotePairingSaveFailed": "Orca verificó al anfitrión, pero no pudo guardarlo. Compruebe el almacenamiento del navegador e inténtelo de nuevo."
       },
       "web": {
         "preload": {
@@ -235,7 +312,8 @@
           "51f15c37d3": "No se puede abrir la carpeta: {{value0}}",
           "f2e00db373": "No se encontró el archivo: {{value0}}",
           "checkRunDetailsUnavailable": "No hay detalles disponibles para este check.",
-          "checkRunDetailsLoadFailed": "No se pudieron cargar los detalles del check."
+          "checkRunDetailsLoadFailed": "No se pudieron cargar los detalles del check.",
+          "checkRunDetailsRepoUnavailable": "Los detalles del repositorio no están disponibles para esta verificación."
         },
         "github": {
           "f129c42773": "GitHub no devolvió el comentario nuevo.",
@@ -267,7 +345,12 @@
         "workspace": {
           "cleanup": {
             "9d6e531da6": "El espacio de trabajo ya no existe.",
-            "changedSinceConfirmation": "El espacio de trabajo cambió después de la confirmación. Actualiza para revisarlo antes de eliminarlo."
+            "changedSinceConfirmation": "El espacio de trabajo cambió después de la confirmación. Actualiza para revisarlo antes de eliminarlo.",
+            "hostCollision": "Error: este espacio de trabajo existe en varios hosts en la misma ruta",
+            "hostUnresolved": "Orca no sabe qué anfitrión es el propietario de este espacio de trabajo. Actualiza los proyectos y revísalos de nuevo.",
+            "gitStatusUnavailable": "Orca no ha podido comprobar el estado Git de este espacio de trabajo. Inténtalo de nuevo o elimínalo de la barra lateral específica del anfitrión o de la lista de proyectos.",
+            "gitStatusUnavailableOlderPeer": "Orca no pudo hacer coincidir este error de estado de git con un anfitrión. Actualice el compañero conectado anterior o elimine el espacio de trabajo de su barra lateral o lista de proyectos específicos del anfitrión.",
+            "forceNeedsApproval": "Revise y confirme este espacio de trabajo antes de forzar su eliminación."
           }
         },
         "worktrees": {
@@ -301,7 +384,25 @@
           "runtimeScopeForbiddenDescription": "Los espacios de trabajo no están disponibles con un emparejamiento de acceso móvil. Vuelve a conectarte con el enlace del navegador desde Ajustes → Servidores remotos de Orca → Comparte este servidor Orca.",
           "createdWithoutParentNesting": "Creado sin anidarlo bajo \"{{value0}}\"",
           "createdWithoutParentNestingUnnamed": "Creado sin anidarlo bajo el worktree padre seleccionado",
-          "createdWithoutParentNestingDetail": "El espacio de trabajo padre ya no estaba disponible. Puedes establecerlo desde el menú del espacio de trabajo."
+          "createdWithoutParentNestingDetail": "El espacio de trabajo padre ya no estaba disponible. Puedes establecerlo desde el menú del espacio de trabajo.",
+          "c6cf133786": "Este espacio de trabajo ya no está disponible.",
+          "a17f4d2e93": "No se ha podido actualizar este espacio de trabajo.",
+          "preservedBranchCleanupHostAmbiguous": "Hay varias limpiezas de sucursales preservadas pendientes para «{{value0}}»; especifique el anfitrión.",
+          "metadata": {
+            "worktree": {
+              "meta": {
+                "persist": {
+                  "877e3638d8": "Actualizar el tiempo de ejecución remoto para cambiar el problema vinculado de este espacio de trabajo",
+                  "4367540861": "Actualizar el tiempo de ejecución remoto para vincular problemas Lineares",
+                  "github": {
+                    "pr": {
+                      "suppression": "Actualizar el tiempo de ejecución remoto para desvincular las solicitudes de extracción de GitHub"
+                    }
+                  }
+                }
+              }
+            }
+          }
         },
         "repos": {
           "2975400634": "Actualiza el servidor Orca para abrir carpetas que no sean Git en este host.",
@@ -315,7 +416,10 @@
           "3be0f7df04": "No se puede abrir la carpeta en el host seleccionado",
           "15cf5319ec": "{{path}} se verificó en {{hostName}}, pero ese host no reportó ninguna carpeta utilizable.",
           "2dcd706774": "El proyecto también existe en otro perfil",
-          "presenceProfileOverflow": "{{names}} +{{count}} más"
+          "presenceProfileOverflow": "{{names}} +{{count}} más",
+          "removeProjectFailed": "No se ha podido eliminar el proyecto ",
+          "wslFilesystemBoundaryTitle": "Este proyecto se almacena en una unidad de Windows",
+          "wslFilesystemBoundaryDescription": "Git para este proyecto se ejecuta en {{distro}}, que llega a las unidades de Windows a través del puente del sistema de archivos WSL. Espera que git sea aproximadamente 20 veces más lento de lo que sería en una copia almacenada dentro de {{distro}}."
         },
         "settings": {
           "e12dab333b": "No se pudo cambiar de servidor",
@@ -348,6 +452,23 @@
             "f518e89aa5": "El proyecto ya existe en ese perfil",
             "f03ae7f27b": "Error al transferir proyecto"
           }
+        },
+        "runtime": {
+          "status": {
+            "runtimeHostDisconnectedDescription": "Compruebe que Orca se está ejecutando en este servidor y que su conexión de red está funcionando, a continuación, inténtelo de nuevo.",
+            "runtimeHostUnreachableNamed": "No se puede alcanzar {{hostName}}",
+            "runtimeHostUnreachable": "No se puede contactar con el servidor de Orca",
+            "tryAgain": "Probar de nuevo"
+          }
+        },
+        "terminal": {
+          "quick": {
+            "command": {
+              "hosts": {
+                "5b7d781d67": "Error al guardar el comando rápido"
+              }
+            }
+          }
         }
       }
     },
@@ -393,7 +514,12 @@
           "muse_label": "Muse",
           "zcode_label": "ZCode",
           "codebuddy_label": "CodeBuddy",
-          "jcode_label": "Jcode"
+          "jcode_label": "Jcode",
+          "freebuff_label": "Freebuff",
+          "dsh_label": "DeepSeek Harness",
+          "qoder_label": "Qoder CLI",
+          "opencode2_label": "OpenCode 2",
+          "qoder_cn_label": "Qoder CLI China"
         },
         "skill": {
           "cli": {
@@ -525,7 +651,12 @@
             "9e37a5b1b3": "Ejecutar trabajo independiente en paralelo",
             "bddc4c09b8": "Ejecutar un flujo de trabajo por fases",
             "ab0e9803b7": "Entregar a otro worktree",
-            "5e0d489fe1": "Entregar una tarea activa"
+            "5e0d489fe1": "Entregar una tarea activa",
+            "handoffSummary": "Mover la propiedad a otro agente con suficiente contexto para continuar.",
+            "worktreeHandoffSummary": "Mover el trabajo a un agente que ya se está ejecutando en una rama diferente.",
+            "childSequenceSummary": "Utilice agentes secundarios uno tras otro cuando cada fase depende de la última.",
+            "childParallelSummary": "Divida las tareas de investigación o implementación que no se superponen entre los agentes secundarios.",
+            "prSplitSummary": "Dé a cada agente secundario su propio árbol de trabajo para que la implementación paralela se mantenga revisable."
           }
         }
       },
@@ -627,6 +758,15 @@
         },
         "activation": {
           "cannotOpenFolderWorkspace": "No se puede abrir el espacio de trabajo de carpeta"
+        },
+        "creation": {
+          "flow": {
+            "structured": {
+              "launch": {
+                "unknown": "No se ha podido confirmar si se ha abierto el chat {{value0}}. Vuelve a intentarlo para comprobarlo de nuevo."
+              }
+            }
+          }
         }
       },
       "folderWorkspacePathStatus": {
@@ -634,13 +774,15 @@
           "missing": "Carpeta no encontrada",
           "notDirectory": "La ruta no es una carpeta",
           "ambiguousConnection": "No se puede determinar la conexión",
-          "unavailable": "No se puede verificar la carpeta"
+          "unavailable": "No se puede verificar la carpeta",
+          "unrecognized": "La carpeta no se puede utilizar"
         },
         "description": {
           "missing": "Orca no puede encontrar {{path}}. Elimina y vuelve a importar este espacio de trabajo de carpeta.",
           "notDirectory": "{{path}} existe, pero no es una carpeta.",
           "ambiguousConnection": "Orca no puede determinar a qué conexión SSH pertenece este alcance de carpeta.",
-          "unavailable": "Orca no puede verificar esta carpeta ahora mismo. Revisa el host o la conexión SSH e inténtalo de nuevo."
+          "unavailable": "Orca no puede verificar esta carpeta ahora mismo. Revisa el host o la conexión SSH e inténtalo de nuevo.",
+          "unrecognized": "Orca no puede usar {{path}}, y esta versión no reconoce el motivo. Actualiza Orca para ver los detalles."
         },
         "createError": {
           "title": {
@@ -668,7 +810,8 @@
         "wakeEphemeralVmFailed": "Error al activar el espacio de trabajo VM efímera"
       },
       "ephemeralVmWorkspaceTarget": {
-        "projectRootRegistrationFailed": "Error al registrar la raíz del proyecto creada por la receta en el entorno de ejecución"
+        "projectRootRegistrationFailed": "Error al registrar la raíz del proyecto creada por la receta en el entorno de ejecución",
+        "provisionedRootRequiresSsh": "Las recetas de raíz aprovisionada actualmente requieren una conexión SSH directa."
       },
       "blocked": {
         "notification": {
@@ -718,7 +861,21 @@
           "import": {
             "toast": {
               "restartFallbackUnavailableNone": "None of the {{value0}} cookies could be loaded, and the restart fallback was unavailable. The previous cookies for this profile were replaced. Try the import again.",
-              "restartFallbackUnavailablePartial": "Imported {{value0}} of {{value1}} cookies. The rest could not be loaded, and the restart fallback was unavailable. Try the import again."
+              "restartFallbackUnavailablePartial": "Imported {{value0}} of {{value1}} cookies. The rest could not be loaded, and the restart fallback was unavailable. Try the import again.",
+              "googleCookiesSkipped": "Las cookies de Google no se han importado. Abre un navegador en Orca en {{value0}} con este perfil y, a continuación, inicia sesión en Google.",
+              "undecryptableAppBound": "Orca no puede descifrar {{value0}} de las cookies de este navegador porque utilizan cifrado vinculado a la aplicación. Puede importar cookies de un archivo utilizando \"De archivo...\".",
+              "undecryptableAppBoundMixed": "Orca no puede descifrar {{value0}} de las cookies de este navegador porque usan cifrado vinculado a la aplicación; {{value1}} más no se pudo descifrar por otra razón. Puede importar cookies de un archivo utilizando \"De archivo...\".",
+              "undecryptableKeyring": "No se han podido descifrar las {{value0}} cookies porque el llavero del sistema no estaba disponible. Desbloquee su llavero de inicio de sesión (o instale un proveedor del Servicio Secreto como gnome-keyring) e importe de nuevo.",
+              "undecryptableKeyringMixed": "Las cookies {{value0}} no se pudieron descifrar porque el llavero del sistema no estaba disponible; {{value1}} more no se pudo descifrar por otro motivo. Desbloquee su llavero de inicio de sesión (o instale un proveedor del Servicio Secreto como gnome-keyring) e importe de nuevo.",
+              "undecryptableUnknown": "No se han podido descifrar las {{value0}} cookies y se han omitido. Cierre el navegador de origen por completo y vuelva a intentar la importación.",
+              "unrecognizedWarning": "La importación de cookies finalizó con una advertencia que esta versión de Orca no reconoce. Actualice Orca para ver los detalles, luego revise este perfil antes de confiar en sus cookies.",
+              "undecryptableUnrecognizedReason": "Las cookies {{value0}} no se pudieron descifrar y se omitieron por una razón que esta versión de Orca no reconoce. Actualiza Orca para ver los detalles y vuelve a intentar la importación.",
+              "partitionSkipped": "No se importaron {{value0}} cookies porque no se pudo leer su partición de sitio. Vuelve a iniciar sesión en esos sitios en Orca.",
+              "locationClientHosted": "Lee desde este dispositivo y guárdalo aquí para el espacio de trabajo {{value0}}.",
+              "locationRemoteHost": "Lee desde los navegadores en {{value0}} y guárdalo allí.",
+              "googleCookiesSkippedLocal": "Las cookies de Google no se han importado. Abre un navegador en Orca con este perfil y, a continuación, inicia sesión en Google.",
+              "googleCookiesSkippedClientHosted": "Las cookies de Google no se han importado. Abre una pestaña del navegador en el espacio de trabajo {{value0}} con este perfil (se abre en este dispositivo) y, a continuación, inicia sesión en Google.",
+              "googleCookiesSkippedRemoteWorkspace": "Las cookies de Google no se han importado. Abre una pestaña del navegador en el espacio de trabajo {{value0}} con este perfil y, a continuación, inicia sesión en Google."
             }
           }
         }
@@ -757,6 +914,25 @@
         "tooLarge": "Es demasiado grande para copiarlo, así que Orca no pudo pasárselo al agente.",
         "storageFull": "El almacenamiento de Orca para archivos soltados está lleno, así que Orca no pudo pasárselo al agente.",
         "generic": "Vuelve a soltar los archivos."
+      },
+      "activateAiVaultStructuredSession": {
+        "unavailable": "La sesión del agente estructurado aún no está disponible. Vuelve a intentarlo en un momento.",
+        "gone": "Este chat ya no está en este anfitrión, por lo que no se puede volver a abrir aquí.",
+        "hostCannotOpen": "Este chat no se puede volver a abrir hasta que se actualice Orca."
+      },
+      "ephemeralVmWorktreeCreation": {
+        "sparseCheckoutUnsupported": "Las recetas con raíz aprovisionada no admiten sparse checkout."
+      },
+      "worktreeJumpNavigation": {
+        "filteredNotice": "Este árbol de trabajo está oculto por los filtros de la barra lateral. El espacio de trabajo se abrió, pero no se muestra en Spaces."
+      },
+      "file": {
+        "preview": {
+          "pairedOutsideWorktree": "Los archivos fuera del espacio de trabajo aún no se pueden previsualizar en un servidor emparejado."
+        }
+      },
+      "clipboardWriteFailure": {
+        "tooLarge": "El texto es demasiado grande para copiarlo."
       }
     },
     "hooks": {
@@ -764,7 +940,8 @@
         "59718b120b": "El espacio de trabajo de destino ya no está disponible.",
         "16a21d6413": "La reconexión SSH requiere credenciales interactivas.",
         "386db94f3e": "El proyecto de destino ya no está disponible.",
-        "3ad7d77f57": "El espacio de trabajo de destino está en un host distinto al destino de ejecución de esta automatización."
+        "3ad7d77f57": "El espacio de trabajo de destino está en un host distinto al destino de ejecución de esta automatización.",
+        "workspaceHostUnresolved": "El espacio de trabajo de destino abarca más de un host, así que esta ejecución no tiene un único host que usar."
       },
       "useComposerState": {
         "7eb3f44ff7": "El agente seleccionado está deshabilitado. Elige un agente habilitado antes de crear.",
@@ -775,7 +952,10 @@
         "folderWorkspaceCreateFailedTitle": "No se pudo crear el espacio de trabajo de carpeta",
         "folderWorkspaceCreateFailedMessage": "No se pudo crear el espacio de trabajo de carpeta. Revisa los detalles del error de arriba e inténtalo de nuevo.",
         "setupAgentStartupPolicySaveFailed": "Error al guardar el comportamiento de inicio",
-        "5f3d2c8a1b": "Error al resolver la base del MR"
+        "5f3d2c8a1b": "Error al resolver la base del MR",
+        "dropPartiallyAttached": "No se pudieron adjuntar {{failureCount}} de {{count}} elementos.",
+        "dropPartiallyAttached_one": "No se pudo adjuntar {{failureCount}} de {{count}} elemento.",
+        "dropPartiallyAttached_other": "No se pudieron adjuntar {{failureCount}} de {{count}} elementos."
       },
       "useGlobalFileDrop": {
         "38c9f034ff": "No se pudieron cargar los archivos soltados.",
@@ -889,7 +1069,14 @@
         "linearDescription": "Cómo funciona Linear en Orca, lista de configuración, habilidad del agente y ejemplos de prompts.",
         "pluginsTitle": "Plugins",
         "pluginsDescription": "Instala y administra plugins experimentales de Orca.",
-        "tasksDescription": "Conecta proveedores, instala la habilidad de Linear y elige qué aparece en Tareas."
+        "tasksDescription": "Conecta proveedores, instala la habilidad de Linear y elige qué aparece en Tareas.",
+        "artifactsTitle": "Artefactos",
+        "artifactsDescription": "Comparte archivos HTML y Markdown con tu equipo y gestiona sus enlaces públicos.",
+        "automationsTitle": "Automatizaciones",
+        "automationsDescription": "Programa el trabajo del agente y elige si Automatizaciones aparece en la barra lateral.",
+        "shareSkillsTitle": "Compartir skills",
+        "shareSkillsDescription": "Comparte tus skills con un enlace no listado. Cualquiera que lo tenga puede instalarlos.",
+        "floatingWorkspaceWebDescription": "Pestañas globales de terminal y markdown."
       },
       "useAppMenuPaste": {
         "pasteTooLarge": "El contenido pegado es demasiado grande."
@@ -902,6 +1089,36 @@
         "description": "Los mensajes de permisos de macOS pueden aparecer cuando un agente o una herramienta de terminal que se ejecuta en Orca intenta acceder a archivos protegidos. Concede acceso total al disco en Ajustes para reducir estos avisos.",
         "openSettings": "Abrir ajustes",
         "dismiss": "No volver a mostrar"
+      },
+      "useInstalledAgentSkills": {
+        "unreadableSkillSource": "Una carpeta de skills no respondió, así que este estado puede estar incompleto."
+      },
+      "useMacTccAttributionSeveredNotice": {
+        "title": "Los permisos de macOS podrían no llegar a las terminales de Orca",
+        "description": "Las terminales de Orca en ejecución las aloja un daemon iniciado por una instalación anterior de Orca. Es posible que macOS no les aplique los permisos de Accesibilidad, Automatización o archivos protegidos de Orca. Reinicia el daemon desde Gestionar sesiones para restaurar el acceso. Esto cerrará todas las terminales de Orca en ejecución.",
+        "openManageSessions": "Abrir Gestionar sesiones",
+        "dismiss": "Descartar",
+        "folderAccessTitle": "Las terminales no pueden leer tu {{folder}}",
+        "folderAccessDescription": "macOS está bloqueando el servicio de terminal de Orca en esta carpeta, así que los comandos que se ejecuten allí podrían fallar hasta que se solucione.",
+        "folderAccessFix": "Solucionar"
+      },
+      "ipc": {
+        "events": {
+          "browserStateIpcBridge": {
+            "docPreviewLinkFailed": "No se pudo abrir este enlace en Orca Browser."
+          },
+          "os": {
+            "markdown": {
+              "file": {
+                "open": {
+                  "bridge": {
+                    "1e9a1a63c4": "No se pudo abrir el archivo Markdown."
+                  }
+                }
+              }
+            }
+          }
+        }
       }
     },
     "components": {
@@ -911,7 +1128,11 @@
         "a4c8e1b2f7": "Codex sigue conectado como {{value0}}",
         "d3e8a1f4b2": "Cuenta cambiada",
         "9375620cc3": "Reinicia esta sesión para usar {{value0}}. Se mantiene en la cuenta anterior hasta que lo hagas.",
-        "6133594b12": "Mantener cuenta anterior"
+        "6133594b12": "Mantener cuenta anterior",
+        "8f0d5c92a1": "La configuración de Codex cambió",
+        "3ea91b5c07": "Esta sesión de Codex usa una configuración obsoleta",
+        "e6b7139d2a": "Reinicia esta sesión para cargar tu configuración actual de Codex.",
+        "7b1d20f4c8": "Mantener sesión actual"
       },
       "FirstLaunchBanner": {
         "b9e1b966c7": "Descartar aviso",
@@ -1113,7 +1334,18 @@
           "activity": "Actividad",
           "noActivity": "Sin actividad aún."
         },
-        "checkActionRequiredHint": "Esta verificación necesita una acción manual en GitHub (por ejemplo, aprobar la ejecución del workflow) antes de que se desbloquee la fusión."
+        "checkActionRequiredHint": "Esta verificación necesita una acción manual en GitHub (por ejemplo, aprobar la ejecución del workflow) antes de que se desbloquee la fusión.",
+        "e15a8b77ef": "No hay detalles en línea disponibles para esta verificación.",
+        "e45324fbed": "No se pudieron cargar los detalles de la verificación.",
+        "dcb3c546fe": "Reintentar",
+        "85a2b66f54": "Abrir archivos en GitHub",
+        "86d84a17ca": "Añadir un comentario de revisión",
+        "d9fa90b625": "No se pudo cargar el diff.",
+        "4aecf121e7": "Cerrar",
+        "8812225174": "Reabrir",
+        "09d67a0f9b": "No se pudo cerrar la PR",
+        "88809e79db": "No se pudo reabrir la PR",
+        "00f55cc17b": "El acceso al repositorio no está disponible para esta PR."
       },
       "GitLabItemDialog": {
         "65e784c1f1": "Reabrir",
@@ -1178,7 +1410,8 @@
         "3a051b8ade": "Work item",
         "32f8bef818": "Sin output de log.",
         "4168eb2c51": "Resolver",
-        "commentTooLarge": "El comentario es demasiado grande para enviarlo de forma segura."
+        "commentTooLarge": "El comentario es demasiado grande para enviarlo de forma segura.",
+        "gitlabActionFailed": "La acción de GitLab falló."
       },
       "JiraIssueWorkspace": {
         "b0b92666c9": "Comentar",
@@ -1426,7 +1659,11 @@
         "addSshHostHint": "Use an existing machine over SSH",
         "addRemoteOrcaServer": "Add Remote Orca Server",
         "addRemoteOrcaServerHint": "Pair another Orca runtime",
-        "hostConnectionFailed": "Connection failed"
+        "hostConnectionFailed": "Connection failed",
+        "defaultBranchUpdateFailed": "No se pudo actualizar la rama predeterminada del proyecto. Inténtalo de nuevo.",
+        "setLocation": "Establecer ubicación del proyecto",
+        "setLocationOnHost": "Establecer ubicación del proyecto en {{host}}",
+        "setLocationTooltip": "Elige una carpeta o clona este proyecto en {{host}}."
       },
       "NewWorkspaceComposerModal": {
         "createWorktree": "Crear worktree",
@@ -1607,7 +1844,10 @@
         "4b8ae7303f": "No se pudo cargar la diferencia.",
         "closePullRequestFailed": "No se pudo cerrar el pull request",
         "reopenPullRequestFailed": "No se pudo reabrir el pull request",
-        "diffLoadTimedOut": "Se agotó el tiempo de espera al cargar esta diferencia."
+        "diffLoadTimedOut": "Se agotó el tiempo de espera al cargar esta diferencia.",
+        "6b1d5ee3e4": "No hay detalles en línea disponibles para esta verificación.",
+        "e04c027d98": "No se pudieron cargar los detalles de la verificación.",
+        "5df7c41d2a": "Reintentar"
       },
       "QuickOpen": {
         "1dbd3f59ff": "Mover",
@@ -1996,7 +2236,9 @@
         "61ed600d29": "\"{{value0}}\" tiene cambios no guardados. ¿Quieres guardar antes de cerrar?",
         "cdc9ac4b2d": "editor",
         "e57db40c11": "No se pudo generar el comando de inicio para {{value0}}.",
-        "5b2c1a9e44": "No se detectó ninguna CLI de agente; instala una o elige un agente predeterminado en Ajustes."
+        "5b2c1a9e44": "No se detectó ninguna CLI de agente; instala una o elige un agente predeterminado en Ajustes.",
+        "b7c1f0a934": "No se pudo contactar con un host remoto, así que Orca no puede saber si el trabajo sigue en ejecución allí. ¿Cerrar la ventana de todos modos?",
+        "quitSnapshotSaveFailed": "Salida cancelada: no se pudo guardar la instantánea de la sesión ({{value0}})."
       },
       "TerminalSearch": {
         "db234b7519": "Cerrar",
@@ -2053,7 +2295,8 @@
         "a4650b0dc4": "No se pudo usar la compilación local",
         "b1e390250d": "No se pudo completar el cambio de compilación local.",
         "d29740d175": "La compilación seleccionada no pudo ser usada.",
-        "37d45c9ec1": "Elegir otra compilación"
+        "37d45c9ec1": "Elegir otra compilación",
+        "7f1a4c9e02": "Tu gestor de paquetes del sistema instaló Orca, así que actualízalo desde allí; Orca no puede instalar esta versión por sí mismo."
       },
       "WorktreeJumpPalette": {
         "ac037cfac2": "Mover",
@@ -2097,7 +2340,8 @@
         "pluginCommandFailed": "No se pudo ejecutar el comando del plugin.",
         "27f10cca63": "Busca chats, terminales, worktrees, ajustes y acciones...",
         "2770f02910": "Busca chats, terminales, worktrees, ajustes y acciones",
-        "recentChatsTerminalsHeader": "Chats y terminales recientes"
+        "recentChatsTerminalsHeader": "Chats y terminales recientes",
+        "lastActiveTime": "Última actividad hace {{value0}}"
       },
       "github": {
         "pr": {
@@ -2281,7 +2525,29 @@
           },
           "ProjectViewStates": {
             "3b9c1d5e47": "Esta vista aún no tiene elementos.",
-            "7e4a2f80c6": "Los elementos añadidos recientemente pueden tardar un poco en aparecer."
+            "7e4a2f80c6": "Los elementos añadidos recientemente pueden tardar un poco en aparecer.",
+            "ac83c45672": "Cambie a una vista de tabla o hoja de ruta para trabajar con este proyecto en Orca.",
+            "e4cc8b14f2": "Orca representa vistas de proyectos de tabla y hoja de ruta. Esta vista utiliza un diseño que aún no se puede representar."
+          },
+          "ProjectRoadmap": {
+            "be52f7b6db": "Esta vista de hoja de ruta no tiene un campo de fecha o iteración para colocar elementos, así que Orca los muestra en una lista.",
+            "6405e036e0": "Mes",
+            "f2b1cabef7": "Trimestre",
+            "b6afc6fe45": "Año",
+            "343888b143": "Colocado por {{value0}}",
+            "6a088a5da1": "{{value0}} sin fechas",
+            "86eebd6020": "Hoy",
+            "0bb1c1bc07": "Zoom de línea de tiempo",
+            "e304235879": "Artículo",
+            "e077c79083": "Sin fechas"
+          },
+          "ProjectRoadmapBar": {
+            "cd68ccc17a": "{{value0}} — {{value1}}",
+            "7d1220d979": "Artículo restringido"
+          },
+          "ProjectPickerPanels": {
+            "04ec212ccb": "Hoja de ruta",
+            "9fe1ac868c": "No compatible"
           }
         },
         "GitHubMarkdownComposer": {
@@ -2410,6 +2676,11 @@
             "label": "Cerrar como duplicado",
             "description": "Duplicado de otro issue"
           }
+        },
+        "CommentReactions": {
+          "addReaction": "Añadir reacción",
+          "removeNamedReaction": "Eliminar la reacción {{value0}}",
+          "addNamedReaction": "Añadir reacción {{value0}}"
         }
       },
       "linear": {
@@ -2616,7 +2887,9 @@
             "selectedForDeletionCount": "Seleccionados para eliminar: {{value0}}",
             "deleteButtonCount": "Eliminar {{value0}}",
             "archivedStatus": "Archivado",
-            "readyStatus": "Listo"
+            "readyStatus": "Listo",
+            "f637f63882": "El administrador de recursos cuenta {{value0}}; esta lista encontró {{value1}}. Ese contador lee solo el registro de actividad de Orca, mientras que este escaneo también verifica el historial de git de cada espacio de trabajo y omite los controles remotos desconectados.",
+            "74f6c16279": "Atrás"
           },
           "backgroundRemoval": {
             "removed": "Espacios de trabajo eliminados: {{value0}}",
@@ -2663,6 +2936,16 @@
             "dirtyFilesBlocker": "Archivos modificados",
             "unknownBaseBlocker": "No se pudieron verificar confirmaciones sin enviar",
             "dismissedBlocker": "Ignorado"
+          },
+          "workspace": {
+            "cleanup": {
+              "candidate": {
+                "row": {
+                  "b5d2b33e47": "Eliminando…",
+                  "e1135728e3": "En cola para eliminación"
+                }
+              }
+            }
           }
         }
       },
@@ -2697,12 +2980,15 @@
           "commands": {
             "TerminalQuickCommandActionToggle": {
               "b0d58e37ed": "Prompt de agente",
-              "b5ea4d64f6": "Comando de terminal"
+              "b5ea4d64f6": "Comando de terminal",
+              "terminal_short": "Terminal",
+              "agent_short": "Agente"
             },
             "TerminalQuickCommandAppendEnterSwitch": {
               "e4e5fed3b3": "Alternar agregar Enter",
               "c936c2d6d2": "Enviar inmediatamente en lugar de solo insertar texto.",
-              "5fa607d807": "Agregar Enter"
+              "5fa607d807": "Agregar Enter",
+              "767e4be3e3": "Agregar Enter: ejecutar inmediatamente"
             },
             "TerminalQuickCommandDialog": {
               "925b8e0f6e": "Avanzado",
@@ -2719,7 +3005,11 @@
               "dc921c17ee": "Prompt",
               "5b3f634a55": "Agregar comando rápido",
               "f9b184fc16": "Editar comando rápido",
-              "6751598542": "editar"
+              "6751598542": "editar",
+              "command_label": "Dominio",
+              "agent_toolbar_hint": "Apoyos/objetivo, habilidades, caminos",
+              "agent_footer_hint": "Las indicaciones de varias líneas están bien: manténgalas enfocadas.",
+              "resize_hint": "Arrastra la esquina para cambiar el tamaño"
             },
             "TerminalQuickCommandDialogFooter": {
               "2e2b958dfc": "Guardar",
@@ -2753,22 +3043,21 @@
             "stop_command_description": "Al cerrar esta terminal, se detendrá el comando que se está ejecutando en ella.",
             "dont_ask_again": "No volver a preguntar para terminales en ejecución",
             "stop_agent_confirm": "Detener agente",
-            "stop_command_confirm": "Detener y cerrar"
+            "stop_command_confirm": "Detener y cerrar",
+            "automatic_resume_warning": "Esta terminal no se reanudará automáticamente. Cancele y ponga el espacio de trabajo en suspensión para reanudarlo más tarde."
           },
           "MobileDriverOverlay": {
             "c6460cf584": "Recuperar control",
-            "c8f2e1a4b9": "Recuperar control de este terminal",
             "c44659e09f": "Teléfono controlando",
-            "7cffad954c": "Contraer",
             "3eed73394f": "Tu teclado está en pausa",
-            "faa367dc74": "Tu teléfono dejó esto en tamaño móvil",
-            "54f7d6f69d": "Recuperar control de todos los terminales",
-            "b3d8e1f42a": "Restaurar este terminal",
-            "e8c4f2a91b": "Restaurar todos los terminales",
-            "f2a8b9c1d3": "Desde tu teléfono",
             "c7e4a2b8f1": "Tu teléfono tiene el control",
-            "d9f3c6e2a4": "El teclado de escritorio está en pausa. Recupera este terminal para escribir aquí, recupera todos los terminales que controla tu teléfono o contrae para seguir observando.",
-            "a6b1d8f3e2": "La sesión del teléfono terminó. Restaura el tamaño de escritorio para este terminal o para todos los terminales que tu teléfono dejó en tamaño móvil."
+            "4b7e1c9a20": "Todavía del tamaño adecuado para tu teléfono.",
+            "9d2f6a3e58": "Tu sesión telefónica terminó. Restaurar para que se ajuste a esta ventana.",
+            "1e5c8b7d43": "Restaurar",
+            "6a3d9f2c71": "Restaurar todo",
+            "8c1a5e9f36": "La escritura en el escritorio está en pausa. La salida continúa transmitiéndose.",
+            "2f7b4d1e95": "recuperar todo",
+            "3a9c5f7e12": "Minimizar"
           },
           "TerminalAgentSessionForkDialog": {
             "17fc841e59": "Copiar contexto",
@@ -2801,7 +3090,8 @@
             "c2f0b72b8d": "Insertar",
             "925f49f210": "Expandir panel",
             "df766809e0": "Contraer panel",
-            "cff67afad1": "Copiar contexto"
+            "cff67afad1": "Copiar contexto",
+            "15dd899676": "Añadir a {{value0}}…"
           },
           "TerminalErrorToast": {
             "e4aa243f8c": "Reiniciar servicio",
@@ -2810,7 +3100,15 @@
             "cc6d997c65": "Reinicia el servicio del terminal desde aquí para borrar el estado obsoleto.",
             "remoteTerminalClosed": "La terminal remota se cerró.",
             "ptyAllocationLimit": "Tu sistema no puede asignar más dispositivos pty. Cierra algunas terminales que no estés usando, en Orca o en otro programa, y vuelve a intentarlo.",
-            "terminalProcessLimit": "Tu sistema no puede iniciar otro proceso de terminal. Cierra las terminales que no uses o sal de los procesos que no necesites y vuelve a intentarlo."
+            "terminalProcessLimit": "Tu sistema no puede iniciar otro proceso de terminal. Cierra las terminales que no uses o sal de los procesos que no necesites y vuelve a intentarlo.",
+            "retry": "Reintentar",
+            "retrying": "Reintentando…",
+            "retryUnavailable": "Reintentar no pudo volver a conectarse todavía. Vuelve a intentarlo en breve.",
+            "ownerUnknown": "Orca no pudo verificar el propietario de esta terminal.",
+            "42b283ecfc": "Orca no pudo volver a conectar de manera segura esta terminal porque el host no pudo verificar su sesión guardada. Orca dejó la sesión guardada sin cambios. Haga clic en Reintentar para intentar volver a conectarse ahora. Si aún no puede volver a conectarse, abra una nueva terminal.",
+            "e16012e31e": "El demonio de terminal propietario de esta sesión salió, por lo que no se pudo recuperar la sesión y su desplazamiento hacia atrás. Abra una nueva terminal para continuar.",
+            "sessionUnavailable": "Orca no pudo volver a conectarse a la sesión de terminal de este panel en el host. Abra una nueva terminal para continuar.",
+            "sourceRestoring": "Reconectando este terminal: se está restableciendo su salida. La sesión aún está en marcha."
           },
           "TerminalProcessExitOverlay": {
             "capacityTitle": "Se alcanzó el límite de consolas de Git Bash",
@@ -2963,6 +3261,29 @@
           },
           "TerminalRestoringPlaceholder": {
             "restoring": "Restaurando terminal…"
+          },
+          "TerminalLinkActionPopover": {
+            "openLink": "Abrir enlace",
+            "openFile": "Abrir archivo",
+            "switchWorkspace": "Cambiar espacio de trabajo",
+            "openInFinder": "Abrir en el Finder",
+            "openFolder": "Abrir carpeta",
+            "openWithDefaultApp": "Abrir con la aplicación predeterminada",
+            "switchTerminal": "terminal de interruptor",
+            "openTaskTerminal": "Abrir terminal de tareas",
+            "systemBrowser": "Navegador del sistema",
+            "orcaBrowser": "Navegador Orca",
+            "terminalLinkSettings": "Configuración de enlace de terminal",
+            "copyLink": "Copiar enlace",
+            "copied": "Copiado",
+            "copiedLink": "Enlace copiado",
+            "copyLinkFailed": "No se pudo copiar el enlace",
+            "downloadOpenWithDefaultApp": "Descargar y abrir con la aplicación predeterminada",
+            "downloadOpenFailed": "No se pudo descargar '{{value0}}'."
+          },
+          "TerminalQuickCommandsSubmenu": {
+            "3ccc7981bb": "Anfitrión no disponible",
+            "54f29b7c0d": "Cargando host…"
           }
         }
       },
@@ -3025,7 +3346,10 @@
             "1d04b1630b": "Dividir hacia abajo",
             "6b3efb106e": "Dividir hacia arriba",
             "fdd29eb669": "Fijar pestaña",
-            "8e9d603a09": "Desanclar pestaña"
+            "8e9d603a09": "Desanclar pestaña",
+            "revealInFinder": "Revelar en Finder",
+            "openContainingFolder": "Abrir carpeta contenedora",
+            "revealInFileExplorer": "Revelar en el Explorador de archivos"
           },
           "QuickLaunchButton": {
             "348a04c1ad": "Ajustes de Agents…",
@@ -3189,6 +3513,14 @@
           },
           "TerminalTabLeadingIcon": {
             "7ab2964bea": "Finalización de agente sin leer"
+          },
+          "TabBarQuickCommandAddActions": {
+            "45a2f36d51": "Dominio",
+            "b856c833ae": "Comando en {{value0}}"
+          },
+          "TabBarQuickCommandHostLoadStatus": {
+            "82e294f3ca": "Anfitrión no disponible",
+            "7c129b08ff": "Cargando host…"
           }
         }
       },
@@ -3306,7 +3638,9 @@
             "connectedHostCount_other": "{{count}} hosts",
             "connecting": "Conectando…",
             "workspaceConflict": "Conflicto del espacio de trabajo",
-            "workspaceSyncError": "Error de sincronización del espacio de trabajo"
+            "workspaceSyncError": "Error de sincronización del espacio de trabajo",
+            "runtime_unavailable_transport_up": "Orca no disponible",
+            "runtime_workspace_window_closed": "Ventana del espacio de trabajo cerrada"
           },
           "CaffeinateStatusSegment": {
             "active": "Activo",
@@ -3376,10 +3710,12 @@
             "grokUsageAria": "Abrir detalles de uso de Grok",
             "grokUsageMenu": "Uso de Grok",
             "floatingTerminalNewActivity": "{{label}}, nueva actividad",
+            "4fba7dc1e7": "saldo {{value0}}",
             "codexSignInSuccess": "Sesión iniciada en Codex",
             "codexSignInError": "No se pudo iniciar sesión en Codex. Inténtalo de nuevo.",
             "cursorUsageMenu": "Uso de Cursor",
-            "hiddenUsageProviders": "También: {{value0}}"
+            "hiddenUsageProviders": "También: {{value0}}",
+            "zcodeUsageMenu": "Uso del código Z"
           },
           "StatusBarUsageEmptyCta": {
             "828c764a79": "Conectar una cuenta",
@@ -3554,6 +3890,16 @@
                 "message": "Ejecuta cursor-agent login en una terminal del equipo donde se ejecuta Orca y vuelve a intentar consultar el uso."
               },
               "plan": "Plan"
+            },
+            "zcode": {
+              "mcp": "MCP"
+            },
+            "minimax": {
+              "expired": {
+                "label": "El inicio de sesión expiró",
+                "apiKey": "La clave API MiniMax expiró. Reemplácelo en Configuración.",
+                "cookie": "La cookie de sesión MiniMax expiró. Reemplácelo en Configuración."
+              }
             }
           },
           "SshTargetStatusRow": {
@@ -3650,7 +3996,24 @@
             "resumingLabel": "Reanudando {{value0}} chats",
             "resumingAriaOne": "Reanudando 1 chat. Haz clic para ver los detalles.",
             "resumingAria": "Reanudando {{value0}} chats. Haz clic para ver los detalles.",
-            "resumingTooltip": "Restaurando los chats interrumpidos y pidiéndoles que continúen…"
+            "resumingTooltip": "Restaurando los chats interrumpidos y pidiéndoles que continúen…",
+            "labelOne": "1 chat para reanudar",
+            "label": "{{value0}} chats para reanudar",
+            "ariaLabelOne": "1 chat disponible para reanudar",
+            "ariaLabel": "{{value0}} chats disponibles para reanudar",
+            "tooltip": "Abrir chats interrumpidos disponibles para reanudar"
+          },
+          "RuntimeHostStatusRow": {
+            "previous_connection_closed": "La conexión anterior cerrada.",
+            "workspace_window_closed": "La ventana del espacio de trabajo está cerrada.",
+            "checking_host": "Orca está comprobando si este host es accesible",
+            "restoring_connection": "Orca está intentando restablecer la conexión.",
+            "host_unreachable": "No se puede acceder a Orca en este host",
+            "runtime_unavailable": "El transporte SSH está conectado, pero el tiempo de ejecución de Orca no está disponible",
+            "runtime_unavailable_explanation": "Es posible que el host remoto todavía esté ejecutándose; sólo la conexión en tiempo de ejecución de Orca no está disponible.",
+            "contact_note": "Es posible que el host todavía esté ejecutándose; sólo la conexión Orca no está disponible.",
+            "last_connected": "Última conexión {{value0}}",
+            "reconnect_attempt": "Intento {{value0}}"
           }
         }
       },
@@ -3760,7 +4123,8 @@
           "rangeLast7Days": "Últimos 7 días",
           "rangeLast30Days": "Últimos 30 días",
           "rangeLast90Days": "Últimos 90 días",
-          "rangeAllTime": "Todo el tiempo"
+          "rangeAllTime": "Todo el tiempo",
+          "costExcludesUnpricedModels": "• excluye modelos sin precio"
         },
         "OpenCodeUsagePane": {
           "349f7c3f5c": "Total",
@@ -3837,7 +4201,8 @@
           "908c470587": "codex",
           "eb6a066185": "claude",
           "eee19cfade": "resumen",
-          "grokUsageTab": "Grok"
+          "grokUsageTab": "Grok",
+          "trackingSince": "Seguimiento desde {{value0}}"
         },
         "UsageOverviewPane": {
           "22ed1b7669": "sesiones",
@@ -3927,13 +4292,19 @@
               "a7f937fb29": "{{value0}} sesiones - {{value1}} {{value2}}",
               "c8f3a2d1e0b4": "turnos",
               "d9a4b3e2f1c5": "eventos",
-              "recentCombinedActivity": "Actividad combinada reciente de tokens de Claude, Codex, OpenCode y Muse."
+              "recentCombinedActivity": "Actividad combinada reciente de tokens de Claude, Codex, OpenCode y Muse.",
+              "statusScanning": "Exploración",
+              "statusEnabled": "Activado",
+              "statusOff": "Apagado"
             }
           }
         },
         "UsageBreakdownSection": {
           "7765a4c3e1": "n/a",
-          "247c93ca92": "• precios inferidos"
+          "247c93ca92": "• precios inferidos",
+          "32176e1d44": "vueltas",
+          "79a69522a5": "eventos",
+          "02a046792e": "sesiones •"
         },
         "UsageSessionsTable": {
           "1afc25eb06": "Turnos",
@@ -4028,10 +4399,32 @@
           "remoteShareNotice": "Estas skills están en {{host}}. Abre Skills en esa máquina para compartirlas.",
           "viewSwitch": "Mostrar",
           "searchLinks": "Buscar enlaces",
-          "deleteSkills": "Eliminar skills…"
+          "deleteSkills": "Eliminar skills…",
+          "984405683f": "Complemento",
+          "4d177feabd": "incluido",
+          "aa59462502": "Repositorio",
+          "571c5818c1": "Hogar",
+          "0bc1379f4c": "Todas las fuentes",
+          "38e0951c3a": "Habilidades del agente",
+          "fb6bf60b52": "Claude",
+          "426be2aac6": "Codex",
+          "39b6998ddb": "Todos los proveedores",
+          "e46e162e2e": "de",
+          "b088e0785d": "Beta",
+          "7e828fb2c6": "Atrás",
+          "ab5b777350": "Se comprobaron las carpetas de habilidades de inicio, repositorio, paquetes y complementos.",
+          "0c74e7ff34": "Instalado"
         },
         "SkillShareSelectionControls": {
-          "01c5a15e02": "Compartir skills"
+          "01c5a15e02": "Compartir skills",
+          "01c5a15e05": "Compartir habilidades {{value0}}",
+          "01c5a15e01": "Cancelar compartir",
+          "01c5a15e03": "{{value0}} seleccionado",
+          "01c5a15e04": "Seleccionar todos los resultados",
+          "01c5a15e06": "Abra esta habilidad en su propia máquina para compartirla.",
+          "01c5a15e07": "Instala esta habilidad antes de compartirla.",
+          "01c5a15e08": "Solo se pueden compartir habilidades en el hogar y el espacio de trabajo.",
+          "01c5a15e09": "Una habilidad con este nombre ya está seleccionada de otra fuente."
         },
         "SkillRow": {
           "updatedUnknown": "Sin fecha",
@@ -4040,7 +4433,11 @@
           "detailPath": "Ruta",
           "skillActions": "Acciones para {{value0}}",
           "viewDetails": "Ver detalles",
-          "deleteSkill": "Eliminar…"
+          "deleteSkill": "Eliminar…",
+          "notShareable": "No compartible",
+          "detailSource": "Fuente",
+          "detailContents": "Contenido",
+          "notDeletable": "No eliminable"
         },
         "SkillsList": {
           "listLabel": "Skills"
@@ -4072,7 +4469,19 @@
           "shareOne": "Compartir {{count}} skill",
           "shareOther": "Compartir {{count}} skills",
           "linkOne": "{{count}} enlace",
-          "linkOther": "{{count}} enlaces"
+          "linkOther": "{{count}} enlaces",
+          "installOne": "Instalar la habilidad {{count}}",
+          "installOther": "Instalar habilidades {{count}}",
+          "retryOne": "Reintentar la habilidad {{count}}",
+          "retryOther": "Reintentar habilidades {{count}}",
+          "deleteOne": "Eliminar habilidad {{count}}",
+          "deleteOther": "Eliminar habilidades {{count}}",
+          "deletedOne": "Habilidad {{count}} eliminada",
+          "deletedOther": "Habilidades {{count}} eliminadas",
+          "deleteFolderOne": "Carpeta {{count}}",
+          "deleteFolderOther": "{{count}} carpetas",
+          "deleteLinkOne": "enlace {{count}}",
+          "deleteLinkOther": "Enlaces {{count}}"
         },
         "filter": {
           "allAgents": "Todos los agentes",
@@ -4179,7 +4588,9 @@
           "upToDate": "Actualizado",
           "installed": "Instalado",
           "details": "Details",
-          "needsAttention": "Review skill"
+          "needsAttention": "Review skill",
+          "checking": "De cheques...",
+          "checkFailed": "Verificación fallida"
         },
         "SkillUpdateResultRows": {
           "stillOutdated": "Still out of date after the update ran."
@@ -4191,6 +4602,376 @@
         "host": {
           "local": "Esta máquina",
           "remote": "Entorno conectado"
+        },
+        "SkillShareDialog": {
+          "reconnect": "Vuelva a conectar su cuenta Orca antes de compartir.",
+          "unconfigured": "Conecte una cuenta de Orca Cloud antes de compartir.",
+          "prepareFailed": "No se pudo preparar esta habilidad para compartir.",
+          "peopleRequired": "Selecciona al menos un compañero de equipo.",
+          "publishCancelled": "Subida cancelada. La copia preparada todavía está disponible para volver a intentarlo.",
+          "publishFailed": "No se pudo publicar esta habilidad. La copia preparada todavía está disponible para volver a intentarlo.",
+          "copied": "Compartir enlace copiado",
+          "preparing": "Preparando vista previa…",
+          "ready": "Enlace de habilidad listo",
+          "title": "Compartir habilidad",
+          "readyDescription": "Los destinatarios se autentican en Orca antes de poder inspeccionarlo o instalarlo.",
+          "newVersionDescription": "Revise los archivos exactos y luego publique una versión inmutable en el paquete de nube existente.",
+          "description": "Revise los archivos exactos, elija quién puede acceder a ellos y luego publique una versión inmutable.",
+          "0f07fa2a79": "Publicar habilidad",
+          "7aa4ba0dba": "Publicar nueva versión",
+          "3a51d0f34f": "Cancelar carga",
+          "e9d652ae3d": "Cancelado…",
+          "30985d4fc0": "Cancelar",
+          "3af85f6add": "Hecho",
+          "readyDescriptionV2": "Cualquiera que tenga este enlace no listado puede inspeccionar e instalar las habilidades.",
+          "descriptionV2": "Revise los archivos exactos y luego publique una versión inmutable detrás de un enlace no listado.",
+          "publishBundle": "Publicar paquete",
+          "cancelRequestFailed": "Orca no pudo enviar la solicitud de cancelación. Es posible que la carga aún finalice."
+        },
+        "SkillCard": {
+          "d25a1b8ae6": "Compartir habilidad",
+          "01c5a16e01": "Seleccione {{value0}}"
+        },
+        "SkillCloudManagementActions": {
+          "ed753624c0": "Eliminar paquete en la nube",
+          "640bc6b92e": "Confirmar la eliminación del paquete",
+          "6b6adf68c1": "Eliminar la versión de la nube seleccionada",
+          "bbec37d8f8": "Confirmar la eliminación de la versión",
+          "7a80285dad": "Dejar de compartir",
+          "0ac5c175fd": "Confirmar dejar de compartir",
+          "9e6bd31487": "No hay enlaces para compartir activos.",
+          "c7f2b69122": "Dejar de compartir bloquea futuras instalaciones. Las copias ya instaladas en cualquier máquina permanecen allí.",
+          "8cac3b9362": "Enlaces activos",
+          "cc8e4ef6ba": "Guardar acceso",
+          "eb603f7888": "fuera de la lista actual se conservarán.",
+          "3d346ddce8": "destinatario existente",
+          "2b8c569ea7": "Organización actual",
+          "2552c12fea": "Acceso",
+          "505cd6105c": "Controles para compartir en la nube",
+          "linkCopied": "Compartir enlace copiado",
+          "activeLinkBearerDescription": "Cualquiera que tenga un enlace activo puede inspeccionar e instalar las habilidades. La revocación bloquea el acceso futuro pero deja las copias instaladas sin cambios.",
+          "copyLink": "Copiar enlace"
+        },
+        "SkillInstallDialog": {
+          "39acb9e8f4": "instalar habilidad",
+          "59c3b76cdd": "Reintentar la instalación",
+          "241e72f9d6": "Instalando…",
+          "05588076a9": "Cancelar instalación",
+          "d198ec91e5": "Cerrar",
+          "4a00d133c5": "Orca verifica el acceso y la identidad del paquete antes de cambiar la máquina seleccionada.",
+          "fcbec627cc": "Instalar habilidad compartida",
+          "01c5a14e01": "Instalar habilidades compartidas",
+          "opening": "Abriendo este enlace…"
+        },
+        "SkillInstallManagementDialog": {
+          "8095927ff3": "Cerrar",
+          "e91af0079f": "Eliminar",
+          "470d8d2476": "Confirmar eliminación",
+          "c1d03ee50d": "Cancelar instalación",
+          "561e49ccd1": "Instalar la versión seleccionada",
+          "2ae587d39c": "Reintentar cobertura incompleta",
+          "f7c5075e77": "Descartar cambios y eliminar",
+          "e1884c812e": "Descartar cambios e instalar la versión.",
+          "070654c6d1": "Orca los conservará a menos que descartes explícitamente los cambios locales.",
+          "74b70892ea": "Los archivos locales fueron modificados.",
+          "86ed219b55": "Elige una versión",
+          "9c04bd0120": "Versión instalada",
+          "64c71cf7b9": "No se encontraron instalaciones de habilidades administradas por Orca en esta máquina.",
+          "0900db719a": "— desconectado",
+          "176fef9516": "· SSH",
+          "6cb1fbe039": "esta computadora",
+          "3677ae58e7": "Actualice, revierta o elimine de forma segura las versiones instaladas por Orca.",
+          "44d118a8f7": "Administrar habilidades instaladas",
+          "1c9e7f420a": "Habilidades del paquete instalado",
+          "34c2ef9e71": "Instalar habilidades {{count}}",
+          "a0cab67c2f": "Eliminar habilidades {{count}}",
+          "f970d8088d": "Confirmar la eliminación de {{count}} habilidades",
+          "dab29e4b54": "{{installed}} instalado · {{updated}} actualizado · {{keptLocal}} mantenido local",
+          "installAnotherMachine": "Instalar en otra máquina"
+        },
+        "SkillInstallReviewContent": {
+          "89e2601162": "Desechar y reemplazar",
+          "a5675fb371": "contenido y lo dejó intacto. Consérvelo o deséchelo explícitamente y reemplácelo con esta versión.",
+          "37d990b94c": "cambió",
+          "2a31912f14": "Orca encontrada",
+          "651b7d8a57": "La copia local necesita una decisión",
+          "98ed90e523": "Una habilidad contiene instrucciones y puede incluir guiones. Trátelo como código de su autor.",
+          "f72ee4022a": "SHA-256",
+          "3d8421ca2f": "ejecutable",
+          "87137bcb8d": "guiones",
+          "fab8fce842": "archivos",
+          "8f9833d509": "Versión inmutable",
+          "66270286ac": "· Puedes volver a intentarlo de forma segura.",
+          "1b6ad2ca5c": "comprobado.",
+          "3fc62a61eb": "colocación",
+          "157de228b4": "inspeccionar habilidad",
+          "69236de8d6": "De cheques…",
+          "27672470d9": "Abrir el enlace no instala nada. Revise primero la versión inmutable.",
+          "66cff7a804": "https://app.orca.dev/skills/share/…",
+          "93eb0fe8c7": "Enlace de habilidad de Orca",
+          "releaseNotes": "Notas de la versión:",
+          "targetHeader": "Objetivo de instalación"
+        },
+        "SkillInstallTargetFields": {
+          "8e6a972229": "No se conocen espacios de trabajo en esta máquina.",
+          "7a366323e7": "Carpeta",
+          "d628c416a2": "árbol de trabajo de git",
+          "5845cfe543": "Elija un árbol de trabajo o carpeta",
+          "0e5b43a9e3": "Espacio de trabajo",
+          "0c10a406fb": "WSL·",
+          "e5b0d15e64": "sistema operativo anfitrión",
+          "cb47652227": "Entorno de ejecución",
+          "a4dfd33095": "Un espacio de trabajo",
+          "c779621aa0": "Habilidades globales",
+          "63cc9e31fe": "Destino",
+          "85d85880df": "· SSH",
+          "71eefd7660": "— desconectado",
+          "0785d0a503": "— actualización requerida",
+          "8562dd1e6e": "esta computadora",
+          "b8a0b706ad": "Máquina"
+        },
+        "SkillInstallWorkspaceCombobox": {
+          "search": "Buscar espacios de trabajo...",
+          "empty": "No se encontraron espacios de trabajo."
+        },
+        "SkillShareReviewContent": {
+          "e3caf6baeb": "Revocar este enlace bloquea el acceso futuro. No elimina las copias ya instaladas en las máquinas de los destinatarios.",
+          "6d6233a3a4": "Copiar enlace",
+          "0142581727": "Subiendo…",
+          "ad940367a5": "Validando y publicando…",
+          "bf02d6ed9e": "¿Qué cambió en esta versión?",
+          "f0c0411549": "Notas de la versión",
+          "4895d3e0ee": "No hay compañeros de equipo disponibles.",
+          "8188f5d765": "puede acceder al enlace.",
+          "fe204e06f0": "la organización",
+          "0cd4b3e396": "Todos actualmente en",
+          "f25429e266": "personas seleccionadas",
+          "0a49d901ab": "Organización",
+          "6817a7f6f8": "Acceso a habilidades",
+          "c15d90c10b": "Se requiere una cuenta de Orca Cloud conectada.",
+          "266527d295": "Publicando como {{value0}}{{value1}}.",
+          "78d863235c": "Acceso",
+          "b3b1d4b911": "SHA-256",
+          "77f636eac3": "ejecutable",
+          "8edd32622f": "guiones",
+          "3121f44358": "archivos",
+          "2dca0b720b": "Publicar nueva versión de habilidad",
+          "01c5a17e01": "{{value0}} habilidades",
+          "01c5a17e02": "Revisión de habilidades incluidas.",
+          "01c5a17e03": "{{value0}} archivos · {{value1}}",
+          "unlistedLinkTitle": "Enlace no listado",
+          "unlistedPublishingAs": "Publicando como {{value0}}. Cualquiera que tenga el enlace puede inspeccionar e instalar estas habilidades.",
+          "unlistedLinkDetails": "El enlace no se puede buscar ni aparece públicamente. Revocarlo para bloquear el acceso futuro; quedan copias instaladas.",
+          "bundleReady": "Enlace del paquete de habilidades listo",
+          "publishBundleVersion": "Publicar una nueva versión del paquete de habilidades",
+          "shareBundle": "Compartir paquete de habilidades",
+          "publishingLink": "Enlace de publicación…",
+          "verifyingPackage": "Verificando paquete…"
+        },
+        "SkillBundleInstallFlow": {
+          "01c5a13e01": "Cerrar",
+          "01c5a13e02": "Cancelar instalación",
+          "01c5a13e03": "Instalando…",
+          "01c5a13e04": "Reintentar habilidades {{value0}}",
+          "01c5a13e05": "Instalar habilidades {{value0}}"
+        },
+        "SkillBundleInstallOutcome": {
+          "01c5a12e01": "Instalado",
+          "01c5a12e02": "Actualizado",
+          "01c5a12e03": "Sin alterar",
+          "01c5a12e04": "Mantenido local",
+          "01c5a12e05": "Fallido",
+          "01c5a12e06": "Cancelado",
+          "01c5a12e07": "La instalación del paquete necesita atención.",
+          "01c5a12e08": "Habilidades instaladas y verificadas.",
+          "01c5a12e09": "{{value0}} habilidades seleccionadas marcadas.",
+          "01c5a12e10": "Necesita volver a intentarlo"
+        },
+        "SkillBundleInstallReview": {
+          "01c5a11e01": "Versión inmutable",
+          "01c5a11e02": "{{value0}} habilidades",
+          "01c5a11e03": "Archivos {{value0}}",
+          "01c5a11e04": "{{value0}} guiones",
+          "01c5a11e05": "{{value0}} ejecutable",
+          "01c5a11e06": "SHA-256",
+          "01c5a11e09": "Notas de la versión:",
+          "01c5a11e0a": "Las habilidades contienen instrucciones y pueden incluir guiones. Trátelos como código de su autor.",
+          "01c5a11e0b": "Habilidades para instalar",
+          "01c5a11e0c": "Elija cualquier subconjunto de este paquete.",
+          "01c5a11e0d": "Seleccionar todo",
+          "01c5a11e0e": "Sin descripción",
+          "01c5a11e0f": "{{value0}} archivos · {{value1}} scripts",
+          "01c5a11e10": "{{value0}} ejecutable",
+          "01c5a11e11": "Las copias locales necesitan una decisión.",
+          "01c5a11e12": "Orca conservará estas copias locales de forma predeterminada. Seleccione solo las copias que desea descartar y reemplazar.",
+          "01c5a11e13": "Reemplazar {{value0}} ({{value1}})",
+          "01c5a11e14": "{{value0}} nuevo",
+          "01c5a11e15": "{{value0}} sin cambios",
+          "01c5a11e16": "{{value0}} actualizaciones",
+          "01c5a11e17": "{{value0}} conflictos"
+        },
+        "SkillManagedInstallList": {
+          "86c76cb262": "Paquete de habilidades {{count}}"
+        },
+        "skill-install-progress-state": {
+          "currentSkill": "Instalando {{value0}} de {{value1}}: {{value2}}…"
+        },
+        "SkillSelectionBar": {
+          "selectAll": "Seleccione todos los {{count}} elegibles",
+          "clear": "Claro"
+        },
+        "share": {
+          "fileExecutable": "ejecutable",
+          "fileScript": "guion",
+          "reviewFiles": "Revisar archivos que se pueden ejecutar",
+          "reviewSkills": "Revisión de habilidades incluidas.",
+          "releaseNotesVersion": "Notas de la versión",
+          "releaseNotesOptional": "Agregar notas de la versión (opcional)",
+          "releaseNotesFirst": "Describe esta versión",
+          "readyDescription": "Copia el enlace para compartirlo.",
+          "newVersionDescription": "Publica una versión inmutable del paquete existente.",
+          "description": "Publica una versión inmutable detrás de un enlace no listado.",
+          "accessSummary": "Cualquiera que tenga el enlace puede instalarlo. No aparece en ninguna parte y revocarlo bloquea nuevas instalaciones, no copias ya instaladas. Publicando como {{value0}}.",
+          "manageLinks": "Administrar o revocar este enlace en Configuración",
+          "scriptOne": "Guión {{count}}",
+          "scriptOther": "{{count}} guiones",
+          "executableOne": "{{count}} ejecutable",
+          "executableOther": "{{count}} ejecutables",
+          "noExecutableContent": "Sin scripts ni ejecutables",
+          "newVersionDescriptionPlain": "Agrega una nueva versión al enlace existente.",
+          "accessSummaryShort": "Enlace no listado: cualquiera que lo tenga puede instalarlo. Publicando como {{value0}}.",
+          "accessSummaryPlain": "Enlace no listado: cualquiera que lo tenga puede instalarlo."
+        },
+        "description": {
+          "showLess": "Mostrar menos",
+          "showMore": "Mostrar más"
+        },
+        "install": {
+          "authorizing": "Autorizando el acceso al paquete...",
+          "installing": "Descargando, verificando e instalando...",
+          "selectSkill": "Seleccione al menos una habilidad.",
+          "chooseWorkspace": "Elija un espacio de trabajo.",
+          "reconnectBeforeInstalling": "Vuelva a conectar su cuenta de Orca antes de realizar la instalación.",
+          "bundleVerificationFailed": "La instalación falló antes de que Orca pudiera verificar el paquete solicitado.",
+          "destinationAlreadyFinished": "El destino ya había terminado esta instalación.",
+          "enterShareLink": "Ingrese un enlace para compartir habilidades de Orca.",
+          "shareUnavailable": "Este recurso compartido no está disponible. El enlace puede no ser válido, caducado o revocado.",
+          "requestedVersionVerificationFailed": "La instalación falló antes de que Orca pudiera verificar la versión solicitada.",
+          "versionVerificationFailed": "Orca no pudo verificar la versión solicitada.",
+          "inspectManagedFailed": "Orca no pudo inspeccionar las instalaciones administradas en esta máquina.",
+          "reconnectForVersionHistory": "Vuelva a conectar su cuenta de Orca para cargar el historial de versiones.",
+          "versionHistoryUnavailable": "El historial de versiones no está disponible para esta habilidad.",
+          "bundleSkillsMissing": "Esta versión no contiene ninguna de las habilidades del paquete instalado.",
+          "reconnectBeforeVersionChange": "Vuelva a conectar su cuenta Orca antes de cambiar de versión.",
+          "removeFailed": "Orca no pudo eliminar esta habilidad de forma segura.",
+          "agentsLabel": "Agentes",
+          "agentsCanonical": "Siempre instalado para {{value0}}, que decía {{value1}}.",
+          "agentsNoneChosen": "Sin agentes adicionales",
+          "agentsSummary": "También: {{value0}}",
+          "agentNotInstalled": "No instalado",
+          "bundleDestinationSummary": "{{value0}} nuevo · {{value1}} ya instalado · {{value2}} necesita una decisión",
+          "trustNote": "Las habilidades son instrucciones y códigos de su autor. Instala lo que confías.",
+          "agentsNone": "No hay agentes seleccionados",
+          "agentsSelected": "Instalación para: {{value0}}",
+          "agentAlways": "Siempre",
+          "agentsCanonicalNote": "{{value0}} lee {{value1}}, que escribe cada instalación.",
+          "linkHint": "Abrir un enlace nunca instala nada: primero lo revisas.",
+          "rowNeedsDecision": "Necesita una decisión",
+          "rowInstalled": "Ya instalado",
+          "rowUpdate": "Actualizar",
+          "rowNew": "Nuevo",
+          "chooseSkills": "Elija qué instalar desde este enlace.",
+          "singleRunnableWarning": "Esta habilidad incluye scripts o archivos binarios.",
+          "runnableWarning": "{{affectedCount}} de {{selectedCount}} habilidades seleccionadas incluyen scripts o archivos binarios: {{affected}}.",
+          "reviewRunnableFiles": "Incluye scripts o archivos binarios.",
+          "reviewSupportingFiles": "Incluye archivos de soporte",
+          "reviewInstructions": "Acerca de esta habilidad",
+          "supportingFileWarning": "Las habilidades seleccionadas incluyen {{fileCount}} más allá de SKILL.md.",
+          "agentAccessWarning": "Las habilidades contienen instrucciones que su agente puede seguir. Continúe solo si confía en la fuente de este enlace para compartir.",
+          "fileBinary": "binario",
+          "fileRunnable": "ejecutable",
+          "agentsCountBadge": "{{count}} seleccionado",
+          "agentsCountLabel": "{{count}} {{label}}",
+          "targetAgentsHeader": "Agentes objetivo",
+          "deselectAll": "Deseleccionar opcional",
+          "selectAll": "Seleccionar todo",
+          "canonicalHeader": "Agentes Estándar (Siempre Incluidos)",
+          "canonicalExplanation": "Estos agentes leen de forma nativa {{root}}, que Orca instala de forma predeterminada:",
+          "additionalAgentsHeader": "Directorios de agentes adicionales"
+        },
+        "SkillSharedLinkRow": {
+          "contentsUnavailable": "No se pudo cargar lo que contiene este enlace.",
+          "loading": "Cargando contenidos…",
+          "deleteFailed": "Orca no pudo eliminar esto de la nube.",
+          "deleted": "Eliminado de la nube",
+          "confirmDelete": "Confirmar eliminación",
+          "moreActions": "Otras acciones para {{name}}",
+          "deletePackage": "Eliminar de la nube"
+        },
+        "SkillSharedLinksView": {
+          "loading": "Cargando enlaces compartidos…",
+          "noMatches": "Ningún enlace coincide con esta búsqueda."
+        },
+        "SkillsSharedLinksHeader": {
+          "back": "Volver a habilidades",
+          "backTooltip": "Volver a habilidades · Esc",
+          "unlisted": "No listado: solo las personas con un enlace pueden abrirlo."
+        },
+        "managedInstall": {
+          "versionLabel": "Versión",
+          "editedWarning": "Sus ediciones se conservan a menos que decida descartarlas.",
+          "finishInstall": "Terminar de instalar",
+          "useVersion": "Usa esta versión",
+          "reinstall": "Reinstalar",
+          "cancel": "Cancelar",
+          "sendToMachine": "Enviar a otra máquina",
+          "confirmRemove": "Confirmar eliminación",
+          "remove": "Eliminar",
+          "discardEditsRemove": "Descartar mis ediciones y eliminar",
+          "discardEdits": "Descartar mis ediciones y reinstalar",
+          "titleMore": "{{name}} +{{count}}",
+          "scopeWorkspace": "este espacio de trabajo",
+          "scopeGlobal": "En todos lados",
+          "installedOn": "Instalado {{date}}",
+          "stateEdited": "Editado después de instalar",
+          "stateMissing": "Faltan archivos",
+          "skillEdited": "Editado",
+          "skillMissing": "Desaparecido",
+          "versionCurrent": "{{date}} (instalado)",
+          "installElsewhere": "Instalar en otro lugar..."
+        },
+        "skillWarningPreview": {
+          "bundleDescription": "Un paquete de vista previa que cubre todos los niveles de advertencia.",
+          "instructionsOnlyDescription": "Instrucciones contenidas íntegramente en SKILL.md.",
+          "supportingFilesDescription": "Incluye archivos de referencia legibles más allá de las instrucciones principales.",
+          "runnableFilesDescription": "Incluye scripts que un agente puede ejecutar con su acceso.",
+          "binaryFilesDescription": "Incluye activos opacos y un binario ejecutable."
+        },
+        "SkillDelete": {
+          "dismissResults": "Descartar",
+          "reasonBundled": "Incluido con Orca: sería restaurado",
+          "reasonPlugin": "Instalado mediante un complemento; en su lugar, elimine el complemento",
+          "reasonUnowned": "Esta habilidad se encuentra fuera de las carpetas de habilidades de Orca; elimínela donde está almacenada.",
+          "reasonMissing": "Esta habilidad ya no está en el disco.",
+          "reasonStale": "Esta habilidad cambió desde que se cargó la lista: actualice e intente nuevamente",
+          "blockedLine": "{{count}} × {{reason}}",
+          "resultLine": "{{count}} × {{label}}",
+          "statusSkipped": "Saltado",
+          "statusBusy": "Ocupado: hay otra operación de habilidad en curso",
+          "statusPartial": "Parcialmente eliminado: algunos archivos todavía están en el disco con un nombre oculto",
+          "statusFailed": "Error: nada cambió",
+          "statusDeleted": "Eliminado",
+          "confirmHost": "En {{host}}.",
+          "confirmPermanent": "Esto no se puede deshacer.",
+          "failed": "No se pudieron eliminar habilidades",
+          "hostUnavailable": "No se pudo acceder a la máquina seleccionada. Actualiza e inténtalo de nuevo.",
+          "hostUnresolved": "Todavía estoy encontrando la máquina que posee estas habilidades.",
+          "hostUpdateRequired": "Actualice Orca en la máquina seleccionada para eliminar habilidades.",
+          "nothingOne": "Esa habilidad no se puede eliminar desde aquí.",
+          "nothingOther": "Ninguna de las {{count}} habilidades seleccionadas se puede eliminar desde aquí.",
+          "placementSummaryParts": "Elimina {{parts}} a través de {{roots}}.",
+          "placementJoin": "y",
+          "retainedSource": "La habilidad en sí permanece en {{path}}."
         }
       },
       "sidebar": {
@@ -4324,7 +5105,8 @@
           "32a7256d85": "Clonar",
           "69f5b5380d": "Clonando...",
           "cloneOnHostDescription": "Introduce la URL de Git y elige dónde clonarlo en {{value0}}.",
-          "cloneParentFolder": "Carpeta padre"
+          "cloneParentFolder": "Carpeta padre",
+          "remoteCloneParentPlaceholder": "/home/user/projects"
         },
         "AutoRenameFailedDialog": {
           "aed1623b1e": "Cerrar",
@@ -4450,7 +5232,8 @@
           "d36883e046": "Cancelar",
           "b79b39d865": "Quitar proyecto",
           "removeDescriptionSsh": "Esto solo elimina {{name}} de Orca. Sus archivos permanecen en {{host}}; vuelve a añadir ese host SSH para recuperarlo.",
-          "removeDescriptionLocal": "Esto solo elimina {{name}} de Orca. Sigue estando en tu disco."
+          "removeDescriptionLocal": "Esto solo elimina {{name}} de Orca. Sigue estando en tu disco.",
+          "removeDescriptionVmRecipe": "Esto elimina {{name}} de Orca. Su receta de VM determina si el entorno y sus archivos se eliminan permanentemente."
         },
         "ScrollToCurrentWorkspaceToolbarButton": {
           "23989bb663": "Mostrar espacio de trabajo activo"
@@ -4555,7 +5338,9 @@
           "196c1b5362": "Abrir tareas de GitLab",
           "0ccba862b8": "Abrir tareas de GitHub",
           "fee535205b": "Tareas",
-          "d599269755": "Ocultar de la barra lateral"
+          "d599269755": "Ocultar de la barra lateral",
+          "artifacts": "Artefactos",
+          "skills": "Habilidades"
         },
         "SidebarRepositoryFilterSection": {
           "d3a9c4cea1": "Limpiar",
@@ -4602,7 +5387,9 @@
           "cliCreated": "Hide CLI-created",
           "detachedHead": "Ocultar HEAD desacoplado",
           "keepDefaultBranch": "Excepto la rama predeterminada",
-          "keepDefaultBranchAria": "Mantener visible la rama predeterminada al ocultar los espacios de trabajo en reposo"
+          "keepDefaultBranchAria": "Mantener visible la rama predeterminada al ocultar los espacios de trabajo en reposo",
+          "otherClients": "Ocultar espacios de trabajo de otros clientes",
+          "otherClientsAria": "Ocultar espacios de trabajo creados desde otros clientes Orca en servidores remotos compartidos"
         },
         "SidebarWorkspaceOptionsMenu": {
           "95c9754653": "Diseño de actividad del Agent",
@@ -4662,7 +5449,8 @@
           "65a9820bd1": "Estados de Agents",
           "219ebf1961": "Nombre de rama",
           "folderPathIdentity": "Rama / ruta de carpeta",
-          "cli": "Orca CLI"
+          "cli": "Orca CLI",
+          "workspaceOptions": "Opciones de espacio de trabajo"
         },
         "SshTargetRow": {
           "4677394048": "Conectando…",
@@ -4780,7 +5568,8 @@
           "cliCreated": "Created by Orca CLI",
           "jiraIssue": "Jira {{value0}}",
           "viewOnJira": "Ver en Jira",
-          "linkedJira": "Jira {{value0}} vinculado"
+          "linkedJira": "Jira {{value0}} vinculado",
+          "openInOrcaBrowser": "Abrir en el navegador Orca"
         },
         "WorktreeCardMetadataStatusBadges": {
           "fe188062a1": "Estado: Abierto",
@@ -4831,7 +5620,10 @@
           "setParentWorkspace": "Establecer worktree padre...",
           "workspaceSection": "Espacio de trabajo",
           "primaryDeleteDisabled": "El worktree principal no se puede eliminar. Quita el proyecto en su lugar.",
-          "deleteWorktree": "Eliminar worktree"
+          "deleteWorktree": "Eliminar worktree",
+          "sleepWithDescendants": "Dormir con Descendientes ({{value0}})",
+          "sleepWithDescendantsDescription": "Cierre los paneles activos en este espacio de trabajo y en todos los descendientes anidados para liberar memoria y CPU.",
+          "deleteWithDescendants": "Eliminar con Descendientes…"
         },
         "WorktreeList": {
           "d880ea0744": "Crea un grupo y mueve este proyecto a él.",
@@ -4875,7 +5667,9 @@
           "hostDisconnected": "Desconectado",
           "failedNestWorkspace": "No se pudo anidar el espacio de trabajo",
           "sidebarRowMissing": "El destino ya no existe",
-          "failedUnnestWorkspace": "Error al expandir el espacio de trabajo"
+          "failedUnnestWorkspace": "Error al expandir el espacio de trabajo",
+          "groupRenameFailed": "No se pudo cambiar el nombre del grupo",
+          "groupRenameFailedDesc": "Orca no pudo confirmar el nuevo nombre con el anfitrión del grupo. Vuelva a verificar el grupo después de volver a conectarse."
         },
         "WorktreeMetaDialog": {
           "3db0a2a593": "Cancelar",
@@ -4896,7 +5690,12 @@
           "65770ad0f0": "Edita enlaces y notas de GitHub para este espacio de trabajo.",
           "382fd11a3e": "Editar detalles del worktree",
           "2174f17011": "Guardar",
-          "61d6f612cf": "Guardando..."
+          "61d6f612cf": "Guardando...",
+          "a0d191b7a7": "Edite enlaces de problemas, enlaces de solicitudes de extracción y notas para este espacio de trabajo.",
+          "gitlabDescription": "Edite enlaces de problemas, enlaces de solicitudes de fusión y notas para este espacio de trabajo.",
+          "gitlabMR": "GitLab Señor",
+          "gitlabPlaceholder": "SEÑOR ! o URL de GitLab",
+          "gitlabHelp": "Pegue una URL de solicitud de fusión o ingrese un número. Déjelo en blanco para eliminar el enlace."
         },
         "WorktreeOpenInMenu": {
           "1417fd8380": "Personalizar apps...",
@@ -5022,7 +5821,8 @@
               "ae57cbf6e4": "No se pudo eliminar el espacio de trabajo",
               "7488ed8711": "Ver",
               "2b20ce87b3": "Forzar eliminación",
-              "4f3876c0f5": "Falló la eliminación forzada"
+              "4f3876c0f5": "Falló la eliminación forzada",
+              "workspaceListChanged": "La lista de espacios de trabajo cambió"
             },
             "toast": {
               "1d0fa5c0a5": "No se pudo eliminar el espacio de trabajo {{value0}}",
@@ -5030,7 +5830,16 @@
               "905fc8efac": "Git ya eliminó este espacio de trabajo. Usa Forzar eliminación para borrarlo de Orca.",
               "0899ebdb28": "Git ya olvidó este espacio de trabajo, pero su directorio todavía está en disco. Usa Forzar eliminación para eliminar el directorio huérfano.",
               "locked": "Este espacio de trabajo está bloqueado por Git. Ejecute git worktree unlock <worktree-path> desde su repositorio, luego intente la eliminación de nuevo.",
-              "lockedReason": "Este espacio de trabajo está bloqueado por Git. Git reportó: {{value0}}. Ejecute git worktree unlock <worktree-path> desde su repositorio, luego intente la eliminación de nuevo."
+              "lockedReason": "Este espacio de trabajo está bloqueado por Git. Git reportó: {{value0}}. Ejecute git worktree unlock <worktree-path> desde su repositorio, luego intente la eliminación de nuevo.",
+              "unstoppedPty": "Orca no pudo confirmar que todos los terminales de este espacio de trabajo hayan salido, por lo que se detuvo antes de eliminar cualquier archivo. Utilice Forzar eliminación para eliminarlo de todos modos.",
+              "unstoppedPtyLive": "Este espacio de trabajo todavía tiene terminales en ejecución, por lo que Orca se detuvo antes de eliminar cualquier archivo. Forzar eliminación los matará y descartará cualquier trabajo no comprometido que tengan.",
+              "runningAgentSession": "Orca no pudo confirmar que todas las sesiones del agente en este espacio de trabajo se hayan cerrado, por lo que se detuvo antes de eliminar ningún archivo. Utilice Forzar eliminación para eliminarlo de todos modos.",
+              "runningAgentSessionLive": "Este espacio de trabajo todavía tiene sesiones de agente en ejecución que Orca no pudo cerrar, por lo que se detuvo antes de eliminar cualquier archivo. Forzar eliminación descartará cualquier trabajo que tenga."
+            },
+            "failure": {
+              "archive": {
+                "waiver": "Eliminar de todos modos"
+              }
             }
           }
         },
@@ -5296,12 +6105,18 @@
           "setParentFor": "Establecer padre para"
         },
         "WorktreeCardStatusSlot": {
-          "branchIdentity": "Rama"
+          "branchIdentity": "Rama",
+          "sleeping": "Durmiendo"
         },
         "NewExternalWorktreesInboxLine": {
           "9f2d4c8b17": "Ocultar worktrees externos permanentemente para {{value0}}",
           "5e1b8d3f62": "Ocultar worktrees externos permanentemente",
-          "c3e8a1f4b2": "No volver a mostrar"
+          "c3e8a1f4b2": "No volver a mostrar",
+          "2a6f31d8c7": "árbol de trabajo oculto",
+          "5b90e4a2f6": "árboles de trabajo ocultos",
+          "7f18c5b0d3": "Revisar el árbol de trabajo oculto {{value0}} en {{value1}}",
+          "4e2b7a9c05": "Revisar {{value0}} árboles de trabajo ocultos en {{value1}}",
+          "6c07f3a91e": "{{value0}} en {{value1}}"
         },
         "NoticeHostGlyph": {
           "hostDisconnected": "{{hostName}} está desconectado",
@@ -5365,7 +6180,34 @@
           "linkDestination": "Destino del enlace",
           "sshTunnel": "Estoy usando un túnel SSH",
           "sshTunnelHelp": "De lo contrario, este enlace apunta a este dispositivo y no puede identificar el otro equipo.",
-          "loopbackBlocked": "Activa la opción de túnel SSH o crea un enlace nuevo con la dirección de Tailscale o LAN del otro host."
+          "loopbackBlocked": "Activa la opción de túnel SSH o crea un enlace nuevo con la dirección de Tailscale o LAN del otro host.",
+          "sshAlreadyExists": "Ese host SSH ya está en Orca.",
+          "sshConfigPickerLoadFailed": "No se pudo leer ~/.ssh/config.",
+          "sshConfigPickerResolveFailed": "No se pudo resolver ese host de configuración SSH.",
+          "sshConfigPickerRestartRequired": "Reinicie Orca para terminar de aplicar la actualización del selector de configuración SSH.",
+          "sshConfigPickerFilled": "Llenado desde {{value0}}. Revisar y guardar.",
+          "sshConfigPickerTitle": "Elija entre ~/.ssh/config",
+          "sshConfigPickerDescription": "Elija un anfitrión para completar el formulario. No se guarda nada hasta que haces clic en Guardar.",
+          "sshConfigPickerFilter": "Filtrar hosts…",
+          "sshConfigPickerHostsLabel": "Hosts de configuración SSH",
+          "sshConfigPickerLoading": "Leyendo ~/.ssh/config…",
+          "sshConfigPickerEmpty": "No hay hosts en ~/.ssh/config",
+          "sshConfigPickerNoMatch": "No hay hosts coincidentes",
+          "sshConfigPickerEmptyHint": "Agregue una entrada de Host allí o regrese y escriba los detalles manualmente.",
+          "sshConfigPickerNoMatchHint": "Pruebe con otro filtro o regrese y escriba manualmente.",
+          "sshConfigPickerMoreResults": "Mostrando las primeras {{value0}} coincidencias. Limita tu filtro para encontrar más.",
+          "sshConfigPickerInOrca": "en Orca",
+          "sshConfigPickerPreviouslyRemoved": "Eliminado de Orca",
+          "sshConfigPickerBulkHint": "La sincronización masiva permanece en Configuración → SSH",
+          "sshConfigPickerBack": "Atrás",
+          "fillFromSshConfig": "Rellenar desde ~/.ssh/config…",
+          "sshConfigPickerAddingAll": "Agregando hosts…",
+          "sshConfigPickerAddAll": "Añadir todos los {{value0}} a Orca",
+          "sshConfigPickerNoNewHosts": "No hay nuevos hosts para agregar",
+          "sshConfigPickerAddAllEmpty": "Agregar todo a Orca",
+          "identityFileFromConfigHint": "Dejado vacío a propósito: Orca usa todas las claves ~/.ssh/config resuelve para {{value0}}. Escriba una ruta para usar solo esa clave.",
+          "sshConfigPickerRetry": "Probar de nuevo",
+          "sshConfigPickerResolving": "Lectura…"
         },
         "ForgetSshWorkspaceDialog": {
           "reconnectFailed": "Error de reconexión",
@@ -5410,6 +6252,95 @@
           "copied": "Comando copiado",
           "retry": "Reintentar ahora",
           "restored": "Git funciona de nuevo. Worktrees actualizados."
+        },
+        "WorktreeIssueLinkField": {
+          "25852bfc59": "Linear",
+          "5b440069e6": "GitHub",
+          "161b2d053a": "Abrir problema vinculado",
+          "d4785f9954": "Los enlaces de problemas se establecen cuando se crea un espacio de trabajo de carpeta y no se pueden cambiar aquí todavía.",
+          "964d9bc00a": "No es una clave de problema Linear ni una URL de problema Linear.app.",
+          "0a7a2c6efd": "No es un número de problema de GitHub ni una URL de problema.",
+          "72486800ff": "Al guardar se desvinculan {{first}} y {{second}}: un espacio de trabajo rastrea un problema.",
+          "2c245ac134": "Al guardar se desvincula {{link}}: un espacio de trabajo rastrea un problema.",
+          "d8c8a30d1f": "No se pudo abrir ese problema. Comprueba el identificador y tu conexión Linear.",
+          "269198eeda": "No se pudo abrir ese problema. Verifica el número y tu conexión de GitHub.",
+          "f047887705": "Pegue una URL de GitHub o Linear, o ingrese un número. Déjelo en blanco para eliminar el enlace.",
+          "ad78f9bee2": "Asunto",
+          "662ae142f8": "Número de problema, o una URL de GitHub o Linear",
+          "929c98d05a": "Proveedor de problemas"
+        },
+        "worktreeIssueDisplacement": {
+          "3f61c0a8d2": "Linear {{value}}",
+          "9c4b7e1f60": "GitHub #{{value}}"
+        },
+        "WorktreeCardSshHostControl": {
+          "connectFailed": "La conexión SSH falló",
+          "removedTooltip": "Host SSH eliminado: la reconexión no está disponible",
+          "removedName": "Se eliminó el host SSH {{value0}}",
+          "connectedTooltip": "Proyecto en host SSH",
+          "connectedName": "Proyecto en host SSH {{value0}}",
+          "connectingName": "Conexión al host SSH {{value0}}",
+          "authFailedName": "Vuelva a conectar el host SSH {{value0}}: falló la autenticación",
+          "retryName": "Vuelva a intentar la conexión SSH a {{value0}}",
+          "connectName": "Conéctese al host SSH {{value0}}",
+          "authFailedTooltip": "{{value0}} · autenticación fallida",
+          "failedTooltip": "{{value0}} · conexión fallida"
+        },
+        "preserved": {
+          "branch": {
+            "batch": {
+              "toast": {
+                "a3cdd9d9e6": "Git mantuvo {{count}} ramas locales porque pueden contener confirmaciones no fusionadas. Las ramas mantenidas no conservan las carpetas del espacio de trabajo; sus confirmaciones permanecen en el repositorio. Orca puede continuar liberando espacio en el disco del espacio de trabajo en segundo plano.",
+                "a3cdd9d9e6_one": "Git mantuvo la rama local {{count}} porque puede contener confirmaciones no fusionadas. Las ramas mantenidas no conservan las carpetas del espacio de trabajo; sus confirmaciones permanecen en el repositorio. Orca puede continuar liberando espacio en el disco del espacio de trabajo en segundo plano.",
+                "a3cdd9d9e6_other": "Git mantuvo {{count}} ramas locales porque pueden contener confirmaciones no fusionadas. Las ramas mantenidas no conservan las carpetas del espacio de trabajo; sus confirmaciones permanecen en el repositorio. Orca puede continuar liberando espacio en el disco del espacio de trabajo en segundo plano.",
+                "6310412304": "Revisar sucursales {{count}}",
+                "6310412304_one": "Revisar sucursal {{count}}",
+                "6310412304_other": "Revisar sucursales {{count}}",
+                "cea24c2b7d": "{{count}} espacios de trabajo eliminados",
+                "cea24c2b7d_one": "{{count}} espacio de trabajo eliminado",
+                "cea24c2b7d_other": "{{count}} espacios de trabajo eliminados",
+                "0e0379f24a": "{{count}} sucursales mantenidas",
+                "0e0379f24a_one": "{{count}} sucursal mantenida",
+                "0e0379f24a_other": "{{count}} sucursales mantenidas",
+                "4cf75caab7": "{{value0}}, {{value1}}",
+                "e61d78054f": "Eliminando sucursales locales: {{value0}}",
+                "1e1a5f6763": "Sucursales locales eliminadas: {{value0}}",
+                "43d9395605": "{{value0}} eliminado, {{value1}} no eliminado",
+                "d42f1f14e0": "Reintentar {{count}} ramas",
+                "d42f1f14e0_one": "Reintentar rama {{count}}",
+                "d42f1f14e0_other": "Reintentar {{count}} ramas"
+              }
+            }
+          }
+        },
+        "PreservedBranchBatchReviewDialog": {
+          "c4bf8e7eaf": "Revisar sucursales mantenidas",
+          "f21976c9a8": "Seleccione las sucursales locales que desea forzar la eliminación. Las sucursales no seleccionadas permanecen en sus repositorios.",
+          "38c947f7c5": "Seleccionar todo",
+          "9602129d38": "{{value0}} de {{value1}} seleccionado",
+          "ee39e872d5": "Puede estar desfusionado",
+          "676db406fd": "Cabeza no disponible",
+          "285e1e4882": "Cancelar",
+          "a0f9863597": "Forzar eliminación de ramas {{count}}",
+          "a0f9863597_one": "Forzar eliminación de rama {{count}}",
+          "a0f9863597_other": "Forzar eliminación de ramas {{count}}"
+        },
+        "WorktreeListScrollToTopButton": {
+          "jumpToTop": "Saltar hacia arriba"
+        },
+        "RepoScanUnavailableIndicator": {
+          "title": "Error en el análisis del árbol de trabajo para {{value0}}",
+          "retry": "Reintentar escaneo",
+          "retained": "Los árboles de trabajo existentes se conservan hasta que el análisis se realice correctamente. Haga clic en el icono de advertencia para volver a intentarlo.",
+          "xcodeLicense": "Las herramientas de desarrollo de Apple requieren la aceptación de la licencia antes de que Git pueda ejecutarse.",
+          "developerTools": "Las herramientas de desarrollo de línea de comandos de Apple faltan o no están disponibles.",
+          "architectureMismatch": "No se pudo ejecutar un ejecutable relacionado con Git porque su arquitectura de CPU es incompatible con este host de ejecución. Instale Git y herramientas relacionadas para la arquitectura del host.",
+          "copyDiagnostics": "Copiar diagnóstico"
+        },
+        "manualSortSwitch": {
+          "title": "Orden cambiado a Manual",
+          "description": "Manual mantiene los espacios de trabajo donde los colocas.",
+          "restore": "Volver a {{label}}"
         }
       },
       "shared": {
@@ -5438,7 +6369,35 @@
           "c34fb1098d": "Las pestañas de terminal se cerraron y se solicitó el apagado.",
           "d9657ac204": "Se solicitó el apagado de la sesión de terminal.",
           "e8f25bd903": "No se pudo completar la limpieza del terminal.",
-          "a702d4196e": "Esto cierra cada pestaña de terminal en todos los espacios de trabajo y solicita el apagado de sus sesiones de terminal actuales. Cualquier trabajo de terminal no guardado se pierde. El daemon en sí continúa ejecutándose y se pueden abrir terminales nuevas inmediatamente. Esta acción no se puede deshacer."
+          "a702d4196e": "Esto cierra cada pestaña de terminal en todos los espacios de trabajo y solicita el apagado de sus sesiones de terminal actuales. Cualquier trabajo de terminal no guardado se pierde. El daemon en sí continúa ejecutándose y se pueden abrir terminales nuevas inmediatamente. Esta acción no se puede deshacer.",
+          "01d6b7c64e": "Las terminales abiertas y los agentes se reiniciarán. Los terminales en hosts remotos no se ven afectados.",
+          "922548bc66": "¿Reiniciar el servicio de terminal?"
+        },
+        "MacFolderAccessFixDialog": {
+          "stepAllow": "Permitir Orca en Archivos y Carpetas",
+          "openSystemSettings": "Abrir configuración del sistema",
+          "stepRestart": "Reiniciar el servicio de terminal de Orca",
+          "restartConsequence": "Las terminales abiertas y los agentes se reiniciarán.",
+          "restarting": "Reiniciando…",
+          "restart": "Reanudar",
+          "restartFailed": "El reinicio falló. Vuelva a intentarlo desde Configuración → Terminal → Administrar sesiones.",
+          "title": "Repara el acceso a tu {{folder}}",
+          "lead": "macOS está bloqueando el servicio de terminal de Orca desde esta carpeta.",
+          "done": "Hecho",
+          "cancel": "Cancelar",
+          "stepAllowUnknown": "No se pudo verificar. Omitir si ya está permitido.",
+          "stepAllowDenied": "Orca ya está permitido, pero macOS no lo aplica al servicio de terminal. Restablecer vuelve a pedir permiso a macOS. Haga clic en Permitir cuando se le solicite.",
+          "stepReallow": "Vuelve a permitir Orca para tu {{folder}}",
+          "reset": "Restablecer permiso",
+          "resetting": "Restableciendo…",
+          "resetFailed": "No se pudo restablecer el permiso. Utilice la configuración del sistema en su lugar.",
+          "resetStillBlocked": "Todavía bloqueado después del reinicio."
+        },
+        "macFolderAccessFolderName": {
+          "documents": "Carpeta de documentos",
+          "desktop": "Carpeta de escritorio",
+          "downloads": "Carpeta de descargas",
+          "workspace": "carpeta del espacio de trabajo"
         }
       },
       "setup": {
@@ -5609,7 +6568,34 @@
               "placeholder": "Déjalo en blanco para usar la clave guardada por /connect o OPENCODE_API_KEY",
               "help": "Se usa para mostrar el uso de OpenCode Go en la barra de estado. La cookie de sesión de abajo solo es necesaria para cuentas antiguas de consola (OpenCode Black)."
             }
-          }
+          },
+          "d5267cce63": "). La cookie de autenticación todavía cubre el descubrimiento del espacio de trabajo; La autenticación por sí sola no es suficiente para su uso. La autenticación OpenCode Go está basada en la web y se comparte entre terminales Windows y WSL.",
+          "62ab430f94": "Pegue el encabezado completo de la cookie desde DevTools → Red → cualquier solicitud de opencode.ai, incluida __Host-console_session (p. ej.",
+          "37b4b4a3f7": "autenticación=…; __Host-console_session=…",
+          "0335bd31d5": "Pegue el encabezado completo de la cookie opencode.ai, incluido __Host-console_session, para recuperar el límite de velocidad.",
+          "codexLoginLinkPending": "Codex abrió este enlace de inicio de sesión en su navegador. Cópielo para terminar de iniciar sesión en otro lugar: una ventana privada u otro perfil.",
+          "codexLoginLinkCopied": "Copiado",
+          "codexLoginLinkCopy": "Copiar enlace",
+          "codexLoginLinkOpen": "Abierto",
+          "codexLoginLinkCopyFailed": "No se pudo copiar el enlace.",
+          "d6f1b9b6a2": "Se requiere la clave API MiniMax.",
+          "7c5d8a4e1b": "La clave API MiniMax no se guardó.",
+          "4d2c7b9e83": "Clave API MiniMax guardada.",
+          "f8a4b9d210": "Punto final MiniMax",
+          "0b3a9f6c2e": "Elija el host que coincida con su cuenta. Tanto en el extranjero (platform.minimax.io) como en China (platform.minimaxi.com) aceptan una cookie de sesión o una clave API.",
+          "83b6a1f7c4": "Clave API MiniMax",
+          "4f2c8a7e1b": "Pegue su clave API MiniMax",
+          "a7b1e3c5d2": "olvidar clave",
+          "usageTracking": "Configure el seguimiento de uso de MiniMax para su cuenta.",
+          "credentialsNotSet": "Credenciales no configuradas",
+          "selectedEndpointStorage": "Almacenado localmente y enviado al punto final MiniMax seleccionado para actualizaciones de uso.",
+          "endpointOverseas": "En el extranjero (plataforma.minimax.io)",
+          "endpointChina": "China (plataforma.minimaxi.com)",
+          "openSelectedConsole": "Abra {{url}} en su navegador e inicie sesión.",
+          "cookieSelectedEndpoint": "Almacenado localmente y enviado al punto final MiniMax seleccionado para actualizaciones de uso.",
+          "copySelectedConsoleCookie": "Abra la consola seleccionada, inicie sesión y luego copie el encabezado de solicitud de cookies de DevTools (Red → cualquier solicitud restante → Cookie).",
+          "apiKeySelectedEndpoint": "Pegue la clave API desde su consola MiniMax → Claves API. Almacenado localmente y enviado al punto final MiniMax seleccionado para actualizaciones de uso. La clave API tiene prioridad sobre la cookie.",
+          "apiKeyInstructions": "Copie la clave API desde su consola MiniMax → Claves API. Una clave API guardada tiene prioridad sobre la cookie; Utilice la tecla Olvidar para volver a la cookie."
         },
         "AdvancedPane": {
           "40b29e0bf3": "Reiniciar",
@@ -5649,7 +6635,10 @@
           "5f818f12ab": "Preparando...",
           "4c05b9d7cb": "Preparando el terminal de configuración.",
           "installLabel": "Instalar",
-          "updateLabel": "Actualizar"
+          "updateLabel": "Actualizar",
+          "setupCommandFailed": "El comando de configuración salió con el código {{value0}}. Este error desaparecerá después de un reintento exitoso.",
+          "setupFailed": "Error de configuración",
+          "retrySetup": "Reintentar"
         },
         "AgentsPane": {
           "d83834f5e6": "Detectando agents instalados…",
@@ -5698,7 +6687,9 @@
           "03e1a5081a": "on {{value0}}",
           "25a41a9aad": "Re-detect agents installed on the active server",
           "remoteDetectionFailed": "Couldn’t detect installed agents. Check the host connection and try again.",
-          "retryDetection": "Retry"
+          "retryDetection": "Retry",
+          "storedDefaultUndetected": "Guardado como predeterminado, pero no detectado en este momento",
+          "noAgentsDetected": "No se detectaron agentes. Si hay uno instalado, es posible que la sonda haya agotado su tiempo de espera."
         },
         "AppIconSelector": {
           "d5a112dc9b": "Icono siguiente",
@@ -5871,7 +6862,8 @@
           "b4c167764d": "Se importaron {{value0}} cookies desde un archivo a {{value1}}.",
           "a3f8c2d1e0b4": "Se importaron {{value0}} cookies de {{value1}} ({{value2}}) a {{value3}}.",
           "b4e9d3f2a1c5": "Se importaron {{value0}} cookies de {{value1}} a {{value2}}.",
-          "c5a273a809": "Desde {{value0}}"
+          "c5a273a809": "Desde {{value0}}",
+          "b5c0479e21": "Agente de usuario no modificado"
         },
         "BrowserUseComputerUseNotice": {
           "15b5e680ba": "Abrir Computer Use",
@@ -6032,7 +7024,10 @@
           "6b5a2cd3a5": "Accesibilidad",
           "6b17602073": "Restablecer acceso",
           "506f2acf7a": "Restableciendo acceso...",
-          "4b65070096": "darwin"
+          "4b65070096": "darwin",
+          "statusGranted": "Otorgada",
+          "statusUnsupported": "Solo MacOS",
+          "statusNotEnabled": "No habilitado"
         },
         "DeveloperPermissionsPane": {
           "4c17304beb": "Actualizar",
@@ -6061,7 +7056,39 @@
           "e5b5f3d6b9": "Cámara",
           "cc8151d9fa": "Entrada de voz, transcripción, grabación de audio, sox, ffmpeg y CLI de Whisper.",
           "16381e040a": "Micrófono",
-          "dac08ec03e": "Trabajando..."
+          "dac08ec03e": "Trabajando...",
+          "actionRequest": "Pedido",
+          "actionOpenSettings": "Abrir ajustes",
+          "actionTriggerPrompt": "Aviso de activación",
+          "statusGranted": "Otorgada",
+          "statusDenied": "Denegado",
+          "statusNotRequested": "No solicitado",
+          "statusRestricted": "Restringido",
+          "statusUnsupported": "Solo MacOS",
+          "statusEntitled": "Con derecho",
+          "statusCheckManually": "Comprobar manualmente",
+          "actionRequestAccess": "Solicitar acceso",
+          "localNetworkPromptCheck": "Busque un mensaje de macOS",
+          "localNetworkPromptGuidance": "Si se le solicita, elija Permitir. Si no aparece ningún mensaje, abra Configuración del sistema y habilite Orca en Privacidad y seguridad → Red local.",
+          "localNetworkOpenSettings": "Abrir configuración del sistema",
+          "openSettingsFailed": "No se pudo abrir la configuración del sistema",
+          "localNetworkOpenSystemSettings": "Abrir configuración del sistema",
+          "statusManagedByMacOS": "Gestionado por macOS",
+          "connectionTestInvalidTarget": "Ingrese un nombre de host o IP LAN privada y un puerto del 1 al 65535.",
+          "connectionTestTimeout": "Se agotó el tiempo de conexión. Verifique la configuración de destino, servicio y red local de macOS.",
+          "connectionTestRefused": "El host respondió, pero el puerto rechazó la conexión.",
+          "connectionTestUnreachable": "No se pudo alcanzar el objetivo.",
+          "connectionTestUnresolved": "No se pudo resolver el nombre de host.",
+          "connectionTestUnsupported": "La prueba de conexión está disponible en la aplicación de escritorio macOS.",
+          "connectionTestFailed": "No se pudo completar la prueba de conexión.",
+          "connectionTestTitle": "Conexión de prueba",
+          "connectionTestDescription": "Ingrese un servicio en otro dispositivo en su red local. Orca prueba la misma ruta de red utilizada por las herramientas de terminal.",
+          "connectionTestLastVerified": "Última verificación",
+          "connectionTestNotYetVerified": "No se guardó ninguna prueba exitosa.",
+          "connectionTestHost": "Anfitrión",
+          "connectionTestPort": "Puerto",
+          "connectionTestRunning": "Pruebas...",
+          "connectionTestAction": "Conexión de prueba"
         },
         "ExperimentalPane": {
           "9762364929": "Usa APFS clone-copy en macOS cuando sea posible; si no, crea symlinks de las carpetas o archivos configurados en los worktrees creados.",
@@ -6110,7 +7137,13 @@
             "shellEnvTitle": "Usar el entorno de tu shell",
             "shellEnvCopy": "Los chats de Codex y Claude empiezan con todas las variables que exporta tu shell de inicio de sesión, igual que un terminal. Desactívalo para elegir cuáles reciben.",
             "shellEnvToggleLabel": "Alternar el uso del entorno de tu shell",
-            "resumeCopy": "Cuando Orca se cierra o instala una actualización, los chats que estaban trabajando se reanudan automáticamente al volver a abrir Orca."
+            "resumeCopy": "Cuando Orca se cierra o instala una actualización, los chats que estaban trabajando se reanudan automáticamente al volver a abrir Orca.",
+            "structuredTitle": "Utilice el chat nativo estructurado actualizado",
+            "structuredCopy": "Abra nuevos agentes de Codex y Claude como chats estructurados. Off los abre en el chat respaldado por la terminal. Los chats que ya existen permanecen como están.",
+            "structuredScope": "Se ejecuta en esta máquina y en servidores Orca emparejados que ejecutan una versión que lo admita; Los servidores más antiguos mantienen el chat del terminal. Los hosts WSL y SSH continúan usando el chat de terminal y Windows recurre a él a menos que Orca pueda leer las horas de inicio del proceso.",
+            "structuredToggleLabel": "Alternar chat nativo estructurado actualizado",
+            "resumeTitle": "Reanudar los chats de trabajo automáticamente después de reiniciar",
+            "resumeToggleLabel": "Alternar reanudación automática después de un reinicio"
           },
           "agentDashboard": {
             "title": "Panel de agentes",
@@ -6179,7 +7212,11 @@
           "b82f86d7d2": "Corrector ortográfico de Rich Markdown",
           "5195f0b9ef": "Muestra subrayados y sugerencias ortográficas del navegador al editar Rich Markdown.",
           "7ddd66fede": "Ajuste de línea en el editor",
-          "9b18de6eea": "Ajusta las líneas largas en editores de archivos en lugar de requerir desplazamiento horizontal."
+          "9b18de6eea": "Ajusta las líneas largas en editores de archivos en lugar de requerir desplazamiento horizontal.",
+          "f1b3ceeb98": "Diferencia Mostrar espacios en blanco",
+          "94a479cef3": "Muestra las diferencias de espacios en blanco iniciales y finales en las diferencias.",
+          "collapseUnchangedTitle": "Contraer regiones sin cambios",
+          "collapseUnchangedDescription": "Muestra solo las líneas modificadas y un poco de contexto circundante en una diferencia de archivo, ocultando el resto detrás de bandas expandibles. La diferencia Ver todos los cambios siempre colapsa de esta manera."
         },
         "AdvancedNetworkSettingsSection": {
           "3e431564b5": "localhost, 127.0.0.1, *.internal",
@@ -6200,7 +7237,11 @@
           "5cb5475664": "Confirmar antes de cerrar pestañas fijadas",
           "36b2a5dc6d": "Muestra un diálogo de confirmación antes de cerrar una pestaña fijada.",
           "projectRuntime": "Runtime del proyecto",
-          "projectRuntimeDescription": "Runtime predeterminado para proyectos locales de Windows que no lo sobrescriben."
+          "projectRuntimeDescription": "Runtime predeterminado para proyectos locales de Windows que no lo sobrescriben.",
+          "editor_preview_tabs": "Reutilice una pestaña de vista previa al explorar archivos",
+          "editor_preview_tabs_description": "Al hacer un solo clic en un archivo en el Explorador o al seguir un enlace en la fuente de Markdown, se reutiliza una pestaña de vista previa en cursiva por grupo en lugar de abrir una nueva. Editar, hacer doble clic o fijar mantiene esa pestaña abierta. Desactívelo para darle a cada archivo su propia pestaña.",
+          "confirm_running_terminal_close": "Confirmar antes de cerrar terminales en funcionamiento",
+          "confirm_running_terminal_close_description": "Pregunte antes de detener un agente o comando en ejecución al cerrar una terminal."
         },
         "GeneralSupportSection": {
           "af7d9f4396": "¡Gracias por el apoyo!",
@@ -6242,7 +7283,8 @@
           "31fd7150cf": "Buscando actualizaciones...",
           "3394d1f663": "de cheques",
           "d69a09b672": "Las actualizaciones se verifican automáticamente al iniciarse.",
-          "7173352632": "idle"
+          "7173352632": "idle",
+          "e3b9d21c07": "está disponible. Actualice Orca a través del administrador de paquetes de su sistema: Orca no puede instalar esta versión por sí solo."
         },
         "GeneralWorkspaceSettingsSection": {
           "3d538a98f7": "Elige las apps disponibles en el menú Abrir en de un espacio de trabajo.",
@@ -6263,7 +7305,10 @@
           "externalWorktrees": "Worktrees externos",
           "externalWorktreesDescription": "Elige si los worktrees creados fuera de Orca aparecen de forma predeterminada.",
           "show": "Mostrar",
-          "hide": "Ocultar"
+          "hide": "Ocultar",
+          "31e300af1c": "Preguntar antes de eliminar artefactos",
+          "fb29a73a17": "Muestra un cuadro de diálogo de confirmación antes de eliminar un artefacto compartido y romper su enlace público.",
+          "bf46474e33": "Muestra una confirmación antes de eliminar un artefacto compartido. Cualquiera que mantenga su enlace público pierde el acceso."
         },
         "GhosttyImportModal": {
           "9d3e56ca36": "Aplicar cambios",
@@ -6539,7 +7584,6 @@
         },
         "MobilePane": {
           "dd3cd78d04": "Escanear con Orca Móvil",
-          "35100bca5d": "Mientras usas un terminal en tu teléfono, Orca lo reduce para que se ajuste a la pantalla del teléfono. Cuando cierras la app o cambias a otra, esto controla si se queda en tamaño de teléfono (para que las herramientas CLI interactivas no se reacomoden) o vuelve al tamaño del escritorio. Siempre puedes usar Restaurar este terminal o Restaurar todos los terminales en el banner para cambiar el tamaño manualmente.",
           "ee56f1c7e4": "Cuando sales de la aplicación móvil",
           "3939fd062c": "Revocar un dispositivo lo desconecta inmediatamente.",
           "254a6d09e4": "Emparejado",
@@ -6560,7 +7604,12 @@
           "1b1b70279a": "Aún no hay dispositivos emparejados.",
           "1592afcc7a": "Aún no hay dispositivos emparejados. Escanea el código QR con la aplicación móvil de Orca.",
           "relayDegradedNotice": "No se pudo contactar con Relay: este código solo funciona en tu LAN o Tailscale. Genera uno nuevo e inténtalo de nuevo.",
-          "pairingQrError": "Este código de emparejamiento no se pudo representar como código QR. Cópialo en Orca Mobile."
+          "pairingQrError": "Este código de emparejamiento no se pudo representar como código QR. Cópialo en Orca Mobile.",
+          "pairingCodeReady": "Código de emparejamiento listo",
+          "copyPairingCode": "Copiar código de emparejamiento",
+          "diagnosticsCopied": "Diagnóstico copiado",
+          "diagnosticsCopyFailed": "No se pudieron copiar los diagnósticos",
+          "5e2c7a1f84": "Mientras usas un terminal en tu teléfono, Orca lo reduce para que se ajuste a la pantalla de tu teléfono. Cuando cierra la aplicación o la abandona, esto controla si permanece en el tamaño del teléfono (para que las herramientas CLI interactivas no vuelvan a fluir) o cambia de tamaño a su escritorio. Siempre puedes usar Restaurar o Restaurar todo en el banner para cambiar el tamaño manualmente."
         },
         "MobileSettingsPane": {
           "9a3c280e49": "GitHub Releases",
@@ -6651,7 +7700,9 @@
           "9bedd2a6e5": "Permite a los agentes transferir contexto y coordinar el trabajo a través de Orca.",
           "07641b9768": "Skill de orquestación",
           "2aacdb0517": "Coordina agentes de programación en handoffs, handoffs de worktree y trabajo de agentes secundarios.",
-          "191ac34567": "Orquestación de agentes"
+          "191ac34567": "Orquestación de agentes",
+          "nestedWorkerDepthTitle": "Profundidad del trabajador anidado",
+          "nestedWorkerDepthDescription": "¿Cuántas generaciones de trabajadores despedidos pueden engendrar sus propios trabajadores? 1 mantiene el árbol de agentes plano: un coordinador envía trabajadores y esos trabajadores no envían."
         },
         "OrchestrationSetupCard": {
           "e7d2a5146c": "Permite a los agentes transferir contexto y coordinar el trabajo a través de Orca.",
@@ -6660,7 +7711,13 @@
         "OrchestrationSkillAgentCoverage": {
           "6dec5ce2d2": "Cobertura de agentes",
           "ffe13e36fb": "Falta",
-          "1e8f8d8fae": "Listo"
+          "1e8f8d8fae": "Listo",
+          "checking": "Comprobando agentes instalados y rutas de habilidades...",
+          "noAgents": "No se detectaron CLI de agentes en PATH. Instale agentes en Configuración → Agentes, luego vuelva a verificar.",
+          "fullCoverage_one": "Cada agente detectado tiene la habilidad.",
+          "fullCoverage_other": "Todos los agentes {{value0}} detectados tienen la habilidad.",
+          "noCoverage": "Instale la habilidad anterior y luego vuelva a verificar.",
+          "partialCoverage": "{{value0}} de {{value1}} agentes detectados tienen la habilidad."
         },
         "OrchestrationSkillPromptDialog": {
           "f08d45293d": "Copiar comando",
@@ -6728,7 +7785,13 @@
           "8d525e5f15": "Copiado",
           "53b17a4b1b": "No se pudo copiar",
           "a9a564b7e7": "Copiar {{value0}}",
-          "69a1441a21": "Nada que copiar"
+          "69a1441a21": "Nada que copiar",
+          "89f7e57fcc": "Guardado en",
+          "d59bd333c3": "Actualice este servidor Orca para administrar sus comandos rápidos.",
+          "f2bf411640": "No se pudieron cargar comandos desde este host.",
+          "7ecfee5b8e": "Reintentar",
+          "601d6af51f": "Cargando comandos…",
+          "923ba89646": "No se pudieron actualizar los comandos de este host. Mostrando los últimos comandos cargados."
         },
         "RecentTabOrderControl": {
           "3b17c81ede": "Orden de la barra de pestañas",
@@ -6927,7 +7990,9 @@
           "show": "Mostrar",
           "hide": "Ocultar",
           "externalWorktreesGlobal": "Valor global predeterminado: {{value0}}",
-          "useGlobal": "Usar valor global"
+          "useGlobal": "Usar valor global",
+          "hostStateWorkspaceWindowClosed": "Ventana del espacio de trabajo cerrada",
+          "hostWorkspaceWindowClosedHelp": "Se puede acceder al servidor pero su ventana Orca está cerrada. Abra Orca en {{value0}} para usar esta configuración."
         },
         "RepositorySourceControlAiActionRows": {
           "548a6e1281": "Plantilla de comando",
@@ -7082,7 +8147,11 @@
           "troubleshootStepRegenerate": "Genera un enlace de acceso nuevo y usa aquí solo el más reciente.",
           "troubleshootTunnel": "¿Usas un reenvío local SSH? Vuelve a Conectarse a un host, pega el enlace de bucle local y activa «Estoy usando un túnel SSH» en Avanzado.",
           "cloudVmWorkflow": "VM en la nube",
-          "cloudVmWorkflowHelp": "Gestionar máquinas en la nube creadas mediante recetas"
+          "cloudVmWorkflowHelp": "Gestionar máquinas en la nube creadas mediante recetas",
+          "serverWorkspaceWindowClosed": "Ventana del espacio de trabajo cerrada",
+          "serverRuntimeUnavailable": "Orca no disponible",
+          "serverRuntimeUnavailableDescription": "El transporte SSH está conectado, pero el tiempo de ejecución de Orca no respondió. Es posible que el host todavía esté ejecutándose.",
+          "serverReconnecting": "Reconectando"
         },
         "RuntimePairingGeneratedUrlRows": {
           "0495f68959": "Copiar {{value0}}"
@@ -7363,7 +8432,8 @@
           "4db9afce1c": "El puerto debe estar entre 1 y 65535",
           "0e5aa04161": "Se requiere un host o alias de configuración SSH",
           "f1fc50dad2": "No se pudieron cargar destinos SSH",
-          "0cda732f43": "La prueba de conexión falló"
+          "0cda732f43": "La prueba de conexión falló",
+          "terminateUnverifiable": "No se pudo acceder a {{terminals}} terminal(es) remota(s). Vuelve a conectarte para acabar con ellos."
         },
         "SshPassphraseDialog": {
           "d5a234456f": "Cancelar",
@@ -7378,7 +8448,11 @@
           "8a349e3fac": "Frase de contraseña para {{value0}}",
           "cab3d5f5a5": "Contraseña para {{value0}}",
           "1f3dde805d": "Frase de contraseña de clave SSH",
-          "106bd57f4a": "Contraseña SSH"
+          "106bd57f4a": "Contraseña SSH",
+          "a21f9e74c0": "Verificación SSH",
+          "981352fb42": "Completa el desafío de verificación para",
+          "456516603b": "Introduzca la respuesta",
+          "c624f64b86": "Continuar"
         },
         "SshTargetCard": {
           "ec6543cee9": "Conectar",
@@ -7443,7 +8517,12 @@
           "addTitle": "Agregar host SSH",
           "editDescription": "Actualiza los detalles de conexión de esta máquina. Los cambios se aplican en la próxima conexión.",
           "addDescription": "Agrega una máquina persistente en la que puedas iniciar sesión por SSH.",
-          "editingPrefix": "Editando"
+          "editingPrefix": "Editando",
+          "remoteRuntime": "Tiempo de ejecución",
+          "remoteRuntimeHelp": "Qué Node.js ejecuta Orca en este host. El nodo administrado por Orca carga el suyo propio y no necesita npm; Host Node utiliza Node.js ya instalado allí.",
+          "remoteRuntimeAuto": "Automático",
+          "remoteRuntimePinnedNode": "Nodo gestionado por Orca",
+          "remoteRuntimeHostNode": "Nodo anfitrión"
         },
         "TasksPane": {
           "f71d8a9dd3": "Proveedores de tareas",
@@ -7620,7 +8699,38 @@
             "fastDescription": "Multiplicador adicional al desplazarse con una tecla modificadora.",
             "tui": "TUI",
             "tuiDescription": "Eventos discretos de rueda para apps de terminal de pantalla completa."
-          }
+          },
+          "8dbe0bc942": "Argumentos del shell, uno por línea",
+          "f58cb71f53": "--rcfile\n/path/to/rcfile",
+          "48b91a3ed2": "Argumentos personalizados",
+          "7bd83fc1d0": "-l (predeterminado)",
+          "5ffc4777b6": "Modo de argumentos del shell",
+          "578ec79449": "Escribe un argumento por línea. Déjalo vacío para no pasar ningún argumento.",
+          "884a006065": "Inicia el shell como shell de inicio de sesión con -l.",
+          "01c600daff": "Argumentos del shell",
+          "e3ae5aed18": ". Cambia al shell del sistema o elige un ejecutable de este host.",
+          "59573d0b33": "Escribe un nombre de shell del PATH o la ruta a un ejecutable. Orca lo inicia como shell de inicio de sesión.",
+          "5e06e87730": "Ruta del shell personalizado",
+          "c2bf02ce2f": "fish, nu o /bin/zsh",
+          "f51cc79784": "Shell personalizado",
+          "dd3f4c35da": "Shell del sistema ({{value0}})",
+          "fd05fb109c": "Shell del terminal",
+          "69724e8f0c": "Elige qué abre Orca en los nuevos paneles de terminal locales.",
+          "c2ddb189e7": "rcfile",
+          "73c211e979": "wrapper",
+          "4faf688f78": "login",
+          "44f8a56f66": "args",
+          "af893aa433": "argumentos",
+          "ddc72a4860": "predeterminado",
+          "d469840b75": "nushell",
+          "17ad899ba4": "bash",
+          "c9bc93d343": "zsh",
+          "0cbe5ad727": "fish",
+          "81694f1584": "terminal",
+          "a909136b3f": "shell",
+          "1c29734248": "Shell que se usa en los nuevos paneles de terminal",
+          "9589abc009": "Shell predeterminado",
+          "5a5eac2f44": "No se encontró el shell: {{value0}}"
         },
         "TerminalSettingsPreview": {
           "a63953a48a": "Vista previa del tema {{value0}}",
@@ -7757,7 +8867,8 @@
           "f9a9cf6928": "Se requiere permiso del micrófono antes de habilitar el dictado de voz.",
           "1eac933202": "Se abrió Privacidad y seguridad de macOS. Vuelve a habilitar el dictado después de otorgar acceso.",
           "cd9fe37556": "Permiso de micrófono concedido",
-          "6fa734ed95": "Eliminar {{value0}}"
+          "6fa734ed95": "Eliminar {{value0}}",
+          "openAiKeyName": "Su clave de transcripción OpenAI"
         },
         "WorktreeSymlinksSection": {
           "1c1e35b219": "Quitar {{value0}}",
@@ -7865,6 +8976,25 @@
                 "usage": "uso"
               },
               "title": "Uso de Cursor"
+            },
+            "37020a02c2": "consola",
+            "25591bf95b": "Pegue el encabezado completo de la cookie opencode.ai, incluido __Host-console_session, para recuperar el límite de velocidad.",
+            "d16378a88f": "minimax",
+            "b2c4e7f1a8": "punto final",
+            "3a9b6d2c4e": "clave API",
+            "5d8f1a3b7c": "porcelana",
+            "7e2a4b8c1d": "exterior",
+            "zcodePlan": {
+              "title": "Plan de codificación GLM",
+              "description": "Realice un seguimiento del uso del plan de codificación GLM Z.AI o Zhipu (BigModel). Elija el sitio y guarde la clave API del plan.",
+              "kw": {
+                "glm": "glm",
+                "zai": "zai",
+                "zhipu": "zhipu",
+                "bigmodel": "modelo grande",
+                "codingPlan": "plan de codificación",
+                "rateLimit": "límite de tasa"
+              }
             }
           }
         },
@@ -7947,7 +9077,21 @@
             "agentPermissions": "Permisos de agentes",
             "agentPermissionsDescription": "Cambia los permisos predeterminados de los agentes entre Yolo y Manual.",
             "agentRuntime": "Runtime del agente",
-            "agentRuntimeDescription": "Elige si los agentes se detectan y ejecutan en Windows o en WSL de forma predeterminada."
+            "agentRuntimeDescription": "Elige si los agentes se detectan y ejecutan en Windows o en WSL de forma predeterminada.",
+            "7e15b89f6e": "servidor",
+            "ff457e1e7b": "demonio",
+            "9f3becc4e8": "compartido",
+            "34337ed5c7": "aislar",
+            "9a84e65118": "descripción general de los agentes",
+            "runtime": "tiempo de ejecución",
+            "agentLocation": "ubicación del agente",
+            "installedAgentsWsl": "agentes instalados en wsl",
+            "permission": "permiso",
+            "permissions": "permisos",
+            "yolo": "yolo",
+            "manual": "manual",
+            "skip": "saltar",
+            "checks": "cheques"
           }
         },
         "appearance": {
@@ -8068,7 +9212,11 @@
             },
             "leftSidebarAppearance": {
               "title": "Apariencia de la barra lateral izquierda",
-              "description": "Haz que la barra lateral izquierda coincida con tu terminal, conserve el valor predeterminado o use un tinte."
+              "description": "Haz que la barra lateral izquierda coincida con tu terminal, conserve el valor predeterminado o use un tinte.",
+              "project": "proyecto",
+              "terminal": "Terminal",
+              "background": "fondo",
+              "tint": "tinte"
             },
             "workspaceCardLayout": {
               "title": "Diseño de tarjetas de espacios de trabajo",
@@ -8085,7 +9233,15 @@
             "4d5b9427b5": "Cuando está activado, cerrar la ventana mantiene Orca en ejecución en la bandeja del sistema en lugar de salir.",
             "showPinnedWorktreesInGroups": {
               "title": "Mostrar también los worktrees fijados en sus listas originales",
-              "description": "Los worktrees fijados permanecen en Fijados y también aparecen en Todos, Proyecto, Estado y PR."
+              "description": "Los worktrees fijados permanecen en Fijados y también aparecen en Todos, Proyecto, Estado y PR.",
+              "pinned": "fijado",
+              "worktree": "árbol de trabajo",
+              "workspace": "espacio de trabajo",
+              "all": "todo",
+              "project": "proyecto",
+              "status": "estado",
+              "pr": "pr",
+              "duplicate": "duplicado"
             },
             "antigravityUsageTitle": "Uso de Antigravity",
             "antigravityUsageDescription": "Muestra el uso de suscripción de Antigravity en la barra de estado.",
@@ -8102,6 +9258,19 @@
                 "cursor": "cursor"
               },
               "title": "Uso de Cursor"
+            },
+            "zcodeUsageTitle": "Uso del código Z",
+            "zcodeUsageDescription": "Muestre el uso de cuota del plan de codificación ZCode en la barra de estado.",
+            "zcode": "código z",
+            "zai": "zai",
+            "glm": "glm",
+            "tray": {
+              "tray": "bandeja",
+              "system": "bandeja del sistema",
+              "minimize": "minimizar",
+              "close": "cerca",
+              "notification": "área de notificaciones",
+              "background": "fondo"
             }
           }
         },
@@ -8188,7 +9357,42 @@
             "a942905148": "URL abierta al crear una nueva pestaña del navegador. Déjelo vacío para abrir una pestaña en blanco.",
             "c3903322d2": "Página de inicio predeterminada",
             "19ea5607cf": "Etiquetas de localhost para worktrees",
-            "4e0fdf0a3f": "Abre los puertos del workspace como URL localhost de Orca específicas del worktree para que las pestañas del navegador sean más fáciles de distinguir."
+            "4e0fdf0a3f": "Abre los puertos del workspace como URL localhost de Orca específicas del worktree para que las pestañas del navegador sean más fáciles de distinguir.",
+            "terminalLinkActions": {
+              "terminal": "Terminal",
+              "chat": "chat",
+              "click": "clic",
+              "actions": "acciones",
+              "popover": "popover",
+              "menu": "menú",
+              "disable": "desactivar"
+            },
+            "6f5199381e": "puertos",
+            "8f036ea11f": "árbol de trabajo",
+            "c4e3bf3282": "pestañas",
+            "a8c55c9c91": "favicon",
+            "660c1dd007": "etiquetas",
+            "clientHostedRemote": {
+              "remote": "remoto",
+              "client": "cliente",
+              "host": "host",
+              "desktop": "de oficina",
+              "placement": "colocación"
+            },
+            "sshWorkspaceRouting": {
+              "ssh": "ssh",
+              "proxy": "apoderado",
+              "tunnel": "túnel",
+              "routing": "enrutamiento",
+              "network": "red"
+            },
+            "userAgent": {
+              "identity": "identidad",
+              "userAgent": "agente de usuario",
+              "native": "nativo",
+              "cleaned": "limpiado",
+              "restart": "Reanudar"
+            }
           },
           "use": {
             "search": {
@@ -8387,12 +9591,26 @@
               "title": "Chat UI",
               "description": "Previsualiza la interfaz de chat de escritorio para sesiones de terminal de agentes compatibles.",
               "grok": "grok",
-              "queue": "cola"
+              "queue": "cola",
+              "native": "nativo",
+              "chat": "chat",
+              "claude": "claude",
+              "codex": "codex",
+              "openclaude": "claudia abierta",
+              "omp": "omp",
+              "terminal": "Terminal",
+              "agent": "agente"
             },
             "agentDashboard": {
               "title": "Panel de agentes",
               "description": "Tablero Kanban para monitorear agentes en diferentes worktrees, en ventana o como ventana emergente.",
-              "dashboard": "panel"
+              "dashboard": "panel",
+              "agent": "agente",
+              "kanban": "Kanban",
+              "popout": "ventana emergente",
+              "board": "junta",
+              "inWindow": "en la ventana",
+              "worktrees": "árboles de trabajo"
             }
           }
         },
@@ -8564,7 +9782,43 @@
             "editorFontFamily": "Fuente del editor",
             "editorFontFamilyDesc": "Fuente utilizada por los editores de archivos y vistas de diferencias. Dejar vacío para seguir la fuente de la terminal.",
             "externalWorktrees": "Worktrees externos",
-            "externalWorktreesDescription": "Elige si los worktrees creados fuera de Orca aparecen de forma predeterminada."
+            "externalWorktreesDescription": "Elige si los worktrees creados fuera de Orca aparecen de forma predeterminada.",
+            "editor_preview_tabs_short": "La exploración de archivos reutiliza una pestaña de vista previa en lugar de abrir una nueva.",
+            "preview": "avance",
+            "reuse": "reutilizar",
+            "replace": "reemplazar",
+            "explorer": "explorador",
+            "italic": "itálico",
+            "browsing": "hojeada",
+            "collapseUnchanged": "Contraer regiones sin cambios",
+            "collapseUnchangedDesc": "Muestra solo las líneas modificadas y un poco de contexto circundante en una diferencia de archivo, ocultando el resto detrás de bandas expandibles. La diferencia Ver todos los cambios siempre colapsa de esta manera.",
+            "collapseUnchangedKw": "colapsar",
+            "hideUnchangedKw": "ocultar sin cambios",
+            "foldKw": "doblar",
+            "editorFontKw": "fuente",
+            "f96cdaf37d": "corrector ortográfico",
+            "a51d23f4a1": "corrector ortográfico",
+            "641358460a": "ortografía",
+            "d755962089": "subrayado rojo",
+            "projectRuntime": "tiempo de ejecución del proyecto",
+            "runtime": "tiempo de ejecución",
+            "wsl": "wsl",
+            "867dddea41": "fijado",
+            "afa37a34e1": "cerca",
+            "terminal": "Terminal",
+            "agent": "agente",
+            "close": "cerca",
+            "windowsHost": "anfitrión de ventanas",
+            "distro": "distribución",
+            "execution": "ejecución",
+            "externalKeyword": "externo",
+            "visibility": "visibilidad",
+            "sidebar": "barra lateral",
+            "5250cf0e48": "alfiler",
+            "running_terminal": "correr",
+            "command": "dominio",
+            "confirm": "confirmar",
+            "omp": "OMP"
           }
         },
         "git": {
@@ -8618,7 +9872,8 @@
             "defaultCompareBase": "base de comparación predeterminada",
             "defaultBranch": "rama predeterminada",
             "repositoryDefault": "predeterminada del repositorio",
-            "branchUpstream": "upstream de la rama"
+            "branchUpstream": "upstream de la rama",
+            "diffBase": "base diferencial"
           }
         },
         "input": {
@@ -8675,7 +9930,9 @@
             "41ccade05c": "gh",
             "b79c21bd42": "github",
             "7166b9090c": "Autenticación de GitHub a través de la CLI de gh.",
-            "f16e41cc72": "Integración de GitHub"
+            "f16e41cc72": "Integración de GitHub",
+            "760e2446e0": "Autenticación de Bitbucket Cloud con un token API guardado o variables de entorno.",
+            "af5ae87847": "token de acceso"
           }
         },
         "jira": {
@@ -8704,7 +9961,10 @@
               "d5c5b47bb9": "actualizar",
               "fb854902d9": "conectando",
               "9a9f8d4910": "Conecta Jira Cloud para explorar, crear y vincular issues.",
-              "74f3063026": "{{value0}} sitio{{value1}} con conexión"
+              "74f3063026": "{{value0}} sitio{{value1}} con conexión",
+              "statusConnected": "Conectado",
+              "statusNotConnected": "No conectado",
+              "jiraTokenName": "Tu token API de Jira"
             }
           }
         },
@@ -8823,7 +10083,13 @@
               "1de96ec8a6": "Mostrar botón de Orca Mobile",
               "682293cadf": "Mostrar el botón de Orca Mobile en la parte superior de la barra lateral izquierda.",
               "e4f4daea0e": "relé",
-              "5d5af8e041": "iPhone"
+              "5d5af8e041": "iPhone",
+              "74618577c7": "móvil",
+              "5e5b8878bf": "teléfono",
+              "5bff6a2ef0": "barra lateral",
+              "6cf5f54ce1": "botón",
+              "648eeada79": "esconder",
+              "ac79fe4a04": "espectáculo"
             }
           }
         },
@@ -9078,7 +10344,25 @@
             "externalWorktreesDescription": "Sobrescribe si los worktrees creados fuera de Orca aparecen en este proyecto.",
             "copy": "copy",
             "clone": "clone",
-            "apfs": "apfs"
+            "apfs": "apfs",
+            "runtime": "tiempo de ejecución",
+            "wsl": "wsl",
+            "waitForSetupBeforeAgent": "espere la configuración antes de iniciar el agente",
+            "external": "externo",
+            "visibility": "visibilidad",
+            "sidebar": "barra lateral",
+            "fork": "tenedor",
+            "upstream": "upstream",
+            "syncFork": "bifurcación de sincronización",
+            "fastForward": "avance rápido",
+            "behindUpstream": "detrás aguas arriba",
+            "origin": "origen",
+            "defaultBranch": "rama predeterminada",
+            "execution": "ejecución",
+            "windowsHost": "anfitrión de ventanas",
+            "distro": "distribución",
+            "agentRuntime": "tiempo de ejecución del agente",
+            "skillRuntime": "tiempo de ejecución de habilidades"
           }
         },
         "runtime": {
@@ -9117,7 +10401,8 @@
             "7e3fc707aa": "terminal",
             "0ecba9aa5f": "teclado",
             "ebd7d81e1d": "Elige si Orca o el terminal con foco tiene prioridad cuando los atajos se superponen.",
-            "f052906167": "Atajos en terminal"
+            "f052906167": "Atajos en terminal",
+            "groupShortcut": "{{value0}} atajo"
           }
         },
         "ssh": {
@@ -9189,7 +10474,9 @@
               "c38c18be15": "selección",
               "797fdfe4ca": "seleccionar",
               "603818e8d8": "Copia automáticamente las selecciones del terminal al portapapeles en cuanto se hace una selección.",
-              "3bdc84f059": "Copiar al seleccionar"
+              "3bdc84f059": "Copiar al seleccionar",
+              "zellij": "zellij",
+              "grok": "asimilar"
             }
           },
           "search": {
@@ -9383,7 +10670,47 @@
               "title": "Modo del tema",
               "keyword_target": "destino",
               "keyword_editing": "edición"
-            }
+            },
+            "39ea7c0d28": "Terminal",
+            "close_terminal": "cerca",
+            "agent": "agente",
+            "d31ed1ac1c": "rcfile",
+            "d9e29543a1": "wrapper",
+            "50ba80b6dd": "login",
+            "36ba1a1357": "args",
+            "5304b12d5c": "argumentos",
+            "7c3ede6f12": "nushell",
+            "bf09070e31": "bash",
+            "d26257a80d": "zsh",
+            "454df22a5e": "fish",
+            "ddd5efe113": "shell",
+            "1733ccd3e9": "Shell del terminal",
+            "scroll": "voluta",
+            "scrolling": "desplazamiento",
+            "speed": "velocidad",
+            "wheel": "rueda",
+            "trackpad": "panel táctil",
+            "a0c44061ee": "confirmar",
+            "running": "correr",
+            "command": "dominio",
+            "tui": "tui",
+            "process": "proceso",
+            "prompt": "inmediato",
+            "stop": "detener",
+            "minimumContrast": {
+              "title": "Contraste de color",
+              "description": "Mejore la legibilidad del texto o conserve los colores elegidos por los programas de terminal.",
+              "contrast": "contraste",
+              "minimum": "mínimo",
+              "ratio": "relación",
+              "readability": "legibilidad",
+              "wcag": "wcag",
+              "powerline": "línea eléctrica",
+              "statusline": "línea de estado",
+              "dim": "oscuro",
+              "colors": "bandera"
+            },
+            "3de504994c": "Shell y argumentos que se usan en los nuevos paneles de terminal interactivos locales"
           },
           "windows": {
             "search": {
@@ -9447,7 +10774,13 @@
               "20574cbc72": "Habilitar dictado de voz",
               "322d457a0d": "transcripción",
               "dcc7846641": "Configure la clave API de OpenAI utilizada para los modelos de voz a texto en la nube.",
-              "ebfd0b32e5": "Transcripción OpenAI"
+              "ebfd0b32e5": "Transcripción OpenAI",
+              "microphoneTitle": "Micrófono",
+              "microphoneDescription": "Elija qué dispositivo de entrada utiliza el dictado de voz.",
+              "micInput": "aporte",
+              "micDevice": "dispositivo",
+              "micAirpods": "airpods",
+              "micDefault": "valor predeterminado del sistema"
             }
           }
         },
@@ -9476,7 +10809,13 @@
           "e5995ce268": "Mantener la computadora activa mientras los agentes están trabajando",
           "95d3031db2": "Mantiene esta computadora y la pantalla activas mientras los agentes están trabajando. El comportamiento al cerrar la tapa sigue la configuración de energía de este dispositivo.",
           "a42f6fbdd8": "Mantiene esta computadora y la pantalla activas mientras los agentes están trabajando. Orca también le pide a este dispositivo que permanezca activo cuando la tapa está cerrada, sujeto a su política de energía.",
-          "modeTitle": "Mantener la computadora activa"
+          "modeTitle": "Mantener la computadora activa",
+          "modeDescriptionMac": "Elige Activado, Agente o Desactivado. El modo Agente evita la suspensión por inactividad mientras los agentes trabajan, para que las tareas largas terminen con la tapa abierta. Cerrar la tapa sigue poniendo este Mac en suspensión.",
+          "lidNoteMac": "Evita la suspensión por inactividad con la tapa abierta; cerrar la tapa sigue poniendo este Mac en suspensión.",
+          "modeDescriptionWindows": "Elija Activado, Agente o Desactivado. El modo agente permanece activo mientras los agentes están trabajando; El comportamiento de cierre de la tapa sigue la configuración de energía de este dispositivo.",
+          "modeDescriptionDefault": "Elija Activado, Agente o Desactivado. El modo de agente permanece activo mientras los agentes están trabajando. Orca también le pide a este dispositivo que permanezca despierto cuando la tapa está cerrada, sujeto a su política de energía.",
+          "lidNoteWindows": "El comportamiento de cierre de la tapa sigue la configuración de energía de este dispositivo.",
+          "lidNoteDefault": "Orca también le pide a este dispositivo que permanezca despierto cuando la tapa está cerrada, sujeto a su política de energía."
         },
         "AgentAwakeSetting": {
           "on": "Activado",
@@ -9499,7 +10838,8 @@
           "unavailableOption": "{{user}} @ {{host}} (no disponible)",
           "capabilityBlocked": "La vinculación no está disponible hasta que la CLI de GitHub de este runtime admita `gh auth token --user` (gh ≥ 2.40).",
           "capabilityUnknownHint": "No se pudo determinar si la CLI de GitHub de este runtime admite la vinculación de cuentas. Borra la vinculación o reintenta.",
-          "notEnforced": "Guardado, pero este runtime no lo aplica (host de versión mixta)."
+          "notEnforced": "Guardado, pero este runtime no lo aplica (host de versión mixta).",
+          "refreshAccounts": "Actualizar cuentas de GitHub"
         },
         "agent-status-hooks-copy": {
           "7707c15abb": "Hooks de estado del agente",
@@ -9572,7 +10912,11 @@
                   "6f30fc4216": "El estado de la CLI de GitHub aún no está disponible en este runtime.",
                   "6b2cfb52b4": "gh",
                   "b4d900e7f1": "Pull requests, issues y checks mediante la",
-                  "account_scope_prefix": "Alcance de la cuenta"
+                  "account_scope_prefix": "Alcance de la cuenta",
+                  "statusNotInstalled": "No instalado",
+                  "statusConnected": "Conectado",
+                  "statusUnavailable": "Indisponible",
+                  "statusNotAuthenticated": "No autenticado"
                 }
               }
             }
@@ -9604,7 +10948,10 @@
                 "disconnect_all": "Desconectar todo",
                 "account_scope_prefix": "Alcance de la cuenta",
                 "2d60ec7921": "Connect a Jira Cloud site with an API token, or a self-hosted Jira with a personal access token or username and password. Credentials are sent to the selected remote runtime and stored there with runtime-supported encryption.",
-                "977e360b71": "Connect a Jira Cloud site with an API token, or a self-hosted Jira with a personal access token or username and password. Credentials are stored locally and encrypted when local runtime storage supports it."
+                "977e360b71": "Connect a Jira Cloud site with an API token, or a self-hosted Jira with a personal access token or username and password. Credentials are stored locally and encrypted when local runtime storage supports it.",
+                "statusConnected": "Conectado",
+                "statusNotConnected": "No conectado",
+                "linearTokenName": "Su token de API Linear"
               }
             }
           }
@@ -9645,7 +10992,13 @@
                   "63a7f47392": "ORCA_BITBUCKET_EMAIL",
                   "24ac1c69dc": "El estado de Bitbucket aún no está disponible en este runtime.",
                   "a924e8dcd1": "Pull requests y estados de build mediante tokens de la API de Bitbucket Cloud.",
-                  "0fa5629dad": "Pull requests y estados de build"
+                  "0fa5629dad": "Pull requests y estados de build",
+                  "statusConnected": "Conectado",
+                  "statusUnavailable": "Indisponible",
+                  "statusNotConfigured": "No configurado",
+                  "statusAuthFailed": "Error de autenticación",
+                  "statusConfigured": "Configurado",
+                  "statusOptionalSetup": "Configuración opcional"
                 }
               }
             }
@@ -9696,7 +11049,9 @@
           "hostOverride": "Anulación del host",
           "workspaceDirectory": "Se hereda el valor predeterminado del cliente hasta que un host necesite su propio directorio de worktree.",
           "providerHost": "Host del proveedor",
-          "providerAccounts": "Las credenciales y comprobaciones de cuenta pertenecen al cliente local o al servidor remoto seleccionado que posee la integración del proveedor."
+          "providerAccounts": "Las credenciales y comprobaciones de cuenta pertenecen al cliente local o al servidor remoto seleccionado que posee la integración del proveedor.",
+          "hostCollectionProjectScopes": "Colección de hosts + alcances del proyecto",
+          "terminalQuickCommandHostCollections": "Los comandos se guardan en el host Orca seleccionado y luego se aplican globalmente o en la configuración de un proyecto. Los comandos de este dispositivo también permanecen disponibles en espacios de trabajo remotos."
         },
         "RepositoryForkSyncSection": {
           "defaultBranch": "rama predeterminada",
@@ -9863,7 +11218,8 @@
           "orcaCloudSignOut": "Cerrar sesión",
           "orcaCloudConnect": "Conectar perfil",
           "orcaCloudRefresh": "Actualizar estado",
-          "orcaCloudNotConfigured": "Configura ORCA_CLOUD_API_URL y ORCA_CLOUD_CLIENT_ID para previsualizar el inicio de sesión de Orca Cloud en esta versión de desarrollo."
+          "orcaCloudNotConfigured": "Configura ORCA_CLOUD_API_URL y ORCA_CLOUD_CLIENT_ID para previsualizar el inicio de sesión de Orca Cloud en esta versión de desarrollo.",
+          "deleteAnywayClicked": "Eliminar de todos modos hecho clic"
         },
         "EphemeralVmRecipeRow": {
           "useInWorkspace": "Usar en el espacio de trabajo"
@@ -9896,12 +11252,21 @@
           "cloudVmTitle": "Runtimes de VM en la nube",
           "cloudVmRefresh": "Actualizar runtimes de VM en la nube",
           "cloudVmLoading": "Comprobando runtimes de VM en la nube…",
-          "cloudVmEmptyWithSetup": "Aún no hay runtimes de VM en la nube. Crea uno desde un espacio de trabajo mediante una receta de entorno."
+          "cloudVmEmptyWithSetup": "Aún no hay runtimes de VM en la nube. Crea uno desde un espacio de trabajo mediante una receta de entorno.",
+          "stoppingCleanup": "Parada…",
+          "stopCleanup": "detener la limpieza",
+          "cleanupStopped": "Limpieza detenida",
+          "stopCleanupFailed": "No se pudo detener la limpieza de Cloud VM."
         },
         "ephemeralVms": {
           "search": {
             "description": "Aprende cómo las recetas del repositorio dan a cada espacio de trabajo su propio entorno desechable bajo demanda.",
-            "cloudVmTitle": "VM en la nube"
+            "cloudVmTitle": "VM en la nube",
+            "keywordVm": "vm",
+            "keywordSandbox": "salvadera",
+            "keywordCloud": "nube",
+            "keywordRecipe": "receta",
+            "keywordEphemeral": "efímero"
           }
         },
         "EphemeralVmsPane": {
@@ -9959,7 +11324,12 @@
               },
               "search": {
                 "title": "Linear",
-                "description": "Estado de la habilidad de Linear, ejemplos de uso y enlaces a la configuración de Fuentes de tareas."
+                "description": "Estado de la habilidad de Linear, ejemplos de uso y enlaces a la configuración de Fuentes de tareas.",
+                "linear": "lineal",
+                "tickets": "entradas",
+                "issues": "asuntos",
+                "skill": "habilidad",
+                "orcaLinear": "orca-lineal"
               }
             }
           }
@@ -9981,7 +11351,9 @@
           "e6dadc1e2b": "Monthly usage",
           "75e396bf42": "Included monthly usage for Grok unified-billing accounts.",
           "b36fa2c908": "Signed in. Orca reads the Grok CLI session stored on disk.",
-          "f08c41de73": "Session expired — run grok on the computer running Orca and wait for it to start. If prompted, complete sign-in, then click Refresh usage. No chat message is needed."
+          "f08c41de73": "Session expired — run grok on the computer running Orca and wait for it to start. If prompted, complete sign-in, then click Refresh usage. No chat message is needed.",
+          "0bb18642b7": "Uso",
+          "a8f4139350": "Grok no informó ningún porcentaje de uso para esta cuenta."
         },
         "AppearanceWindowSidebarSection": {
           "usagePercentageDisplayUsed": "Usado",
@@ -10019,7 +11391,9 @@
           "signInRequired": "Solo Relay — LAN no necesita una cuenta.",
           "relayUnavailable": "Orca Relay no está disponible en esta compilación. Usa LAN.",
           "signInAgain": "Volver a iniciar sesión para Relay",
-          "localTitle": "LAN"
+          "localTitle": "LAN",
+          "retrying": "Reintentando",
+          "relayCell": "celda de relevo"
         },
         "MobilePairingSetupSection": {
           "title": "Vincular un teléfono",
@@ -10407,7 +11781,8 @@
           "noteKeysBody": "Las claves de API y los espacios de trabajo se guardan para el entorno de ejecución activo.",
           "noteVisibilityTitle": "Ocultar no desconecta",
           "noteVisibilityBody": "Ocultar Linear en Fuentes de tareas solo lo quita del selector. No elimina la clave ni la habilidad.",
-          "setupChecking": "Comprobando…"
+          "setupChecking": "Comprobando…",
+          "setupUnverified": "No se puede verificar"
         },
         "TaskSourceLinearSetup": {
           "connectTitle": "Conectar Linear",
@@ -10433,7 +11808,8 @@
           "statusHidden": "Oculto en Tareas",
           "statusIncomplete": "Necesita configuración",
           "collapseSetup": "Contraer los pasos de configuración de {{provider}}",
-          "expandSetup": "Mostrar los pasos de configuración de {{provider}}"
+          "expandSetup": "Mostrar los pasos de configuración de {{provider}}",
+          "statusUnverified": "No se puede verificar"
         },
         "TaskSourceShowInTasksStep": {
           "shown": "Visible",
@@ -10481,7 +11857,9 @@
           "connectionDetails": "Detalles de conexión",
           "endpointKind": "Tipo de destino",
           "networkConnection": "Conexión de red",
-          "notAttempted": "No se intentó"
+          "notAttempted": "No se intentó",
+          "saveFailed": "No se pudo guardar el host",
+          "saveFailedHelp": "El anfitrión fue verificado, pero Orca no pudo salvarlo. Verifique el nombre y el almacenamiento de la configuración local y vuelva a intentarlo."
         },
         "CloudVmSetupGuide": {
           "title": "Crear una VM en la nube",
@@ -10524,6 +11902,329 @@
           "offCount": "{{count}} desactivadas",
           "machines": "Máquinas",
           "machinesDescription": "Elige qué máquinas pueden mostrar notificaciones en este equipo. El interruptor de un servidor vinculado también controla el trabajo al que se accede a través de él."
+        },
+        "QuickCommandsList": {
+          "noSearchMatches": "Ningún comando coincide con esta búsqueda."
+        },
+        "QuickCommandsToolbar": {
+          "searchLabel": "Comandos de búsqueda"
+        },
+        "TerminalAdvancedTypographyControls": {
+          "f5fa1a08f1": "Peso de fuente en negrita",
+          "0e0d1ee15a": "Ajuste independientemente del peso de la fuente. Algunas fuentes asignan varios valores a una cara, así que reduzca el peso de la fuente o elija otra fuente si la negrita no cambia."
+        },
+        "TerminalTccAttributionNotice": {
+          "openManageSessions": "Abrir Gestionar sesiones",
+          "body": "El demonio de terminal se inició mediante una instalación de Orca que ya no existe, por lo que macOS no puede atribuir sus comandos a Orca: las concesiones de accesibilidad y automatización se ignoran silenciosamente (osascript falla con el error -25211). Reiniciar el demonio soluciona este problema; Se cerrarán las sesiones de terminal en ejecución.",
+          "title": "Las concesiones de permisos de macOS no llegan a los terminales"
+        },
+        "artifacts": {
+          "title": "Artefactos",
+          "description": "Comparte archivos HTML y Markdown con tu equipo y gestiona sus enlaces públicos.",
+          "keywordPermission": "permiso",
+          "connected": "Conectado",
+          "enable": "Habilitar artefactos",
+          "enableDescription": "Agregue artefactos a la barra lateral para poder abrir y eliminar archivos compartidos.",
+          "account": "cuenta Orca",
+          "signInRequired": "Es necesario iniciar sesión para cargar y administrar artefactos.",
+          "signIn": "Iniciar sesión en Orca",
+          "howToTitle": "Cómo utilizar artefactos",
+          "howToDescription": "Publique archivos HTML o Markdown como enlaces públicos y luego compártalos con su equipo.",
+          "shareStepTitle": "Elige un archivo para compartir",
+          "shareStepDescription": "Abra un archivo HTML o Markdown y seleccione Compartir como artefacto o pídale a un agente que lo comparta.",
+          "linkStepTitle": "Copia el enlace público",
+          "linkStepDescription": "Después de publicar, copie el enlace y envíelo a su equipo.",
+          "manageStepTitle": "Gestionarlo en Orca",
+          "manageStepDescription": "Abra Artefactos desde la barra lateral para obtener una vista previa o eliminar enlaces.",
+          "openArtifacts": "Artefactos abiertos",
+          "openArtifactsDescription": "Ver y eliminar enlaces compartidos a través de su cuenta.",
+          "showButton": "Botón Mostrar artefactos",
+          "showButtonDescription": "Muestra el acceso directo a Artefactos en la barra lateral.",
+          "signInTitle": "Inicia sesión para compartir artefactos",
+          "signInAgain": "Iniciar sesión nuevamente",
+          "openArtifactsDescriptionV2": "Obtenga una vista previa, copie y administre enlaces compartidos a través de su cuenta.",
+          "signInDescription": "Utilice su cuenta Orca para cargar artefactos y administrar sus enlaces públicos.",
+          "enableStepTitle": "Habilitar el intercambio de artefactos",
+          "enableStepWebDescription": "Abra Configuración → Artefactos en la aplicación de escritorio Orca en el dispositivo host y habilite la publicación.",
+          "enableStepDescription": "Active \"Permitir la publicación de enlaces de artefactos públicos\" arriba.",
+          "allowPublishing": "Permitir la publicación de enlaces de artefactos públicos",
+          "allowPublishingWebDescription": "Solo escritorio. Abra Configuración → Artefactos en el dispositivo host para cambiar esta configuración.",
+          "allowPublishingDescription": "Publique archivos HTML y Markdown como enlaces que cualquiera con la URL puede abrir. Los enlaces existentes permanecen hasta que los elimine de Artifacts.",
+          "howToDescriptionDisabled": "Habilite el uso compartido de artefactos arriba para publicar archivos HTML o Markdown como enlaces públicos.",
+          "allowPublishingSearchDescription": "Permita que Orca publique archivos HTML y Markdown como enlaces públicos.",
+          "keywordArtifacts": "artefactos",
+          "keywordShare": "compartir",
+          "keywordPublish": "publicar",
+          "keywordPublic": "público",
+          "keywordHtml": "HTML",
+          "keywordMarkdown": "Markdown",
+          "keywordUpload": "subir"
+        },
+        "orcaAccount": {
+          "keywordLogin": "acceso",
+          "connected": "Conectado",
+          "keywordCloud": "nube",
+          "account": "cuenta Orca",
+          "signInAgain": "Iniciar sesión nuevamente",
+          "signIn": "Iniciar sesión en Orca",
+          "reconnectRequired": "Tu sesión expiró. Inicie sesión nuevamente para utilizar las funciones de la nube.",
+          "unavailable": "El inicio de sesión de Orca no está disponible en esta compilación.",
+          "signedOut": "Inicie sesión para ampliar Orca con funciones en la nube, incluidos Artifacts y Orca Relay.",
+          "checking": "Comprobando el estado de la cuenta...",
+          "signOut": "desconectar",
+          "title": "Cuenta Orca",
+          "description": "Comparte tu trabajo al instante y accede a tu escritorio desde Orca Mobile estés donde estés.",
+          "searchDescription": "Iniciar o cerrar sesión en la cuenta utilizada por Artifacts y Orca Relay.",
+          "benefitsTitle": "Incluido con tu cuenta",
+          "artifactsTitle": "Compartir artefactos",
+          "artifactsDescription": "Publique archivos HTML y Markdown, luego administre cada enlace compartido desde Orca.",
+          "relayTitle": "Relevo de Orca",
+          "relayDescription": "Conecte Orca Mobile a esta computadora de escritorio a través de celular o cualquier Wi-Fi.",
+          "skillsTitle": "Compartir habilidades",
+          "skillsDescription": "Comparta una habilidad o un conjunto completo detrás de un enlace no listado e instálelas en cualquier máquina que utilice.",
+          "keywordAccount": "cuenta",
+          "keywordLogout": "cerrar sesión",
+          "keywordSignIn": "iniciar sesión",
+          "keywordSignOut": "desconectar",
+          "keywordRelay": "relé"
+        },
+        "automations": {
+          "title": "Automatizaciones",
+          "description": "Programa el trabajo del agente y elige si Automatizaciones aparece en la barra lateral.",
+          "keywordAgent": "agente",
+          "showButton": "Botón Mostrar automatizaciones",
+          "showButtonDescription": "Muestra el acceso directo a Automatizaciones en la barra lateral.",
+          "howItWorksTitle": "Cómo funcionan las automatizaciones",
+          "howItWorksDescription": "Programe el trabajo del agente una vez, luego deje que Orca cree cada ejecución y mantenga sus resultados juntos.",
+          "defineStepTitle": "Describe el trabajo",
+          "defineStepDescription": "Elija un proyecto, agente, aviso y cronograma.",
+          "runStepTitle": "Orca comienza cada carrera",
+          "runStepDescription": "El agente seleccionado obtiene un nuevo espacio de trabajo cuando vence el cronograma.",
+          "reviewStepTitle": "Revisa los resultados",
+          "reviewStepDescription": "Inspeccione ejecuciones recientes y continúe el trabajo cuando lo necesite.",
+          "openAutomations": "Automatizaciones abiertas",
+          "openAutomationsDescription": "Cree horarios e inspeccione ejecuciones recientes.",
+          "keywordAutomations": "automatizaciones",
+          "keywordSchedule": "cronograma",
+          "keywordRuns": "corre"
+        },
+        "shareSkills": {
+          "title": "Compartir skills",
+          "description": "Comparte tus skills con un enlace no listado. Cualquiera que lo tenga puede instalarlos.",
+          "searchDescription": "Comparte tus skills con un enlace no listado. Cualquiera que lo tenga puede instalarlos.",
+          "linkCopied": "Compartir enlace copiado",
+          "copyLink": "Copiar enlace",
+          "confirmUnshare": "Confirmar dejar de compartir",
+          "unshare": "Dejar de compartir",
+          "signInAgain": "Iniciar sesión nuevamente",
+          "signIn": "Iniciar sesión en Orca",
+          "keywordShare": "compartir",
+          "allowAgentPublishing": "Permitir que los agentes y la CLI de Orca publiquen enlaces de habilidades",
+          "allowAgentPublishingDescription": "Permita que los comandos publiquen habilidades instaladas con nombres explícitos. Las carpetas de habilidades pueden contener scripts, configuración o secretos, por lo que está desactivado de forma predeterminada.",
+          "allowAgentPublishingWebDescription": "Solo escritorio. Abra Configuración → Compartir habilidades en el dispositivo host para cambiar esta configuración.",
+          "selectTitle": "Seleccione una o más habilidades",
+          "selectDescription": "Abra Habilidades, elija Compartir habilidades y seleccione las habilidades para agruparlas detrás de un enlace.",
+          "reviewTitle": "Revisar y publicar",
+          "reviewDescription": "Revise los archivos, scripts y ejecutables incluidos antes de cargar el paquete inmutable.",
+          "copyTitle": "Copia el enlace no listado",
+          "copyDescription": "Cualquiera que tenga el enlace puede inspeccionar e instalar todas las habilidades seleccionadas sin iniciar sesión.",
+          "manageTitle": "Administrar o revocar enlaces",
+          "manageDescription": "Revocar bloquea el acceso futuro. Las habilidades ya instaladas en otra máquina permanecen allí.",
+          "linkTitle": "Enlaces de habilidades no listados",
+          "linkDescription": "Los paquetes compartidos no se pueden buscar ni enumerar en Orca. El enlace es la credencial, así que envíelo sólo a personas en las que confíe.",
+          "signInTitle": "Inicia sesión para compartir habilidades",
+          "signInWebDescription": "La publicación y la gestión de enlaces están disponibles en la aplicación de escritorio de Orca.",
+          "signInDescription": "Utilice su cuenta Orca para publicar paquetes y administrar sus enlaces. Los destinatarios no necesitan una cuenta.",
+          "howToTitle": "Cómo compartir habilidades",
+          "howToDescription": "Publique una habilidad o un paquete, como una colección de 30 habilidades, detrás de un enlace.",
+          "openSkills": "Habilidades abiertas",
+          "openSkillsDescription": "Publique un paquete, instálelo desde un enlace o administre habilidades instaladas y compartidas.",
+          "linksReconnect": "Inicie sesión nuevamente para administrar enlaces compartidos.",
+          "linksUnavailable": "Los enlaces compartidos no están disponibles en este momento.",
+          "linkRevoked": "Enlace revocado",
+          "revokeFailed": "Orca no pudo revocar este enlace.",
+          "activeLinks": "Enlaces compartidos activos",
+          "activeLinksDescription": "Sólo las personas con un enlace pueden abrirlo. Dejar de compartir un enlace para bloquear futuras inspecciones e instalaciones.",
+          "refreshLinks": "Refrescar",
+          "noActiveLinks": "No hay enlaces activos. Publica un paquete de habilidades desde Skills para crear uno.",
+          "showButton": "Botón Mostrar habilidades",
+          "showButtonDescription": "Muestra el acceso directo a Habilidades en la barra lateral.",
+          "manageInSkills": "Gestionar en Habilidades",
+          "keywordSkills": "habilidades",
+          "keywordBundle": "manojo",
+          "keywordLink": "enlace",
+          "keywordUnlisted": "no estante en la lista",
+          "keywordRevoke": "revocar"
+        },
+        "bitbucket": {
+          "credentials": {
+            "dialog": {
+              "cancel": "Cancelar",
+              "connectFailed": "La conexión falló",
+              "title": "Conectar Bitbucket",
+              "description": "Utilice una credencial de Bitbucket Cloud para explorar solicitudes de extracción y estados de compilación. Orca lo verifica antes de guardar.",
+              "remoteRuntime": "Las credenciales de Bitbucket guardadas aquí se almacenan únicamente en esta máquina local. En su lugar, establezca las variables de entorno ORCA_BITBUCKET_* en el tiempo de ejecución remoto.",
+              "environmentManaged": "Bitbucket ya está configurado a través de las variables de entorno ORCA_BITBUCKET_*, que tienen prioridad. Desactívelos para guardar una credencial en Orca.",
+              "authModeLabel": "Método de autenticación de Bitbucket",
+              "modeBasic": "Token de correo electrónico y API",
+              "modeToken": "token de acceso",
+              "accessToken": "token de acceso",
+              "accessTokenPlaceholder": "Token de acceso al repositorio, proyecto o espacio de trabajo",
+              "email": "Correo electrónico de la cuenta de Atlassian",
+              "emailPlaceholder": "tu@ejemplo.com",
+              "apiToken": "token API",
+              "apiTokenPlaceholder": "Token API de Atlassian",
+              "baseUrl": "URL base de API (opcional)",
+              "baseUrlPlaceholder": "https://api.bitbucket.org/2.0",
+              "tokenHint": "Los tokens de acceso al repositorio, al proyecto y al espacio de trabajo se crean desde la página de configuración de Bitbucket correspondiente y necesitan acceso de lectura para las solicitudes de extracción.",
+              "basicHint": "Cree un token API de Atlassian para su cuenta y luego vincúlelo con la dirección de correo electrónico propietaria.",
+              "docsLink": "Documentos del token API de Bitbucket",
+              "storageNote": "Almacenado en esta máquina con almacenamiento cifrado cuando el llavero del sistema operativo está disponible. Las variables de entorno ORCA_BITBUCKET_* siempre tienen prioridad sobre lo que guarda aquí.",
+              "verifying": "Verificando...",
+              "connect": "Conectar"
+            }
+          },
+          "integration": {
+            "card": {
+              "description": "Solicitudes de extracción y estados de compilación para Bitbucket Cloud.",
+              "edit": "Editar credenciales",
+              "connect": "Conectar",
+              "accountUnknown": "Nube de Bitbucket",
+              "authModeToken": "token de acceso",
+              "authModeBasic": "Token de correo electrónico y API",
+              "disconnect": "Desconectar Bitbucket",
+              "envManaged": "Configurado a través de variables de entorno. Desarme las variables ORCA_BITBUCKET_* para administrar esta credencial en Orca.",
+              "storedAuthFailed": "La credencial de Bitbucket guardada no se pudo autenticar. Edítelo o verifique que el token todavía tenga acceso a la solicitud de extracción.",
+              "storedCredential": "Guardado en Orca en esta máquina. Las variables de entorno ORCA_BITBUCKET_* tienen prioridad cuando se configuran.",
+              "notConfigured": "Conecte una cuenta de Bitbucket Cloud con un token API de Atlassian o un token de acceso. Las variables de entorno ORCA_BITBUCKET_* también funcionan y tienen prioridad.",
+              "disconnectFailed": "No se pudo eliminar la credencial de Bitbucket guardada.",
+              "statusLoadFailed": "No se pudo verificar si hay una credencial de Bitbucket guardada.",
+              "replaceCredentials": "Agregar o reemplazar credenciales",
+              "credentialName": "Tu credencial de Bitbucket"
+            }
+          }
+        },
+        "contrast": {
+          "off": "Apagado",
+          "title": "Contraste de color",
+          "description": "Mejore la legibilidad del texto o conserve los colores elegidos por los programas de terminal.",
+          "ratio": "Objetivo de contraste",
+          "autoDescription": "Equilibra la legibilidad con el tema de tu terminal. Recomendado.",
+          "offDescription": "Mantiene los colores del programa sin cambios, incluido el texto atenuado y los separadores Powerline.",
+          "customDescription": "Elija cuánto desea aumentar el contraste entre el texto y su fondo.",
+          "auto": "Automático",
+          "custom": "Costumbre",
+          "targetDescription": "Los valores más altos aumentan el contraste siempre que sea posible. Los colores de fondo permanecen sin cambios.",
+          "subtle": "Sutil",
+          "strong": "Fuerte"
+        },
+        "ZcodePlanAccountsSection": {
+          "title": "Plan de codificación GLM",
+          "forgetKey": "olvidar clave",
+          "site": {
+            "bigmodel": "Zhipu · BigModel (open.bigmodel.cn)",
+            "zai": "Z.AI (z.ai)"
+          },
+          "window": {
+            "session": "5 horas",
+            "weekly": "Semanalmente",
+            "mcp": "PCM mensual"
+          },
+          "resetIn": "— se reinicia en {{value0}}",
+          "keyRequired": "Se requiere la clave API del plan de codificación GLM.",
+          "keySaved": "Clave API del plan de codificación GLM guardada.",
+          "keySaveFailed": "Error al actualizar las credenciales del plan de codificación GLM.",
+          "subtitle": "Realice un seguimiento del uso del plan de codificación GLM Z.AI o Zhipu (BigModel) en la barra de estado. Guarde la clave API del plan aquí; no es necesaria la configuración de ZCode CLI.",
+          "consoleLink": "Obtener clave API",
+          "keyStored": "Clave API guardada · {{value0}}",
+          "keyStoredHelp": "Se almacena localmente y se envía únicamente al sitio seleccionado para actualizaciones de uso. Tiene prioridad sobre el inicio de sesión CLI de ZCode.",
+          "usingCli": "Usando el inicio de sesión CLI de ZCode",
+          "usingCliHelp": "Orca lee la clave del plan de codificación de ~/.zcode/cli/config.json. Guarde una clave API a continuación para vincular el plan aquí.",
+          "notConfigured": "No hay ningún plan de codificación GLM vinculado",
+          "notConfiguredHelp": "Guarde la clave API del plan a continuación o inicie sesión con la CLI de ZCode en esta computadora.",
+          "refreshUsage": "Actualizar uso",
+          "siteTitle": "Sitio del plan",
+          "keyTitle": "clave API",
+          "saved": "Guardado",
+          "notSaved": "No guardado",
+          "siteDescription": "Elija la consola a la que pertenece su plan de codificación: Z.AI para el sitio internacional, Zhipu BigModel para el sitio continental.",
+          "keyDescription": "Pegue la clave API de la página Claves API de la consola seleccionada. Almacenado localmente, cifrado cuando el sistema operativo lo admite y enviado únicamente a ese sitio para actualizaciones de uso.",
+          "keyPlaceholder": "Pegue la clave API de su plan de codificación GLM",
+          "replace": "Reemplazar",
+          "save": "Ahorrar",
+          "keyHelp": "La misma clave que usan sus herramientas de codificación para el plan (por ejemplo, Claude Code con ANTHROPIC_BASE_URL apuntando al sitio). Cambiar el sitio anterior cambia qué host lo recibe.",
+          "usageTitle": "Uso del plan",
+          "usageDescription": "Ventanas de cuota activas para el plan de codificación vinculado, actualizadas con el ciclo de uso de la barra de estado.",
+          "planLevel": "Plano: {{value0}}",
+          "hostOnly": "Cambie el sitio del plan y la clave API en la aplicación de escritorio de la computadora que ejecuta Orca.",
+          "detailsUnavailable": "Los detalles de las credenciales del plan solo se pueden leer en la computadora que ejecuta Orca.",
+          "siteUnavailable": "El sitio del plan de host no está disponible"
+        },
+        "VoiceMicrophoneSetting": {
+          "label": "Micrófono",
+          "systemDefault": "Valor predeterminado del sistema",
+          "unavailable": "indisponible",
+          "description": "Dispositivo de entrada utilizado para dictado de voz. La configuración predeterminada del sistema sigue la configuración del micrófono del sistema operativo.",
+          "accessHint": "Permitir el acceso al micrófono para enumerar los dispositivos de entrada.",
+          "allowAccess": "Permitir acceso",
+          "noMicrophoneFound": "No se encontró ningún micrófono. Conecte uno y vuelva a intentarlo.",
+          "openFailedDetail": "No se pudo abrir el micrófono. {{value0}}",
+          "openFailed": "No se pudo abrir el micrófono.",
+          "openedSystemSettings": "Se abrió Privacidad y seguridad de macOS. Concede acceso al micrófono y vuelve a intentarlo.",
+          "permissionDenied": "El acceso al micrófono está bloqueado. Concédelo en la configuración de tu sistema y vuelve a intentarlo."
+        },
+        "EphemeralVmCleanupStopDialog": {
+          "stopping": "Parada…",
+          "confirm": "detener la limpieza",
+          "title": "¿Detener la limpieza?",
+          "description": "La máquina virtual puede permanecer en funcionamiento e incurrir en cargos. Puede volver a intentar la limpieza más tarde.",
+          "cancel": "seguir limpiando"
+        },
+        "BrowserTerminalLinkActionsSetting": {
+          "title": "Clics en la URL del terminal",
+          "description": "Muestra las acciones disponibles al hacer clic en un enlace en la terminal o en una transcripción de chat. Desactive esto para requerir {{modifier}}-hacer clic en la terminal.",
+          "descriptionV2": "Controle los clics en las URL detectadas impresas en paneles de terminales y transcripciones de chat.",
+          "plainClickLabel": "clic simple",
+          "plainClickDescription": "Elija si un clic izquierdo muestra acciones, abre la URL o la deja en el terminal. Cmd/Ctrl-clic siempre se abre directamente.",
+          "plainClickAriaLabel": "Comportamiento de URL de clic simple",
+          "middleClickLabel": "clic medio",
+          "middleClickDescription": "Elija lo que hace un clic con la rueda del mouse en una URL de terminal detectada.",
+          "middleClickAriaLabel": "clic medio",
+          "actionsLabel": "Comportamiento",
+          "openUrlLabel": "Abrir URL",
+          "leaveToTerminalLabel": "Salir a la terminal"
+        },
+        "ReleaseChannelSection": {
+          "switchFailed": "No se pudo cambiar a esa compilación.",
+          "title": "Canal de lanzamiento",
+          "description": "Cambie de canal de actualización o salte a cualquier versión publicada, incluidas las más antiguas. Se permiten rebajas y las compilaciones no autorizadas se pueden romper.",
+          "devOnly": "Solo desarrollador",
+          "channelAriaLabel": "Canal de actualización",
+          "hourlyWarning": "Las construcciones por hora se envían directamente desde la principal sin puerta de prueba, y las de Windows no están firmadas. Tenga a mano una estructura estable.",
+          "dailyWarning": "Las compilaciones diarias se envían directamente desde la página principal sin puerta de prueba y las de Windows no están firmadas. Tenga a mano una estructura estable.",
+          "adhocWarning": "Las compilaciones ad hoc provienen de una rama que no ha aterrizado y las de Windows no están firmadas. Quien corte uno puede abandonarlo; tenga a mano una estructura estable.",
+          "loadingBuilds": "Cargando compilaciones…",
+          "noBuilds": "No se encontraron compilaciones",
+          "refresh": "Actualizar lista de compilación",
+          "cacheHint": "Las listas de compilación se almacenan en caché durante 5 minutos. Actualice para comprobar si hay nuevas compilaciones.",
+          "switchTo": "Cambiar para construir",
+          "alreadyRunning": "Esta es la compilación que estás ejecutando.",
+          "willSwitch": "{{value0}} → {{value1}}",
+          "webUnavailable": "El cambio de compilación solo está disponible en la aplicación de escritorio.",
+          "devChannelUnsupportedAria": "{{value0}} (solo {{value1}})",
+          "devChannelUnsupported": "Las compilaciones {{value0}} se producen solo para {{value1}}. Linux permanece en Estable o RC.",
+          "downloadInstaller": "Descargar instalador",
+          "manualInstallHint": "Las compilaciones {{value0}} no están firmadas en Windows, por lo que el actualizador en la aplicación no puede instalar una sobre una compilación firmada. Ejecute el instalador descargado una vez (Windows le advertirá sobre un editor desconocido) y cada cambio posterior, incluido el regreso a Estable, funcionará desde aquí."
+        },
+        "NativeChatSupportedAgents": {
+          "label": "Agentes apoyados:"
+        },
+        "TerminalRenderingSection": {
+          "6d4c55bacc": "Imágenes en línea",
+          "fffab5890b": "Muestre imágenes directamente en el terminal utilizando los protocolos gráficos SIXEL, iTerm2 (IIP) y Kitty."
+        },
+        "UnsealedCredentialNotice": {
+          "body": "{{credential}} se almacena sin cifrar: este sistema no tiene ningún conjunto de claves del sistema operativo que Orca pueda usar. Cualquiera que pueda leer su disco o una copia de seguridad del mismo puede leer la credencial. Instale y desbloquee gnome-keyring o kwallet, luego guárdelo nuevamente para sellarlo."
         }
       },
       "right": {
@@ -10582,7 +12283,11 @@
               "branch": "Sync Branch"
             },
             "7e4b2a19c0": "No se pudo resolver el PR de GitHub para responder.",
-            "430f1a62d4": "No se pudo resolver el hilo seleccionado en el host."
+            "430f1a62d4": "No se pudo resolver el hilo seleccionado en el host.",
+            "updateReactionFailed": "No se pudo actualizar la reacción.",
+            "gitlabMoreActions": "Más acciones de MR",
+            "gitlabUnlink": "Desvincular MR",
+            "gitlabLinkAnother": "Vincular otro MR"
           },
           "CreatePullRequestDialog": {
             "2bc1b4345e": "Cancelar",
@@ -10658,7 +12363,11 @@
             "f9d7ca753d": "Copiar rutas",
             "3161c4e425": "carpeta",
             "e887fa4b2e": "Abrir en terminal",
-            "1d8e182c32": "Ver archivo"
+            "1d8e182c32": "Ver archivo",
+            "revealInFinder": "Revelar en Finder",
+            "openContainingFolder": "Abrir carpeta contenedora",
+            "revealInFileExplorer": "Revelar en el Explorador de archivos",
+            "clipboardStagingUnavailable": "No se pudo copiar el archivo porque el almacenamiento temporal de Orca no está disponible"
           },
           "FileExplorerToolbar": {
             "d238264654": "Mostrar archivos ignorados por Git",
@@ -10702,7 +12411,19 @@
             "b25f63edd7": "abierto",
             "d2ca293f3d": "Procesando…",
             "ef064cb7c3": "por defecto",
-            "59b4dccf70": "destructivo"
+            "59b4dccf70": "destructivo",
+            "closeDraft": "Cerrar",
+            "closedToast": "{{value0}} cerrado",
+            "9a41a687b7": "Cola hasta #{{pr}} · {{count}} PR",
+            "38a1bccb14": "Cola hasta #{{pr}} · {{count}} PR",
+            "3de88351c5": "GitHub agregará esta solicitud de extracción y todas las solicitudes de extracción debajo de ella a la cola de combinación.",
+            "a32fe6dba6": "GitHub fusionará esta solicitud de extracción y todas las solicitudes de extracción que se encuentren debajo de ella en la pila.",
+            "73e0e1819d": "Pila de cola...",
+            "e555a41d32": "Fusionando pila...",
+            "markingReady": "Marcado listo...",
+            "markReady": "Marcar listo para revisión",
+            "draftMoreActions": "Más acciones de {{value0}}",
+            "readyToast": "{{value0}} marcado como listo para revisión"
           },
           "PortsPanel": {
             "3ea4a02a8f": "Cancelar",
@@ -11031,7 +12752,13 @@
             "a4e93c21d7": "Rama actual: {{value0}}",
             "c7d4e2f801": "Cambiar ref base: {{value0}}",
             "f3a1b8c204": "upstream",
-            "createPrIntentGenerateDetailsFailed": "No se pudieron generar los detalles de revisión. Reintentar Crear PR."
+            "createPrIntentGenerateDetailsFailed": "No se pudieron generar los detalles de revisión. Reintentar Crear PR.",
+            "entryStageFailed": "No se pudo preparar \"{{value0}}\"",
+            "entryUnstageFailed": "No se pudo eliminar la etapa \"{{value0}}\"",
+            "entryDiscardFailed": "No se pudo descartar \"{{value0}}\"",
+            "entryDeleteFailed": "No se pudo eliminar \"{{value0}}\"",
+            "entryFailedInWorkspace": "{{value0}} en {{value1}}",
+            "diffCommentNotesCopyFailed": "No se pudieron copiar notas"
           },
           "SourceControlAgentActionDialog": {
             "8e856842d1": "No se pudo iniciar el agente seleccionado.",
@@ -11183,7 +12910,10 @@
                 "actionRequiredHint": "Este check requiere una acción manual en GitHub (por ejemplo, aprobar la ejecución del workflow) antes de que el merge quede desbloqueado.",
                 "b3195cba33": "Desmarcar autor como bot",
                 "f588b46a6c": "Marcar autor como bot",
-                "e45324fbed": "No se pudieron cargar los detalles del check."
+                "e45324fbed": "No se pudieron cargar los detalles del check.",
+                "dcb3c546fe": "Reintentar",
+                "checksUnresolvedChip": "irresoluto",
+                "checksUnresolvedStripHint": "Estas comprobaciones finalizaron sin un veredicto de aprobación o desaprobación."
               },
               "empty": {
                 "state": {
@@ -11354,7 +13084,24 @@
                   "2388413f28": "Esta solicitud de fusión está cerrada",
                   "88d044c42f": "Cerrado",
                   "ee482a2bad": "Este merge request ya se hizo merge",
-                  "fae95ae20d": "Mergeado"
+                  "fae95ae20d": "Mergeado",
+                  "5105b0e584": "Se requiere aprobación",
+                  "46dc85711b": "GitLab requiere aprobación antes de que este MR pueda fusionarse",
+                  "893a999c8c": "Cambios solicitados",
+                  "c65408a99d": "Un revisor solicitó cambios en esta solicitud de fusión",
+                  "01ab632a21": "Hilos no resueltos",
+                  "4191fdfcec": "GitLab requiere que las discusiones no resueltas se resuelvan antes de fusionarse",
+                  "bf628700f6": "Los controles deben pasar",
+                  "37d8637c70": "GitLab requiere que la canalización tenga éxito antes de que este MR pueda fusionarse",
+                  "049ea91a82": "El oleoducto sigue funcionando",
+                  "382c70faeb": "Detrás",
+                  "2c61100b3a": "Actualizar la rama antes de fusionar",
+                  "195917574e": "De cheques",
+                  "ff6db2db63": "GitLab todavía está calculando el estado de esta solicitud de fusión",
+                  "4ecc0d90ee": "Obstruido",
+                  "a0f3de7023": "GitLab informa que esta solicitud de fusión está bloqueada",
+                  "804ecf93e8": "GitLab no ha informado un estado de fusión final",
+                  "a5c049afe4": "GitLab dice que este MR puede fusionarse"
                 }
               }
             }
@@ -11522,6 +13269,72 @@
                   "8f9a0b1c2d": "No hay nada para hacer commit. La rama está actualizada.",
                   "h3i4j5k607": "Comprobando si esta rama puede crear un {{value0}}…"
                 }
+              },
+              "branch": {
+                "line": {
+                  "total": {
+                    "chip": {
+                      "c8d5b21e07": "Fuente",
+                      "daa8e8e59b": "{{value0}} líneas agregadas, {{value1}} líneas eliminadas",
+                      "8a9b97b666": "{{value0}} líneas agregadas",
+                      "52c366d88d": "{{value0}} líneas eliminadas",
+                      "4c1f70ba92": "{{value0}} - código de prueba: {{value1}} líneas agregadas, {{value2}} líneas eliminadas",
+                      "6b2d0f14a7": "Pruebas",
+                      "9e4a3c5081": "No prueba",
+                      "3d7e9b1042": "No generado",
+                      "a1b2c3d4e5": "Desglose del código",
+                      "b2c3d4e5f6": "Líneas de código",
+                      "7f3e1a9c24": "{{value0}} — generado: {{value1}} líneas agregadas, {{value2}} líneas eliminadas",
+                      "7a04c6f8b3": "Generado"
+                    }
+                  }
+                }
+              },
+              "compare": {
+                "summary": {
+                  "dd72a6fd37": "{{value0}} confirma{{value1}} antes de {{value2}}"
+                }
+              },
+              "conflict": {
+                "status": {
+                  "cards": {
+                    "5302a1ddba": "Fusionar conflictos",
+                    "7f3af87549": "Rebase de conflictos",
+                    "6a8e9ad490": "Conflictos selectos",
+                    "bdf8772106": "Conflictos",
+                    "edc2d82a2b": "Fusión en progreso",
+                    "5c3707aa44": "Rebase en progreso",
+                    "ffe53a1da6": "Selección en progreso",
+                    "35eb76d323": "Operación en curso"
+                  }
+                }
+              },
+              "content": {
+                "status": {
+                  "3f425c239c": "No hay cambios en esta sucursal.",
+                  "640f6fdb36": "Este espacio de trabajo está limpio y esta rama no tiene cambios antes de {{value0}}",
+                  "8deb86bbec": "base",
+                  "978eba351e": "El texto de búsqueda es demasiado grande",
+                  "0bce43409f": "Utilice un filtro de archivos más corto.",
+                  "1b6caf533d": "No hay archivos coincidentes",
+                  "00c07771b7": "Ningún archivo modificado coincide con \"{{value0}}\""
+                }
+              },
+              "commit": {
+                "area": {
+                  "cc5739bd1d": "Generando mensaje de confirmación…",
+                  "4cbd0cd9d2": "Compromiso en progreso...",
+                  "e7876a2bde": "Prepare al menos un archivo para generar un mensaje.",
+                  "0904be2505": "Borre el mensaje para regenerar.",
+                  "1ea9ba37aa": "Elija un agente en Configuración -> Git -> Source Control AI."
+                }
+              },
+              "diff": {
+                "comments": {
+                  "list": {
+                    "cefacd0ec7": "archivo completo"
+                  }
+                }
               }
             }
           },
@@ -11530,6 +13343,11 @@
               "control": {
                 "ai": {
                   "cfafa92509": "No hay conflictos sin resolver para enviar."
+                },
+                "bulk": {
+                  "actions": {
+                    "2f67630884": "Falló la etapa de etapa/des etapa masiva"
+                  }
                 }
               }
             }
@@ -11553,7 +13371,8 @@
             "fca915a67a": "Remote items are permanently deleted and cannot be undone. Local items move to the {{value0}}."
           },
           "useFileExplorerHandlers": {
-            "32cd9fd991": "No se puede abrir el destino del enlace simbólico"
+            "32cd9fd991": "No se puede abrir el destino del enlace simbólico",
+            "folderLinksOutsideProject": "Esta carpeta enlaza fuera del proyecto, así que no se puede abrir aquí."
           },
           "useFileExplorerImport": {
             "25919b2050": "Se omitió {{value0}} {{value1}}.",
@@ -11574,6 +13393,17 @@
                   }
                 }
               }
+            },
+            "hosted": {
+              "review": {
+                "button": {
+                  "label": {
+                    "96ae7358e0": "Empuje y cree PR en la pila",
+                    "8e8149a0bf": "Crear borrador de PR en pila",
+                    "8df1a05952": "Crear PR en la pila"
+                  }
+                }
+              }
             }
           },
           "AiVaultPanel": {
@@ -11603,7 +13433,10 @@
             "sessionHostMismatchUnsupported": "Esta sesión pertenece a un host diferente. Abre un espacio de trabajo en el mismo host para reanudarla.",
             "prepareSessionResumeFailed": "Could not prepare this session for resume.",
             "sessionDeleted": "Sesión eliminada",
-            "sessionDeleteFailed": "No se pudo eliminar la sesión"
+            "sessionDeleteFailed": "No se pudo eliminar la sesión",
+            "resumeInChatConflict": "Otro chat ya está manteniendo esta conversación.",
+            "resumeInChatTranscriptMissing": "El historial de esta conversación no se pudo cargar, por lo que no se puede reanudar en el chat.",
+            "resumeInChatFailed": "No se pudo reanudar esta sesión en un chat nuevo."
           },
           "AiVaultPanelControls": {
             "scanningSessions": "Buscando sesiones",
@@ -11738,7 +13571,8 @@
             "delete": "Eliminar",
             "deleteReasonNonLocalHost": "Solo se pueden eliminar las sesiones de este dispositivo.",
             "deleteReasonSyntheticPath": "Esta sesión no se puede eliminar desde Orca.",
-            "deleteReasonUnsupportedAgent": "Las sesiones de {{value0}} no se pueden eliminar desde Orca."
+            "deleteReasonUnsupportedAgent": "Las sesiones de {{value0}} no se pueden eliminar desde Orca.",
+            "resumeInNewChat": "Reanudar en nuevo chat"
           },
           "AiVaultSessionDeleteDialog": {
             "title": "¿Eliminar esta sesión?",
@@ -11806,7 +13640,6 @@
           },
           "aiVaultSessionLogOpen": {
             "workspaceGone": "Couldn't open log — workspace is no longer available.",
-            "notAuthorized": "Couldn't open log — path not authorized.",
             "alreadyEditable": "Log is already open for editing."
           },
           "github": {
@@ -11825,6 +13658,34 @@
                   "d9dd7c6687": "Couldn't refresh from GitHub. Showing the last known status."
                 }
               }
+            },
+            "pr": {
+              "stack": {
+                "confirmation": {
+                  "84f6f5b9eb": "Incluye: {{numbers}}.",
+                  "541984b2eb": "¿Cola hasta #{{pr}}?",
+                  "4809f55cdb": "{{included}}GitHub agregará la solicitud de extracción {{count}} a la cola de combinación. La cola elige el método de combinación y puede fusionarlos en grupos separados.",
+                  "be8f2621be": "{{included}}GitHub agregará {{count}} solicitudes de extracción a la cola de combinación juntas. La cola elige el método de combinación y puede fusionarlos en grupos separados.",
+                  "92ca033e72": "Poner en cola {{count}} PR",
+                  "478a527b15": "Poner en cola {{count}} PR",
+                  "1feef35ca4": "¿Fusionar a través de #{{pr}}?",
+                  "c3e036c99f": "{{included}}GitHub fusionará {{count}} PR de forma atómica usando {{method}}. Si no puede fusionarla, no se fusionará nada.",
+                  "369aba4b32": "{{included}}GitHub fusionará {{count}} PR de forma atómica usando {{method}}. Si alguna no se puede fusionar, no se fusionará ninguna.",
+                  "493c78f521": "Fusionar {{count}} PR",
+                  "eb7051d268": "Fusionar {{count}} PR"
+                },
+                "merge": {
+                  "55ae29b907": "Fusionar a través de #{{pr}} · {{count}} PR",
+                  "b8446f6ec2": "Fusionar a través de #{{pr}} · {{count}} PR",
+                  "189d0ec614": "#{{pr}} sigue siendo un borrador.",
+                  "640fb50d9c": "#{{pr}} está cerrada.",
+                  "46ffcbda75": "#{{pr}} tiene conflictos de fusión.",
+                  "6dabefd63e": "#{{pr}} tiene cambios solicitados.",
+                  "2bb21fc326": "#{{pr}} aún necesita aprobación de revisión.",
+                  "c23faf74df": "#{{pr}} debe actualizarse.",
+                  "f561e80968": "#{{pr}} está bloqueada."
+                }
+              }
             }
           },
           "PluginPanel": {
@@ -11843,6 +13704,40 @@
             "mayBeSlower": "Puede ser más lento",
             "slowest": "Más lento",
             "unlimited": "Sin límite"
+          },
+          "GitHubPRStackMap": {
+            "3511405914": "cerrada",
+            "8a9bdc36c0": "fusionada",
+            "568c647ccd": "borrador",
+            "bea9ade223": "conflictos",
+            "838aadf512": "verificaciones fallidas",
+            "316039b5db": "verificaciones pendientes",
+            "4b1e5ee9d3": "cambios solicitados",
+            "9a17b5255c": "revisión necesaria",
+            "d3d97cf3f2": "aprobada",
+            "e6cb964305": "abierta",
+            "7737bd66be": "Contraer pila #{{value0}}",
+            "0c1645ebd0": "Expandir pila #{{value0}}",
+            "e3ee2daa32": "Pila #{{value0}}",
+            "cb440931b7": "{{value0}} de {{value1}} · {{value2}}",
+            "525259fa17": "Los detalles de la pila no están disponibles temporalmente."
+          },
+          "CreateHostedReviewBasePicker": {
+            "205ef284fa": "Rama base",
+            "bb4b41d563": "desde {{value0}}",
+            "5a9315b61a": "Ninguna rama coincide con «{{value0}}». Pulsa Enter para usarla de todos modos.",
+            "da4d57c9c2": "Déjalo vacío para usar {{value0}}."
+          },
+          "CreateHostedReviewComposerFields": {
+            "90cabf6cfc": "Apilar esta PR encima de #{{value0}}",
+            "ff81473a57": "Crea una GitHub Stack o amplía la pila existente del elemento superior.",
+            "29732f2fb0": "nueva PR"
+          },
+          "AiVaultSearchEvidence": {
+            "sourceUnverifiable": "No se pudo verificar la disponibilidad de la transcripción",
+            "sourceMissing": "La transcripción ya no está disponible",
+            "metadataMatch": "Coincidencia en los metadatos de la sesión",
+            "sourceActionsUnavailable": "La fuente de la transcripción no está disponible."
           }
         }
       },
@@ -12125,7 +14020,8 @@
             "searchJira": "Busca issues de Jira o pega la URL de un issue",
             "jiraMode": "Jira",
             "jiraSelectBindFailed": "Couldn’t link this Jira issue. Pick the matching site or reconnect Jira, then try again.",
-            "emoji": "Emoji"
+            "emoji": "Emoji",
+            "loadingLinearIssue": "Cargando problema Linear..."
           },
           "ProjectCombobox": {
             "empty": "Ningún proyecto coincide con tu búsqueda.",
@@ -12139,6 +14035,15 @@
             "listLabel": "Run targets",
             "label": "Run on",
             "browse": "Browse run targets"
+          },
+          "SetProjectLocationDialog": {
+            "title": "Establecer ubicación del proyecto",
+            "description": "Elige dónde se ubica {{project}} en {{host}}.",
+            "browseFolder": "Examinar carpeta",
+            "browseFolderHelp": "Usa un checkout o una carpeta existente en este host.",
+            "cloneFromUrl": "Clonar desde URL",
+            "cloneFromUrlHelp": "Clona este repositorio en {{host}}.",
+            "saveLocation": "Establecer ubicación"
           }
         }
       },
@@ -12191,7 +14096,19 @@
           "relayDegradedNotice": "No se pudo contactar con Relay: este código solo funciona en tu LAN o Tailscale.",
           "pairingQrError": "Este código de emparejamiento no se pudo representar como código QR. Cópialo en Orca Mobile.",
           "directAddressDisclosure": "También usar una ruta local más rápida",
-          "directAddressHint": "Opcional. Elige la dirección Wi‑Fi o Tailscale que el teléfono usará cuando esté cerca — suele ser más rápido que Relay. Relay sigue funcionando cuando estás fuera."
+          "directAddressHint": "Opcional. Elige la dirección Wi‑Fi o Tailscale que el teléfono usará cuando esté cerca — suele ser más rápido que Relay. Relay sigue funcionando cuando estás fuera.",
+          "pairingCodeReady": "Código de emparejamiento listo",
+          "noRelayCode": "No hay código de emparejamiento disponible",
+          "noPairingCode": "No hay código de emparejamiento disponible",
+          "qrSignInRequired": "Inicia sesión para crear un código de emparejamiento de Relay",
+          "qrRenderFailed": "No se pudo generar el código QR; copia el código de abajo",
+          "qrGeneratePrompt": "Genera un código de emparejamiento para continuar",
+          "pairThisMac": "Empareja este Mac.",
+          "pairThisPc": "Empareja este PC.",
+          "pairThisComputer": "Empareja este equipo.",
+          "androidHelp": {
+            "guide": "Guía de instalación"
+          }
         },
         "MobilePage": {
           "e17393c6a3": "Vista previa del teléfono",
@@ -12204,7 +14121,9 @@
           "4e1eb5d55c": "No se pudo revocar el dispositivo",
           "255372e6e8": "Dispositivo revocado",
           "1b4509a8a1": "emparejado",
-          "c5909374cf": "introducción"
+          "c5909374cf": "introducción",
+          "diagnosticsCopied": "Diagnóstico copiado",
+          "diagnosticsCopyFailed": "No se pudieron copiar los diagnósticos"
         },
         "MobilePageToolbar": {
           "ad2284a9e2": "Cerrar · Esc",
@@ -12319,7 +14238,10 @@
         "NetworkInterfacePicker": {
           "trigger-label": "Dirección de red para anunciar",
           "custom-option": "{{address}} (personalizada)",
-          "add-custom": "Añadir dirección personalizada…"
+          "add-custom": "Añadir dirección personalizada…",
+          "custom-section": "Costumbre",
+          "no-address-selected": "No se ha seleccionado ninguna dirección",
+          "remove-custom": "Eliminar {{address}}"
         },
         "WindowsFirewallNotice": {
           "repair-success": "Windows Firewall now allows Orca Mobile on private networks",
@@ -12336,6 +14258,20 @@
           "blocked-description": "An existing inbound Block rule can override the pairing exception. Repair removes conflicting TCP rules for this Orca app, then allows port {{port}} on Private networks.",
           "repair": "Repair firewall access",
           "relay-note": "El emparejamiento sigue funcionando por Orca Relay: permitirlo solo añade la conexión local más rápida."
+        },
+        "MobileRelayMintFailureNotice": {
+          "retrying": "Reintentando…",
+          "copyDiagnostics": "Copiar diagnóstico",
+          "retryingTitle": "Reintentando Orca Relay…",
+          "unavailableTitle": "Orca Relay no está disponible en este escritorio.",
+          "title": "No se pudo crear un código de emparejamiento de Relay.",
+          "retryingBody": "Creando un nuevo código de emparejamiento. Esto puede tardar un momento en una conexión remota.",
+          "unavailableBody": "Usa LAN para emparejar mediante Tailscale o la misma red Wi‑Fi.",
+          "body": "Reintenta, o usa LAN para emparejar mediante Tailscale o la misma red Wi‑Fi.",
+          "useLan": "Usar LAN",
+          "retry": "Reintentar Relay",
+          "reconnectTitle": "Tu sesión de la cuenta de Orca ha caducado.",
+          "reconnectBody": "Inicia sesión de nuevo para usar Orca Relay, o usa LAN para emparejar mediante Tailscale o la misma red Wi‑Fi."
         }
       },
       "gitlab": {
@@ -12657,7 +14593,20 @@
                     "copy": {
                       "workOnTwoTasks": "Trabaja en dos tareas a la vez",
                       "agentSkillsName": "Da a los agentes las skills de Orca",
-                      "agentSkillsDescription": "Instala las skills que los agentes usan para manejar el navegador de Orca, controlar tu computadora y coordinar trabajo de varios pasos."
+                      "agentSkillsDescription": "Instala las skills que los agentes usan para manejar el navegador de Orca, controlar tu computadora y coordinar trabajo de varios pasos.",
+                      "62bac8f43c": "Trabaja en 2 árboles de trabajo a la vez. Cada uno está aislado (incluso en el mismo proyecto). Perfecto para trabajar en 2 funciones a la vez.",
+                      "908898c3ee": "Usa el navegador de Orca",
+                      "43781563c3": "Explora tu aplicación web sin salir de Orca. Captura cualquier elemento y envía su código fuente y estilos exactos a un agente con un clic.",
+                      "29aa2c2077": "Activar notificaciones",
+                      "71bd9a8c95": "Entérate al instante cuando un agente termina, necesita atención o se bloquea.",
+                      "46db810da8": "Elige tu agente predeterminado",
+                      "b8e5bae17f": "Empieza a trabajar más rápido con tu agente preferido ya seleccionado.",
+                      "ad342dd4c6": "Conectar integraciones",
+                      "06fe30fdb0": "Inicia un agente desde una tarea con un clic y mantén el estado del PR a la vista.",
+                      "eddc532e58": "Automatiza la configuración del espacio de trabajo",
+                      "56049b74c2": "Ejecuta comandos de instalación y configuración automáticamente para que cada nuevo árbol de trabajo esté listo para los agentes.",
+                      "2cf795433b": "Inicia trabajo en varios repositorios",
+                      "42525ba8a4": "Trae tus repositorios clave a Orca para iniciar trabajo de agentes sin buscar carpetas."
                     }
                   }
                 }
@@ -12736,7 +14685,8 @@
                 "4e71d72912": "Error al iniciar sesión en Claude.",
                 "9ddeb558f9": "Cuenta de Claude agregada.",
                 "29d0653961": "Iniciar sesión",
-                "945865332e": "Iniciando sesión"
+                "945865332e": "Iniciando sesión",
+                "accountStatusUnknown": "Estado de la cuenta desconocido"
               },
               "UsagePage": {
                 "64265cb295": "29% usado 5h",
@@ -13025,7 +14975,9 @@
           "724a13568d": "en {{value0}}",
           "6094135eec": "frente a {{value0}}",
           "a4420ca1f7": "Ajuste activado",
-          "dde325ddfe": "Ajuste desactivado"
+          "dde325ddfe": "Ajuste desactivado",
+          "2e91bc89d1": "Espacios en blanco activados",
+          "2bf19c54ad": "Espacios en blanco desactivados"
         },
         "ConflictComponents": {
           "f338288514": "Cargando contenido del conflicto…",
@@ -13055,7 +15007,12 @@
         "CsvViewer": {
           "eedd0d37a7": "columnas",
           "ac31d2cd60": "filas",
-          "a233d55b77": "Archivo vacío"
+          "a233d55b77": "Archivo vacío",
+          "delimiterComma": "Coma",
+          "delimiterSemicolon": "Punto y coma",
+          "delimiterTab": "Tabulador",
+          "delimiterAuto": "Auto ({{delimiter}})",
+          "delimiter": "Delimitador"
         },
         "DiffNotesSendMenu": {
           "f1aa04b5cf": "Este archivo",
@@ -13110,14 +15067,18 @@
           "f0fd4174b5": "Abre la pestaña de archivo para usar la edición enriquecida de Markdown",
           "a10d9b8337": "Abrir archivo",
           "2076ecfc9c": "Cambio anterior",
-          "631dab0df3": "Cambio siguiente"
+          "631dab0df3": "Cambio siguiente",
+          "revealInFinder": "Revelar en Finder",
+          "openContainingFolder": "Abrir carpeta contenedora",
+          "revealInFileExplorer": "Revelar en el Explorador de archivos"
         },
         "EditorPanelMarkdownActionsMenu": {
           "3e0ce48c24": "Exportar como PDF",
           "561251019a": "Más acciones",
           "8c8b7f5ff5": "Mostrar front matter",
           "10c39d58c1": "Ocultar front matter",
-          "1eef809708": "Ajuste de línea"
+          "1eef809708": "Ajuste de línea",
+          "4dedd55efa": "Mostrar espacios en blanco"
         },
         "EditorPanelShell": {
           "e2c4dec350": "Cargando editor…"
@@ -13568,7 +15529,8 @@
           "e2b4d7c8a1": "Elige un agente para esta comprobación",
           "f1c9e3a6d4": "Elige un agente para corregir la comprobación",
           "5e2a9c3f88": "Abrir archivo en esta línea",
-          "actionRequired": "Acción requerida"
+          "actionRequired": "Acción requerida",
+          "copyOutput": "Copiar salida"
         },
         "check": {
           "run": {
@@ -13588,14 +15550,17 @@
           }
         },
         "richMarkdownLargeTextPaste": {
-          "tooLarge": "El contenido pegado es demasiado grande."
+          "tooLarge": "El contenido pegado es demasiado grande.",
+          "stopped": "El pegado grande se detuvo antes de terminar.",
+          "cancelled": "Pegado grande cancelado porque su destino original cambió."
         },
         "CheckRunJobs": {
           "1c0a4d7e02": "tuvo éxito",
           "2d3b8f1a55": "saltado",
           "3e6c9a2b71": "pendiente",
           "4f7d0c3e88": "pasos fallidos",
-          "5a8e1d4f23": " · "
+          "5a8e1d4f23": " · ",
+          "copy": "Tareas de copia"
         },
         "ExternalFileChangeBanner": {
           "7c41e90d12": "Este archivo cambió en el disco mientras tenías ediciones sin guardar. Guardar sobrescribirá el contenido más reciente del disco.",
@@ -13641,6 +15606,51 @@
               }
             }
           }
+        },
+        "CheckRunCopyButton": {
+          "copied": "Copiado",
+          "failed": "No se pudo copiar",
+          "empty": "Nada que copiar"
+        },
+        "HtmlDocPreview": {
+          "documentPathCopied": "Copiado",
+          "openExternallyControl": "Abrir con la aplicación predeterminada",
+          "dismissAccessRequest": "Descartar",
+          "documentTooLargePanel": "Este documento es demasiado grande para previsualizarlo. Ábrelo en el editor.",
+          "documentUnreadablePanel": "Orca no pudo leer este archivo del espacio de trabajo.",
+          "multipleAssetsFailedNotice": "No se pudieron cargar {{count}} archivos de este documento.",
+          "assetTooLargeNotice": "{{path}} es demasiado grande para cargarse en esta vista previa.",
+          "assetUnsupportedNotice": "Este espacio de trabajo no puede enviar {{path}} a una vista previa.",
+          "assetUnreadableNotice": "Orca no pudo leer {{path}} del espacio de trabajo.",
+          "previewAriaLabel": "Vista previa de HTML",
+          "reloadPreviewControl": "Recargar vista previa",
+          "previewUnavailableTitle": "Vista previa no disponible",
+          "copyDocumentPathControl": "Copiar ruta del archivo",
+          "workspaceFileChipLabel": "Archivo del espacio de trabajo",
+          "previewMenuControl": "Opciones de vista previa",
+          "openSourceControl": "Abrir archivo fuente",
+          "copyDocumentRelativePathControl": "Copiar ruta relativa",
+          "openExternallyUnknownHostError": "No se puede abrir '{{value0}}': el host que lo posee ya no se conoce.",
+          "downloadBlockedNotice": "Las descargas están desactivadas en las vistas previas de documentos.",
+          "directoryAuthorizationFailed": "No se pudo permitir el acceso a este directorio.",
+          "directoryAccessRequest": "Esta vista previa quiere leer archivos en {{path}}.",
+          "allowDirectory": "Permitir carpeta",
+          "directoryAccessRequestOverflow": "{{folders}}, y {{count}} más",
+          "directoryAccessRequestMultiple": "Esta vista previa quiere leer archivos en {{folders}}.",
+          "allowDirectories": "Permitir {{count}} carpetas",
+          "editAddressControl": "Editar dirección"
+        },
+        "CheckRunAnnotations": {
+          "copy": "Copiar anotaciones"
+        },
+        "LargeDiffLoadPrompt": {
+          "a0af0198aa": "Los diffs grandes no se renderizan de forma predeterminada.",
+          "c3d9f4a712": "El tamaño de este diff aún no se conoce, así que se carga a petición.",
+          "f7fa7a40d0": "Cargar diff"
+        },
+        "richMarkdownImageInsertionFeedback": {
+          "importedFileKept": "Inserción de imagen cancelada porque el destino cambió. El archivo importado se conservó.",
+          "destinationChanged": "Inserción de imagen cancelada porque el destino cambió. Inténtalo de nuevo."
         }
       },
       "diff": {
@@ -13675,7 +15685,9 @@
           "55127a3706": "Dictado fallido: {{value0}}",
           "bb7f599ee7": "Abrir configuración",
           "2d5b9fabf9": "Acceso al micrófono denegado. Conceda acceso en la configuración del sistema, luego reinicie Orca.",
-          "5d2c3e7ae3": "No se detectó ninguna voz."
+          "5d2c3e7ae3": "No se detectó ninguna voz.",
+          "micFallback": "Micrófono seleccionado no disponible. Se usará el predeterminado del sistema.",
+          "micDisconnected": "Micrófono desconectado. Dictado detenido."
         },
         "DictationIndicator": {
           "335e1bc6cb": "Detener dictado",
@@ -13751,7 +15763,8 @@
             "4a9568f773": "Atrás",
             "4f86e2a10b": "Saltar recorrido",
             "d974f32a83": "Descartar recorrido",
-            "ffa4412b66": "próximo"
+            "ffa4412b66": "próximo",
+            "complete": "Hecho"
           },
           "ContextualTourProgressDots": {
             "7734cb8ad3": "de",
@@ -13761,7 +15774,27 @@
             "tour": {
               "overlay": {
                 "measurement": {
-                  "38b3155418": "Próximo"
+                  "38b3155418": "Próximo",
+                  "automations": {
+                    "intro": {
+                      "title": "¿Qué es una automatización?",
+                      "body": "Las automatizaciones ejecutan trabajo de agentes según un horario. Añade una automatización haciendo clic en este botón."
+                    },
+                    "results": {
+                      "title": "Encuentra los resultados",
+                      "body": "Las ejecuciones muestran cuándo se ejecutaron las automatizaciones, qué ocurrió y dónde inspeccionar su salida."
+                    }
+                  },
+                  "client": {
+                    "hosted": {
+                      "browser": {
+                        "intro": {
+                          "title": "Esta página se representa en tu escritorio",
+                          "body": "Las pestañas del navegador remoto ahora se representan en este dispositivo. El tráfico de red sigue pasando por el host remoto."
+                        }
+                      }
+                    }
+                  }
                 }
               }
             }
@@ -13806,8 +15839,18 @@
                 "removeWorktree": "quitar worktree",
                 "trashWorktree": "mandar worktree a la papelera",
                 "addQuickCommand": "agregar comando rápido",
-                "newQuickCommand": "nuevo comando rápido"
-              }
+                "newQuickCommand": "nuevo comando rápido",
+                "splitChatRight": "dividir chat a la derecha",
+                "moveChatRight": "mover chat a la derecha",
+                "chatPaneRight": "panel de chat a la derecha",
+                "splitChatDown": "dividir chat abajo",
+                "moveChatDown": "mover chat abajo",
+                "chatPaneBelow": "panel de chat abajo"
+              },
+              "splitChatRight": "Dividir chat a la derecha",
+              "splitChatRightDescription": "Abre el chat activo en un panel dividido a la derecha.",
+              "splitChatDown": "Dividir chat abajo",
+              "splitChatDownDescription": "Abre el chat activo en un panel dividido abajo."
             }
           },
           "palette": {
@@ -13850,7 +15893,8 @@
             "a6914ee43f": "Devolver",
             "f4ecd61552": "Esta pestaña se controla desde su teléfono. Vuelva a usarlo en el escritorio.",
             "d9768ec642": "La entrada del navegador está en pausa",
-            "20539eca03": "El móvil impulsa este navegador"
+            "20539eca03": "El móvil impulsa este navegador",
+            "7c31b0da94": "No se pudo recuperar esta pestaña. Revisa la sesión del teléfono e inténtalo de nuevo."
           },
           "BrowserPane": {
             "1ded0d3168": "Copiar captura de pantalla",
@@ -13939,7 +15983,9 @@
             "6e776f9ef9": "Falló la descarga",
             "756bfc25c9": "Abrir",
             "09a9489aa5": "Mostrar",
-            "2a4c4b8e1f": "Copiar"
+            "2a4c4b8e1f": "Copiar",
+            "b71dc3d930": "Reconectar",
+            "fileUrlUnsupported": "Esta pestaña del navegador no puede abrir archivos locales. Usa \"Abrir vista previa al lado\" en el archivo."
           },
           "BrowserToolbarMenu": {
             "429ef481f9": "Cancelar",
@@ -13990,6 +16036,69 @@
                 }
               }
             }
+          },
+          "annotate": {
+            "use": {
+              "browser": {
+                "page": {
+                  "grab": {
+                    "annotations": {
+                      "0c7b9b2b7a": "Copiado",
+                      "c937229f19": "Captura tomada",
+                      "1f5cb19034": "Anotación añadida"
+                    }
+                  }
+                }
+              }
+            },
+            "browser": {
+              "page": {
+                "annotation": {
+                  "tray": {
+                    "024467ceac": "Cancelar",
+                    "c16f932cb3": "Ahorrar",
+                    "09a7c1df70": "Editar anotación {{value0}}",
+                    "449d2c2629": "Intención de la anotación"
+                  }
+                }
+              }
+            }
+          },
+          "download": {
+            "savedToRemote": "Guardado en {{value1}} en {{value2}}"
+          },
+          "navigate": {
+            "use": {
+              "browser": {
+                "page": {
+                  "navigation": {
+                    "downloads": {
+                      "8683b84b9e": "La página del navegador no está lista para soltar archivos.",
+                      "22272f2784": "Suelta los archivos sobre la página del navegador, no sobre la barra de herramientas."
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "webauthn": {
+          "account": {
+            "cancel": "Cancelar",
+            "fallback": "Clave de acceso",
+            "title": "Elige una clave de acceso",
+            "description": "Elige la cuenta que usarás con esta clave de seguridad.",
+            "site": "Sitio"
+          }
+        },
+        "profile": {
+          "user": {
+            "agent": {
+              "option": {
+                "04af3dc12b": "Usar user agent sin modificar",
+                "5bf47a3c91": "Puede mejorar el inicio de sesión con Google, pero puede reducir la compatibilidad con sitios protegidos contra bots."
+              }
+            }
           }
         }
       },
@@ -14097,7 +16206,8 @@
           "4133d33862": "Crear automatización",
           "0a75e5e2fa": "Crear automatización Hermes",
           "03142e7721": "Editar la automatización de Hermes",
-          "17086b48ee": "Editar automatización"
+          "17086b48ee": "Editar automatización",
+          "4c8e1a72b9": "Una tarea de agente recurrente"
         },
         "AutomationMissedRunGraceField": {
           "0f4459e91d": "48 horas",
@@ -14130,7 +16240,8 @@
           "8faaa00726": "Correr",
           "53fc5f07ab": "Historial de ejecución",
           "a00e38d1a3": "n / A",
-          "fdb3caa8fb": "conocido"
+          "fdb3caa8fb": "conocido",
+          "historyUnavailable": "El historial de ejecuciones no está disponible desde este host. Esto no significa que la automatización haya fallado ni que no tenga ejecuciones."
         },
         "AutomationRunPageFrame": {
           "40a511bed4": "Ejecutar contexto",
@@ -14254,7 +16365,11 @@
           "tableStatus": "Estado",
           "tableActions": "Acciones",
           "newAutomation": "Nueva automatización",
-          "rowActions": "Acciones de automatización"
+          "rowActions": "Acciones de automatización",
+          "tableLastRun": "Última ejecución",
+          "noListMatches": "Ninguna automatización coincide.",
+          "destinationProjectUnavailable": "Elige un proyecto que pertenezca al destino de automatización seleccionado.",
+          "ownerChanged": "Esta automatización cambió de host. Actualiza e inténtalo de nuevo."
         },
         "CreateFromPicker": {
           "f061f49e3f": "Buscar ramas del repositorio...",
@@ -14355,6 +16470,14 @@
               "ba20c92073": "Programación personalizada",
               "086a5a9fe2": "Programación no válida"
             }
+          },
+          "list": {
+            "last": {
+              "run": {
+                "done": "Hecho",
+                "failed": "Fallido"
+              }
+            }
           }
         },
         "external": {
@@ -14416,6 +16539,105 @@
           "noProjects": "No hay proyectos configurados en {host}. Agregue uno allí o elija otro host.",
           "updateRequired": "Actualice el servidor de Orca en {hosts} para almacenar automatizaciones allí.",
           "move": "Al guardar se crea esta automatización en {host} y se eliminan la original y su historial de ejecuciones."
+        },
+        "emptyState": {
+          "hostLoading": "Cargando host…",
+          "unknownHost": "este host",
+          "hostLoadingDetail": "Esperando a que {{hostLabel}} informe sus automatizaciones.",
+          "hostError": "No se pudieron cargar las automatizaciones de {{hostLabel}}",
+          "hostUnavailableDetail": "No se pudo contactar con el host, por lo que sus automatizaciones son desconocidas.",
+          "hostIncompatibleDetail": "Este servidor es demasiado antiguo para delimitar automatizaciones por host.",
+          "hostStaleDetail": "La actualización más reciente no se completó.",
+          "hostNotConnected": "{{hostLabel}} no está conectado",
+          "hostNotConnectedDetail": "Conéctate a este host para ver las automatizaciones almacenadas en él.",
+          "hostEmpty": "No hay automatizaciones en {{hostLabel}}",
+          "searchNoMatch": "Ninguna automatización coincide con tu búsqueda",
+          "filtersNoMatch": "Ninguna automatización coincide con tus filtros",
+          "allHostsEmpty": "No hay automatizaciones en los hosts cargados"
+        },
+        "hostNotice": {
+          "loading": "Cargando host…",
+          "unavailable": "No se pudo contactar con {{hostLabel}}. Se muestran las automatizaciones cargadas por última vez desde él.",
+          "ghost": "{{hostLabel}} se eliminó. Las automatizaciones que aún tiene asignadas siguen en la lista.",
+          "removed": "El host seleccionado ya no está disponible. Se muestran todos los hosts."
+        },
+        "hostPicker": {
+          "loadingHost": "Cargando host…",
+          "allHosts": "Todos los hosts"
+        },
+        "ownerConflict": {
+          "dismiss": "Descartar"
+        },
+        "hostStatus": {
+          "action": {
+            "retry": "Reintentar",
+            "reconnect": "Reconectar",
+            "updateServer": "Actualizar servidor"
+          },
+          "execution": {
+            "connected": "Conectado",
+            "disconnected": "No conectado",
+            "unavailable": "Indisponible",
+            "connectedDescription": "Este host está conectado y puede ejecutar automatizaciones.",
+            "connecting": "Conectando",
+            "connectingDescription": "Conectando con este host.",
+            "disconnectedDescription": "Las automatizaciones de este host no pueden ejecutarse hasta que se restablezca la conexión.",
+            "unavailableDescription": "Este destino de ejecución ya no está disponible.",
+            "unknown": "Conexión desconocida",
+            "unknownDescription": "El estado de conexión de este host aún no se ha cargado."
+          },
+          "authority": {
+            "loading": "Cargando",
+            "loadingDescription": "Cargando automatizaciones de este host.",
+            "fresh": "Actualizado",
+            "freshDescription": "Automatizaciones cargadas de este host.",
+            "refreshing": "Actualizando",
+            "refreshingDescription": "Comprobando cambios en este host.",
+            "staleError": "Sin actualizar",
+            "staleErrorDescription": "Se muestran las automatizaciones cargadas por última vez desde este host. La actualización más reciente no se completó.",
+            "unavailable": "Inaccesible",
+            "unavailableDescription": "No se pudo contactar con este host, por lo que no se pudieron cargar sus automatizaciones.",
+            "incompatible": "Actualizar servidor",
+            "incompatibleDescription": "Este servidor no admite consultas de automatizaciones delimitadas por host. Actualízalo para cargar las automatizaciones de este host."
+          },
+          "query": {
+            "legacyUnscopedDescription": "Este servidor lista automatizaciones sin delimitación por host, por lo que no se pueden editar ni ejecutar desde aquí.",
+            "incompatible": "Actualizar servidor",
+            "incompatibleDescription": "Este servidor es demasiado antiguo para delimitar automatizaciones por host. Actualízalo para gestionar automatizaciones aquí.",
+            "viewOnly": "Solo lectura",
+            "targetRemovedDescription": "Este host se eliminó, por lo que sus automatizaciones ya no se pueden editar ni ejecutar desde aquí.",
+            "targetUnverifiedDescription": "Este host no se ha verificado desde que se perdió su conexión, por lo que sus automatizaciones no se pueden editar ni ejecutar desde aquí.",
+            "targetUnregisteredDescription": "Este host no tiene registro, por lo que sus automatizaciones no se pueden editar ni ejecutar desde aquí."
+          }
+        },
+        "AutomationEditorPromptSection": {
+          "a7c3e91b04": "Editar nombre"
+        },
+        "AutomationListSortHeader": {
+          "sortedAscending": "{{value0}}, orden ascendente",
+          "sortedDescending": "{{value0}}, orden descendente"
+        },
+        "hostSummary": {
+          "partialFailure": "No se pudieron cargar {{failed}} de {{total}} hosts"
+        },
+        "capturedOwner": {
+          "orphan": "Esta automatización no tiene host donde ejecutarse. Elimínala o vuelve a añadir el host al que pertenece.",
+          "unfenced": "Orca en este host necesita una actualización antes de que puedas ver el historial de ejecuciones o gestionar esta automatización. Las ejecuciones programadas aún pueden continuar en el host."
+        },
+        "ownerAction": {
+          "failed": "Esa acción de automatización no se completó."
+        },
+        "externalScope": {
+          "unknownManager": "Esta automatización externa ya no aparece para ningún host visible.",
+          "uncheckedHost": "No se pudieron comprobar los gestores de automatizaciones externas en {{hostLabel}}.",
+          "uncheckedHosts": "No se pudieron comprobar los gestores de automatizaciones externas en {{count}} hosts."
+        },
+        "enablement": {
+          "paused": "En pausa"
+        },
+        "runHistory": {
+          "occurrencesWithLatest": "{{times}} veces, la más reciente {{date}}",
+          "occurrences": "{{times}} veces"
         }
       },
       "agent": {
@@ -14485,7 +16707,8 @@
           "viewSection": "Vista"
         },
         "ActivityScopeFilterControls": {
-          "resetScope": "Mostrar todos los hosts y proyectos"
+          "resetScope": "Mostrar todos los hosts y proyectos",
+          "hiddenCount": "{{value0}} oculto"
         },
         "ActivityThreadRow": {
           "clearNotification": "Borrar notificación"
@@ -14494,12 +16717,37 @@
           "f915168c8e": "no leído",
           "d6a8de3934": "agentes",
           "dc708f3eff": "Agents cercanos"
+        },
+        "ActivityThreadHoverCard": {
+          "workspace": "Espacio de trabajo",
+          "pathCopied": "Ruta copiada al portapapeles",
+          "copyPathFailed": "No se pudo copiar la ruta",
+          "copyPath": "Copiar ruta",
+          "jumpToWorkspace": "Ir al espacio de trabajo"
+        },
+        "clearCompleted": {
+          "clearedOne": "Se borró 1 agente completado",
+          "clearedMany": "Se borraron {{count}} agentes completados",
+          "undo": "Deshacer"
+        },
+        "standaloneWorktree": {
+          "floatingTerminal": "Terminal flotante",
+          "standaloneTerminal": "Terminal independiente"
         }
       },
       "confirmation": {
         "dialog": {
           "8490e5d36a": "Confirmar",
-          "56f5c60e0c": "Cancelar"
+          "56f5c60e0c": "Cancelar",
+          "92bac3217e": "No volver a preguntar"
+        },
+        "skip": {
+          "openSettings": "Abrir ajustes",
+          "saved": "Omitiremos esta confirmación la próxima vez.",
+          "savedDescription": "Puedes cambiar esto en Ajustes.",
+          "preference": {
+            "0b0cb6e3f9": "No se pudo guardar la preferencia de confirmación."
+          }
         }
       },
       "jira": {
@@ -14653,6 +16901,114 @@
               "chooseSource": "Elige el origen de tareas"
             }
           }
+        },
+        "page": {
+          "github": {
+            "github": {
+              "work": {
+                "item": {
+                  "row": {
+                    "issue": "Asunto",
+                    "draftPullRequest": "Pull request en borrador",
+                    "pullRequest": "Pull request"
+                  }
+                }
+              },
+              "detail": {
+                "host": {
+                  "8d5cde4770": "Pull requests",
+                  "312ca15778": "Lista de GitHub"
+                }
+              },
+              "issue": {
+                "label": {
+                  "selector": {
+                    "2a1862c470": "Cargando etiquetas…"
+                  }
+                }
+              }
+            }
+          },
+          "chrome": {
+            "task": {
+              "page": {
+                "gitlab": {
+                  "filters": {
+                    "e157d7ce4d": "MRs",
+                    "2328f6a40c": "Mis tareas"
+                  }
+                }
+              }
+            }
+          },
+          "dialogs": {
+            "new": {
+              "github": {
+                "issue": {
+                  "dialog": {
+                    "e02508846c": "este repositorio"
+                  }
+                }
+              },
+              "linear": {
+                "issue": {
+                  "dialog": {
+                    "dialogTitle": "Nueva incidencia de Linear",
+                    "dialogDescription": "Crea una incidencia de Linear para el equipo seleccionado."
+                  }
+                }
+              }
+            },
+            "task": {
+              "page": {
+                "connect": {
+                  "dialogs": {
+                    "353c7dc71d": "Actualizar acceso"
+                  }
+                }
+              }
+            }
+          },
+          "hooks": {
+            "use": {
+              "task": {
+                "page": {
+                  "jira": {
+                    "create": {
+                      "dialog": {
+                        "jiraRequiredFieldsLoadFailed": "No se pudieron cargar los campos requeridos de Jira."
+                      }
+                    }
+                  },
+                  "linear": {
+                    "active": {
+                      "collection": {
+                        "d8b3cd9488": "Proyecto: {{value0}}",
+                        "68462f8b29": "Vista: {{value0}}"
+                      }
+                    }
+                  },
+                  "session": {
+                    "resume": {
+                      "savedLinearProjectMissing": "No se encontró el proyecto de Linear guardado.",
+                      "savedLinearProjectRestoreFailed": "No se pudo restaurar el proyecto de Linear guardado.",
+                      "savedLinearViewMissing": "No se encontró la vista guardada de Linear.",
+                      "savedLinearViewRestoreFailed": "No se pudo restaurar la vista guardada de Linear."
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "linear": {
+            "linear": {
+              "connect": {
+                "empty": {
+                  "3e00e8ebd4": "Cargando Linear"
+                }
+              }
+            }
+          }
         }
       },
       "taskPageEmptyState": {
@@ -14715,7 +17071,9 @@
         "allWorkspacesTitle": "Selecciona un espacio de trabajo",
         "allWorkspacesBody": "Los filtros de estado, asignatario y etiquetas usan IDs de un solo espacio de trabajo de Linear. Elige un espacio de trabajo para filtrar por esos atributos.",
         "optionsFromTeam": "Opciones de {{team}}",
-        "clearAll": "Limpiar todos los filtros"
+        "clearAll": "Limpiar todos los filtros",
+        "partialCoverage": "parcial",
+        "partialCoverageTitle": "Es posible que algunos equipos queden fuera de este filtro. Abre Filtros para ver los detalles."
       },
       "linear-issue-attribute-filter-sections": {
         "status": "Estado",
@@ -14729,7 +17087,8 @@
         "searchStatus": "Filtrar estado…",
         "searchLabels": "Filtrar etiquetas…",
         "searchAssignee": "Filtrar asignatario…",
-        "back": "Atrás"
+        "back": "Atrás",
+        "partialCoverageMarker": "· parcial"
       },
       "browser-pane": {
         "markup": {
@@ -14794,7 +17153,31 @@
         "ArtifactsPage": {
           "deleteTitle": "¿Eliminar el artefacto?",
           "deleteDescription": "“{{name}}” ya no estará disponible en su enlace público.",
-          "delete": "Eliminar"
+          "delete": "Eliminar",
+          "title": "Artefactos",
+          "retry": "Reintentar",
+          "signInHeading": "Iniciar sesión en Orca",
+          "signIn": "Iniciar sesión en Orca",
+          "signInAgainAction": "Iniciar sesión nuevamente",
+          "refresh": "Refrescar",
+          "signInAgain": "Inicia sesión en Orca de nuevo para cargar los artefactos.",
+          "loadFailed": "No se pudieron cargar los artefactos.",
+          "deleteFailed": "No se pudo eliminar el artefacto.",
+          "signInCopy": "Inicia sesión para ver y gestionar los artefactos compartidos desde tu cuenta.",
+          "empty": "No hay artefactos compartidos",
+          "emptyCopy": "Abre un archivo HTML o Markdown y selecciona Compartir como artefacto, o pídele a tu agente que lo comparta.",
+          "openArtifact": "Abrir artefacto",
+          "deleteArtifact": "Eliminar artefacto",
+          "moreAvailable": "Hay más artefactos disponibles",
+          "moreAvailableCopy": "Carga la página siguiente para continuar.",
+          "loadMoreFailed": "No se pudieron cargar más artefactos.",
+          "publishingOff": "La publicación está desactivada",
+          "publishingOffCopy": "Nada en este dispositivo puede crear aún un enlace público de artefacto. Permite la publicación en Ajustes → Artefactos, luego comparte desde un archivo HTML o Markdown abierto o pídele a tu agente.",
+          "openArtifactsSettings": "Abrir Ajustes → Artefactos",
+          "reconnectHeading": "Inicia sesión en Orca de nuevo",
+          "reconnectCopy": "Inicia sesión de nuevo para ver y gestionar los artefactos compartidos desde tu cuenta.",
+          "unconfiguredCopy": "El inicio de sesión de la cuenta de Orca aún no está configurado en esta máquina.",
+          "openAccountSettings": "Abrir ajustes de la cuenta"
         },
         "ArtifactPublishButton": {
           "a4a49da6af": "Compartir como artefacto",
@@ -14832,7 +17215,53 @@
           "openLink": "Abrir enlace",
           "updating": "Actualizando…",
           "update": "Actualizar el contenido compartido"
-        }
+        },
+        "copyLink": "Copiar enlace",
+        "ArtifactDetailHeader": {
+          "close": "Cerrar",
+          "publicLink": "Cualquiera con este enlace puede verlo"
+        },
+        "ArtifactListTableHeader": {
+          "updated": "Actualizado",
+          "actions": "Comportamiento",
+          "name": "Nombre",
+          "type": "Tipo",
+          "size": "Tamaño",
+          "expires": "Caduca"
+        },
+        "typeMarkdown": "Markdown",
+        "typeHtml": "HTML",
+        "previewUnavailable": "Vista previa no disponible",
+        "copySuccess": "Enlace del artefacto copiado",
+        "copyFailed": "No se pudo copiar el enlace del artefacto",
+        "openInBrowser": "Abrir en el navegador",
+        "preview": "Vista previa del artefacto",
+        "previewUnavailableDescription": "Abre este artefacto en tu navegador para verlo.",
+        "actions": "Acciones del artefacto",
+        "ArtifactActions": {
+          "more": "Más acciones del artefacto"
+        },
+        "ArtifactCollection": {
+          "loadMore": "Cargar más",
+          "noMatches": "Sin resultados"
+        },
+        "updatedAt": "Actualizado {{when}}",
+        "updatedRecently": "recientemente",
+        "expiryUnknown": "Caducidad desconocida",
+        "expired": "Enlace caducado",
+        "expires": "El enlace caduca {{when}}",
+        "ArtifactDetailDrawer": {
+          "description": "Previsualiza y gestiona este artefacto compartido."
+        },
+        "ArtifactListSearchField": {
+          "label": "Buscar artefactos",
+          "placeholder": "Buscar...",
+          "clear": "Borrar búsqueda"
+        },
+        "ArtifactsPageSkeleton": {
+          "loading": "Cargando artefactos"
+        },
+        "expiredCompact": "Caducado"
       },
       "ComposerParentWorktreePicker": {
         "label": "Worktree padre",
@@ -14859,7 +17288,23 @@
         "activitySubagentOne": "Subagente en ejecución: {{value0}}",
         "activityUnnamed": "sin nombre",
         "updateBody": "Estos chats estaban trabajando cuando Orca instaló una actualización. Al reanudarlos, cada uno se restaura donde se detuvo, con su contexto completo, y se pide al agente que revise lo que estaba haciendo antes de continuar. Tu propio prompt no se vuelve a enviar.",
-        "body": "Estos chats estaban trabajando cuando Orca se cerró. Al reanudarlos, cada uno se restaura donde se detuvo, con su contexto completo, y se pide al agente que revise lo que estaba haciendo antes de continuar. Tu propio prompt no se vuelve a enviar."
+        "body": "Estos chats estaban trabajando cuando Orca se cerró. Al reanudarlos, cada uno se restaura donde se detuvo, con su contexto completo, y se pide al agente que revise lo que estaba haciendo antes de continuar. Tu propio prompt no se vuelve a enviar.",
+        "title": "¿Reanudar los chats interrumpidos?",
+        "resuming": "Reanudando…",
+        "untitled": "Chat sin título",
+        "listLabel": "Chats que se reanudarían",
+        "dontAskAgain": "No volver a preguntar (reanudar automáticamente)",
+        "dontAskAgainHint": "Puedes desactivarlo en Ajustes → Experimental → Interfaz de chat.",
+        "continuedOne": "Se reanudó 1 chat y se le pidió continuar",
+        "continuedMany": "Se reanudaron {{value0}} chats y se les pidió continuar",
+        "selectAgent": "Reanudar {{value0}} chat \"{{value1}}\" en {{value2}}",
+        "resumeSelected": "Reanudar {{value0}} chats",
+        "resumeSelectedOne": "Reanudar 1 chat",
+        "continueUnconfirmed": "La entrega de la continuación no está confirmada para {{value0}} chats. Ábrelos para comprobarlo antes de enviar otro mensaje.",
+        "continueUnconfirmed_one": "La entrega de la continuación no está confirmada para {{value0}} chat. Ábrelo para comprobarlo antes de enviar otro mensaje.",
+        "continueUnconfirmed_other": "La entrega de la continuación no está confirmada para {{value0}} chats. Ábrelos para comprobarlo antes de enviar otro mensaje.",
+        "dismissAll": "Descartar todo",
+        "dismissUnconfirmed": "No se confirmó el descarte de la oferta de reanudación; es posible que siga en la barra de estado."
       },
       "NativeChatResumeOutcomeRow": {
         "openChat": "Abrir chat",
@@ -14887,6 +17332,83 @@
             "hostOnly": "Los detalles del inicio de sesión de Cursor solo se pueden leer en el equipo donde se ejecuta Orca."
           }
         }
+      },
+      "BrowserCookieImportDisclosure": {
+        "title": "Los inicios de sesión de Google no se importan",
+        "description": "Inicia sesión en Google directamente en Orca."
+      },
+      "native": {
+        "chat": {
+          "NativeChatStructuredSession": {
+            "a5e7f14068": "Reintentar",
+            "1f772bb5d0": "La entrega del mensaje no está confirmada.",
+            "93ef441197": "El mensaje no se envió."
+          },
+          "NativeChatLaunchRetry": {
+            "retry": "Reintentar",
+            "failed": "No se pudo iniciar el chat.",
+            "unknown": "No se pudo confirmar la conexión del chat."
+          }
+        }
+      },
+      "browserPane": {
+        "workspaceDoc": {
+          "externalLinkConfirm": "Abrir enlace",
+          "externalLinkCancel": "Cancelar",
+          "externalLinkTitle": "¿Abrir el enlace a {{host}}?"
+        }
+      },
+      "UnexpectedSignoutCard": {
+        "3e8f5c2a91": "Descartar",
+        "c5b3e8a17d": "Iniciar sesión en Orca",
+        "8d2e4f7a1b": "Compartir artefactos",
+        "6e3f1a9c5b": "Relevo de Orca",
+        "4b7d2e8f1a": "Conecte Orca Mobile a esta computadora de escritorio a través de celular o cualquier Wi-Fi.",
+        "9a4c6b2d7e": "Compartir habilidades",
+        "9f2c1a4b7d": "Se cerró tu sesión",
+        "7b4d9e1f2a": "Inicia sesión de nuevo como {{value0}} para restaurar el uso compartido de artefactos, Orca Relay y el uso compartido de skills.",
+        "5a1c8d3e6f": "Inicia sesión de nuevo para restaurar el uso compartido de artefactos, Orca Relay y el uso compartido de skills.",
+        "1f6b2c9d4e": "Lo que recuperas",
+        "2c9a5b6e8d": "Publica archivos HTML y Markdown y gestiona todos los enlaces compartidos desde Orca.",
+        "3d8e5f1b9c": "Comparte skills mediante un enlace no listado e instálalos en cualquier máquina que uses."
+      },
+      "linear-issue-attribute-filter-coverage-notice": {
+        "statusPartialTeamCoverage": "Filtrando {{value0}} de {{value1}} estados de equipo; las incidencias de los equipos restantes no se incluyen.",
+        "labelsPartialTeamCoverage": "Filtrando {{value0}} de {{value1}} etiquetas de equipo; las incidencias de los equipos restantes no se incluyen.",
+        "statusAtIdLimit": "Filtrando el máximo que esto admite: {{value0}} estados de equipo. Las filas elegidas más allá de ese límite se omiten.",
+        "labelsAtIdLimit": "Filtrando el máximo que esto admite: {{value0}} etiquetas de equipo. Las filas elegidas más allá de ese límite se omiten."
+      },
+      "WorktreeBaseFallbackDialog": {
+        "title": "Espacio de trabajo creado a partir de una base local",
+        "description": "La referencia de seguimiento remoto \"{{value0}}\" no estaba disponible, así que Orca usó la local \"{{value1}}\" en su lugar. Es posible que este espacio de trabajo no incluya los últimos cambios remotos.",
+        "dismiss": "Entendido"
+      },
+      "LinuxPackageInstallRecoveryCard": {
+        "e3de29c86a": "Mostrar paquete",
+        "55c86654b7": "Copiar comando de instalación",
+        "53e1559f99": "Se requiere instalación manual",
+        "a7ac6ec78b": "Orca descargó el paquete del sistema. Cierra Orca antes de finalizar la actualización desde un terminal.",
+        "82c6dbea00": "Copia el comando, cierra Orca y ejecútalo en un terminal del sistema en el equipo donde está instalado Orca. Vuelve a abrir Orca cuando termine.",
+        "53c4b8e148": "Ningún agente de autenticación utilizable respondió a la solicitud de instalación con privilegios.",
+        "c732bcbf8f": "Comprobando el paquete...",
+        "aa57fa4f80": "Comando copiado. Cierra Orca, ejecútalo en un terminal del sistema para instalar {{value0}} y vuelve a abrir Orca.",
+        "b7e7c5bc95": "Orca comprueba el archivo descargado con los metadatos de la versión en el momento en que crea este comando. El paquete del sistema en sí no tiene verificación de firma, y Orca no puede responder por el archivo después de ese punto."
+      },
+      "BrowserPane": {
+        "streamConnectionLost": "Se perdió la conexión con el servidor remoto.",
+        "streamConnectionUnreachable": "No se puede acceder al servidor remoto.",
+        "streamRestartFailed": "No se pudo reiniciar la transmisión del navegador remoto.",
+        "streamCapabilityUnsupported": "El entorno de ejecución seleccionado no admite la transmisión del navegador remoto."
+      },
+      "BrowserCookieImportMachineNotice": {
+        "clientLabel": "Navegadores en este dispositivo",
+        "remoteLabel": "Navegadores en {{value0}}",
+        "clientNoteLocalStorage": "Las importaciones leen los navegadores de este dispositivo. Las cookies se guardan localmente.",
+        "remoteNoteRemoteStorage": "Las importaciones leen los navegadores en {{value0}}. Las cookies se guardan en esa máquina y puede aparecer un aviso de permiso en su pantalla."
+      },
+      "HostedReviewUnlinkMenuItem": {
+        "label": "Desvincular {{value0}} del espacio de trabajo",
+        "description": "Orca ocultará los detalles de {{value0}} {{value1}} en este espacio de trabajo. El {{value0}} y la rama en {{value2}} no se modificarán."
       }
     },
     "i18n": {
@@ -14922,6 +17444,12 @@
         "loadFailed": "No se pudo cargar el registro del job de GitLab.",
         "emptyTrace": "No hay ningún registro disponible para este job de GitLab.",
         "timedOut": "Se agotó el tiempo de espera al cargar el registro del job de GitLab."
+      },
+      "githubCheckDetailsTimeout": {
+        "timedOut": "Se agotó el tiempo al cargar los detalles de la verificación."
+      },
+      "gitlabIpcTimeout": {
+        "timedOut": "Se agotó el tiempo al comunicarse con GitLab."
       }
     },
     "ssh": {
@@ -15125,16 +17653,95 @@
         "skillScopeBuiltIn": "Integrado",
         "skillScopePlugin": "Plugin",
         "skillsLoaded": "Habilidades cargadas",
-        "noCommands": "No hay comandos coincidentes"
+        "noCommands": "No hay comandos coincidentes",
+        "imagePreviewUnavailable": "Vista previa no disponible",
+        "imageSaving": "Guardando la imagen pegada…",
+        "pendingAttachmentLimit": "Hay demasiados archivos adjuntos en espera. Termina de redactar antes de adjuntar más.",
+        "viewAttachment": "Ver imagen",
+        "imagePreview": "Vista previa de la imagen a tamaño completo",
+        "workspaceAttachmentMismatch": "Los archivos solo se pueden adjuntar a su espacio de trabajo de origen.",
+        "attachmentOwnerChanged": "Este espacio de trabajo cambió de host durante la conexión; vuelve a soltar los archivos.",
+        "attachmentUnreadable": "No se pudieron leer los archivos soltados."
       },
       "tool": {
         "running": "Ejecutando…",
-        "result": "Resultado"
+        "result": "Resultado",
+        "exitCode": "salida {{value0}}",
+        "milliseconds": "{{value0}}ms",
+        "countOne": "1 llamada a herramienta",
+        "countN": "{{value0}} llamadas a herramientas",
+        "moreCalls": "+{{value0}} más",
+        "failedCount": "{{value0}} fallidas",
+        "failedCallsLabel": "Llamadas a herramientas fallidas: {{value0}}",
+        "runningPreview": "Ejecutando {{preview}}",
+        "runningCommand": "Ejecutando comando",
+        "runningNamedPreview": "Ejecutando {{toolName}} {{preview}}",
+        "runningNamed": "Ejecutando {{toolName}}",
+        "ranCommandOneToolSummary": "Se ejecutó {{commandCount}} comando y se usó {{toolCount}} herramienta",
+        "ranCommandManyToolsSummary": "Se ejecutó {{commandCount}} comando y se usaron {{toolCount}} herramientas",
+        "ranCommandsOneToolSummary": "Se ejecutaron {{commandCount}} comandos y se usó {{toolCount}} herramienta",
+        "ranCommandsManyToolsSummary": "Se ejecutaron {{commandCount}} comandos y se usaron {{toolCount}} herramientas",
+        "usedOneSummary": "Se usó 1 herramienta",
+        "usedManySummary": "Se usaron {{toolCount}} herramientas",
+        "editedFile": "Archivo editado",
+        "addedFile": "Archivo añadido",
+        "deletedFile": "Archivo eliminado",
+        "renamedFile": "Archivo renombrado",
+        "copyDiff": "Copiar diff",
+        "diffGap": "Líneas no mostradas",
+        "diffTruncated": "Diff truncado",
+        "runReadOne": "Se leyó 1 archivo",
+        "runReadMany": "Se leyeron {{value0}} archivos",
+        "runSearchOne": "Se buscó 1 vez",
+        "runSearchMany": "Se buscó {{value0}} veces",
+        "runListFilesOne": "Se listó 1 directorio",
+        "runListFilesMany": "Se listaron {{value0}} directorios",
+        "runCommandOne": "Se ejecutó 1 comando",
+        "runCommandMany": "Se ejecutaron {{value0}} comandos",
+        "runFileChangeOne": "Se editó 1 archivo",
+        "runToolOne": "Se usó 1 herramienta",
+        "runFileChangeMany": "Se editaron {{value0}} archivos",
+        "runWebSearchOne": "Se buscó en la web 1 vez",
+        "runWebSearchMany": "Se buscó en la web {{value0}} veces",
+        "runIntegrationOne": "Se usó 1 integración",
+        "runIntegrationMany": "Se usaron {{value0}} integraciones",
+        "runAgentOne": "Se ejecutó 1 agente",
+        "runAgentMany": "Se ejecutaron {{value0}} agentes",
+        "runPlanOne": "Se actualizó el plan",
+        "runPlanMany": "Se actualizó el plan {{value0}} veces",
+        "runToolMany": "Se usaron {{value0}} herramientas",
+        "runPair": "{{value0}} y {{value1}}",
+        "runList": "{{value0}} y {{value1}}",
+        "runLiveReadOne": "Leyendo 1 archivo",
+        "runLiveReadMany": "Leyendo {{value0}} archivos",
+        "runLiveSearchOne": "Buscando 1 vez",
+        "runLiveSearchMany": "Buscando {{value0}} veces",
+        "runLiveListFilesOne": "Listando 1 directorio",
+        "runLiveListFilesMany": "Listando {{value0}} directorios",
+        "runLiveCommandOne": "Ejecutando 1 comando",
+        "runLiveCommandMany": "Ejecutando {{value0}} comandos",
+        "runLiveFileChangeOne": "Editando 1 archivo",
+        "runLiveFileChangeMany": "Editando {{value0}} archivos",
+        "runLiveWebSearchOne": "Buscando en la web 1 vez",
+        "runLiveWebSearchMany": "Buscando en la web {{value0}} veces",
+        "runLiveIntegrationOne": "Usando 1 integración",
+        "runLiveIntegrationMany": "Usando {{value0}} integraciones",
+        "runLiveAgentOne": "Ejecutando 1 agente",
+        "runLiveAgentMany": "Ejecutando {{value0}} agentes",
+        "runLivePlanOne": "Actualizando el plan",
+        "runLivePlanMany": "Actualizando el plan {{value0}} veces",
+        "runLiveToolOne": "Usando 1 herramienta",
+        "runLiveToolMany": "Usando {{value0}} herramientas"
       },
       "status": {
         "responding": "El agente está respondiendo",
         "interruptedAfter": "Interrumpido tras {{value0}}",
-        "failedAfter": "Falló tras {{value0}}"
+        "failedAfter": "Falló tras {{value0}}",
+        "working": "Trabajando…",
+        "thinking": "Pensando",
+        "workingFor": "Trabajando durante {{value0}}",
+        "workedFor": "Trabajó durante {{value0}}",
+        "toggleDetails": "Alternar detalles del turno"
       },
       "jumpToLatest": "Saltar a lo último",
       "toggle": {
@@ -15184,7 +17791,14 @@
       "approval": {
         "title": "¿Permitir {{value0}}?",
         "allow": "Permitir",
-        "deny": "Denegar"
+        "deny": "Denegar",
+        "cancel": "Cancelar",
+        "reason": "Motivo",
+        "blockedPath": "Ruta bloqueada",
+        "askRule": "Regla de solicitud",
+        "plan": {
+          "file": "Archivo de plan"
+        }
       },
       "launchPromptNotDelivered": "No entregado — revisa la terminal",
       "fileLinks": {
@@ -15200,8 +17814,27 @@
       "dismissDeliveryNotice": "Descartar",
       "messageNotSent": "Mensaje no enviado",
       "deliveryUnconfirmed": "Entrega sin confirmar — revisa el chat antes de reintentar",
+      "messageSending": "Enviando…",
       "subagents": {
-        "unnamed": "Subagente"
+        "unnamed": "Subagente",
+        "state": {
+          "failedCount": "{{value0}} fallidas",
+          "working": "trabajando",
+          "failed": "falló",
+          "stopped": "detenido",
+          "unverifiable": "sin actualización reciente",
+          "unverifiableCount": "{{value0}} sin actualización reciente",
+          "completed": "completado",
+          "idle": "idle",
+          "workingCount": "{{value0}} trabajando",
+          "idleCount": "{{value0}} inactivo",
+          "stoppedCount": "{{value0}} detenido"
+        },
+        "startedOne": "Inició 1 subagente",
+        "startedN": "Inició {{value0}} subagentes",
+        "ranOne": "Ejecutó 1 subagente",
+        "ranN": "Ejecutó {{value0}} subagentes",
+        "tokens": "{{value0}} tokens"
       },
       "queuedMessages": {
         "alreadySent": "Este mensaje ya se envió.",
@@ -15225,7 +17858,123 @@
         "queuePausedCleared": "Cola en pausa después de que borraste la conversación",
         "queuePaused": "Cola en pausa",
         "resume": "Reanudar"
-      }
+      },
+      "receipt": {
+        "cancelled": "Cancelado",
+        "unavailable": "Respuesta seleccionada no disponible",
+        "resolved": "Resuelto",
+        "resolver": "Respondido en {{device}}",
+        "cancelledBy": "Cancelado en {{device}}"
+      },
+      "backgroundTasks": {
+        "groupAgents": "Agentes",
+        "groupTasks": "Tareas",
+        "monitoring": "Supervisando tareas en segundo plano",
+        "stop": "Detener",
+        "stopTask": "Detener {{value0}}",
+        "stopAll": "Detener tareas en segundo plano",
+        "agent": "Agente en segundo plano",
+        "workflow": "Flujo de trabajo en segundo plano",
+        "command": "Comando en segundo plano",
+        "monitor": "Monitor en segundo plano",
+        "task": "Tarea en segundo plano",
+        "outputFile": "Salida: {{value0}}",
+        "detailsUnavailable": "Los detalles de la tarea no están disponibles para esta sesión.",
+        "countAgentsOne": "1 agente",
+        "countAgentsMany": "{{value0}} agentes",
+        "countShellOne": "1 shell",
+        "countShellMany": "{{value0}} shells",
+        "countShellCommandOne": "1 comando de shell",
+        "countMonitorsOne": "1 monitor",
+        "countMonitorsMany": "{{value0}} monitores",
+        "countWorkflowsOne": "1 flujo de trabajo",
+        "countWorkflowsMany": "{{value0}} flujos de trabajo",
+        "countTasksOne": "1 tarea",
+        "countTasksMany": "{{value0}} tareas",
+        "headerTotal": "{{value0}} tareas en segundo plano",
+        "stateWorking": "trabajando",
+        "stateMonitoring": "supervisando",
+        "stateWaiting": "esperando",
+        "stateBlocked": "bloqueado",
+        "stateDone": "listo",
+        "stateIdle": "detenido",
+        "stateUnverifiable": "sin actualización reciente",
+        "stateUnverifiableCount": "{{value0}} sin actualización reciente",
+        "reasonWaiting": "necesita aprobación",
+        "reasonBlocked": "falló",
+        "groupShell": "Shell",
+        "groupMonitors": "Monitores",
+        "groupWorkflows": "Flujos de trabajo"
+      },
+      "taskList": {
+        "title": "Tareas",
+        "completed": "Completado",
+        "inProgress": "En curso",
+        "pending": "Pendiente",
+        "empty": "Sin tareas",
+        "progress": "{{completed}} de {{total}} tareas completadas",
+        "added": "Se añadió {{task}}",
+        "removed": "Se eliminó {{task}}",
+        "started": "Se inició {{task}}",
+        "finished": "Se completó {{task}}",
+        "reset": "Marcado como pendiente: {{task}}",
+        "updated": "Se actualizó {{task}}",
+        "unchanged": "Tareas sin cambios",
+        "showAll": "Lista completa de tareas"
+      },
+      "turnDiff": {
+        "one": "1 archivo modificado",
+        "many": "{{count}} archivos modificados",
+        "partial": "Diff parcial",
+        "recorded": "Totales de las ediciones registradas en este turno."
+      },
+      "notices": {
+        "compaction": "Contexto compactado",
+        "details": "Detalles",
+        "plan": "Plan",
+        "historyRepaired": "No se pudo cargar parte del historial de este chat.",
+        "historyItemTooLarge": "Esta parte del chat era demasiado grande para mostrarla."
+      },
+      "providerFrame": {
+        "byteLength": "{{value0}} bytes"
+      },
+      "railLabel": "Tus mensajes",
+      "railImageMessage": "Imagen adjunta",
+      "railEmptyMessage": "Mensaje",
+      "ask": {
+        "awaiting": "Esperando entrada del usuario:",
+        "awaitingUnnamed": "Esperando entrada del usuario",
+        "asked": "Preguntó:",
+        "questionCount": "{{value0}} preguntas"
+      },
+      "conversationCommand": {
+        "pendingWork": "Espera a que terminen el trabajo y los mensajes pendientes antes de usar este comando."
+      },
+      "drop": {
+        "title": "Suelta para adjuntar a este chat",
+        "subtitle": "Los archivos se añaden a tu mensaje como rutas que el agente puede leer."
+      },
+      "copyCode": "Copiar código",
+      "goal": {
+        "placeholder": "Describe tu objetivo y define resultados medibles para obtener mejores resultados",
+        "clear": "Borrar objetivo",
+        "chip": "Objetivo",
+        "exitMode": "Salir del modo objetivo",
+        "sentAsGoal": "Enviado como objetivo",
+        "collapse": "Ocultar objetivo completo",
+        "expand": "Mostrar objetivo completo",
+        "pause": "Pausar objetivo",
+        "resume": "Reanudar objetivo",
+        "pursuing": "Objetivo en curso",
+        "paused": "Objetivo en pausa",
+        "blocked": "Objetivo bloqueado",
+        "limited": "Objetivo limitado",
+        "attachmentsUnsupported": "Elimina los adjuntos antes de establecer un objetivo."
+      },
+      "structuredSessionHostDeclined": "Se abrió {{value0}} en una terminal",
+      "structuredSessionHostDeclinedDescription": "Este servidor no puede ejecutar un chat de {{value0}} en este espacio de trabajo.",
+      "structuredSessionHostUnreachable": "No se pudo contactar con {{value0}}",
+      "structuredSessionHostUnreachableDescription": "Orca no abrió un chat de {{value0}}. Comprueba la conexión con el servidor y vuelve a intentarlo."
     },
     "tab": {
       "bar": {
@@ -15252,6 +18001,232 @@
         "presentation": {
           "gitlabMergeRequestNumber": "MR #{{value0}}",
           "githubPullRequestNumber": "PR #{{value0}}"
+        },
+        "browse": {
+          "facet": {
+            "agent": "Agente",
+            "git": "Git",
+            "review": "Revisión",
+            "ticket": "Tickets",
+            "location": "Ubicación",
+            "safety": "Seguridad",
+            "activity": "Actividad",
+            "size": "Tamaño en disco",
+            "status": "Estado del espacio de trabajo",
+            "context": "Contexto local"
+          },
+          "host": "Anfitrión",
+          "repo": "Repositorio",
+          "noWorkspaces": "No se encontraron espacios de trabajo.",
+          "sort": {
+            "name": "Espacio de trabajo",
+            "repo": "Repositorio",
+            "host": "Anfitrión",
+            "agent": "Agente",
+            "behind": "Detrás",
+            "size": "Tamaño",
+            "git": "Git",
+            "review": "Revisión",
+            "tier": "Seguridad",
+            "blockerCount": "Bloqueos",
+            "lastActivity": "Última actividad",
+            "lastVisited": "Última apertura",
+            "created": "Creado",
+            "path": "Ruta",
+            "workspaceStatus": "Estado",
+            "ahead": "Adelantado",
+            "branch": "Rama",
+            "ticket": "Ticket",
+            "localContext": "Abrir contexto"
+          },
+          "review": {
+            "open": "Abierto",
+            "draft": "Borrador",
+            "merged": "Fusionado",
+            "closed": "Cerrado",
+            "unknown": "Desconocido",
+            "otherProvider": "Otro"
+          },
+          "ticket": {
+            "linear": "Linear",
+            "issue": "Asunto",
+            "workItem": "Elemento de trabajo"
+          },
+          "selectedCount": "{{value0}} seleccionado",
+          "chip": {
+            "kind": {
+              "agent": "Agente",
+              "host": "Anfitrión",
+              "git": "Git",
+              "review": "Revisión",
+              "reviewProvider": "Proveedor",
+              "tier": "Seguridad",
+              "dismissed": "Ignorado",
+              "prunable": "Podable",
+              "locked": "Bloqueado",
+              "status": "Estado",
+              "ticket": "Ticket",
+              "archived": "Archivado",
+              "pinned": "Fijado",
+              "unread": "Sin leer",
+              "reviewState": "Estado de revisión",
+              "ticketSource": "Origen del ticket",
+              "context": "Contexto",
+              "repo": "Repositorio",
+              "blocker": "Bloqueo",
+              "comment": "Comentario",
+              "retainedAgents": "Agentes finalizados"
+            },
+            "idleDays": "Inactivo {{value0}}d+",
+            "neverVisited": "Nunca visitado",
+            "minSize": "Al menos {{value0}} MB",
+            "maxSize": "Como máximo {{value0}} MB",
+            "excludesUnsized": "Solo medidos",
+            "excludesStatusless": "Tiene estado",
+            "list": "{{value0}}: {{value1}}",
+            "triState": "{{value0}}: {{value1}}",
+            "only": "Solo",
+            "exclude": "Excluido",
+            "minAhead": "Adelantado {{value0}}+",
+            "minBehind": "Atrasado {{value0}}+",
+            "presence": "{{value0}}: {{value1}}",
+            "branchQuery": "Rama: {{value0}}",
+            "pathPrefix": "Ruta: {{value0}}",
+            "has": "Tiene",
+            "none": "Ninguno",
+            "completelyEmpty": "Nada que perder",
+            "selectableOnly": "Solo eliminables"
+          },
+          "noSizes": "Aún no se han medido los tamaños de los espacios de trabajo.",
+          "noSizesDescription": "Los tamaños aparecen después de medir el uso de disco.",
+          "measureSizes": "Escanear",
+          "measureSizesTitle": "Escanear tamaños de espacios de trabajo",
+          "measureSizesDescription": "Escanea el uso de disco para comparar, ordenar y filtrar espacios de trabajo por tamaño.",
+          "sizeOnDisk": "Tamaño en disco: {{value0}}",
+          "checkingGitRow": "Comprobando estado de Git",
+          "searchPlaceholder": "Buscar nombre, repositorio, rama, ruta, host",
+          "searchLabel": "Buscar espacios de trabajo",
+          "filters": "Filtros",
+          "showingCount": "Mostrando {{value0}} de {{value1}}",
+          "clearFilters": "Borrar filtros",
+          "checkingGit": "Comprobando estado de Git: quedan {{value0}}",
+          "minAhead": "Confirmaciones por delante ≥",
+          "minBehind": "Confirmaciones por detrás ≥",
+          "branchQuery": "La rama contiene",
+          "prunable": "Podable",
+          "locked": "Bloqueado",
+          "reviewPresence": "PR / MR",
+          "reviewProvider": "Proveedor",
+          "ticketPresence": "Incidencia vinculada",
+          "pathPrefix": "La ruta empieza por",
+          "tier": {
+            "ready": "Listo",
+            "review": "Necesita revisión",
+            "protected": "Protegido"
+          },
+          "blockerMode": "Coincidencia de bloqueador",
+          "blockerModeAny": "Tiene alguno",
+          "blockerModeNone": "No tiene ninguno",
+          "blockers": "Bloqueos",
+          "dismissed": "Ignorado",
+          "selectableOnly": "Solo espacios de trabajo que puedo eliminar ahora",
+          "idleSignal": {
+            "lastVisited": "Sin abrir",
+            "lastActivity": "Sin actividad",
+            "created": "Creado antes de"
+          },
+          "presence": {
+            "none": "No tiene ninguno",
+            "any": "Cualquiera",
+            "some": "Tiene uno"
+          },
+          "idleMinDays": "Inactivo durante al menos",
+          "days": "días",
+          "neverVisited": "Nunca abierto",
+          "minSize": "Al menos",
+          "maxSize": "Como máximo",
+          "includeUnsized": "Incluir espacios de trabajo sin medir",
+          "matchStatusless": "Incluir espacios de trabajo sin estado",
+          "archived": "Archivado",
+          "pinned": "Fijado",
+          "unread": "Sin leer",
+          "comment": "Tiene comentario",
+          "retainedDoneAgents": "Transcripciones de agente finalizadas",
+          "contextPresence": "Pestañas, terminales y comentarios abiertos",
+          "completelyEmpty": "Nada más que perder",
+          "noMatches": "Ningún espacio de trabajo coincide con estos filtros.",
+          "noMatchesDescription": "Todos los espacios de trabajo están en una sola lista: amplía un filtro o bórralos.",
+          "selectAll": "Seleccionar todos los espacios de trabajo coincidentes",
+          "sortBy": "Ordenar por",
+          "sortByField": "Ordenar por {{value0}}",
+          "git": {
+            "clean": "Limpio",
+            "dirty": "Cambios sin confirmar",
+            "unpushed": "Confirmaciones sin subir",
+            "unknown": "Sin comprobar"
+          },
+          "agent": {
+            "working": "Trabajando",
+            "permission": "Esperándote",
+            "idle": "Inactivo"
+          },
+          "triState": {
+            "any": "Cualquiera",
+            "only": "Solo",
+            "exclude": "Excluir"
+          },
+          "tierField": "Nivel de limpieza",
+          "idleSignalField": "Señal de inactividad",
+          "selectionVanishedOne": "1 espacio de trabajo seleccionado ya no existe.",
+          "selectionVanished": "{{value0}} espacios de trabajo seleccionados ya no existen.",
+          "updatedAgo": "Actualizado {{value0}}",
+          "refreshing": "Actualizando…",
+          "refreshingProgress": "Actualizando {{value0}}/{{value1}}",
+          "notMeasured": "Sin medir",
+          "openWorkspaceNamed": "Abrir {{value0}}",
+          "openWorkspace": "Abrir espacio de trabajo",
+          "workspaceStatus": "Estado del espacio de trabajo: {{value0}}",
+          "measuringSizesProgress": "Escaneando {{value0}}/{{value1}}",
+          "measuringSizes": "Escaneando tamaños",
+          "measureSizesFailed": "No se pudieron escanear los tamaños de los espacios de trabajo",
+          "gitStatusCheckFailed": "Falló la comprobación del estado de Git",
+          "gitStatusUnverified": "No se pudo verificar el estado de Git",
+          "deleteAnyway": "Eliminar de todos modos",
+          "forceDeleteProjectionOne": "{{count}} espacio de trabajo muestra riesgo actualmente y puede necesitar una eliminación forzada",
+          "forceDeleteProjectionMany": "{{count}} espacios de trabajo muestran riesgo actualmente y pueden necesitar una eliminación forzada",
+          "selectionWithheldOne": "1 espacio de trabajo seleccionado está oculto por los filtros actuales y se ha deseleccionado.",
+          "selectionWithheld": "{{value0}} espacios de trabajo seleccionados están ocultos por los filtros actuales y se han deseleccionado.",
+          "selectAllCountOne": "Seleccionar 1 espacio de trabajo con comprobación de seguridad",
+          "selectAllCount": "Seleccionar los {{value0}} espacios de trabajo con comprobación de seguridad",
+          "appliedFilters": "Filtros aplicados",
+          "removeFilter": "Quitar filtro {{value0}}"
+        },
+        "scan": {
+          "noWorkspaces": "No se encontraron espacios de trabajo.",
+          "progress": "Escaneando espacios de trabajo ({{value0}}/{{value1}})",
+          "singleError": "No se pudo comprobar {{value0}}: {{value1}}. Puede que falten espacios de trabajo. Actualiza para reintentar.",
+          "moreErrors": ", +{{value0}} más",
+          "multipleErrors": "No se pudieron comprobar {{value0}} repositorios ({{value1}}{{value2}}). Puede que falten espacios de trabajo. Actualiza para reintentar.",
+          "readyOneOne": "1 espacio de trabajo encontrado, con 1 sugerencia de limpieza.",
+          "readyOneMany": "1 espacio de trabajo encontrado, con {{value0}} sugerencias de limpieza.",
+          "readyManyOne": "{{value0}} espacios de trabajo encontrados, con 1 sugerencia de limpieza.",
+          "readyManyMany": "{{value0}} espacios de trabajo encontrados, con {{value1}} sugerencias de limpieza.",
+          "fallbackRepository": "un repositorio",
+          "gitListFailed": "Git no pudo listar los árboles de trabajo",
+          "readyOne": "1 espacio de trabajo encontrado.",
+          "readyMany": "{{value0}} espacios de trabajo encontrados."
+        },
+        "host": {
+          "candidateName": "{{value0}} en {{value1}}",
+          "label": "Host: {{value0}}",
+          "unknown": "Host desconocido"
+        },
+        "relativeTime": {
+          "never": "Nunca",
+          "justNow": "Ahora mismo",
+          "minutesAgo": "hace {{value0}} min",
+          "hoursAgo": "hace {{value0}} h",
+          "daysAgo": "hace {{value0}} d"
         }
       },
       "creation": {
@@ -15304,6 +18279,77 @@
         "queueFollowUpsTitle": "Poner mensajes en cola",
         "queueFollowUpsCopy": "Los mensajes que envías mientras el agente trabaja esperan como tarjetas que puedes enviar ahora, editar o eliminar. Los mensajes con imágenes se envían de inmediato.",
         "queueFollowUpsToggleLabel": "Alternar la cola de mensajes"
+      },
+      "TerminalInteraction": {
+        "copyTrimsGutter": "Recortar margen al copiar",
+        "copyTrimsGutterDescription": "Elimina el margen izquierdo tras el que se dibuja la salida del agente, para que el texto copiado no quede indentado. Solo se quita la indentación que comparten todas las líneas seleccionadas."
+      },
+      "terminal": {
+        "clipboard": {
+          "search": {
+            "gutter": "margen",
+            "indent": "indentación",
+            "margin": "margen",
+            "leading": "inicial",
+            "whitespace": "espacios en blanco",
+            "spaces": "espacios"
+          }
+        }
+      }
+    },
+    "onboarding": {
+      "flow": {
+        "actions": {
+          "continue": "Continuar",
+          "addFirstProject": "Añade tu primer proyecto",
+          "openingAddProject": "Abriendo Añadir proyecto..."
+        },
+        "stepTooltip": {
+          "agent": "Agente predeterminado",
+          "theme": "Apariencia",
+          "windowsTerminal": "Terminal de Windows",
+          "notifications": "Notificaciones",
+          "integrations": "Integraciones"
+        }
+      },
+      "skipConfirmation": {
+        "skip": "Omitir",
+        "keepGoing": "No, continuar"
+      },
+      "theme": {
+        "hints": {
+          "system": "Igual que el SO",
+          "dark": "Suave a la vista",
+          "light": "Brillante y nítido"
+        }
+      },
+      "integrations": {
+        "capabilities": {
+          "startWorkspaceFromIssue": "Inicia un espacio de trabajo desde cualquier incidencia o pull request de GitHub, rellenado con su título y contexto",
+          "browseIssues": "Explora incidencias y pull requests de GitHub en la vista Tareas sin salir de Orca",
+          "reviewStatus": "Consulta el estado de la incidencia, la revisión y las verificaciones de CI en cada árbol de trabajo",
+          "managePullRequests": "Lee, comenta y fusiona pull requests sin salir de Orca"
+        }
+      }
+    },
+    "jiraUserPicker": {
+      "select": "Seleccione {{value0}}",
+      "search": "Buscar usuarios",
+      "empty": "No se encontraron usuarios"
+    },
+    "status": {
+      "bar": {
+        "workspaceSpace": {
+          "otherTopLevelItems": "Otros elementos de nivel superior ({{value0}})"
+        }
+      }
+    },
+    "cmd-j": {
+      "paletteSessionAge": {
+        "minutes": "{{value0}} min",
+        "hours": "{{value0}} h",
+        "days": "{{value0}} d",
+        "underOneMinute": "<1 min"
       }
     }
   },
@@ -15345,7 +18391,8 @@
     "terminal": {
       "closed": "No live terminal — this agent's pane has closed.",
       "focusWorktree": "Open worktree",
-      "close": "Close"
+      "close": "Close",
+      "remotePreviewUnavailable": "No hay vista previa para esta sesión remota: abre el espacio de trabajo para ver la terminal."
     },
     "close": "Close dashboard",
     "settingsTooltip": "Configuración del tablero",
@@ -15377,6 +18424,12 @@
     "settings": {
       "showIdle": "Mostrar agentes inactivos",
       "showIdleCopy": "Incluye agentes que han permanecido inactivos durante 30 minutos sin informar que finalizaron. Ocultos de forma predeterminada."
+    },
+    "host": {
+      "ssh": "Anfitrión SSH",
+      "sshNamed": "Host SSH · {{host}}",
+      "remoteNamed": "Host remoto de Orca · {{host}}",
+      "remote": "Host remoto de Orca"
     }
   },
   "dashboard": {
@@ -15409,7 +18462,83 @@
       "certificateChallengeExpired": "Esta aprobación de certificado caducó. Vuelve a intentarlo con la página para solicitar una nueva.",
       "certificateChallengeChanged": "La solicitud de certificado cambió. Vuelve a intentarlo con la página y revisa la nueva advertencia.",
       "certificateChallengeUnavailable": "Esta solicitud de certificado ya no está disponible. Vuelve a intentarlo con la página para solicitar una nueva.",
-      "certificateProceedFailed": "Orca no pudo aprobar esta solicitud de certificado. Vuelve a intentarlo con la página e inténtalo de nuevo."
+      "certificateProceedFailed": "Orca no pudo aprobar esta solicitud de certificado. Vuelve a intentarlo con la página e inténtalo de nuevo.",
+      "sshRoutedHint": "Esta página navega a través del host SSH del espacio de trabajo; puede que el host esté desconectado o no pueda acceder a este sitio.",
+      "recheckSshRoute": "Ejecutar comprobación de conexión"
+    },
+    "guestRecovery": {
+      "title": "La página del navegador se detuvo",
+      "failed": "La página del navegador se detuvo inesperadamente. Reintenta para restaurarla."
+    },
+    "clientHosted": {
+      "preparationFailed": "No se pudo iniciar el navegador remoto en este escritorio. Comprueba la conexión emparejada y vuelve a intentarlo.",
+      "unavailableTitle": "Navegador alojado en el cliente no disponible",
+      "unavailableDescription": "Esta página está asociada a otro escritorio o ya no está disponible.",
+      "download": {
+        "started": "Descargando {{filename}}…",
+        "completed": "{{filename}} descargado",
+        "canceled": "Descarga cancelada.",
+        "failed": "No se pudo completar la descarga."
+      },
+      "popupBlocked": "Ventana emergente bloqueada: {{origin}}",
+      "hostPaneOfflineTitle": "Ese dispositivo ya no está conectado",
+      "hostPaneNamedTitle": "Mostrando en {{device}}",
+      "hostPaneTitle": "Mostrando en otro dispositivo",
+      "hostPaneOfflineDescription": "Esta página permanece en la lista para que puedas cerrarla desde aquí. Volverá cuando el dispositivo se reconecte.",
+      "hostPaneDescription": "Esta página se renderiza en el escritorio emparejado que la abrió.",
+      "hostRowClose": "Cerrar página alojada",
+      "hostRowCloseFailed": "No se pudo cerrar esta página. Puede que el dispositivo que la aloja esté ocupado; vuelve a intentarlo.",
+      "hostRowOfflineNamed": "Sin conexión: estaba alojada en {{device}}",
+      "hostRowOffline": "Sin conexión: el dispositivo que la alojaba se cerró",
+      "hostRowNamed": "Alojada en {{device}}",
+      "hostRow": "Alojada en otro dispositivo"
+    },
+    "navigation": {
+      "back": "Atrás",
+      "forward": "Adelante",
+      "reload": "Recargar"
+    },
+    "reopenOnServer": {
+      "action": "Reabrir en el servidor",
+      "pending": "Reabriendo…",
+      "caveat": "Esto abre una nueva página en el host remoto en la última dirección de esta página. El estado de sesión iniciada y otros estados transitorios pueden diferir, y una página que provenga del envío de un formulario se abrirá en blanco.",
+      "failed": "No se pudo abrir esta página en el host remoto. Comprueba la conexión y vuelve a intentarlo."
+    },
+    "sshRoute": {
+      "preparingTitle": "Conectando a través del host SSH",
+      "errorTitle": "Enrutamiento del navegador por SSH no disponible",
+      "errorDescription": "Las páginas de este espacio de trabajo navegan a través de su host SSH, y esa conexión no está disponible ahora mismo.",
+      "retry": "Reintentar",
+      "tryAnyway": "Intentar de todos modos",
+      "browseLocally": "Navegar desde este dispositivo",
+      "forwardingBlockedTitle": "El servidor SSH bloquea el tráfico del navegador",
+      "sshUnavailableTitle": "Conexión SSH no disponible",
+      "forwardingBlockedDescription": "Este servidor rechaza el reenvío TCP (a menudo «AllowTcpForwarding no» en su configuración de sshd), que es necesario para navegar a través de él. Pide a su administrador que permita el reenvío, o navega desde este dispositivo.",
+      "sshUnavailableDescription": "Las páginas de este espacio de trabajo navegan a través de su host SSH, y esa conexión no está disponible ahora mismo. Reconecta el host y vuelve a intentarlo.",
+      "showDetails": "Mostrar detalles"
+    },
+    "sshEgress": {
+      "routedTooltip": "Navegando a través de {{value0}}",
+      "localTooltip": "Navegando desde este dispositivo, no desde {{value0}}",
+      "localChip": "Este dispositivo",
+      "routedDetail": "El tráfico de red y el DNS pasan por el host SSH del espacio de trabajo.",
+      "localDetail": "Las páginas se cargan desde esta máquina y su red.",
+      "settingsLink": "Ajustes de enrutamiento"
+    },
+    "remoteEgress": {
+      "clientHostedTooltip": "Navegando a través de {{value0}}",
+      "streamedTooltip": "Navegando en {{value0}}",
+      "clientHostedDetail": "La página se renderiza en este dispositivo. El tráfico de red y el DNS pasan por el host remoto.",
+      "streamedDetail": "La página se ejecuta en el host remoto y se transmite a este dispositivo."
+    },
+    "remote": {
+      "findUnavailable": "Buscar en la página no está disponible mientras esta página se transmite desde el host remoto."
+    },
+    "userAgentMigration": {
+      "degradedDescription": "No se pudo inspeccionar una elección antigua de identidad del navegador. Elige Limpiada o Nativa en los ajustes del navegador; los cambios surten efecto tras reiniciar.",
+      "description": "Se eliminaron los ajustes de user-agent por perfil. Elige Limpiada o Nativa en los ajustes del navegador; los cambios surten efecto tras reiniciar.",
+      "title": "La identidad del navegador ahora es para toda la app",
+      "openSettings": "Abrir ajustes"
     }
   },
   "runtimeRpc": {
@@ -15498,6 +18627,18 @@
       "recent3Title": "Borrador de notas de la versión",
       "settingsLink": "Ajustes → Búsqueda de sesiones de agentes",
       "startSearching": "Empezar a buscar"
+    },
+    "voice": {
+      "demoPrompt": "Revisa este diff en busca de casos límite y agrega pruebas para lo que encuentres.",
+      "startDictation": "Iniciar dictado",
+      "agentPromptTitle": "Prompt del agente",
+      "listening": "Escuchando...",
+      "focusPaneInstruction": "Enfoca un terminal, editor o prompt del agente, luego presiona",
+      "startInstruction": "para iniciar el dictado por voz. Presiona",
+      "stopInstruction": "de nuevo para detener.",
+      "unassignedInstruction": "Asigna un atajo de dictado antes de iniciar el dictado por voz en un panel enfocado.",
+      "settingsInstruction": "Cambia el modelo, el modo de dictado o el atajo en cualquier momento en",
+      "settingsLink": "Ajustes → Voz"
     }
   },
   "fileExplorer": {
@@ -15569,6 +18710,13 @@
       "searching": "Buscando…",
       "searchFailed": "La búsqueda no pudo finalizar. Inténtalo de nuevo.",
       "refreshFailed": "No se pudo actualizar la vista previa. Se muestra la versión anterior; abre la vista de código para ver el contenido actual."
+    },
+    "richMarkdown": {
+      "tooLarge": "El archivo supera el límite de edición enriquecida de {{limit}}. Se muestra el modo de código fuente.",
+      "openAnyway": "Abrir de todos modos"
+    },
+    "fileLoad": {
+      "hostUnresolved": "El host no pudo encontrar el espacio de trabajo de este archivo. Puede que se haya eliminado o que el host aún no lo conozca. Reintenta o cierra esta pestaña desde la barra de pestañas."
     }
   },
   "accounts": {
@@ -15585,6 +18733,230 @@
       "removeTitle": "¿Eliminar la cuenta administrada?",
       "removeDescription": "Detén primero los agentes que usan este perfil. Al eliminarlo se borran sus credenciales y conversaciones guardadas. Tu inicio de sesión del sistema no cambia.",
       "cancel": "Cancelar"
+    },
+    "antigravity": {
+      "retry": "Reintentar",
+      "remove": "Eliminar",
+      "usage": "Actualizar uso",
+      "scope": "Administra la cuenta nativa de agy en {{host}}.",
+      "signIn": "Inicia agy en este host y completa su inicio de sesión en el navegador, luego guarda la cuenta actual. Para agregar otra cuenta, usa /logout en agy e inicia sesión de nuevo.",
+      "docs": "Instrucciones de inicio de sesión",
+      "identityUnknown": "Identidad de sesión no disponible",
+      "signedOut": "No hay ninguna cuenta nativa de agy con sesión iniciada.",
+      "changed": "La cuenta nativa cambió. Selecciona de nuevo una cuenta guardada antes de iniciar agy.",
+      "save": "Guardar cuenta actual",
+      "refresh": "Actualizar cuentas",
+      "working": "Actualizando cuenta",
+      "usageReading": "Sesión: {{session}} · Semanal: {{weekly}}",
+      "saved": "Cuenta de Google guardada",
+      "nativeActive": "Cuenta nativa",
+      "selected": "Seleccionada",
+      "select": "Seleccionar",
+      "sessions": "La selección se aplica a las nuevas sesiones de agy en este host. Las sesiones existentes pueden conservar su cuenta anterior.",
+      "searchTitle": "Cuentas de Antigravity",
+      "searchDescription": "Guarda y selecciona cuentas nativas de Google de agy en el host de ejecución.",
+      "title": "Antigravity",
+      "keyword": {
+        "antigravity": "antigravity",
+        "agy": "agy",
+        "google": "google",
+        "accounts": "accounts"
+      }
     }
+  },
+  "osDocumentOpen": {
+    "failed": "No se pudo abrir el archivo."
+  },
+  "sidebar": {
+    "revealFiltered": {
+      "title": "¿Mostrar el espacio de trabajo oculto?",
+      "description": "El espacio de trabajo activo está oculto en la barra lateral. Mostrarlo solo ajustará los filtros que lo ocultan.",
+      "confirm": "Ajustar filtros y mostrar",
+      "cancel": "Mantener filtros"
+    }
+  },
+  "rendererRecovery": {
+    "reload": "Recargar",
+    "copyCommands": "Copiar comandos",
+    "quit": "Salir",
+    "stalledDetail": "Orca recargó la ventana tras un fallo, pero nunca terminó de cargar.",
+    "crashLoopDetail": "Orca intentó recuperarse {{recoveryCount}} veces seguidas sin éxito.",
+    "driverFallback": "Si eso no ayuda, la causa suele ser un controlador de gráficos.",
+    "genericDetail": "A menudo es un problema del controlador de gráficos o de la instalación. Recarga para reintentar, o sal y vuelve a iniciar Orca.",
+    "title": "Orca sigue sin poder cargarse",
+    "stalledMessage": "La ventana de la app dejó de responder mientras se recargaba tras un fallo.",
+    "crashLoopMessage": "La ventana de la app falló repetidamente y dejó de recargarse automáticamente.",
+    "lowCommitMessage": "Windows se quedó sin memoria.",
+    "lowCommitDetail": "Windows solo tiene {{availableMB}} MB de memoria disponible para las apps, así que la ventana se quedó sin memoria otra vez tras recargar.",
+    "lowCommitAdvice": "Libera memoria cerrando apps que no uses o espacios de trabajo de Orca, o aumenta el tamaño del archivo de paginación de Windows, luego haz clic en Recargar.",
+    "tryAgain": "Reintentar",
+    "launchFailedMessage": "Orca no pudo iniciar el proceso que dibuja su ventana.",
+    "launchFailedDetail": "Orca reintentó {{recoveryCount}} veces sin éxito.",
+    "processLimitDetail": "El sistema se negó a crear un nuevo proceso porque tu cuenta de usuario alcanzó su límite de procesos. A menudo lo causan terminales, servidores de desarrollo o agentes descontrolados. Cierra algunos y haz clic en Reintentar.",
+    "launchFailedGenericDetail": "El sistema se negó a iniciarlo. Libera memoria o cierra otras apps, luego haz clic en Reintentar. Si sigue ocurriendo, reinstala Orca."
+  },
+  "sessionSearch": {
+    "panel": {
+      "retry": "Probar de nuevo",
+      "resultsOne": "{{count}} resultado",
+      "resultsOther": "{{count}} resultados",
+      "noMatches": "No hay sesiones coincidentes en el historial indexado. Prueba otra consulta o ámbito.",
+      "loadMore": "Cargar más coincidencias",
+      "indexedHistory": "Historial indexado",
+      "hostsSkipped": "Sin buscar: {{value0}}",
+      "sortRelevance": "Más relevantes",
+      "sortNewest": "Más recientes",
+      "sortResultsAriaLabel": "Ordenar resultados: {{value0}}",
+      "consent": "¿Activar la búsqueda de texto completo? Orca crea un índice en esta computadora a partir de las transcripciones locales de los agentes, incluidas conversaciones completas y hasta 3.072 caracteres por salida de herramienta. El contenido no se censura. Los clientes emparejados autenticados pueden buscarlo.",
+      "remoteDisabled": "La búsqueda está desactivada en esta computadora. Activa la indexación de transcripciones en esa computadora para buscar sus sesiones.",
+      "notReady": "El índice de búsqueda aún no está listo. Reintenta en un momento.",
+      "noService": "La búsqueda no está disponible en esta computadora. Puede que necesite una actualización de Orca o un entorno de ejecución compatible con la búsqueda.",
+      "unsupportedAgent": "Esta computadora no admite la búsqueda en el historial del agente seleccionado. Actualiza Orca en esa computadora o selecciona otro agente.",
+      "failed": "No se pudo buscar en esta computadora. Verifica su conexión y reintenta.",
+      "changed": "El índice cambió durante la búsqueda. Vuelve a buscar para obtener resultados actuales.",
+      "truncated": "Algunos resultados o textos coincidentes quedaron limitados. Acota tu búsqueda para obtener resultados más precisos.",
+      "enableFailed": "No se pudo activar la búsqueda. Reintenta.",
+      "enable": "Activar",
+      "scopeUnknown": "Esta computadora no tiene este espacio de trabajo ni este proyecto. Cambia el ámbito a Todo para buscar en todo lo que contiene.",
+      "sortSessionsAriaLabel": "Ordenar sesiones: {{value0}}",
+      "sessionsOne": "{{count}} sesión",
+      "sessionsOther": "{{count}} sesiones",
+      "sessionsOfLoaded": "{{value0}} de {{value1}} sesiones",
+      "showMoreSessions": "Mostrar más sesiones",
+      "loadingMoreSessions": "Cargando más sesiones…"
+    }
+  },
+  "sessionHistory": {
+    "status": {
+      "checking": "De cheques…",
+      "error": "No se pudo comprobar el estado. Reintentando…",
+      "unavailable": "La búsqueda no está disponible en esta computadora ahora mismo.",
+      "unreadable": "No se pudieron leer {{failed}} sesiones y se reintentarán.",
+      "roots": "No se pudieron comprobar {{roots}} carpetas de sesiones.",
+      "searchable": "{{sessions}} sesiones · {{messages}} mensajes buscables",
+      "searchableSessions": "{{sessions}} sesiones buscables",
+      "catchingUp": "{{indexed}} de {{total}} sesiones · {{messages}} mensajes buscables",
+      "catchingUpSessions": "{{indexed}} de {{total}} sesiones buscables"
+    },
+    "settings": {
+      "delete": "Claro",
+      "thisComputer": "esta computadora",
+      "open": "Abierto",
+      "updateServer": "Actualizar servidor",
+      "saveError": "No se pudo guardar. Reintenta.",
+      "advanced": "Avanzado",
+      "deleteIndexCopy": "Borrar datos de búsqueda",
+      "deleteTitle": "¿Borrar los datos de búsqueda en esta computadora?",
+      "deleteEnabled": "Desactiva la búsqueda y elimina de esta computadora la copia de búsqueda. Tus sesiones de agente no se ven afectadas.",
+      "deleteDisabled": "Elimina de esta computadora la copia de búsqueda. Tus sesiones de agente no se ven afectadas.",
+      "cleared": "Datos de búsqueda borrados.",
+      "clearError": "No se pudieron borrar los datos de búsqueda. Reintenta.",
+      "webUnsupported": "Activa la búsqueda de sesiones desde la app de escritorio de Orca en esa computadora.",
+      "title": "Búsqueda de sesiones de agente",
+      "description": "Busca todo lo que tus agentes han dicho y hecho, en esta computadora y en cualquier servidor de Orca emparejado.",
+      "searchDescription": "Activa la búsqueda de sesiones para esta computadora y los servidores emparejados, o borra los datos de búsqueda.",
+      "indexComputers": "Buscar dentro de las sesiones",
+      "computersConsent": "Cada computadora guarda una copia de búsqueda de sus propias conversaciones de agente y salidas de herramientas. Nada sale de esa computadora.",
+      "serverVersion": "Orca v{{version}}",
+      "rowSwitchLabel": "Buscar sesiones en {{host}}",
+      "serverOffline": "Sin conexión",
+      "serverTooOld": "Requiere una versión más reciente de Orca.",
+      "serverToggleError": "No se pudo cambiar la búsqueda de sesiones en {{host}}. Reintenta.",
+      "clearedAndTurnedOff": "Búsqueda desactivada y datos de búsqueda borrados.",
+      "remoteServers": "Servidores remotos de Orca",
+      "showMore": "Mostrar {{count}} más",
+      "showFewer": "Mostrar menos",
+      "openInSidebar": "Abrir en la barra lateral",
+      "openInSidebarCopy": "Escribe lo que recuerdes o pídele a un agente: «encuentra la sesión donde arreglamos el tiempo de espera de inicio de sesión».",
+      "enableOnAll": "Activar en todas las computadoras"
+    }
+  },
+  "common": {
+    "retry": "Reintentar"
+  },
+  "terminal": {
+    "codexTerminalServerIsolationNotice": {
+      "openSettings": "Abrir ajustes",
+      "title": "Orca ahora ejecuta Codex sin su servidor compartido",
+      "description": "Esto hace que el estado del agente sea más fiable. Puedes volver a activarlo en Ajustes."
+    },
+    "codexSharedServerBanner": {
+      "fix": "Solucionar",
+      "dismiss": "Descartar",
+      "copied": "Copiado",
+      "done": "Hecho",
+      "cancel": "Cancelar",
+      "stopping": "Parada…",
+      "title": "Este Codex comparte un servidor con tus otras pestañas de Codex",
+      "body": "Las sesiones pueden terminar de forma inesperada y el estado del agente puede ser incorrecto.",
+      "openedBeforeUpdateBody": "Este terminal se abrió antes de que Orca empezara a dar a cada Codex su propio servidor.",
+      "oldTerminalDialogTitle": "Por qué este Codex comparte un servidor",
+      "oldTerminalDialogRisk": "Las sesiones de Codex que comparten un servidor pueden terminar juntas, y el estado del agente puede ser incorrecto.",
+      "oldTerminalDialogCause": "Los terminales antiguos aún comparten un servidor de Codex. Abre un terminal nuevo para ejecutar Codex en un servidor aparte.",
+      "openNewTerminal": "Abrir terminal nuevo",
+      "dontShowAgain": "No volver a mostrar",
+      "dialogTitle": "Dar a cada pestaña de Codex su propio servidor",
+      "dialogDescription": "Las sesiones de Codex iniciadas directamente en un terminal comparten un servidor en segundo plano. Orca mantiene separadas las sesiones de Codex que inicia. Cuando las sesiones comparten un servidor, cerrar una puede terminar con las demás, y el estado del agente puede ser incorrecto.",
+      "copy": "Copiar",
+      "step1Title": "Desactivar el uso compartido del servidor de Codex",
+      "step1Note": "Esto cambia tus ajustes de Codex, así que también se aplica fuera de Orca.",
+      "step2Title": "Detener el servidor compartido en ejecución",
+      "undo": "Para deshacerlo, ejecuta codex features enable daemon_auto_start.",
+      "step2Warning": "Cierra cualquier sesión de Codex abierta que comparta el servidor",
+      "learnMore": "Más información",
+      "turnOff": "Desactivar",
+      "turningOff": "Desactivando…",
+      "turnedOff": "Desactivado",
+      "turnOffFailed": "Orca no pudo desactivar esto.",
+      "stopServer": "Detener servidor",
+      "stopped": "Detenido",
+      "stopFailed": "Orca no pudo detener el servidor.",
+      "confirmStopTitle": "¿Detener el servidor compartido?",
+      "confirmStopDescription": "Esto cierra cualquier sesión de Codex abierta que lo comparta, incluidas las que están fuera de Orca.",
+      "runs": "Ejecuciones"
+    },
+    "sessionSaveFailure": {
+      "title": "No se pudo guardar la sesión del terminal",
+      "capacity": "El dispositivo que guarda este terminal informó de almacenamiento lleno o de una cuota de almacenamiento superada. Libera espacio en ese dispositivo y reintenta.",
+      "unknown": "Orca no pudo guardar el estado del terminal. Reintenta. Si continúa, comparte los registros de Orca con soporte para que podamos identificar la causa."
+    },
+    "codexSharedSettingsNotice": {
+      "title": "Codex en Orca ahora usa ~/.codex",
+      "description": "Codex puede volver a pedir que confíes en carpetas o apruebes comandos. Vuelve a agregar los servidores MCP que agregaste solo en Orca."
+    }
+  },
+  "quickOpen": {
+    "moreMatchesAvailable": "Puede haber más coincidencias disponibles. Refina tu búsqueda para acotar los resultados."
+  },
+  "checksPanel": {
+    "unlinked": {
+      "title": "Pull request desvinculada",
+      "description": "La PR #{{number}} está oculta para este espacio de trabajo. Vuelve a vincularla para restaurar las verificaciones y los detalles de revisión.",
+      "relink": "Vincular PR #{{number}}"
+    }
+  },
+  "sourceControl": {
+    "discard": {
+      "restoreStagedVersionDescription": "Esto restaurará la última versión preparada y descartará la eliminación. No se puede deshacer.",
+      "unstagedChangesDescription": "Esto revertirá los cambios no preparados de este archivo. No se puede deshacer."
+    },
+    "unlinkedPr": {
+      "status": "PR #{{number}} desvinculada"
+    }
+  },
+  "aiVault": {
+    "antigravityReferenceDescription": "Continúa en una nueva conversación de la CLI de Antigravity usando esta transcripción como referencia.",
+    "antigravityIdeToCli": "IDE → CLI",
+    "antigravity2ToCli": "2.0 → CLI",
+    "continueInCli": "Continuar en la CLI",
+    "continueInCliNewTab": "Continuar en la CLI en una pestaña nueva",
+    "subagents": {
+      "loading": "Cargando subagentes…",
+      "loadError": "No se pudieron cargar todos los subagentes.",
+      "empty": "No se encontraron subagentes."
+    }
+  },
+  "fileSearch": {
+    "failed": "La búsqueda falló. Reintenta."
   }
 }
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index 40f29aafcd7..d4c92d9fa99 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -140,7 +140,8 @@
         "portsToggleDescription": "Afficher les ports actifs de l'espace de travail. Cliquez dessus pour les ports par espace de travail et les écouteurs externes.",
         "antigravityToggleDescription": "Afficher l'utilisation de l'abonnement Antigravity pour l'espace de travail actif.",
         "grokToggleDescription": "Afficher l'utilisation des crédits de l'abonnement Grok lorsque vous êtes connecté via Grok CLI.",
-        "cursorToggleDescription": "Afficher l'utilisation du forfait Cursor lorsque vous êtes connecté via cursor-agent ou Cursor IDE."
+        "cursorToggleDescription": "Afficher l'utilisation du forfait Cursor lorsque vous êtes connecté via cursor-agent ou Cursor IDE.",
+        "zcodeToggleDescription": "Afficher l'utilisation du quota du plan de codage ZCode."
       },
       "menuBarIcon": {
         "title": "Afficher l'icône dans la barre de menus",
@@ -196,6 +197,16 @@
         "restartRequired": "Redémarrage requis",
         "unavailable": "L'identité du navigateur n'est pas disponible."
       }
+    },
+    "agents": {
+      "codexTerminalServerIsolation": {
+        "title": "Exécutez chaque terminal Codex sur son propre serveur",
+        "description": "Maintient le bon fonctionnement du statut d'Orca et des onglets de fermeture. Désactivez-la pour utiliser le serveur partagé du Codex et l'aperçu de ses agents. S'applique aux nouveaux terminaux."
+      },
+      "codexSharedServerWarning": {
+        "title": "Avertir lorsqu'un onglet Codex partage un serveur",
+        "description": "Affiche un avis sur un Codex que vous avez démarré vous-même lorsqu'il partage un serveur avec d'autres onglets, car son statut d'agent peut être erroné."
+      }
     }
   },
   "menu": {
@@ -602,7 +613,12 @@
           "muse_label": "Muse",
           "opencode2_label": "OpenCode 2",
           "codebuddy_label": "CodeBuddy",
-          "zcode_label": "ZCode"
+          "zcode_label": "ZCode",
+          "freebuff_label": "Freebuff",
+          "dsh_label": "DeepSeek Harness",
+          "qoder_label": "Qoder CLI",
+          "qoder_cn_label": "Qoder CLI China",
+          "jcode_label": "Jcode"
         },
         "skill": {
           "cli": {
@@ -3135,18 +3151,16 @@
           },
           "MobileDriverOverlay": {
             "c6460cf584": "Reprendre",
-            "c8f2e1a4b9": "Reprendre ce terminal",
             "c44659e09f": "Pilotage par téléphone",
-            "7cffad954c": "Réduire",
             "3eed73394f": "Votre clavier est en pause",
-            "faa367dc74": "Votre téléphone a laissé ce terminal en taille téléphone",
-            "54f7d6f69d": "Reprendre tous les terminaux",
-            "b3d8e1f42a": "Restaurer ce terminal",
-            "e8c4f2a91b": "Restaurer tous les terminaux",
-            "f2a8b9c1d3": "Depuis votre téléphone",
             "c7e4a2b8f1": "Votre téléphone a le contrôle",
-            "d9f3c6e2a4": "Le clavier de l'ordinateur est en pause. Reprenez ce terminal pour taper ici, reprenez tous les terminaux contrôlés par votre téléphone, ou réduisez pour continuer à observer.",
-            "a6b1d8f3e2": "Votre session téléphone est terminée. Restaurez ce terminal à la taille bureau, ou tous les terminaux que votre téléphone a laissés en taille téléphone."
+            "4b7e1c9a20": "Toujours dimensionné pour votre téléphone",
+            "9d2f6a3e58": "Votre session téléphonique est terminée. Restaurer pour s'adapter à cette fenêtre.",
+            "1e5c8b7d43": "Restaurer",
+            "6a3d9f2c71": "Tout restaurer",
+            "8c1a5e9f36": "La saisie sur le bureau est suspendue. La sortie continue à diffuser.",
+            "2f7b4d1e95": "Reprenez tout",
+            "3a9c5f7e12": "Minimiser"
           },
           "TerminalAgentSessionForkDialog": {
             "17fc841e59": "Copier le contexte",
@@ -3791,10 +3805,12 @@
             "grokUsageAria": "Ouvrir les détails d'utilisation Grok",
             "grokUsageMenu": "Utilisation Grok",
             "floatingTerminalNewActivity": "{{label}}, nouvelle activité",
+            "4fba7dc1e7": "solde {{value0}}",
             "codexSignInSuccess": "Connecté à Codex",
             "codexSignInError": "Échec de la connexion à Codex. Veuillez réessayer.",
             "cursorUsageMenu": "Utilisation Cursor",
-            "hiddenUsageProviders": "Aussi : {{value0}}"
+            "hiddenUsageProviders": "Aussi : {{value0}}",
+            "zcodeUsageMenu": "Utilisation du code Z"
           },
           "StatusBarUsageEmptyCta": {
             "828c764a79": "Connecter un compte",
@@ -3992,6 +4008,9 @@
                 "message": "Exécutez cursor-agent login dans un terminal sur l'ordinateur qui exécute Orca, puis réessayez."
               },
               "plan": "Forfait"
+            },
+            "zcode": {
+              "mcp": "MCP"
             }
           },
           "SshTargetStatusRow": {
@@ -6420,6 +6439,11 @@
           "copied": "Commande copiée",
           "retry": "Réessayer maintenant",
           "restored": "Git fonctionne à nouveau. Worktrees actualisés."
+        },
+        "manualSortSwitch": {
+          "title": "Tri modifié en Manuel",
+          "description": "Manuel conserve les espaces de travail là où vous les déposez.",
+          "restore": "Retour à {{label}}"
         }
       },
       "shared": {
@@ -7695,7 +7719,6 @@
         },
         "MobilePane": {
           "dd3cd78d04": "Scanner avec Orca Mobile",
-          "35100bca5d": "Pendant que vous utilisez un terminal sur votre téléphone, Orca le réduit pour tenir sur l'écran du téléphone. À la fermeture de l'app ou quand vous passez à autre chose, ce réglage détermine s'il garde la taille téléphone (pour que les outils CLI interactifs ne se reforment pas) ou reprend sa taille bureau. Vous pouvez toujours utiliser Restaurer ce terminal ou Restaurer tous les terminaux sur la bannière pour redimensionner manuellement.",
           "ee56f1c7e4": "Quand vous quittez l'app mobile",
           "3939fd062c": "La révocation d'un appareil le déconnecte immédiatement.",
           "254a6d09e4": "Appairé",
@@ -7720,7 +7743,8 @@
           "pairingCodeReady": "Code d'appairage prêt",
           "copyPairingCode": "Copier le code d'appairage",
           "diagnosticsCopied": "Diagnostics copiés",
-          "diagnosticsCopyFailed": "Échec de la copie des diagnostics"
+          "diagnosticsCopyFailed": "Échec de la copie des diagnostics",
+          "5e2c7a1f84": "Lorsque vous utilisez un terminal sur votre téléphone, Orca le réduit pour l'adapter à l'écran de votre téléphone. Lorsque vous fermez l'application ou si vous la quittez, cela contrôle si elle reste à la taille du téléphone (afin que les outils CLI interactifs ne soient pas redistribués) ou si elle est redimensionnée sur votre bureau. Vous pouvez toujours utiliser Restaurer ou Tout restaurer sur la bannière pour la redimensionner manuellement."
         },
         "MobileSettingsPane": {
           "9a3c280e49": "GitHub Releases",
@@ -8634,7 +8658,12 @@
           "addTitle": "Ajouter un hôte SSH",
           "editDescription": "Mettez à jour les détails de connexion de cette machine. Les modifications s'appliquent à la prochaine connexion.",
           "addDescription": "Ajoutez une machine permanente sur laquelle vous pouvez vous connecter en SSH.",
-          "editingPrefix": "Modification"
+          "editingPrefix": "Modification",
+          "remoteRuntime": "Durée d'exécution",
+          "remoteRuntimeHelp": "Quel Node.js exécute Orca sur cet hôte. Le nœud géré par Orca télécharge le sien et n'a besoin d'aucun npm ; Host Node utilise le Node.js déjà installé là-bas.",
+          "remoteRuntimeAuto": "Auto ",
+          "remoteRuntimePinnedNode": "Nœud géré par Orca",
+          "remoteRuntimeHostNode": "Nœud hôte"
         },
         "TasksPane": {
           "f71d8a9dd3": "Fournisseurs de tâches",
@@ -8815,7 +8844,38 @@
             "fastDescription": "Multiplicateur supplémentaire lors du défilement avec une touche modificateur.",
             "tui": "TUI",
             "tuiDescription": "Rapports de molette discrets pour les applications de terminal plein écran."
-          }
+          },
+          "8dbe0bc942": "Arguments du shell, un par ligne",
+          "f58cb71f53": "--rcfile\n/path/to/rcfile",
+          "48b91a3ed2": "Arguments personnalisés",
+          "7bd83fc1d0": "-l (par défaut)",
+          "5ffc4777b6": "Mode des arguments du shell",
+          "578ec79449": "Saisissez un argument par ligne. Laissez vide pour ne transmettre aucun argument.",
+          "884a006065": "Démarre le shell comme shell de connexion avec -l.",
+          "01c600daff": "Arguments du shell",
+          "e3ae5aed18": ". Basculez vers le shell système ou choisissez un exécutable sur cet hôte.",
+          "59573d0b33": "Saisissez un nom de shell présent dans le PATH ou le chemin d'un exécutable. Orca le lance comme shell de connexion.",
+          "5e06e87730": "Exécutable du shell personnalisé",
+          "c2bf02ce2f": "fish, nu ou /bin/zsh",
+          "f51cc79784": "Shell personnalisé",
+          "dd3f4c35da": "Shell système ({{value0}})",
+          "fd05fb109c": "Shell du terminal",
+          "69724e8f0c": "Choisissez ce qu'Orca ouvre pour les nouveaux panneaux de terminal locaux.",
+          "c2ddb189e7": "rcfile",
+          "73c211e979": "wrapper",
+          "4faf688f78": "connexion",
+          "44f8a56f66": "Args",
+          "af893aa433": "arguments",
+          "ddc72a4860": "défaut",
+          "d469840b75": "nushell",
+          "17ad899ba4": "bash",
+          "c9bc93d343": "zsh",
+          "0cbe5ad727": "fish",
+          "81694f1584": "terminal/borne",
+          "a909136b3f": "shell",
+          "1c29734248": "Shell utilisé pour les nouveaux panneaux de terminal",
+          "9589abc009": "Shell par défaut",
+          "5a5eac2f44": "Shell introuvable : {{value0}}"
         },
         "TerminalSettingsPreview": {
           "a63953a48a": "Prévisualiser le thème {{value0}}",
@@ -8952,7 +9012,8 @@
           "ad5d036ecc": "Impossible de demander l'autorisation d'accès au micro. La dictée vocale n'a pas été activée.",
           "f9a9cf6928": "L'autorisation d'accès au micro est requise avant d'activer la dictée vocale.",
           "1eac933202": "Panneau Confidentialité et sécurité de macOS ouvert. Réactivez la dictée après avoir accordé l'accès.",
-          "cd9fe37556": "Autorisation d'accès au micro accordée"
+          "cd9fe37556": "Autorisation d'accès au micro accordée",
+          "openAiKeyName": "Votre clé de transcription OpenAI"
         },
         "WorktreeSymlinksSection": {
           "1c1e35b219": "Supprimer {{value0}}",
@@ -9067,6 +9128,18 @@
                 "usage": "utilisation"
               },
               "title": "Utilisation Cursor"
+            },
+            "zcodePlan": {
+              "title": "Plan de codage GLM",
+              "description": "Suivez l'utilisation du plan de codage GLM Z.AI ou Zhipu (BigModel). Choisissez le site et enregistrez la clé API du plan.",
+              "kw": {
+                "glm": "GLM",
+                "zai": "zaï",
+                "zhipu": "zhipu",
+                "bigmodel": "grand modèle",
+                "codingPlan": "plan de codage",
+                "rateLimit": "limite de taux"
+              }
             }
           }
         },
@@ -9158,7 +9231,12 @@
             "yolo": "yolo",
             "manual": "manuel",
             "skip": "sauter",
-            "checks": "chèques"
+            "checks": "chèques",
+            "7e15b89f6e": "serveur",
+            "ff457e1e7b": "démon",
+            "9f3becc4e8": "commun",
+            "34337ed5c7": "isoler",
+            "9a84e65118": "aperçu des agents"
           }
         },
         "appearance": {
@@ -9333,7 +9411,12 @@
                 "cursor": "cursor"
               },
               "title": "Utilisation Cursor"
-            }
+            },
+            "zcodeUsageTitle": "Utilisation du code Z",
+            "zcodeUsageDescription": "Afficher l'utilisation du quota du plan de codage ZCode dans la barre d'état.",
+            "zcode": "code z",
+            "zai": "zaï",
+            "glm": "GLM"
           }
         },
         "auto": {
@@ -10025,7 +10108,8 @@
               "9a9f8d4910": "Connectez Jira Cloud pour parcourir, créer et lier des issues.",
               "74f3063026": "{{value0}} site{{value1}} connecté",
               "statusConnected": "Connecté",
-              "statusNotConnected": "Non connecté"
+              "statusNotConnected": "Non connecté",
+              "jiraTokenName": "Votre jeton API Jira"
             }
           }
         },
@@ -10756,7 +10840,19 @@
               "statusline": "ligne d'état",
               "dim": "faible",
               "colors": "couleurs"
-            }
+            },
+            "d31ed1ac1c": "rcfile",
+            "d9e29543a1": "wrapper",
+            "50ba80b6dd": "connexion",
+            "36ba1a1357": "Args",
+            "5304b12d5c": "arguments",
+            "7c3ede6f12": "nushell",
+            "bf09070e31": "bash",
+            "d26257a80d": "zsh",
+            "454df22a5e": "fish",
+            "ddd5efe113": "shell",
+            "3de504994c": "Shell et arguments utilisés pour les nouveaux panneaux de terminal interactifs locaux",
+            "1733ccd3e9": "Shell du terminal"
           },
           "windows": {
             "search": {
@@ -10865,7 +10961,11 @@
           "a42f6fbdd8": "Maintient cet ordinateur et cet écran éveillés pendant que les agents travaillent. Orca demande également à cet appareil de rester éveillé lorsque le capot est fermé, sous réserve de sa politique d'alimentation.",
           "modeTitle": "Empêcher la mise en veille de l'ordinateur",
           "modeDescriptionWindows": "Choisissez Activé, Agent ou Désactivé. Le mode Agent reste éveillé tant que des agents travaillent ; le comportement à la fermeture du capot suit les paramètres d'alimentation de cet appareil.",
-          "modeDescriptionDefault": "Choisissez Activé, Agent ou Désactivé. Le mode Agent reste éveillé tant que des agents travaillent. Orca demande également à cet appareil de rester éveillé lorsque le capot est fermé, sous réserve de sa politique d'alimentation."
+          "modeDescriptionMac": "Choisissez Activé, Agent ou Désactivé. Le mode Agent empêche la mise en veille pendant que des agents travaillent, pour que les longues tâches se terminent avec le capot ouvert. Fermer le capot met quand même ce Mac en veille.",
+          "modeDescriptionDefault": "Choisissez Activé, Agent ou Désactivé. Le mode Agent reste éveillé tant que des agents travaillent. Orca demande également à cet appareil de rester éveillé lorsque le capot est fermé, sous réserve de sa politique d'alimentation.",
+          "lidNoteMac": "Empêche la mise en veille avec le capot ouvert ; fermer le capot met quand même ce Mac en veille.",
+          "lidNoteWindows": "Le comportement de fermeture du couvercle suit les paramètres d'alimentation de cet appareil.",
+          "lidNoteDefault": "Orca demande également à cet appareil de rester éveillé lorsque le couvercle est fermé, sous réserve de sa politique d'alimentation."
         },
         "agent-status-hooks-copy": {
           "7707c15abb": "Hooks de statut des agents",
@@ -10939,7 +11039,8 @@
                 "2d60ec7921": "Connectez un site Jira Cloud avec un jeton d'API, ou un Jira auto-hébergé avec un jeton d'accès personnel ou un nom d'utilisateur et mot de passe. Les identifiants sont envoyés au runtime distant sélectionné et y sont stockés avec le chiffrement pris en charge par le runtime.",
                 "977e360b71": "Connectez un site Jira Cloud avec un jeton d'API, ou un Jira auto-hébergé avec un jeton d'accès personnel ou un nom d'utilisateur et mot de passe. Les identifiants sont stockés localement et chiffrés lorsque le stockage du runtime local le prend en charge.",
                 "statusConnected": "Connecté",
-                "statusNotConnected": "Non connecté"
+                "statusNotConnected": "Non connecté",
+                "linearTokenName": "Votre jeton API linéaire"
               }
             }
           }
@@ -12088,7 +12189,8 @@
               "notConfigured": "Connectez un compte Bitbucket Cloud avec un token API Atlassian ou un token d'accès. Les variables d'environnement ORCA_BITBUCKET_* marchent aussi et ont priorité.",
               "disconnectFailed": "Impossible de supprimer l'identifiant Bitbucket enregistré.",
               "statusLoadFailed": "Impossible de rechercher un identifiant Bitbucket enregistré.",
-              "replaceCredentials": "Ajouter ou remplacer des informations d'identification"
+              "replaceCredentials": "Ajouter ou remplacer des informations d'identification",
+              "credentialName": "Votre identifiant Bitbucket"
             }
           }
         },
@@ -12181,6 +12283,51 @@
           "offCount": "{{count}} désactivées",
           "machines": "Machines",
           "machinesDescription": "Choisissez les machines autorisées à afficher des notifications sur cet ordinateur. Le réglage d’un serveur associé couvre aussi le travail effectué par son intermédiaire."
+        },
+        "UnsealedCredentialNotice": {
+          "body": "{{credential}} est stocké non crypté : ce système n'a pas de trousseau de clés de système d'exploitation qu'Orca peut utiliser. Toute personne pouvant lire votre disque ou une sauvegarde de celui-ci peut lire les informations d'identification. Installez et déverrouillez gnome-keyring ou kwallet, puis enregistrez-le à nouveau pour le sceller."
+        },
+        "ZcodePlanAccountsSection": {
+          "site": {
+            "bigmodel": "Zhipu · BigModel (open.bigmodel.cn)",
+            "zai": "Z.AI (z.ai)"
+          },
+          "window": {
+            "session": "5 heures",
+            "weekly": "Hebdomadaire",
+            "mcp": "MCP mensuel"
+          },
+          "resetIn": "— se réinitialise dans {{value0}}",
+          "keyRequired": "La clé API du plan de codage GLM est requise.",
+          "keySaved": "Clé API du plan de codage GLM enregistrée.",
+          "keySaveFailed": "La mise à jour des informations d'identification du plan de codage GLM a échoué.",
+          "title": "Plan de codage GLM",
+          "subtitle": "Suivez l'utilisation du plan de codage GLM Z.AI ou Zhipu (BigModel) dans la barre d'état. Enregistrez la clé API du plan ici – aucune configuration ZCode CLI n’est nécessaire.",
+          "consoleLink": "Obtenir la clé API",
+          "keyStored": "Clé API enregistrée · {{value0}}",
+          "keyStoredHelp": "Stocké localement et envoyé uniquement au site sélectionné pour les actualisations d'utilisation. Il est prioritaire sur la connexion ZCode CLI.",
+          "usingCli": "Utilisation de la connexion ZCode CLI",
+          "usingCliHelp": "Orca lit la clé du plan de codage à partir de ~/.zcode/cli/config.json. Enregistrez une clé API ci-dessous pour lier le plan ici à la place.",
+          "notConfigured": "Aucun plan de codage GLM lié",
+          "notConfiguredHelp": "Enregistrez la clé API du plan ci-dessous ou connectez-vous avec la CLI ZCode sur cet ordinateur.",
+          "refreshUsage": "Actualiser l'utilisation",
+          "siteTitle": "Planifier le site",
+          "siteDescription": "Choisissez la console à laquelle appartient votre plan de codage : Z.AI pour le site international, Zhipu BigModel pour le site continental.",
+          "keyTitle": "Clé API",
+          "keyDescription": "Collez la clé API à partir de la page Clés API de la console sélectionnée. Stocké localement, chiffré lorsque le système d'exploitation le prend en charge et envoyé uniquement à ce site pour des actualisations d'utilisation.",
+          "saved": "Enregistré",
+          "notSaved": "Non enregistré",
+          "keyPlaceholder": "Collez la clé API de votre plan de codage GLM",
+          "replace": "Remplacer",
+          "save": "Sauvegarder",
+          "forgetKey": "Clé oubliée",
+          "keyHelp": "La même clé que vos outils de codage utilisent pour le plan (par exemple Claude Code avec ANTHROPIC_BASE_URL pointé vers le site). Le fait de changer de site ci-dessus modifie l'hôte qui le reçoit.",
+          "usageTitle": "Utilisation du forfait",
+          "usageDescription": "Fenêtres de quota en direct pour le plan de codage lié, actualisées avec le cycle d'utilisation de la barre d'état.",
+          "planLevel": "Forfait : {{value0}}",
+          "hostOnly": "Modifiez le site du plan et la clé API dans l'application de bureau sur l'ordinateur exécutant Orca.",
+          "detailsUnavailable": "Les détails des informations d'identification du plan ne sont lisibles que sur l'ordinateur exécutant Orca.",
+          "siteUnavailable": "Site du plan d'hébergement indisponible"
         }
       },
       "right": {
@@ -13327,7 +13474,8 @@
             "fca915a67a": "Les éléments distants sont définitivement supprimés, sans retour arrière. Les éléments locaux sont déplacés dans {{value0}}."
           },
           "useFileExplorerHandlers": {
-            "32cd9fd991": "Impossible d'ouvrir la cible du symlink"
+            "32cd9fd991": "Impossible d'ouvrir la cible du symlink",
+            "folderLinksOutsideProject": "Ce dossier pointe en dehors du projet ; il ne peut pas être ouvert ici."
           },
           "useFileExplorerImport": {
             "25919b2050": "Ignoré : {{value0}} {{value1}}.",
@@ -13595,7 +13743,6 @@
           },
           "aiVaultSessionLogOpen": {
             "workspaceGone": "Impossible d'ouvrir le log — l'espace de travail n'est plus disponible.",
-            "notAuthorized": "Impossible d'ouvrir le log — chemin non autorisé.",
             "alreadyEditable": "Le log est déjà ouvert en édition."
           },
           "github": {
@@ -14963,7 +15110,12 @@
         "CsvViewer": {
           "eedd0d37a7": "colonnes",
           "ac31d2cd60": "lignes",
-          "a233d55b77": "Fichier vide"
+          "a233d55b77": "Fichier vide",
+          "delimiterComma": "Virgule",
+          "delimiterSemicolon": "Point-virgule",
+          "delimiterTab": "Languette",
+          "delimiterAuto": "Automatique ({{delimiter}})",
+          "delimiter": "Délimiteur"
         },
         "DiffNotesSendMenu": {
           "f1aa04b5cf": "Ce fichier",
@@ -15495,7 +15647,9 @@
           }
         },
         "richMarkdownLargeTextPaste": {
-          "tooLarge": "Le collage est trop volumineux."
+          "tooLarge": "Le collage est trop volumineux.",
+          "stopped": "La grosse pâte s'est arrêtée avant d'avoir fini.",
+          "cancelled": "Gros collage annulé car sa cible d'origine a changé."
         },
         "ExternalFileChangeBanner": {
           "7c41e90d12": "Ce fichier a été modifié sur le disque alors que vous avez des modifications non enregistrées. L'enregistrement écrasera le contenu plus récent présent sur le disque.",
@@ -15596,6 +15750,10 @@
           "a0af0198aa": "Les différences importantes ne sont pas rendues par défaut.",
           "c3d9f4a712": "La taille de cette différence n'est pas encore connue, elle se charge donc sur demande.",
           "f7fa7a40d0": "Charge différentielle"
+        },
+        "richMarkdownImageInsertionFeedback": {
+          "importedFileKept": "Insertion d'image annulée car la destination a changé. Le fichier importé a été conservé.",
+          "destinationChanged": "Insertion d'image annulée car la destination a changé. Essayer à nouveau."
         }
       },
       "diff": {
@@ -17888,6 +18046,7 @@
       "dismissDeliveryNotice": "Ignorer",
       "messageNotSent": "Message non envoyé",
       "deliveryUnconfirmed": "Livraison non confirmée — vérifiez le chat avant de réessayer",
+      "messageSending": "Envoi…",
       "queuedMessages": {
         "alreadySent": "Ce message a déjà été envoyé.",
         "editAlreadySent": "Déjà envoyé — votre texte reste dans la zone de saisie.",
@@ -18508,6 +18667,10 @@
   "sourceControl": {
     "unlinkedPr": {
       "status": "PR #{{number}} non lié"
+    },
+    "discard": {
+      "restoreStagedVersionDescription": "Cela restaurera la dernière version intermédiaire et annulera la suppression. Cela ne peut pas être annulé.",
+      "unstagedChangesDescription": "Cela annulera les modifications non planifiées apportées à ce fichier. Cela ne peut pas être annulé."
     }
   },
   "agentsSidebarIntro": {
@@ -18540,7 +18703,10 @@
     "launchFailedMessage": "Orca n'a pas pu démarrer le processus qui affiche sa fenêtre.",
     "launchFailedDetail": "Orca a réessayé {{recoveryCount}} fois sans succès.",
     "processLimitDetail": "Le système a refusé de créer un nouveau processus, car votre compte utilisateur a atteint sa limite de processus. Cela vient souvent de terminaux, de serveurs de développement ou d'agents emballés. Fermez-en quelques-uns, puis cliquez sur Réessayer.",
-    "launchFailedGenericDetail": "Le système a refusé de le démarrer. Libérez de la mémoire ou fermez d'autres applications, puis cliquez sur Réessayer. Si le problème persiste, réinstallez Orca."
+    "launchFailedGenericDetail": "Le système a refusé de le démarrer. Libérez de la mémoire ou fermez d'autres applications, puis cliquez sur Réessayer. Si le problème persiste, réinstallez Orca.",
+    "lowCommitMessage": "Windows manque de mémoire.",
+    "lowCommitDetail": "Windows ne dispose que de {{availableMB}} Mo de mémoire pour les applications, donc la fenêtre a de nouveau manqué de mémoire après le rechargement.",
+    "lowCommitAdvice": "Libérez de la mémoire en fermant les applications inutilisées ou les espaces de travail Orca, ou augmentez la taille du fichier d'échange Windows, puis cliquez sur Recharger."
   },
   "sessionSearch": {
     "panel": {
@@ -18569,7 +18735,8 @@
       "sessionsOther": "{{count}} séances",
       "sessionsOfLoaded": "{{value0}} sur {{value1}} séances",
       "showMoreSessions": "Afficher plus de séances",
-      "loadingMoreSessions": "Chargement de plus de sessions…"
+      "loadingMoreSessions": "Chargement de plus de sessions…",
+      "unsupportedAgent": "Cet ordinateur ne prend pas en charge la recherche dans l'historique de l'agent sélectionné. Mettez à jour Orca sur cet ordinateur ou sélectionnez un autre agent."
     }
   },
   "sessionHistory": {
@@ -18622,7 +18789,12 @@
       "loading": "Chargement des sous-agents…",
       "loadError": "Impossible de charger tous les sous-agents.",
       "empty": "Aucun sous-agent trouvé."
-    }
+    },
+    "antigravityReferenceDescription": "Continue dans une nouvelle conversation Antigravity CLI en utilisant cette transcription comme référence.",
+    "antigravityIdeToCli": "IDE → CLI",
+    "antigravity2ToCli": "2.0 → CLI",
+    "continueInCli": "Continuer en CLI",
+    "continueInCliNewTab": "Continuer dans la CLI dans un nouvel onglet"
   },
   "common": {
     "retry": "Réessayer"
@@ -18699,6 +18871,92 @@
       "removeTitle": "Supprimer le compte géré ?",
       "removeDescription": "Arrêtez d’abord les agents utilisant ce profil. Sa suppression efface les identifiants et conversations enregistrés. Votre connexion système reste inchangée.",
       "cancel": "Annuler"
+    },
+    "antigravity": {
+      "scope": "Gérez le compte agy natif sur {{host}}.",
+      "signIn": "Démarrez agy sur cet hôte et complétez la connexion au navigateur, puis enregistrez le compte actuel. Pour ajouter un autre compte, utilisez /logout dans agy et reconnectez-vous.",
+      "docs": "Instructions de connexion",
+      "retry": "Réessayer",
+      "identityUnknown": "Identité connectée indisponible",
+      "signedOut": "Aucun compte agy natif n'est connecté.",
+      "changed": "Le compte natif a changé. Sélectionnez à nouveau un compte enregistré avant de lancer agy.",
+      "save": "Enregistrer le compte courant",
+      "refresh": "Actualiser les comptes",
+      "usage": "Actualiser l'utilisation",
+      "working": "Mise à jour du compte",
+      "usageReading": "Séance : {{session}} · Hebdomadaire : {{weekly}}",
+      "saved": "Compte Google enregistré",
+      "nativeActive": "Compte natif",
+      "selected": "Choisi",
+      "select": "Sélectionner",
+      "remove": "Retirer",
+      "sessions": "La sélection s'applique aux nouvelles sessions agy sur cet hôte. Les sessions existantes peuvent conserver leur compte précédent.",
+      "searchTitle": "Comptes antigravité",
+      "searchDescription": "Enregistrez et sélectionnez les comptes Google agy natifs sur l’hôte d’exécution.",
+      "title": "Antigravity",
+      "keyword": {
+        "antigravity": "antigravité",
+        "agy": "Agy",
+        "google": "Google",
+        "accounts": "comptes"
+      }
     }
+  },
+  "osDocumentOpen": {
+    "failed": "Échec de l'ouverture du fichier."
+  },
+  "terminal": {
+    "sessionSaveFailure": {
+      "title": "Impossible d'enregistrer la session de terminal",
+      "capacity": "L'appareil enregistrant ce terminal a signalé un stockage complet ou un quota de stockage dépassé. Libérez de l'espace sur cet appareil, puis réessayez.",
+      "unknown": "Orca n'a pas pu sauver l'état terminal. Essayer à nouveau. Si cela continue, partagez les journaux Orca avec l'assistance afin que nous puissions identifier la cause."
+    },
+    "codexTerminalServerIsolationNotice": {
+      "title": "Orca exécute désormais Codex sans son serveur partagé",
+      "description": "Cela rend le statut d’agent plus fiable. Vous pouvez le réactiver dans Paramètres.",
+      "openSettings": "Ouvrir les paramètres"
+    },
+    "codexSharedSettingsNotice": {
+      "title": "Le Codex dans Orca utilise désormais ~/.codex",
+      "description": "Le Codex peut demander à nouveau de faire confiance aux dossiers ou d'approuver les commandes. Ajoutez à nouveau tous les serveurs MCP que vous avez ajoutés uniquement dans Orca."
+    },
+    "codexSharedServerBanner": {
+      "title": "Ce Codex partage un serveur avec vos autres onglets Codex",
+      "body": "Les sessions peuvent se terminer de manière inattendue et le statut de l'agent peut être erroné.",
+      "openedBeforeUpdateBody": "Ce terminal a été ouvert avant qu'Orca ne commence à donner à chaque Codex son propre serveur.",
+      "oldTerminalDialogTitle": "Pourquoi ce Codex partage un serveur",
+      "oldTerminalDialogRisk": "Les sessions Codex qui partagent un serveur peuvent se terminer ensemble et le statut de l'agent peut être erroné.",
+      "oldTerminalDialogCause": "Les terminaux plus anciens partagent toujours un serveur Codex. Ouvrez un nouveau terminal pour exécuter Codex sur un serveur distinct.",
+      "fix": "Réparer",
+      "openNewTerminal": "Ouvrir un nouveau terminal",
+      "dontShowAgain": "Ne plus montrer",
+      "dismiss": "Rejeter",
+      "dialogTitle": "Donnez à chaque onglet du Codex son propre serveur",
+      "dialogDescription": "Les sessions Codex démarrées directement dans un terminal partagent un serveur en arrière-plan. Orca conserve les sessions Codex qu'il démarre séparément. Lorsque des sessions partagent un serveur, la fermeture de l'une peut mettre fin aux autres et le statut de l'agent peut être erroné.",
+      "copy": "Copie",
+      "copied": "Copié",
+      "done": "Fait",
+      "step1Title": "Désactiver le partage du serveur Codex",
+      "step1Note": "Cela modifie vos paramètres Codex et s'applique donc également en dehors d'Orca.",
+      "step2Title": "Arrêtez le serveur partagé en cours d'exécution",
+      "undo": "Pour annuler, exécutez codex features enable daemon_auto_start.",
+      "step2Warning": "Ferme toutes les sessions Codex ouvertes qui partagent le serveur",
+      "learnMore": "Apprendre encore plus",
+      "turnOff": "Éteindre",
+      "turningOff": "Éteindre…",
+      "turnedOff": "Éteint",
+      "turnOffFailed": "Orca ne pouvait pas éteindre ça.",
+      "stopServer": "Arrêter le serveur",
+      "stopping": "Arrêt…",
+      "stopped": "Arrêté",
+      "stopFailed": "Orca n'a pas pu arrêter le serveur.",
+      "confirmStopTitle": "Arrêter le serveur partagé ?",
+      "confirmStopDescription": "Cela ferme toutes les sessions Codex ouvertes qui le partagent, y compris celles en dehors d'Orca.",
+      "cancel": "Annuler",
+      "runs": "Fonctionne"
+    }
+  },
+  "fileSearch": {
+    "failed": "La recherche a échoué. Essayer à nouveau."
   }
 }
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index 4870f2cbb29..2a933088bc5 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -41,7 +41,8 @@
         "portsToggleDescription": "ライブワークスペースポートを表示します。ワークスペーススコープのポートと外部リスナーの場合はこれをクリックします。",
         "antigravityToggleDescription": "アクティブなワークスペースの Antigravity サブスクリプション使用量を表示します。",
         "grokToggleDescription": "Grok CLI でサインインしている場合に Grok サブスクリプションのクレジット使用量を表示します。",
-        "cursorToggleDescription": "cursor-agent または Cursor IDE でサインインしている場合に Cursor プランの使用状況を表示します。"
+        "cursorToggleDescription": "cursor-agent または Cursor IDE でサインインしている場合に Cursor プランの使用状況を表示します。",
+        "zcodeToggleDescription": "ZCode コーディングプランのクォータ使用量を表示します。"
       },
       "menuBarIcon": {
         "title": "メニューバーアイコンを表示",
@@ -97,6 +98,16 @@
         "restartRequired": "再起動が必要です",
         "unavailable": "ブラウザ ID が利用できません。"
       }
+    },
+    "agents": {
+      "codexTerminalServerIsolation": {
+        "title": "各 Codex ターミナルを独自のサーバー上で実行する",
+        "description": "Orca のステータスとタブを閉じる動作が正しく動作するようにします。 Codex の共有サーバーとその Agent の概要を使用するには、オフにします。新規ターミナルに適用されます。"
+      },
+      "codexSharedServerWarning": {
+        "title": "Codex タブがサーバーを共有する場合に警告する",
+        "description": "自分で開始した Codex が他のタブとサーバーを共有している場合、Agent のステータスが間違っている可能性があるため、その Codex に関する通知が表示されます。"
+      }
     }
   },
   "menu": {
@@ -504,7 +515,11 @@
           "opencode2_label": "OpenCode 2",
           "codebuddy_label": "CodeBuddy",
           "zcode_label": "ZCode",
-          "jcode_label": "Jcode"
+          "jcode_label": "Jcode",
+          "freebuff_label": "Freebuff",
+          "dsh_label": "DeepSeek Harness",
+          "qoder_label": "Qoder CLI",
+          "qoder_cn_label": "Qoder CLI China"
         },
         "skill": {
           "cli": {
@@ -3033,18 +3048,16 @@
           },
           "MobileDriverOverlay": {
             "c6460cf584": "操作を取り戻す",
-            "c8f2e1a4b9": "このターミナルを取り戻す",
             "c44659e09f": "スマホ操作中",
-            "7cffad954c": "折りたたむ",
             "3eed73394f": "キーボードが一時停止しています",
-            "faa367dc74": "スマホが携帯サイズのまま残しています",
-            "54f7d6f69d": "すべてのターミナルを取り戻す",
-            "b3d8e1f42a": "このターミナルを復元",
-            "e8c4f2a91b": "すべてのターミナルを復元",
-            "f2a8b9c1d3": "スマホから",
             "c7e4a2b8f1": "スマホが操作中です",
-            "d9f3c6e2a4": "デスクトップのキーボードは一時停止中です。このターミナルを取り戻してここで入力するか、スマホが操作しているすべてのターミナルを取り戻すか、折りたたんで見続けてください。",
-            "a6b1d8f3e2": "スマホのセッションは終了しました。このターミナル、またはスマホが携帯サイズのまま残したすべてのターミナルをデスクトップサイズに復元してください。"
+            "4b7e1c9a20": "スマートフォンにぴったりのサイズ",
+            "9d2f6a3e58": "電話セッションが終了しました。このウィンドウに合わせて復元します。",
+            "1e5c8b7d43": "復元する",
+            "6a3d9f2c71": "すべて復元する",
+            "8c1a5e9f36": "デスクトップの入力が一時停止されます。出力はストリーミングを続けます。",
+            "2f7b4d1e95": "全部取り戻せ",
+            "3a9c5f7e12": "最小化する"
           },
           "TerminalAgentSessionForkDialog": {
             "17fc841e59": "コンテキストをコピーする",
@@ -3697,10 +3710,12 @@
             "grokUsageAria": "Grok の使用状況詳細を開く",
             "grokUsageMenu": "Grok の使用状況",
             "floatingTerminalNewActivity": "{{label}}、新規アクティビティ",
+            "4fba7dc1e7": "残高 {{value0}}",
             "codexSignInSuccess": "Codex にサインインしました",
             "codexSignInError": "Codex のサインインに失敗しました。もう一度お試しください。",
             "cursorUsageMenu": "Cursor の使用状況",
-            "hiddenUsageProviders": "ほかに: {{value0}}"
+            "hiddenUsageProviders": "ほかに: {{value0}}",
+            "zcodeUsageMenu": "Zコードの使用法"
           },
           "StatusBarUsageEmptyCta": {
             "828c764a79": "アカウントを接続する",
@@ -3882,6 +3897,9 @@
                 "message": "Orca を実行しているコンピュータのターミナルで cursor-agent login を実行し、使用状況を再試行してください。"
               },
               "plan": "プラン"
+            },
+            "zcode": {
+              "mcp": "MCP"
             }
           },
           "SshTargetStatusRow": {
@@ -6318,6 +6336,11 @@
           "copied": "コマンドをコピーしました",
           "retry": "今すぐ再試行",
           "restored": "Git が再び動作しています。ワークツリーを更新しました。"
+        },
+        "manualSortSwitch": {
+          "title": "並べ替えが手動に変更されました",
+          "description": "手動では、ドロップした場所にワークスペースが保持されます。",
+          "restore": "{{label}} に戻る"
         }
       },
       "shared": {
@@ -7583,7 +7606,6 @@
         },
         "MobilePane": {
           "dd3cd78d04": "Orca モバイルでスキャン",
-          "35100bca5d": "スマートフォンでターミナルを使用している間、Orca はスマートフォンの画面に合わせてターミナルを縮小します。アプリを閉じるか別のアプリに切り替えるときに、アプリをスマートフォンサイズのままにするか (インタラクティブ CLI ツールがリフローしないように)、サイズを変更してデスクトップに戻るかを制御します。バナーの「このターミナルを復元」または「すべてのターミナルを復元」を使えば、いつでも手動でサイズを変更できます。",
           "ee56f1c7e4": "モバイルアプリを終了するとき",
           "3939fd062c": "デバイスを取り消すと、デバイスはすぐに切断されます。",
           "254a6d09e4": "ペアリング済み",
@@ -7608,7 +7630,8 @@
           "pairingCodeReady": "ペアリングコードの準備完了",
           "copyPairingCode": "ペアリングコードをコピーする",
           "diagnosticsCopied": "診断がコピーされました",
-          "diagnosticsCopyFailed": "診断情報のコピーに失敗しました"
+          "diagnosticsCopyFailed": "診断情報のコピーに失敗しました",
+          "5e2c7a1f84": "スマートフォンでターミナルを使用している間、Orca はスマートフォンの画面に合わせてターミナルを縮小します。アプリを閉じるか別のアプリに切り替えるときに、アプリをスマートフォンサイズのままにするか (インタラクティブ CLI ツールがリフローしないように)、サイズを変更してデスクトップに戻るかを制御します。バナーの [復元] または [すべて復元] を使用すると、いつでも手動でサイズを変更できます。"
         },
         "MobileSettingsPane": {
           "9a3c280e49": "GitHub リリース",
@@ -8516,7 +8539,12 @@
           "addTitle": "SSH ホストを追加",
           "editDescription": "このマシンの接続詳細を更新します。変更は次回の接続時に適用されます。",
           "addDescription": "SSH でログインできる永続的なマシンを追加します。",
-          "editingPrefix": "編集中"
+          "editingPrefix": "編集中",
+          "remoteRuntime": "ランタイム",
+          "remoteRuntimeHelp": "このホスト上で Orca を実行する Node.js。 Orca 管理ノードは独自のノードをアップロードするため、npm は必要ありません。ホストノードは、そこにすでにインストールされている Node.js を使用します。",
+          "remoteRuntimeAuto": "自動",
+          "remoteRuntimePinnedNode": "Orca 管理ノード",
+          "remoteRuntimeHostNode": "ホストノード"
         },
         "TasksPane": {
           "f71d8a9dd3": "タスクプロバイダー",
@@ -8693,7 +8721,38 @@
             "fastDescription": "修飾キーを押しながらスクロールするときの追加倍率。",
             "tui": "TUI",
             "tuiDescription": "全画面ターミナルアプリ向けの離散的なホイール通知。"
-          }
+          },
+          "8dbe0bc942": "シェル引数、1 行に 1 つ",
+          "f58cb71f53": "--rcfile\n/path/to/rcfile",
+          "48b91a3ed2": "カスタム引数",
+          "7bd83fc1d0": "-l (デフォルト)",
+          "5ffc4777b6": "シェル引数モード",
+          "578ec79449": "1 行に 1 つの引数を入力します。空欄にすると引数を渡しません。",
+          "884a006065": "-l を指定してシェルをログインシェルとして起動します。",
+          "01c600daff": "シェル引数",
+          "e3ae5aed18": "。システムシェルに切り替えるか、このホスト上の実行ファイルを選択してください。",
+          "59573d0b33": "PATH 上のシェル名または実行ファイルのパスを入力してください。Orca はログインシェルとして起動します。",
+          "5e06e87730": "カスタムシェルの実行ファイル",
+          "c2bf02ce2f": "fish、nu、または /bin/zsh",
+          "f51cc79784": "カスタムシェル",
+          "dd3f4c35da": "システムシェル ({{value0}})",
+          "fd05fb109c": "ターミナルのシェル",
+          "69724e8f0c": "新規ローカルターミナルペインで Orca が開くシェルを選択します。",
+          "c2ddb189e7": "rcfile",
+          "73c211e979": "ラッパー",
+          "4faf688f78": "ログイン",
+          "44f8a56f66": "引数",
+          "af893aa433": "引数",
+          "ddc72a4860": "デフォルト",
+          "d469840b75": "nushell",
+          "17ad899ba4": "bash",
+          "c9bc93d343": "zsh",
+          "0cbe5ad727": "fish",
+          "81694f1584": "ターミナル",
+          "a909136b3f": "シェル",
+          "1c29734248": "新規ターミナルペインで使用するシェル",
+          "9589abc009": "デフォルトのシェル",
+          "5a5eac2f44": "シェルが見つかりません: {{value0}}"
         },
         "TerminalSettingsPreview": {
           "a63953a48a": "{{value0}} テーマのプレビュー",
@@ -8830,7 +8889,8 @@
           "f9a9cf6928": "音声ディクテーションを有効にする前に、マイクの許可が必要です。",
           "1eac933202": "macOS のプライバシーとセキュリティを開きました。アクセスを許可した後、ディクテーションを再度有効にします。",
           "cd9fe37556": "マイクの許可が与えられました",
-          "6fa734ed95": "{{value0}} を削除"
+          "6fa734ed95": "{{value0}} を削除",
+          "openAiKeyName": "OpenAI 転写キー"
         },
         "WorktreeSymlinksSection": {
           "1c1e35b219": "{{value0}} を削除",
@@ -8945,6 +9005,18 @@
                 "usage": "使用量"
               },
               "title": "Cursor の使用状況"
+            },
+            "zcodePlan": {
+              "title": "GLMコーディングプラン",
+              "description": "Z.AI または Zhipu (BigModel) GLM コーディングプランの使用状況を追跡します。サイトを選択し、プラン API キーを保存します。",
+              "kw": {
+                "glm": "グルム",
+                "zai": "ザイ",
+                "zhipu": "ジプ",
+                "bigmodel": "ビッグモデル",
+                "codingPlan": "コーディング計画",
+                "rateLimit": "レート制限"
+              }
             }
           }
         },
@@ -9036,7 +9108,12 @@
             "yolo": "ヨロ",
             "manual": "マニュアル",
             "skip": "スキップ",
-            "checks": "チェック"
+            "checks": "チェック",
+            "7e15b89f6e": "サーバー",
+            "ff457e1e7b": "デーモン",
+            "9f3becc4e8": "共有された",
+            "34337ed5c7": "隔離する",
+            "9a84e65118": "Agent の概要"
           }
         },
         "appearance": {
@@ -9211,7 +9288,12 @@
                 "cursor": "cursor"
               },
               "title": "Cursor の使用状況"
-            }
+            },
+            "zcodeUsageTitle": "Zコードの使用法",
+            "zcodeUsageDescription": "ZCode コーディングプランのクォータの使用状況をステータスバーに表示します。",
+            "zcode": "zコード",
+            "zai": "ザイ",
+            "glm": "グルム"
           }
         },
         "auto": {
@@ -9903,7 +9985,8 @@
               "9a9f8d4910": "Jira Cloud に接続して、Issue を参照、作成、リンクします。",
               "74f3063026": "{{value0}} サイト{{value1}} が接続されました",
               "statusConnected": "接続済み",
-              "statusNotConnected": "接続されていません"
+              "statusNotConnected": "接続されていません",
+              "jiraTokenName": "Jira API トークン"
             }
           }
         },
@@ -10637,7 +10720,19 @@
               "statusline": "ステータスライン",
               "dim": "薄暗い",
               "colors": "色"
-            }
+            },
+            "d31ed1ac1c": "rcfile",
+            "d9e29543a1": "ラッパー",
+            "50ba80b6dd": "ログイン",
+            "36ba1a1357": "引数",
+            "5304b12d5c": "引数",
+            "7c3ede6f12": "nushell",
+            "bf09070e31": "bash",
+            "d26257a80d": "zsh",
+            "454df22a5e": "fish",
+            "ddd5efe113": "シェル",
+            "3de504994c": "新規ローカル対話型ターミナルペインで使用するシェルと引数",
+            "1733ccd3e9": "ターミナルのシェル"
           },
           "windows": {
             "search": {
@@ -10738,7 +10833,11 @@
           "a42f6fbdd8": "Agent が作業している間、このコンピュータとディスプレイを起きたままにします。Orca は電源ポリシーに従い、蓋が閉じているときもこのデバイスを起きたままにするよう要求します。",
           "modeTitle": "コンピュータをスリープさせない",
           "modeDescriptionWindows": "[オン]、[Agent]、または [オフ] を選択します。Agent モードは、Agent が動作している間は起動したままになります。蓋を閉じる動作は、このデバイスの電源設定に従います。",
-          "modeDescriptionDefault": "[オン]、[Agent]、または [オフ] を選択します。Agent が動作している間、Agent モードは起動したままになります。 Orca はまた、電源ポリシーに従って、蓋が閉じられているときにこのデバイスが起動したままになるように要求します。"
+          "modeDescriptionMac": "[オン]、[Agent]、または [オフ] を選択します。Agent モードは Agent の作業中のアイドルスリープを防止するため、蓋を開けたまま長時間の実行を完了できます。蓋を閉じると、この Mac はスリープします。",
+          "modeDescriptionDefault": "[オン]、[Agent]、または [オフ] を選択します。Agent が動作している間、Agent モードは起動したままになります。 Orca はまた、電源ポリシーに従って、蓋が閉じられているときにこのデバイスが起動したままになるように要求します。",
+          "lidNoteMac": "蓋を開けたままアイドルスリープを防止します。蓋を閉じると、この Mac はスリープします。",
+          "lidNoteWindows": "蓋を閉じる動作は、このデバイスの電源設定に従います。",
+          "lidNoteDefault": "Orca はまた、電源ポリシーに従って、蓋が閉じられているときにデバイスが起動したままになるようにこのデバイスに要求します。"
         },
         "AgentAwakeSetting": {
           "on": "オン",
@@ -10851,7 +10950,8 @@
                 "2d60ec7921": "APIトークンを使用して Jira Cloudサイトに接続するか、パーソナルアクセストークンまたはユーザー名とパスワードを使用してセルフホスト Jira に接続します。認証情報は選択されたリモートランタイムに送信され、ランタイムがサポートする暗号化で保存されます。",
                 "977e360b71": "APIトークンを使用して Jira Cloudサイトに接続するか、パーソナルアクセストークンまたはユーザー名とパスワードを使用してセルフホスト Jira に接続します。認証情報はローカルに保存され、ローカルランタイムストレージがサポートする場合は暗号化されます。",
                 "statusConnected": "接続済み",
-                "statusNotConnected": "接続されていません"
+                "statusNotConnected": "接続されていません",
+                "linearTokenName": "リニア API トークン"
               }
             }
           }
@@ -12018,7 +12118,8 @@
               "notConfigured": "Bitbucket Cloud アカウントを Atlassian API トークンまたはアクセストークンに接続します。 ORCA_BITBUCKET_* 環境変数も機能し、優先されます。",
               "disconnectFailed": "保存された Bitbucket 認証情報を削除できませんでした。",
               "statusLoadFailed": "保存された Bitbucket 認証情報を確認できませんでした。",
-              "replaceCredentials": "認証情報を追加または置換する"
+              "replaceCredentials": "認証情報を追加または置換する",
+              "credentialName": "Bitbucket 認証情報"
             }
           }
         },
@@ -12079,6 +12180,51 @@
           "offCount": "{{count}} 台オフ",
           "machines": "マシン",
           "machinesDescription": "このコンピューターに通知を表示できるマシンを選択します。ペアリングしたサーバーのスイッチは、そのサーバー経由の作業にも適用されます。"
+        },
+        "UnsealedCredentialNotice": {
+          "body": "{{credential}} は暗号化されずに保存されます。このシステムには Orca が使用できる OS キーリングがありません。ディスクまたはそのバックアップを読み取ることができる人は誰でも、認証情報を読み取ることができます。 gnome-keyring または kwallet をインストールしてロックを解除し、再度保存して封印します。"
+        },
+        "ZcodePlanAccountsSection": {
+          "site": {
+            "bigmodel": "Zhipu・BigModel (open.bigmodel.cn)",
+            "zai": "Z.AI（ゼットアイ）"
+          },
+          "window": {
+            "session": "5時間",
+            "weekly": "毎週",
+            "mcp": "MCP毎月"
+          },
+          "resetIn": "— {{value0}} でリセット",
+          "keyRequired": "GLMコーディングプランAPIキーが必要です。",
+          "keySaved": "GLM コーディングプラン API キーが保存されました。",
+          "keySaveFailed": "GLM コーディングプランの認証情報の更新に失敗しました。",
+          "title": "GLMコーディングプラン",
+          "subtitle": "Z.AI または Zhipu (BigModel) GLM コーディングプランの使用状況をステータスバーで追跡します。ここにプラン API キーを保存します。ZCode CLI セットアップは必要ありません。",
+          "consoleLink": "APIキーを取得する",
+          "keyStored": "API キーが保存されました · {{value0}}",
+          "keyStoredHelp": "ローカルに保存され、使用状況を更新するために選択したサイトにのみ送信されます。これは、ZCode CLI サインインよりも優先されます。",
+          "usingCli": "ZCode CLI サインインの使用",
+          "usingCliHelp": "Orca は、~/.zcode/cli/config.json からコーディングプランキーを読み取ります。代わりにここでプランをリンクするには、以下の API キーを保存します。",
+          "notConfigured": "GLM コーディングプランがリンクされていません",
+          "notConfiguredHelp": "以下のプラン API キーを保存するか、このコンピュータ上の ZCode CLI を使用してサインインします。",
+          "refreshUsage": "リフレッシュの使用法",
+          "siteTitle": "企画サイト",
+          "siteDescription": "コーディングプランが属するコンソールを選択します。国際サイトの場合は Z.AI、本土サイトの場合は Zhipu BigModel です。",
+          "keyTitle": "APIキー",
+          "keyDescription": "選択したコンソールの API キーページから API キーを貼り付けます。ローカルに保存され、OS がサポートする場合は暗号化され、使用状況を更新するためにそのサイトにのみ送信されます。",
+          "saved": "保存済み",
+          "notSaved": "保存されていません",
+          "keyPlaceholder": "GLM コーディングプラン API キーを貼り付けます",
+          "replace": "置換",
+          "save": "保存",
+          "forgetKey": "キーを忘れた場合",
+          "keyHelp": "コーディングツールがプランに使用するのと同じキー (たとえば、サイトを指す ANTHROPIC_BASE_URL を持つ Claude Code)。上記のサイトを切り替えると、受信するホストが変わります。",
+          "usageTitle": "プランの使用状況",
+          "usageDescription": "リンクされたコーディングプランのライブクォータウィンドウ。ステータスバーの使用サイクルに応じて更新されます。",
+          "planLevel": "計画: {{value0}}",
+          "hostOnly": "Orca を実行しているコンピュータ上のデスクトップアプリでプランサイトと API キーを変更します。",
+          "detailsUnavailable": "プランの認証情報の詳細は、Orca を実行しているコンピュータでのみ読み取ることができます。",
+          "siteUnavailable": "ホストプランサイトが利用できない"
         }
       },
       "right": {
@@ -13225,7 +13371,8 @@
             "fca915a67a": "リモートの項目は完全に削除され、取り消せません。ローカルの項目は {{value0}} に移動します。"
           },
           "useFileExplorerHandlers": {
-            "32cd9fd991": "シンボリックリンクターゲットを開けません"
+            "32cd9fd991": "シンボリックリンクターゲットを開けません",
+            "folderLinksOutsideProject": "このフォルダーはプロジェクト外へのリンクのため、ここでは開けません。"
           },
           "useFileExplorerImport": {
             "25919b2050": "{{value0}} {{value1}} をスキップしました。",
@@ -13493,7 +13640,6 @@
           },
           "aiVaultSessionLogOpen": {
             "workspaceGone": "ログを開けませんでした。ワークスペースが利用できなくなっています。",
-            "notAuthorized": "ログを開けませんでした。このパスは許可されていません。",
             "alreadyEditable": "ログはすでに編集用に開かれています。"
           },
           "github": {
@@ -14861,7 +15007,12 @@
         "CsvViewer": {
           "eedd0d37a7": "列",
           "ac31d2cd60": "行",
-          "a233d55b77": "空のファイル"
+          "a233d55b77": "空のファイル",
+          "delimiterComma": "コンマ",
+          "delimiterSemicolon": "セミコロン",
+          "delimiterTab": "タブ",
+          "delimiterAuto": "自動 ({{delimiter}})",
+          "delimiter": "デリミタ"
         },
         "DiffNotesSendMenu": {
           "f1aa04b5cf": "このファイル",
@@ -15399,7 +15550,9 @@
           }
         },
         "richMarkdownLargeTextPaste": {
-          "tooLarge": "貼り付け内容が大きすぎます。"
+          "tooLarge": "貼り付け内容が大きすぎます。",
+          "stopped": "大きなペーストは完成する前に止まりました。",
+          "cancelled": "大きなペーストは、元のターゲットが変更されたためキャンセルされました。"
         },
         "CheckRunJobs": {
           "1c0a4d7e02": "成功しました",
@@ -15494,6 +15647,10 @@
           "a0af0198aa": "デフォルトでは、大きな差分はレンダリングされません。",
           "c3d9f4a712": "この diff のサイズはまだ不明なので、リクエストに応じてロードされます。",
           "f7fa7a40d0": "負荷差"
+        },
+        "richMarkdownImageInsertionFeedback": {
+          "importedFileKept": "宛先が変更されたため、画像の挿入はキャンセルされました。インポートされたファイルは保持されました。",
+          "destinationChanged": "宛先が変更されたため、画像の挿入はキャンセルされました。再試行。"
         }
       },
       "diff": {
@@ -17825,6 +17982,7 @@
       "dismissDeliveryNotice": "閉じる",
       "messageNotSent": "メッセージは送信されませんでした",
       "deliveryUnconfirmed": "配信を確認できません — 再試行する前にチャットを確認してください",
+      "messageSending": "送信中…",
       "queuedMessages": {
         "alreadySent": "このメッセージはすでに送信されています。",
         "editAlreadySent": "すでに送信されています — テキストは入力欄に残っています。",
@@ -18524,6 +18682,10 @@
   "sourceControl": {
     "unlinkedPr": {
       "status": "PR #{{number}} のリンクが解除されました"
+    },
+    "discard": {
+      "restoreStagedVersionDescription": "これにより、最後にステージングされたバージョンが復元され、削除が破棄されます。これを元に戻すことはできません。",
+      "unstagedChangesDescription": "これにより、このファイルに対するステージングされていない変更が元に戻ります。これを元に戻すことはできません。"
     }
   },
   "rendererRecovery": {
@@ -18541,7 +18703,10 @@
     "launchFailedMessage": "Orca はウィンドウを描画するプロセスを起動できませんでした。",
     "launchFailedDetail": "Orca は {{recoveryCount}} 回再試行しましたが、成功しませんでした。",
     "processLimitDetail": "ユーザーアカウントのプロセス数が上限に達したため、システムが新しいプロセスの作成を拒否しました。暴走したターミナル、開発サーバー、Agent が原因であることがよくあります。いくつか終了してから「再試行」をクリックしてください。",
-    "launchFailedGenericDetail": "システムが起動を拒否しました。メモリを空けるか他のアプリを終了してから「再試行」をクリックしてください。繰り返し発生する場合は Orca を再インストールしてください。"
+    "launchFailedGenericDetail": "システムが起動を拒否しました。メモリを空けるか他のアプリを終了してから「再試行」をクリックしてください。繰り返し発生する場合は Orca を再インストールしてください。",
+    "lowCommitMessage": "Windows のメモリが不足しています。",
+    "lowCommitDetail": "Windows にはアプリ用に {{availableMB}} MB のメモリしか残っていないため、再ロード後にウィンドウが再びメモリ不足になりました。",
+    "lowCommitAdvice": "未使用のアプリまたは Orca ワークスペースを閉じてメモリを解放するか、Windows ページファイルサイズを増やして、[再読み込み] をクリックします。"
   },
   "sessionSearch": {
     "panel": {
@@ -18570,7 +18735,8 @@
       "sessionsOther": "{{count}} セッション",
       "sessionsOfLoaded": "{{value0}}/{{value1}} セッション",
       "showMoreSessions": "さらにセッションを表示",
-      "loadingMoreSessions": "さらにセッションを読み込んでいます…"
+      "loadingMoreSessions": "さらにセッションを読み込んでいます…",
+      "unsupportedAgent": "このコンピュータは、選択した Agent の履歴検索をサポートしていません。そのコンピュータで Orca を更新するか、別の Agent を選択します。"
     }
   },
   "sessionHistory": {
@@ -18623,7 +18789,12 @@
       "loading": "サブ Agent を読み込み中…",
       "loadError": "すべてのサブ Agent をロードできませんでした。",
       "empty": "サブ Agent が見つかりませんでした。"
-    }
+    },
+    "antigravityReferenceDescription": "このトランスクリプトを参照として使用して、新規 Antigravity CLI 会話を続けます。",
+    "antigravityIdeToCli": "IDE → CLI",
+    "antigravity2ToCli": "2.0 → CLI",
+    "continueInCli": "CLIで続行",
+    "continueInCliNewTab": "新規タブで CLI を続行する"
   },
   "common": {
     "retry": "再試行"
@@ -18700,6 +18871,92 @@
       "removeTitle": "管理アカウントを削除しますか？",
       "removeDescription": "まずこのプロファイルを使う Agent を停止してください。削除すると保存済みの認証情報と会話データが消去されます。システムのログインには影響しません。",
       "cancel": "キャンセル"
+    },
+    "antigravity": {
+      "scope": "{{host}} でネイティブ agy アカウントを管理します。",
+      "signIn": "このホストで agy を起動し、ブラウザのサインインを完了して、現在のアカウントを保存します。別のアカウントを追加するには、agy で /logout を使用し、再度サインインします。",
+      "docs": "サインイン手順",
+      "retry": "再試行",
+      "identityUnknown": "サインインしているIDは利用できません",
+      "signedOut": "ネイティブのAGYアカウントはサインインしていません。",
+      "changed": "ネイティブアカウントが変更されました。AGYを起動する前に、保存したアカウントを再度選択してください。",
+      "save": "現在のアカウントを保存",
+      "refresh": "アカウントを更新する",
+      "usage": "リフレッシュの使用法",
+      "working": "アカウントの更新",
+      "usageReading": "セッション： {{session}} ·毎週： {{weekly}}",
+      "saved": "保存されたGoogleアカウント",
+      "nativeActive": "ネイティブアカウント",
+      "selected": "選択",
+      "select": "選択",
+      "remove": "削除",
+      "sessions": "選択は、このホストの新規AGYセッションに適用されます。既存のセッションでは、以前のアカウントが保持される場合があります。",
+      "searchTitle": "Antigravityアカウント",
+      "searchDescription": "実行ホストにネイティブのagy Googleアカウントを保存して選択します。",
+      "title": "Antigravity",
+      "keyword": {
+        "antigravity": "反重力",
+        "agy": "agy",
+        "google": "グーグル",
+        "accounts": "アカウント"
+      }
     }
+  },
+  "osDocumentOpen": {
+    "failed": "ファイルを開けませんでした。"
+  },
+  "terminal": {
+    "sessionSaveFailure": {
+      "title": "ターミナルセッションを保存できませんでした",
+      "capacity": "このターミナルを保存しているデバイスから、ストレージがいっぱいであるか、ストレージクォータを超えていることが報告されました。そのデバイス上のスペースを解放してから、再試行してください。",
+      "unknown": "Orca はターミナル状態を保存できませんでした。再試行。これが続く場合は、原因を特定できるよう、Orca ログをサポートと共有してください。"
+    },
+    "codexTerminalServerIsolationNotice": {
+      "title": "Orca は共有サーバーなしで Codex を実行できるようになりました",
+      "description": "これにより、Agent のステータスの信頼性が高まります。 [設定] で再度オンにできます。",
+      "openSettings": "設定を開く"
+    },
+    "codexSharedSettingsNotice": {
+      "title": "Orca の Codex は ~/.codex を使用するようになりました",
+      "description": "Codex は、フォルダーを信頼するか、コマンドを承認するかを再度要求する場合があります。 Orca のみに追加した MCP サーバーを再度追加します。"
+    },
+    "codexSharedServerBanner": {
+      "title": "この Codex は他の Codex タブとサーバーを共有しています",
+      "body": "セッションが予期せず終了したり、Agent のステータスが間違ったりする可能性があります。",
+      "openedBeforeUpdateBody": "このターミナルは、Orca が各 Codex に独自のサーバーを提供し始める前にオープンされました。",
+      "oldTerminalDialogTitle": "この Codex がサーバーを共有する理由",
+      "oldTerminalDialogRisk": "サーバーを共有する Codex セッションが同時に終了する可能性があり、Agent のステータスが間違っている可能性があります。",
+      "oldTerminalDialogCause": "古いターミナルは依然として Codex サーバーを共有しています。新規ターミナルを開いて、別のサーバーで Codex を実行します。",
+      "fix": "修理",
+      "openNewTerminal": "新規ターミナルを開く",
+      "dontShowAgain": "二度と表示しないでください",
+      "dismiss": "閉じる",
+      "dialogTitle": "各 Codex タブに独自のサーバーを与える",
+      "dialogDescription": "ターミナルで直接開始された Codex セッションは、1 つのバックグラウンドサーバーを共有します。 Orca は、開始する Codex セッションを個別に保持します。セッションがサーバーを共有している場合、1 つを閉じると他のセッションも終了し、Agent のステータスが不正になる可能性があります。",
+      "copy": "コピー",
+      "copied": "コピーしました",
+      "done": "完了",
+      "step1Title": "Codex サーバー共有をオフにする",
+      "step1Note": "これにより Codex 設定が変更されるため、Orca の外部にも適用されます。",
+      "step2Title": "稼働中の共有サーバーを停止します",
+      "undo": "元に戻すには、codex features enable daemon_auto_start を実行します。",
+      "step2Warning": "サーバーを共有している開いている Codex セッションをすべて閉じます。",
+      "learnMore": "詳しく見る",
+      "turnOff": "消す",
+      "turningOff": "オフにしています…",
+      "turnedOff": "オフになっています",
+      "turnOffFailed": "Orca はこれをオフにすることができませんでした。",
+      "stopServer": "サーバーを停止する",
+      "stopping": "停止中…",
+      "stopped": "停止しました",
+      "stopFailed": "Orca はサーバーを停止できませんでした。",
+      "confirmStopTitle": "共有サーバーを停止しますか?",
+      "confirmStopDescription": "これにより、Orca 外部のものも含め、それを共有している開いている Codex セッションがすべて閉じられます。",
+      "cancel": "キャンセル",
+      "runs": "走る"
+    }
+  },
+  "fileSearch": {
+    "failed": "検索失敗。もう一度お試しください"
   }
 }
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index e04189ae70f..47f09615666 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -41,7 +41,8 @@
         "portsToggleDescription": "라이브 워크스페이스 포트를 표시합니다. 워크스페이스 범위 포트 및 외부 수신기를 보려면 클릭하세요.",
         "antigravityToggleDescription": "활성 워크스페이스에 대한 Antigravity 구독 사용량을 표시합니다.",
         "grokToggleDescription": "Grok CLI로 로그인한 경우 Grok 구독 크레딧 사용량을 표시합니다.",
-        "cursorToggleDescription": "cursor-agent 또는 Cursor IDE로 로그인한 경우 Cursor 플랜 사용량을 표시합니다."
+        "cursorToggleDescription": "cursor-agent 또는 Cursor IDE로 로그인한 경우 Cursor 플랜 사용량을 표시합니다.",
+        "zcodeToggleDescription": "ZCode 코딩 계획 할당량 사용량을 표시합니다."
       },
       "menuBarIcon": {
         "title": "메뉴 바 아이콘 표시",
@@ -97,6 +98,16 @@
         "restartRequired": "다시 시작해야 함",
         "unavailable": "브라우저 ID를 사용할 수 없습니다."
       }
+    },
+    "agents": {
+      "codexTerminalServerIsolation": {
+        "title": "자체 서버에서 각 Codex 터미널 실행",
+        "description": "Orca의 상태와 닫는 탭이 올바르게 작동하도록 유지합니다. CODEX의 공유 서버와 에이전트 개요를 사용하려면 기능을 끄십시오. 새 터미널에 적용됩니다."
+      },
+      "codexSharedServerWarning": {
+        "title": "Codex 탭이 서버를 공유할 때 경고",
+        "description": "에이전트 상태가 잘못되었을 수 있으므로 서버를 다른 탭과 공유할 때 직접 시작한 Codex에 대한 알림을 표시합니다."
+      }
     }
   },
   "menu": {
@@ -504,7 +515,11 @@
           "opencode2_label": "OpenCode 2",
           "codebuddy_label": "CodeBuddy",
           "zcode_label": "ZCode",
-          "jcode_label": "Jcode"
+          "jcode_label": "Jcode",
+          "freebuff_label": "Freebuff",
+          "dsh_label": "DeepSeek Harness",
+          "qoder_label": "Qoder CLI",
+          "qoder_cn_label": "Qoder CLI China"
         },
         "skill": {
           "cli": {
@@ -3033,18 +3048,16 @@
           },
           "MobileDriverOverlay": {
             "c6460cf584": "제어권 가져오기",
-            "c8f2e1a4b9": "이 terminal 다시 가져오기",
             "c44659e09f": "휴대폰 조작 중",
-            "7cffad954c": "접기",
             "3eed73394f": "키보드가 일시중지되었습니다.",
-            "faa367dc74": "휴대폰이 이 화면을 휴대폰 크기로 남겨 두었습니다",
-            "54f7d6f69d": "모든 terminals 제어권 가져오기",
-            "b3d8e1f42a": "이 terminal 복원",
-            "e8c4f2a91b": "모든 terminals 복원",
-            "f2a8b9c1d3": "휴대폰에서",
             "c7e4a2b8f1": "휴대폰이 제어 중",
-            "d9f3c6e2a4": "데스크톱 키보드가 일시 중지되었습니다. 여기서 입력하려면 이 terminals을 다시 가져오거나, 휴대폰이 제어하는 모든 terminals을 다시 가져오거나, 계속 보려면 접으세요.",
-            "a6b1d8f3e2": "휴대폰 세션이 종료되었습니다. 이 terminals 또는 휴대폰이 휴대폰 크기로 남긴 모든 terminals을 데스크톱 크기로 복원하세요."
+            "4b7e1c9a20": "휴대 전화에 맞게 크기가 조정됩니다.",
+            "9d2f6a3e58": "전화 세션이 종료되었습니다. 이 창에 맞게 복원하세요.",
+            "1e5c8b7d43": "복원",
+            "6a3d9f2c71": "모든 창 복구",
+            "8c1a5e9f36": "데스크톱 타이핑이 일시 중지되었습니다. 출력은 계속 스트리밍됩니다.",
+            "2f7b4d1e95": "모두 회수",
+            "3a9c5f7e12": "최소화"
           },
           "TerminalAgentSessionForkDialog": {
             "17fc841e59": "컨텍스트 복사",
@@ -3697,10 +3710,12 @@
             "grokUsageAria": "Grok 사용량 세부 정보 열기",
             "grokUsageMenu": "Grok 사용량",
             "floatingTerminalNewActivity": "{{label}}, 새 활동",
+            "4fba7dc1e7": "잔액 {{value0}}",
             "codexSignInSuccess": "Codex에 로그인했습니다",
             "codexSignInError": "Codex 로그인에 실패했습니다. 다시 시도해 주세요.",
             "cursorUsageMenu": "Cursor 사용량",
-            "hiddenUsageProviders": "그 외: {{value0}}"
+            "hiddenUsageProviders": "그 외: {{value0}}",
+            "zcodeUsageMenu": "ZCode 사용"
           },
           "StatusBarUsageEmptyCta": {
             "828c764a79": "계정 연결",
@@ -3882,6 +3897,9 @@
                 "message": "Orca가 실행 중인 컴퓨터의 터미널에서 cursor-agent login을 실행한 뒤 사용량을 다시 시도하세요."
               },
               "plan": "플랜"
+            },
+            "zcode": {
+              "mcp": "MCP"
             }
           },
           "SshTargetStatusRow": {
@@ -6318,6 +6336,11 @@
           "copied": "명령이 복사됨",
           "retry": "지금 다시 시도",
           "restored": "Git이 다시 작동합니다. 워크트리를 새로고침했습니다."
+        },
+        "manualSortSwitch": {
+          "title": "정렬이 수동으로 변경됨",
+          "description": "매뉴얼 은 워크스페이스를 드롭하는 위치에 유지합니다.",
+          "restore": "{{label}} (으) 로 돌아가기"
         }
       },
       "shared": {
@@ -7546,7 +7569,6 @@
         },
         "MobilePane": {
           "dd3cd78d04": "Orca 모바일로 스캔",
-          "35100bca5d": "휴대폰에서 terminals을 사용하는 동안 Orca는 휴대폰 화면에 맞게 terminals을 축소합니다. 앱을 닫거나 다른 곳으로 전환하면 terminals이 휴대폰 크기로 유지되는지(대화형 CLI 도구가 리플로우되지 않음) 또는 데스크탑으로 다시 크기가 조정되는지 여부가 제어됩니다. 배너에서 '이 terminals 복원' 또는 '모든 terminals 복원'을 사용해 언제든지 수동으로 크기를 조정할 수 있습니다.",
           "ee56f1c7e4": "모바일 앱을 나갈 때",
           "3939fd062c": "장치를 취소하면 즉시 연결이 끊어집니다.",
           "254a6d09e4": "페어링됨",
@@ -7571,7 +7593,8 @@
           "pairingCodeReady": "페어링 코드 준비됨",
           "copyPairingCode": "페어링 코드 복사",
           "diagnosticsCopied": "진단이 복사되었습니다.",
-          "diagnosticsCopyFailed": "진단을 복사하지 못했습니다."
+          "diagnosticsCopyFailed": "진단을 복사하지 못했습니다.",
+          "5e2c7a1f84": "휴대전화에서 단말기를 사용하는 동안 Orca는 휴대전화 화면에 맞게 단말기를 축소합니다. 앱을 닫거나 끄면 휴대전화 크기가 유지되는지 (대화형 CLI 도구가 리플로우되지 않도록) 또는 데스크톱으로 다시 크기가 조정되는지 여부를 제어합니다. 언제든지 배너에서 복원 또는 모두 복원을 사용하여 수동으로 크기를 조정할 수 있습니다."
         },
         "MobileSettingsPane": {
           "9a3c280e49": "GitHub 릴리스",
@@ -8479,7 +8502,12 @@
           "addTitle": "SSH 호스트 추가",
           "editDescription": "이 머신의 연결 세부 정보를 업데이트합니다. 변경 사항은 다음 연결 시 적용됩니다.",
           "addDescription": "SSH로 로그인할 수 있는 영구 머신을 추가합니다.",
-          "editingPrefix": "편집 중"
+          "editingPrefix": "편집 중",
+          "remoteRuntime": "런타임",
+          "remoteRuntimeHelp": "어떤 Node.js가 이 호스트에서 ORCA를 실행하는지. Orca 관리 노드는 자체적으로 업로드하며 npm이 필요하지 않습니다. 호스트 노드는 이미 설치된 Node.js를 사용합니다.",
+          "remoteRuntimeAuto": "자동",
+          "remoteRuntimePinnedNode": "ORCA 관리 노드",
+          "remoteRuntimeHostNode": "호스트 노드"
         },
         "TasksPane": {
           "f71d8a9dd3": "작업 제공자",
@@ -8656,7 +8684,38 @@
             "fastDescription": "수정 키로 스크롤할 때 적용되는 추가 배율.",
             "tui": "TUI",
             "tuiDescription": "전체 화면 터미널 앱을 위한 개별 휠 보고."
-          }
+          },
+          "8dbe0bc942": "셸 인수, 한 줄에 하나",
+          "f58cb71f53": "--rcfile\n/path/to/rcfile",
+          "48b91a3ed2": "사용자 지정 인수",
+          "7bd83fc1d0": "-l (기본)",
+          "5ffc4777b6": "셸 인수 모드",
+          "578ec79449": "한 줄에 인수 하나를 입력하세요. 비워 두면 인수를 전달하지 않습니다.",
+          "884a006065": "-l로 셸을 로그인 셸로 시작합니다.",
+          "01c600daff": "셸 인수",
+          "e3ae5aed18": ". 시스템 셸로 전환하거나 이 호스트의 실행 파일을 선택하세요.",
+          "59573d0b33": "PATH에 있는 셸 이름이나 실행 파일 경로를 입력하세요. Orca가 로그인 셸로 실행합니다.",
+          "5e06e87730": "사용자 지정 셸 실행 파일",
+          "c2bf02ce2f": "fish, nu 또는 /bin/zsh",
+          "f51cc79784": "사용자 지정 셸",
+          "dd3f4c35da": "시스템 셸 ({{value0}})",
+          "fd05fb109c": "터미널 셸",
+          "69724e8f0c": "새 로컬 터미널 창에서 Orca가 열 셸을 선택합니다.",
+          "c2ddb189e7": "rcfile",
+          "73c211e979": "래퍼",
+          "4faf688f78": "로그인",
+          "44f8a56f66": "인수",
+          "af893aa433": "인수",
+          "ddc72a4860": "기본값",
+          "d469840b75": "nushell",
+          "17ad899ba4": "bash",
+          "c9bc93d343": "zsh",
+          "0cbe5ad727": "fish",
+          "81694f1584": "터미널",
+          "a909136b3f": "셸",
+          "1c29734248": "새 터미널 창에 사용할 셸",
+          "9589abc009": "기본 셸",
+          "5a5eac2f44": "셸을 찾을 수 없음: {{value0}}"
         },
         "TerminalSettingsPreview": {
           "a63953a48a": "{{value0}} 테마 미리보기",
@@ -8793,7 +8852,8 @@
           "f9a9cf6928": "음성 받아쓰기를 활성화하려면 마이크 권한이 필요합니다.",
           "1eac933202": "macOS 개인 정보 보호 및 보안을 열었습니다. 액세스 권한을 부여한 후 받아쓰기를 다시 활성화하세요.",
           "cd9fe37556": "마이크 권한이 부여되었습니다.",
-          "6fa734ed95": "{{value0}} 삭제"
+          "6fa734ed95": "{{value0}} 삭제",
+          "openAiKeyName": "OpenAI 트랜스크립션 키"
         },
         "WorktreeSymlinksSection": {
           "1c1e35b219": "{{value0}} 제거",
@@ -8908,6 +8968,18 @@
                 "usage": "사용량"
               },
               "title": "Cursor 사용량"
+            },
+            "zcodePlan": {
+              "title": "GLM 코딩 계획",
+              "description": "Z.AI 또는 Zhipu (BigModel) GLM 코딩 계획 사용 추적. 사이트를 선택하고 요금제 API 키를 저장합니다.",
+              "kw": {
+                "glm": "glm",
+                "zai": "zai",
+                "zhipu": "zhipu",
+                "bigmodel": "bigmodel",
+                "codingPlan": "코딩 계획",
+                "rateLimit": "속도 제한 :"
+              }
             }
           }
         },
@@ -8999,7 +9071,12 @@
             "yolo": "욜로",
             "manual": "수동",
             "skip": "건너뛰다",
-            "checks": "검사"
+            "checks": "검사",
+            "7e15b89f6e": "서버",
+            "ff457e1e7b": "데몬.",
+            "9f3becc4e8": "공유됨",
+            "34337ed5c7": "격리",
+            "9a84e65118": "에이전트 개요"
           }
         },
         "appearance": {
@@ -9174,7 +9251,12 @@
                 "cursor": "cursor"
               },
               "title": "Cursor 사용량"
-            }
+            },
+            "zcodeUsageTitle": "ZCode 사용",
+            "zcodeUsageDescription": "상태 표시줄에 ZCode 코딩 계획 할당량 사용을 표시합니다.",
+            "zcode": "zcode",
+            "zai": "zai",
+            "glm": "glm"
           }
         },
         "auto": {
@@ -9866,7 +9948,8 @@
               "9a9f8d4910": "Jira Cloud를 연결하여 이슈를 찾아보고 생성하고 연결하세요.",
               "74f3063026": "{{value0}} 사이트{{value1}}이(가) 연결되었습니다.",
               "statusConnected": "연결됨",
-              "statusNotConnected": "연결되지 않음"
+              "statusNotConnected": "연결되지 않음",
+              "jiraTokenName": "Jira API 토큰"
             }
           }
         },
@@ -10600,7 +10683,19 @@
               "statusline": "상태 표시줄",
               "dim": "어둑한",
               "colors": "그림 물감"
-            }
+            },
+            "d31ed1ac1c": "rcfile",
+            "d9e29543a1": "래퍼",
+            "50ba80b6dd": "로그인",
+            "36ba1a1357": "인수",
+            "5304b12d5c": "인수",
+            "7c3ede6f12": "nushell",
+            "bf09070e31": "bash",
+            "d26257a80d": "zsh",
+            "454df22a5e": "fish",
+            "ddd5efe113": "셸",
+            "3de504994c": "새 로컬 대화형 터미널 창에 사용할 셸과 인수",
+            "1733ccd3e9": "터미널 셸"
           },
           "windows": {
             "search": {
@@ -10701,7 +10796,11 @@
           "a42f6fbdd8": "agents가 작업하는 동안 이 컴퓨터와 디스플레이를 깨어 있게 유지합니다. Orca는 전원 정책에 따라 뚜껑이 닫혀 있을 때도 이 기기를 깨어 있게 유지하도록 요청합니다.",
           "modeTitle": "컴퓨터 절전 방지",
           "modeDescriptionWindows": "켜짐, 에이전트 또는 꺼짐을 선택합니다. 에이전트 모드는 에이전트가 작업하는 동안 활성 상태를 유지합니다. 덮개 닫힘 동작은 이 기기의 전원 설정을 따릅니다.",
-          "modeDescriptionDefault": "켜짐, 에이전트 또는 꺼짐을 선택합니다. 에이전트 모드는 에이전트가 작업하는 동안 활성 상태를 유지합니다. Orca는 또한 전원 정책에 따라 덮개가 닫혀 있을 때 이 기기가 활성 상태를 유지하도록 요청합니다."
+          "modeDescriptionMac": "켜짐, 에이전트 또는 꺼짐을 선택합니다. 에이전트 모드는 에이전트가 작업하는 동안 유휴 절전을 방지하므로 덮개를 연 상태로 긴 작업을 완료할 수 있습니다. 덮개를 닫으면 이 Mac이 절전 모드로 전환됩니다.",
+          "modeDescriptionDefault": "켜짐, 에이전트 또는 꺼짐을 선택합니다. 에이전트 모드는 에이전트가 작업하는 동안 활성 상태를 유지합니다. Orca는 또한 전원 정책에 따라 덮개가 닫혀 있을 때 이 기기가 활성 상태를 유지하도록 요청합니다.",
+          "lidNoteMac": "덮개를 연 상태에서는 유휴 절전을 방지합니다. 덮개를 닫으면 이 Mac이 절전 모드로 전환됩니다.",
+          "lidNoteWindows": "뚜껑 닫기 동작은 이 장치의 전원 설정을 따릅니다.",
+          "lidNoteDefault": "Orca는 또한 전원 정책에 따라 뚜껑을 닫을 때 이 장치를 깨어 있도록 요청합니다."
         },
         "AgentAwakeSetting": {
           "on": "켜짐",
@@ -10851,7 +10950,8 @@
                 "2d60ec7921": "API 토큰으로 Jira Cloud 사이트를 연결하거나, 개인 액세스 토큰 또는 사용자 이름과 비밀번호로 자체 호스팅 Jira를 연결하세요. 자격 증명은 선택한 원격 런타임으로 전송되어 런타임이 지원하는 암호화로 저장됩니다.",
                 "977e360b71": "API 토큰으로 Jira Cloud 사이트를 연결하거나, 개인 액세스 토큰 또는 사용자 이름과 비밀번호로 자체 호스팅 Jira를 연결하세요. 자격 증명은 로컬에 저장되며 로컬 런타임 저장소가 지원하는 경우 암호화됩니다.",
                 "statusConnected": "연결됨",
-                "statusNotConnected": "연결되지 않음"
+                "statusNotConnected": "연결되지 않음",
+                "linearTokenName": "Linear API 토큰"
               }
             }
           }
@@ -12018,7 +12118,8 @@
               "notConfigured": "Atlassian API 토큰 또는 액세스 토큰을 사용하여 Bitbucket Cloud 계정을 연결하세요. ORCA_BITBUCKET_* 환경 변수도 작동하며 우선 적용됩니다.",
               "disconnectFailed": "저장된 Bitbucket 사용자 인증 정보를 삭제할 수 없습니다.",
               "statusLoadFailed": "저장된 Bitbucket 자격 증명을 확인할 수 없습니다.",
-              "replaceCredentials": "자격 증명 추가 또는 교체"
+              "replaceCredentials": "자격 증명 추가 또는 교체",
+              "credentialName": "Bitbucket 자격 증명"
             }
           }
         },
@@ -12079,6 +12180,51 @@
           "offCount": "{{count}}대 꺼짐",
           "machines": "머신",
           "machinesDescription": "이 컴퓨터에 알림을 표시할 수 있는 컴퓨터를 선택합니다. 페어링된 서버의 스위치는 해당 서버를 통해 수행하는 작업에도 적용됩니다."
+        },
+        "UnsealedCredentialNotice": {
+          "body": "{{credential}} 은 암호화되지 않은 상태로 저장됩니다. 이 시스템에는 ORCA가 사용할 수 있는 OS 키링이 없습니다. 디스크나 디스크의 백업을 읽을 수 있는 사람은 자격 증명을 읽을 수 있습니다. 그놈 키링 또는 kwallet을 설치하고 잠금 해제한 다음 다시 저장하여 봉인합니다."
+        },
+        "ZcodePlanAccountsSection": {
+          "site": {
+            "bigmodel": "Zhipu · BigModel (open.bigmodel.cn)",
+            "zai": "Z.AI (z.ai)"
+          },
+          "window": {
+            "session": "5시간",
+            "weekly": "주간",
+            "mcp": "매월 MCP"
+          },
+          "resetIn": "— {{value0}} 후 초기화",
+          "keyRequired": "GLM 코딩 계획 API 키가 필요합니다.",
+          "keySaved": "GLM 코딩 계획 API 키가 저장되었습니다.",
+          "keySaveFailed": "GLM 코딩 계획 자격 증명 업데이트에 실패했습니다.",
+          "title": "GLM 코딩 계획",
+          "subtitle": "상태 표시줄에서 Z.AI 또는 Zhipu (BigModel) GLM 코딩 계획 사용을 추적합니다. 요금제 API 키를 여기에 저장하세요. ZCode CLI 설정이 필요하지 않습니다.",
+          "consoleLink": "받기 위한 v3 API 키",
+          "keyStored": "API 키 저장 완료 · {{value0}}",
+          "keyStoredHelp": "로컬로 저장되고 사용량 갱신을 위해 선택한 사이트로만 전송됩니다. ZCode CLI 로그인보다 우선합니다.",
+          "usingCli": "ZCode CLI 로그인 사용",
+          "usingCliHelp": "ORCA는 ~/.zcode/cli/config.json에서 코딩 계획 키를 읽습니다. 요금제를 여기에 연결하려면 아래에 API 키를 저장하세요.",
+          "notConfigured": "연결된 GLM 코딩 계획 없음",
+          "notConfiguredHelp": "아래에 요금제 API 키를 저장하거나 이 컴퓨터에서 ZCode CLI로 로그인합니다.",
+          "refreshUsage": "사용량 새로 고침",
+          "siteTitle": "사이트 계획",
+          "siteDescription": "코딩 계획이 속한 콘솔을 선택하십시오: 국제 사이트는 Z.AI, 본토 사이트는 Zhipu BigModel.",
+          "keyTitle": "API 키",
+          "keyDescription": "선택한 콘솔의 API 키 페이지에서 API 키를 붙여넣습니다. 로컬에 저장되고 OS가 지원할 때 암호화되며 사용량 새로 고침을 위해 해당 사이트로만 전송됩니다.",
+          "saved": "저장했습니다",
+          "notSaved": "저장 안 됨",
+          "keyPlaceholder": "GLM 코딩 계획 API 키 붙여넣기",
+          "replace": "교체",
+          "save": "저장",
+          "forgetKey": "키 분실",
+          "keyHelp": "코딩 도구가 계획에 사용하는 것과 동일한 키 (예: ANTHROPIC_BASE_URL이 있는 Claude Code가 사이트를 가리킴). 위의 사이트를 전환하면 수신하는 호스트가 변경됩니다.",
+          "usageTitle": "사용 계획",
+          "usageDescription": "상태 표시줄 사용 주기로 새로 고쳐진 연결된 코딩 계획의 라이브 할당량 창.",
+          "planLevel": "요금제: {{value0}}",
+          "hostOnly": "ORCA를 실행하는 컴퓨터의 데스크톱 앱에서 요금제 사이트 및 API 키를 변경합니다.",
+          "detailsUnavailable": "플랜 자격 증명 세부 정보는 ORCA를 실행하는 컴퓨터에서만 읽을 수 있습니다.",
+          "siteUnavailable": "호스트 요금제 사이트 이용 불가"
         }
       },
       "right": {
@@ -13225,7 +13371,8 @@
             "fca915a67a": "원격 항목은 영구적으로 삭제되며 되돌릴 수 없습니다. 로컬 항목은 {{value0}}(으)로 이동합니다."
           },
           "useFileExplorerHandlers": {
-            "32cd9fd991": "심볼릭 링크 대상을 열 수 없습니다"
+            "32cd9fd991": "심볼릭 링크 대상을 열 수 없습니다",
+            "folderLinksOutsideProject": "이 폴더는 프로젝트 외부로 연결되어 있어 여기에서 열 수 없습니다."
           },
           "useFileExplorerImport": {
             "25919b2050": "{{value0}} {{value1}}을(를) 건너뛰었습니다.",
@@ -13493,7 +13640,6 @@
           },
           "aiVaultSessionLogOpen": {
             "workspaceGone": "로그를 열 수 없습니다 — 워크스페이스를 더 이상 사용할 수 없습니다.",
-            "notAuthorized": "로그를 열 수 없습니다 — 경로가 승인되지 않았습니다.",
             "alreadyEditable": "로그가 이미 편집용으로 열려 있습니다."
           },
           "github": {
@@ -14861,7 +15007,12 @@
         "CsvViewer": {
           "eedd0d37a7": "열",
           "ac31d2cd60": "행",
-          "a233d55b77": "빈 파일"
+          "a233d55b77": "빈 파일",
+          "delimiterComma": "콤마",
+          "delimiterSemicolon": "세미콜론(쌍반점)",
+          "delimiterTab": "탭",
+          "delimiterAuto": "자동 ({{delimiter}})",
+          "delimiter": "분리자"
         },
         "DiffNotesSendMenu": {
           "f1aa04b5cf": "이 파일",
@@ -15399,7 +15550,9 @@
           }
         },
         "richMarkdownLargeTextPaste": {
-          "tooLarge": "붙여넣기 내용이 너무 큽니다."
+          "tooLarge": "붙여넣기 내용이 너무 큽니다.",
+          "stopped": "큰 페이스트는 완성되기 전에 멈췄습니다.",
+          "cancelled": "원래 대상이 변경되어 큰 붙여넣기가 취소되었습니다."
         },
         "CheckRunJobs": {
           "1c0a4d7e02": "성공",
@@ -15494,6 +15647,10 @@
           "a0af0198aa": "큰 diff는 기본적으로 렌더링되지 않습니다.",
           "c3d9f4a712": "이 diff의 크기는 아직 알려지지 않았으므로 요청 시 로드됩니다.",
           "f7fa7a40d0": "로드 차이"
+        },
+        "richMarkdownImageInsertionFeedback": {
+          "importedFileKept": "목적지가 변경되어 이미지 삽입이 취소되었습니다. 가져온 파일이 보관되었습니다.",
+          "destinationChanged": "목적지가 변경되어 이미지 삽입이 취소되었습니다. 다시 시도하십시오."
         }
       },
       "diff": {
@@ -17825,6 +17982,7 @@
       "dismissDeliveryNotice": "닫기",
       "messageNotSent": "메시지가 전송되지 않음",
       "deliveryUnconfirmed": "전달 확인 안 됨 — 다시 시도하기 전에 채팅을 확인하세요",
+      "messageSending": "전송 중…",
       "queuedMessages": {
         "alreadySent": "이 메시지는 이미 전송되었습니다.",
         "editAlreadySent": "이미 전송되었습니다 — 텍스트는 입력창에 남아 있습니다.",
@@ -18524,6 +18682,10 @@
   "sourceControl": {
     "unlinkedPr": {
       "status": "PR #{{number}} 연결 해제됨"
+    },
+    "discard": {
+      "restoreStagedVersionDescription": "이렇게 하면 마지막 단계 버전이 복원되고 삭제가 취소됩니다. 이 작업은 취소할 수 없습니다.",
+      "unstagedChangesDescription": "이렇게 하면 단계가 지정되지 않은 변경 사항이 이 파일로 되돌아갑니다. 이 작업은 취소할 수 없습니다."
     }
   },
   "rendererRecovery": {
@@ -18541,7 +18703,10 @@
     "launchFailedMessage": "Orca가 창을 그리는 프로세스를 시작하지 못했습니다.",
     "launchFailedDetail": "Orca가 {{recoveryCount}}번 다시 시도했지만 성공하지 못했습니다.",
     "processLimitDetail": "사용자 계정이 프로세스 수 한도에 도달하여 시스템이 새 프로세스 생성을 거부했습니다. 폭주한 터미널, 개발 서버 또는 에이전트가 원인인 경우가 많습니다. 일부를 종료한 다음 다시 시도를 클릭하세요.",
-    "launchFailedGenericDetail": "시스템이 시작을 거부했습니다. 메모리를 확보하거나 다른 앱을 종료한 다음 다시 시도를 클릭하세요. 계속 발생하면 Orca를 다시 설치하세요."
+    "launchFailedGenericDetail": "시스템이 시작을 거부했습니다. 메모리를 확보하거나 다른 앱을 종료한 다음 다시 시도를 클릭하세요. 계속 발생하면 Orca를 다시 설치하세요.",
+    "lowCommitMessage": "Windows의 메모리가 부족합니다.",
+    "lowCommitDetail": "Windows에는 앱용 메모리가 {{availableMB}} MB밖에 남아 있지 않으므로 다시 로드한 후 다시 메모리가 부족합니다.",
+    "lowCommitAdvice": "사용하지 않는 앱이나 ORCA 워크스페이스를 닫거나 Windows 페이지 파일 크기를 늘려 메모리를 확보한 다음 다시 로드 를 클릭합니다."
   },
   "sessionSearch": {
     "panel": {
@@ -18570,7 +18735,8 @@
       "sessionsOther": "{{count}} 세션",
       "sessionsOfLoaded": "{{value1}} 세션 중 {{value0}}",
       "showMoreSessions": "더 많은 세션 보기",
-      "loadingMoreSessions": "추가 세션 로드 중…"
+      "loadingMoreSessions": "추가 세션 로드 중…",
+      "unsupportedAgent": "이 컴퓨터는 선택한 에이전트에 대한 이력 검색을 지원하지 않습니다. 해당 컴퓨터에서 ORCA를 업데이트하거나 다른 에이전트를 선택하십시오."
     }
   },
   "sessionHistory": {
@@ -18623,7 +18789,12 @@
       "loading": "하위 에이전트 로드 중…",
       "loadError": "모든 하위 에이전트를 로드할 수 없습니다.",
       "empty": "하위 에이전트를 찾을 수 없습니다."
-    }
+    },
+    "antigravityReferenceDescription": "이 대본을 참고 자료로 사용하여 새로운 Antigravity CLI 대화에서 계속합니다.",
+    "antigravityIdeToCli": "IDE → CLI",
+    "antigravity2ToCli": "2.0 → CLI",
+    "continueInCli": "CLI에서 계속",
+    "continueInCliNewTab": "새 탭의 CLI에서 계속"
   },
   "common": {
     "retry": "다시 시도"
@@ -18700,6 +18871,92 @@
       "removeTitle": "관리 계정을 삭제할까요?",
       "removeDescription": "먼저 이 프로필을 사용하는 에이전트를 중지하세요. 삭제하면 저장된 자격 증명과 대화 데이터가 지워집니다. 시스템 로그인은 변경되지 않습니다.",
       "cancel": "취소"
+    },
+    "antigravity": {
+      "scope": "{{host}} 에서 기본 Agy 계정을 관리합니다.",
+      "signIn": "이 호스트에서 AGY를 시작하고 브라우저 로그인을 완료한 다음 현재 계정을 저장하세요. 다른 계정을 추가하려면 agy에서/logout을 사용하고 다시 로그인하세요.",
+      "docs": "로그인 안내",
+      "retry": "다시 시도",
+      "identityUnknown": "로그인한 ID를 사용할 수 없음",
+      "signedOut": "로그인된 기본 Agy 계정이 없습니다.",
+      "changed": "기본 계정이 변경되었습니다. AGY를 시작하기 전에 저장된 계정을 다시 선택하십시오.",
+      "save": "현재계정",
+      "refresh": "계정 새로고침",
+      "usage": "사용량 새로 고침",
+      "working": "계정 업데이트",
+      "usageReading": "세션: {{session}} · 주간: {{weekly}}",
+      "saved": "저장된 Google 계정",
+      "nativeActive": "기본 계정",
+      "selected": "선택됨",
+      "select": "선택",
+      "remove": "제거",
+      "sessions": "선택은 이 호스트의 새로운 애기 세션에 적용됩니다. 기존 세션은 이전 계정을 유지할 수 있습니다.",
+      "searchTitle": "Antigravity 계정",
+      "searchDescription": "실행 호스트에서 기본 agy Google 계정을 저장하고 선택합니다.",
+      "title": "Antigravity",
+      "keyword": {
+        "antigravity": "반중력",
+        "agy": "agy",
+        "google": "Google",
+        "accounts": "있습니다"
+      }
     }
+  },
+  "osDocumentOpen": {
+    "failed": "파일을 열지 못했습니다."
+  },
+  "terminal": {
+    "sessionSaveFailure": {
+      "title": "터미널 세션을 저장할 수 없습니다",
+      "capacity": "이 터미널을 저장하는 장치가 전체 스토리지 또는 초과된 스토리지 할당량을 보고했습니다. 해당 장치의 여유 공간을 확보한 다음 다시 시도하십시오.",
+      "unknown": "ORCA는 터미널 상태를 저장할 수 없습니다. 다시 시도하세요. 이 문제가 계속되면 원인을 파악할 수 있도록 지원팀과 ORCA 로그를 공유하세요."
+    },
+    "codexTerminalServerIsolationNotice": {
+      "title": "ORCA는 이제 공유 서버 없이 CODEX를 실행합니다",
+      "description": "이를 통해 에이전트 상태를 더욱 안정적으로 유지할 수 있습니다. 설정에서 다시 켤 수 있습니다.",
+      "openSettings": "설정 열기 "
+    },
+    "codexSharedSettingsNotice": {
+      "title": "Orca의 Codex는 이제 ~/.codex를 사용합니다",
+      "description": "Codex는 폴더를 신뢰하거나 명령을 승인하도록 다시 요청할 수 있습니다. ORCA에서만 추가한 MCP 서버를 다시 추가합니다."
+    },
+    "codexSharedServerBanner": {
+      "title": "이 Codex는 다른 Codex 탭과 서버를 공유합니다",
+      "body": "세션이 예기치 않게 종료될 수 있으며 에이전트 상태가 잘못되었을 수 있습니다.",
+      "openedBeforeUpdateBody": "이 터미널은 ORCA가 각 Codex에게 자체 서버를 제공하기 전에 열렸습니다.",
+      "oldTerminalDialogTitle": "이 Codex가 서버를 공유하는 이유",
+      "oldTerminalDialogRisk": "서버를 공유하는 Codex 세션은 함께 종료될 수 있으며 에이전트 상태가 잘못될 수 있습니다.",
+      "oldTerminalDialogCause": "이전 터미널은 여전히 Codex 서버를 공유합니다. 새 터미널을 열어 별도의 서버에서 Codex를 실행합니다.",
+      "fix": "자물쇠",
+      "openNewTerminal": "새 터미널 열기",
+      "dontShowAgain": "다시 보지 않기",
+      "dismiss": "닫기",
+      "dialogTitle": "각 Codex 탭에 자체 서버를 제공합니다",
+      "dialogDescription": "Codex 세션은 터미널 공유 백그라운드 서버에서 직접 시작되었습니다. ORCA는 시작되는 Codex 세션을 별도로 유지합니다. 세션이 서버를 공유할 때 서버를 닫으면 다른 세션이 종료될 수 있으며 에이전트 상태가 잘못될 수 있습니다.",
+      "copy": "복사",
+      "copied": "복사됨",
+      "done": "완료",
+      "step1Title": "Codex 서버 공유 끄기",
+      "step1Note": "이렇게 하면 Codex 설정이 변경되므로 ORCA 외부에서도 적용됩니다.",
+      "step2Title": "실행 중인 공유 서버 중지",
+      "undo": "되돌리려면 codex features enable daemon_auto_start를 실행하세요.",
+      "step2Warning": "서버를 공유하는 열려 있는 Codex 세션을 닫습니다.",
+      "learnMore": "자세히 알아보기",
+      "turnOff": "끄기",
+      "turningOff": "끄는 중...",
+      "turnedOff": "껐어요",
+      "turnOffFailed": "Orca는 이 기능을 끌 수 없었다.",
+      "stopServer": "서버 중지",
+      "stopping": "정지 중",
+      "stopped": "중지됨",
+      "stopFailed": "Orca는 서버를 멈출 수 없었다.",
+      "confirmStopTitle": "공유 서버를 중지하시겠습니까?",
+      "confirmStopDescription": "이는 ORCA 외부 세션을 포함하여 이를 공유하는 모든 공개 Codex 세션을 종료합니다.",
+      "cancel": "취소",
+      "runs": "Runs"
+    }
+  },
+  "fileSearch": {
+    "failed": "검색에 실패했습니다. 다시 시도하세요."
   }
 }
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index 2a9a3ea73b6..04c5fa3f5c6 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -41,7 +41,8 @@
         "portsToggleDescription": "显示实时工作区端口。点击可查看工作区范围的端口和外部监听器。",
         "antigravityToggleDescription": "显示当前工作区的 Antigravity 订阅使用情况。",
         "grokToggleDescription": "通过 Grok CLI 登录后显示 Grok 订阅额度使用情况。",
-        "cursorToggleDescription": "通过 cursor-agent 或 Cursor IDE 登录后显示 Cursor 套餐用量。"
+        "cursorToggleDescription": "通过 cursor-agent 或 Cursor IDE 登录后显示 Cursor 套餐用量。",
+        "zcodeToggleDescription": "显示 ZCode 编码计划配额使用情况。"
       },
       "menuBarIcon": {
         "title": "显示菜单栏图标",
@@ -97,6 +98,16 @@
         "restartRequired": "需要重新启动",
         "unavailable": "浏览器身份不可用。"
       }
+    },
+    "agents": {
+      "codexTerminalServerIsolation": {
+        "title": "在自己的服务器上运行每个 Codex 终端",
+        "description": "保持 Orca 的状态和关闭选项卡正常工作。关闭以使用 Codex 的共享服务器及其代理概述。适用于新终端。"
+      },
+      "codexSharedServerWarning": {
+        "title": "当 Codex 选项卡共享服务器时发出警告",
+        "description": "当您自己启动的 Codex 与其他选项卡共享服务器时，在您自己启动的 Codex 上显示一条通知，因为它的代理状态可能是错误的。"
+      }
     }
   },
   "menu": {
@@ -504,7 +515,11 @@
           "opencode2_label": "OpenCode 2",
           "codebuddy_label": "CodeBuddy",
           "zcode_label": "ZCode",
-          "jcode_label": "Jcode"
+          "jcode_label": "Jcode",
+          "freebuff_label": "Freebuff",
+          "dsh_label": "DeepSeek Harness",
+          "qoder_label": "Qoder CLI",
+          "qoder_cn_label": "Qoder CLI China"
         },
         "skill": {
           "cli": {
@@ -3033,18 +3048,16 @@
           },
           "MobileDriverOverlay": {
             "c6460cf584": "收回",
-            "c8f2e1a4b9": "收回此终端",
             "c44659e09f": "手机控制中",
-            "7cffad954c": "折叠",
             "3eed73394f": "您的键盘已暂停",
-            "faa367dc74": "手机将此终端留在手机尺寸",
-            "54f7d6f69d": "收回所有终端",
-            "b3d8e1f42a": "恢复此终端",
-            "e8c4f2a91b": "恢复所有终端",
-            "f2a8b9c1d3": "来自手机",
             "c7e4a2b8f1": "手机正在控制",
-            "d9f3c6e2a4": "桌面键盘已暂停。收回此终端以在此输入，收回手机控制的所有终端，或折叠以继续观看。",
-            "a6b1d8f3e2": "手机会话已结束。将此终端或手机留在手机尺寸的所有终端恢复为桌面尺寸。"
+            "4b7e1c9a20": "尺寸仍适合您的手机",
+            "9d2f6a3e58": "您的手机会话结束了。恢复以适合此窗口。",
+            "1e5c8b7d43": "恢复",
+            "6a3d9f2c71": "全部恢复",
+            "8c1a5e9f36": "桌面打字已暂停。输出持续流动。",
+            "2f7b4d1e95": "全部收回",
+            "3a9c5f7e12": "最小化"
           },
           "TerminalAgentSessionForkDialog": {
             "17fc841e59": "复制上下文",
@@ -3697,10 +3710,12 @@
             "grokUsageAria": "打开 Grok 使用详情",
             "grokUsageMenu": "Grok 使用情况",
             "floatingTerminalNewActivity": "{{label}}，有新活动",
+            "4fba7dc1e7": "余额 {{value0}}",
             "codexSignInSuccess": "已登录 Codex",
             "codexSignInError": "Codex 登录失败，请重试。",
             "cursorUsageMenu": "Cursor 用量",
-            "hiddenUsageProviders": "另有：{{value0}}"
+            "hiddenUsageProviders": "另有：{{value0}}",
+            "zcodeUsageMenu": "Z代码使用"
           },
           "StatusBarUsageEmptyCta": {
             "828c764a79": "连接账户",
@@ -3882,6 +3897,9 @@
                 "message": "请在运行 Orca 的电脑上的终端中运行 cursor-agent login，然后重新刷新用量。"
               },
               "plan": "套餐"
+            },
+            "zcode": {
+              "mcp": "MCP"
             }
           },
           "SshTargetStatusRow": {
@@ -5595,7 +5613,7 @@
           "f9dc6cc5d3": "重命名项目组",
           "370c6a55dd": "清除筛选条件",
           "b7acbf038b": "未找到工作区",
-          "0c6ee14f23": "孩子",
+          "0c6ee14f23": "子",
           "5fc9d1891b": "正在删除...",
           "c83968f87f": "删除项目",
           "64e55f7f01": "从组中删除",
@@ -5612,7 +5630,7 @@
           "45fbfe0335": "重命名",
           "ebc5c7dcef": "隐藏子工作区",
           "84a2238242": "显示子工作区",
-          "045a8aed48": "孩子们",
+          "045a8aed48": "子工作区",
           "2ca6e29a3c": "仓库",
           "bb85cd86ba": "为 {{value0}} 创建工作区",
           "ebadb7eadb": "{{value0}} {{value1}} 子项 {{value2}}",
@@ -5910,7 +5928,7 @@
           "card": {
             "compact": {
               "agents": {
-                "a128d7006b": "{{value0}} {{value1}} 儿童 {{value2}}",
+                "a128d7006b": "{{value0}} {{value1}} 子 {{value2}}",
                 "289a1d2ca7": "展开{{value0}}。 {{value1}}",
                 "0c1debfe84": "折叠 {{value0}}"
               }
@@ -6318,6 +6336,11 @@
           "copied": "命令已复制",
           "retry": "立即重试",
           "restored": "Git 已恢复正常。工作树已刷新。"
+        },
+        "manualSortSwitch": {
+          "title": "排序更改为手动",
+          "description": "手动将工作区保留在您放置它们的位置。",
+          "restore": "返回{{label}}"
         }
       },
       "shared": {
@@ -7546,7 +7569,6 @@
         },
         "MobilePane": {
           "dd3cd78d04": "使用 Orca 手机端 扫描",
-          "35100bca5d": "当您在手机上使用终端时，Orca 会将其缩小以适合您的手机屏幕。当您关闭应用程序或切换离开时，这可以控制它是保持手机大小（因此交互式 CLI 工具不会回流）还是将大小调整回桌面。您始终可以在横幅上使用“恢复此终端”或“恢复所有终端”来手动调整大小。",
           "ee56f1c7e4": "当您离开手机应用程序时",
           "3939fd062c": "撤销设备会立即断开连接。",
           "254a6d09e4": "配对",
@@ -7571,7 +7593,8 @@
           "pairingCodeReady": "配对码已准备就绪",
           "copyPairingCode": "复制配对码",
           "diagnosticsCopied": "已复制诊断信息",
-          "diagnosticsCopyFailed": "无法复制诊断信息"
+          "diagnosticsCopyFailed": "无法复制诊断信息",
+          "5e2c7a1f84": "当您在手机上使用终端时，Orca 会将其缩小以适合您的手机屏幕。当您关闭应用程序或切换离开时，这可以控制它是保持手机大小（因此交互式 CLI 工具不会回流）还是将大小调整回桌面。您始终可以使用横幅上的“还原”或“全部还原”来手动调整大小。"
         },
         "MobileSettingsPane": {
           "9a3c280e49": "GitHub 发布",
@@ -7676,10 +7699,10 @@
           "1e8f8d8fae": "就绪",
           "checking": "检查已安装的代理和技能路径...",
           "noAgents": "在 PATH 上未检测到代理 CLI。在“设置”→“代理”中安装代理，然后重新检查。",
-          "fullCoverage_one": "所有 1 名已检测的特工都拥有该技能。",
-          "fullCoverage_other": "所有 {{value0}} 已检测的特工都拥有该技能。",
+          "fullCoverage_one": "所有 1 名已检测的智能体都拥有该技能。",
+          "fullCoverage_other": "所有 {{value0}} 已检测的智能体都拥有该技能。",
           "noCoverage": "安装上面的技能，然后重新检查。",
-          "partialCoverage": "{{value1}} 的 {{value0}} 已检测特工拥有该技能。"
+          "partialCoverage": "{{value1}} 的 {{value0}} 已检测智能体拥有该技能。"
         },
         "OrchestrationSkillPromptDialog": {
           "f08d45293d": "复制命令",
@@ -8479,7 +8502,12 @@
           "addTitle": "添加 SSH 主机",
           "editDescription": "更新此机器的连接详情。更改将在下次连接时生效。",
           "addDescription": "添加一台可通过 SSH 登录的持久机器。",
-          "editingPrefix": "正在编辑"
+          "editingPrefix": "正在编辑",
+          "remoteRuntime": "运行时",
+          "remoteRuntimeHelp": "哪个 Node.js 在此主机上运行 Orca。 Orca 管理的Node自己上传，不需要npm；主机节点使用已安装在那里的 Node.js。",
+          "remoteRuntimeAuto": "自动",
+          "remoteRuntimePinnedNode": "Orca 管理的节点",
+          "remoteRuntimeHostNode": "主机节点"
         },
         "TasksPane": {
           "f71d8a9dd3": "任务提供者",
@@ -8656,7 +8684,38 @@
             "fastDescription": "按住修饰键滚动时的额外倍数。",
             "tui": "TUI",
             "tuiDescription": "面向全屏终端应用的离散滚轮报告。"
-          }
+          },
+          "8dbe0bc942": "shell 参数，每行一个",
+          "f58cb71f53": "--rcfile\n/path/to/rcfile",
+          "48b91a3ed2": "自定义参数",
+          "7bd83fc1d0": "-l（默认）",
+          "5ffc4777b6": "shell 参数模式",
+          "578ec79449": "每行输入一个参数。留空则不传递任何参数。",
+          "884a006065": "使用 -l 将 shell 作为登录 shell 启动。",
+          "01c600daff": "shell 参数",
+          "e3ae5aed18": "。请切换到系统 shell 或选择此主机上的可执行文件。",
+          "59573d0b33": "输入 PATH 中的 shell 名称或可执行文件路径。Orca 会将其作为登录 shell 启动。",
+          "5e06e87730": "自定义 shell 可执行文件",
+          "c2bf02ce2f": "fish、nu 或 /bin/zsh",
+          "f51cc79784": "自定义 shell",
+          "dd3f4c35da": "系统 shell ({{value0}})",
+          "fd05fb109c": "终端 shell",
+          "69724e8f0c": "选择 Orca 为新本地终端窗格打开的 shell。",
+          "c2ddb189e7": "rcfile",
+          "73c211e979": "wrapper",
+          "4faf688f78": "登录",
+          "44f8a56f66": "参数",
+          "af893aa433": "参数",
+          "ddc72a4860": "默认",
+          "d469840b75": "nushell",
+          "17ad899ba4": "bash",
+          "c9bc93d343": "zsh",
+          "0cbe5ad727": "fish",
+          "81694f1584": "终端",
+          "a909136b3f": "shell",
+          "1c29734248": "用于新终端窗格的 shell",
+          "9589abc009": "默认 shell",
+          "5a5eac2f44": "未找到 shell：{{value0}}"
         },
         "TerminalSettingsPreview": {
           "a63953a48a": "预览 {{value0}} 主题",
@@ -8793,7 +8852,8 @@
           "f9a9cf6928": "启用语音听写之前需要麦克风许可。",
           "1eac933202": "打开 macOS 隐私和安全。授予访问权限后再次启用听写。",
           "cd9fe37556": "已授予麦克风权限",
-          "6fa734ed95": "删除 {{value0}}"
+          "6fa734ed95": "删除 {{value0}}",
+          "openAiKeyName": "您的 OpenAI 转录密钥"
         },
         "WorktreeSymlinksSection": {
           "1c1e35b219": "删除 {{value0}}",
@@ -9011,7 +9071,12 @@
             "yolo": "约洛",
             "manual": "手动的",
             "skip": "跳过",
-            "checks": "检查"
+            "checks": "检查",
+            "7e15b89f6e": "服务器",
+            "ff457e1e7b": "守护进程",
+            "9f3becc4e8": "共享",
+            "34337ed5c7": "隔离",
+            "9a84e65118": "代理概览"
           }
         },
         "appearance": {
@@ -9186,7 +9251,12 @@
                 "cursor": "cursor"
               },
               "title": "Cursor 用量"
-            }
+            },
+            "zcodeUsageTitle": "Z代码使用",
+            "zcodeUsageDescription": "在状态栏中显示 ZCode 编码计划配额使用情况。",
+            "zcode": "零码",
+            "zai": "在",
+            "glm": "格鲁姆"
           }
         },
         "auto": {
@@ -9878,7 +9948,8 @@
               "9a9f8d4910": "连接 Jira Cloud 以浏览、创建和链接议题。",
               "74f3063026": "{{value0}} 站点{{value1}} 已连接",
               "statusConnected": "已连接",
-              "statusNotConnected": "未连接"
+              "statusNotConnected": "未连接",
+              "jiraTokenName": "您的 Jira API 令牌"
             }
           }
         },
@@ -10060,7 +10131,7 @@
         },
         "orchestration": {
           "search": {
-            "f5d39af41e": "儿童特工",
+            "f5d39af41e": "子智能体",
             "c766a01978": "不可触摸",
             "08c65b12a2": "例子",
             "f278fd04db": "codex",
@@ -10612,7 +10683,19 @@
               "statusline": "状态行",
               "dim": "暗淡",
               "colors": "颜色"
-            }
+            },
+            "d31ed1ac1c": "rcfile",
+            "d9e29543a1": "wrapper",
+            "50ba80b6dd": "登录",
+            "36ba1a1357": "参数",
+            "5304b12d5c": "参数",
+            "7c3ede6f12": "nushell",
+            "bf09070e31": "bash",
+            "d26257a80d": "zsh",
+            "454df22a5e": "fish",
+            "ddd5efe113": "shell",
+            "3de504994c": "用于新本地交互式终端窗格的 shell 和参数",
+            "1733ccd3e9": "终端 shell"
           },
           "windows": {
             "search": {
@@ -10713,7 +10796,11 @@
           "a42f6fbdd8": "在智能体工作时保持此电脑和显示器唤醒。Orca 还会根据电源策略，在合盖时请求此设备保持唤醒。",
           "modeTitle": "防止电脑休眠",
           "modeDescriptionWindows": "选择“打开”、“代理”或“关闭”。代理工作时代理模式保持唤醒状态；盖子关闭行为遵循该设备的电源设置。",
-          "modeDescriptionDefault": "选择“打开”、“代理”或“关闭”。当代理工作时，代理模式保持唤醒状态。 Orca 还要求该设备在盖子关闭时保持唤醒状态，具体取决于其电源策略。"
+          "modeDescriptionMac": "选择“打开”、“代理”或“关闭”。代理模式会在代理工作时防止空闲休眠，因此开盖即可完成长时间任务。合上盖子仍会使此 Mac 进入睡眠状态。",
+          "modeDescriptionDefault": "选择“打开”、“代理”或“关闭”。当代理工作时，代理模式保持唤醒状态。 Orca 还要求该设备在盖子关闭时保持唤醒状态，具体取决于其电源策略。",
+          "lidNoteMac": "开盖时防止空闲休眠；合上盖子仍会使此 Mac 进入睡眠状态。",
+          "lidNoteWindows": "合盖行为遵循该设备的电源设置。",
+          "lidNoteDefault": "Orca 还要求该设备在盖子关闭时保持唤醒状态，具体取决于其电源策略。"
         },
         "AgentAwakeSetting": {
           "on": "开启",
@@ -10863,7 +10950,8 @@
                 "2d60ec7921": "使用 API token 连接 Jira Cloud 站点，或使用个人访问令牌或用户名和密码连接自托管 Jira。凭据会发送到所选远程运行时并以运行时支持的加密方式存储。",
                 "977e360b71": "使用 API token 连接 Jira Cloud 站点，或使用个人访问令牌或用户名和密码连接自托管 Jira。凭据存储在本地，本地运行时存储支持时会进行加密。",
                 "statusConnected": "已连接",
-                "statusNotConnected": "未连接"
+                "statusNotConnected": "未连接",
+                "linearTokenName": "您的 Linear API 令牌"
               }
             }
           }
@@ -12030,7 +12118,8 @@
               "notConfigured": "将 Bitbucket Cloud 帐户与 Atlassian API 令牌或访问令牌连接。 ORCA_BITBUCKET_* 环境变量也起作用并且优先。",
               "disconnectFailed": "无法删除保存的 Bitbucket 凭据。",
               "statusLoadFailed": "无法检查已保存的 Bitbucket 凭据。",
-              "replaceCredentials": "添加或替换凭据"
+              "replaceCredentials": "添加或替换凭据",
+              "credentialName": "您的 Bitbucket 凭证"
             }
           }
         },
@@ -12125,12 +12214,17 @@
           "usageTitle": "套餐用量",
           "usageDescription": "已关联 Coding Plan 的实时配额窗口，随状态栏用量周期刷新。",
           "planLevel": "套餐：{{value0}}",
-          "hostOnly": "请在运行 Orca 的电脑上的桌面应用中更改套餐站点和 API 密钥。"
+          "hostOnly": "请在运行 Orca 的电脑上的桌面应用中更改套餐站点和 API 密钥。",
+          "detailsUnavailable": "计划凭据详细信息只能在运行 Orca 的计算机上读取。",
+          "siteUnavailable": "主机计划网站不可用"
         },
         "NotificationHostToggles": {
           "offCount": "{{count}} 台已关闭",
           "machines": "机器",
           "machinesDescription": "选择哪些机器可以在此电脑上显示通知。已配对服务器的开关也控制通过该服务器开展的工作。"
+        },
+        "UnsealedCredentialNotice": {
+          "body": "{{credential}} 未加密存储 — 该系统没有 Orca 可以使用的操作系统密钥环。任何可以读取您的磁盘或其备份的人都可以读取该凭据。安装并解锁 gnome-keyring 或 kwallet，然后再次保存以密封它。"
         }
       },
       "right": {
@@ -13277,7 +13371,8 @@
             "fca915a67a": "远程项目将永久删除且无法撤销。本地项目将移至 {{value0}}。"
           },
           "useFileExplorerHandlers": {
-            "32cd9fd991": "无法打开符号链接目标"
+            "32cd9fd991": "无法打开符号链接目标",
+            "folderLinksOutsideProject": "此文件夹链接到项目之外，无法在此打开。"
           },
           "useFileExplorerImport": {
             "25919b2050": "跳过 {{value0}} {{value1}}。",
@@ -13545,7 +13640,6 @@
           },
           "aiVaultSessionLogOpen": {
             "workspaceGone": "无法打开日志 — 工作区已不可用。",
-            "notAuthorized": "无法打开日志 — 路径未授权。",
             "alreadyEditable": "日志已处于编辑状态。"
           },
           "github": {
@@ -14081,7 +14175,7 @@
             "2f1a1d10c4": "台式机",
             "156db8a68a": "已创建 PR",
             "4a40af029b": "智能体时间",
-            "00a6903322": "特工产生",
+            "00a6903322": "智能体产生",
             "c0e2e9dcd9": "欢迎回来",
             "af761a0c0d": "设置",
             "5d94e8ddcc": "Orca"
@@ -14913,7 +15007,12 @@
         "CsvViewer": {
           "eedd0d37a7": "列",
           "ac31d2cd60": "行",
-          "a233d55b77": "空文件"
+          "a233d55b77": "空文件",
+          "delimiterComma": "逗号",
+          "delimiterSemicolon": "分号",
+          "delimiterTab": "选项卡",
+          "delimiterAuto": "自动 ({{delimiter}})",
+          "delimiter": "分隔符"
         },
         "DiffNotesSendMenu": {
           "f1aa04b5cf": "这个文件",
@@ -15451,7 +15550,9 @@
           }
         },
         "richMarkdownLargeTextPaste": {
-          "tooLarge": "粘贴内容过大。"
+          "tooLarge": "粘贴内容过大。",
+          "stopped": "大浆糊还没完成就停了。",
+          "cancelled": "大型粘贴被取消，因为其原始目标发生了变化。"
         },
         "CheckRunJobs": {
           "1c0a4d7e02": "已成功",
@@ -15546,6 +15647,10 @@
           "a0af0198aa": "默认情况下不渲染较大的差异。",
           "c3d9f4a712": "此差异的大小尚不清楚，因此会根据请求加载。",
           "f7fa7a40d0": "负载差异"
+        },
+        "richMarkdownImageInsertionFeedback": {
+          "importedFileKept": "由于目的地更改，图像插入被取消。导入的文件被保留。",
+          "destinationChanged": "由于目的地更改，图像插入被取消。再试一次。"
         }
       },
       "diff": {
@@ -15595,7 +15700,7 @@
       },
       "dashboard": {
         "DashboardAgentChildDisclosure": {
-          "1b57ce9fa4": "{{value0}} {{value1}} 儿童 {{value2}}"
+          "1b57ce9fa4": "{{value0}} {{value1}} 子 {{value2}}"
         },
         "DashboardAgentRow": {
           "912e136cd9": "发送",
@@ -16614,7 +16719,7 @@
           "dc708f3eff": "紧密智能体"
         },
         "clearCompleted": {
-          "clearedOne": "清除 1 个已完成的特工",
+          "clearedOne": "清除 1 个已完成的智能体",
           "clearedMany": "已清除 {{count}} 已完成的代理",
           "undo": "撤消"
         },
@@ -17600,7 +17705,7 @@
         "runIntegrationOne": "使用 1 集成",
         "runIntegrationMany": "使用 {{value0}} 集成",
         "runAgentOne": "然 1 代理",
-        "runAgentMany": "然 {{value0}} 特工",
+        "runAgentMany": "然 {{value0}} 智能体",
         "runPlanOne": "更新了计划",
         "runPlanMany": "更新计划 {{value0}} 次",
         "runToolOne": "使用 1 个工具",
@@ -17740,7 +17845,7 @@
         "stop": "停止",
         "stopTask": "停止{{value0}}",
         "stopAll": "停止后台任务",
-        "agent": "后台特工",
+        "agent": "后台智能体",
         "workflow": "后台工作流程",
         "command": "后台命令",
         "monitor": "后台监控",
@@ -17842,6 +17947,7 @@
       "dismissDeliveryNotice": "关闭",
       "messageNotSent": "消息未发送",
       "deliveryUnconfirmed": "无法确认送达 — 重试前请检查聊天",
+      "messageSending": "正在发送…",
       "queuedMessages": {
         "alreadySent": "此消息已发送。",
         "editAlreadySent": "已发送 — 你的文本仍在输入框中。",
@@ -18576,6 +18682,10 @@
   "sourceControl": {
     "unlinkedPr": {
       "status": "PR #{{number}} 未链接"
+    },
+    "discard": {
+      "restoreStagedVersionDescription": "这将恢复最后一个暂存版本并放弃删除。此操作无法撤消。",
+      "unstagedChangesDescription": "这将恢复对此文件的未暂存更改。此操作无法撤消。"
     }
   },
   "rendererRecovery": {
@@ -18593,7 +18703,10 @@
     "launchFailedMessage": "Orca 无法启动绘制其窗口的进程。",
     "launchFailedDetail": "Orca 重试了 {{recoveryCount}} 次，但未成功。",
     "processLimitDetail": "由于你的用户帐户已达到进程数上限，系统拒绝创建新进程。这通常由失控的终端、开发服务器或代理导致。请关闭其中一些，然后点击“重试”。",
-    "launchFailedGenericDetail": "系统拒绝启动它。请释放内存或关闭其他应用，然后点击“重试”。如果问题持续出现，请重新安装 Orca。"
+    "launchFailedGenericDetail": "系统拒绝启动它。请释放内存或关闭其他应用，然后点击“重试”。如果问题持续出现，请重新安装 Orca。",
+    "lowCommitMessage": "Windows 内存不足。",
+    "lowCommitDetail": "Windows 只剩下 {{availableMB}} MB 内存供应用程序使用，因此窗口在重新加载后再次耗尽内存。",
+    "lowCommitAdvice": "通过关闭未使用的应用程序或 Orca 工作区来释放内存，或增加 Windows 页面文件大小，然后单击“重新加载”。"
   },
   "sessionSearch": {
     "panel": {
@@ -18622,7 +18735,8 @@
       "sessionsOther": "{{count}} 会话",
       "sessionsOfLoaded": "{{value0}} 次（共 {{value1}} 次）",
       "showMoreSessions": "显示更多会话",
-      "loadingMoreSessions": "正在加载更多会话..."
+      "loadingMoreSessions": "正在加载更多会话...",
+      "unsupportedAgent": "此计算机不支持所选代理的历史搜索。更新该计算机上的 Orca 或选择其他代理。"
     }
   },
   "sessionHistory": {
@@ -18675,7 +18789,12 @@
       "loading": "正在加载子代理...",
       "loadError": "无法加载所有子代理。",
       "empty": "未找到子代理。"
-    }
+    },
+    "antigravityReferenceDescription": "使用此记录作为参考继续新的Antigravity CLI 对话。",
+    "antigravityIdeToCli": "IDE → CLI",
+    "antigravity2ToCli": "2.0 → 命令行界面",
+    "continueInCli": "在 CLI 中继续",
+    "continueInCliNewTab": "在新选项卡中继续使用 CLI"
   },
   "common": {
     "retry": "重试"
@@ -18752,6 +18871,92 @@
       "removeTitle": "移除托管账户？",
       "removeDescription": "请先停止使用此配置的代理。移除将删除其保存的凭据和对话数据。系统登录不受影响。",
       "cancel": "取消"
+    },
+    "antigravity": {
+      "scope": "管理 {{host}} 上的本机 agy 帐户。",
+      "signIn": "在此主机上启动 agy 并完成其浏览器登录，然后保存当前帐户。要添加其他帐户，请在 agy 中使用 /logout 并再次登录。",
+      "docs": "登录说明",
+      "retry": "重试",
+      "identityUnknown": "登录身份不可用",
+      "signedOut": "没有登录本机 agy 帐户。",
+      "changed": "本机帐户已更改。在启动 agy 之前再次选择已保存的帐户。",
+      "save": "保存当前帐户",
+      "refresh": "刷新帐户",
+      "usage": "刷新使用情况",
+      "working": "正在更新帐户",
+      "usageReading": "会话：{{session}} · 每周：{{weekly}}",
+      "saved": "已保存的 Google 帐户",
+      "nativeActive": "原生账户",
+      "selected": "已选择",
+      "select": "选择",
+      "remove": "移除",
+      "sessions": "选择适用于该主机上的新 agy 会话。现有会话可能会保留其以前的帐户。",
+      "searchTitle": "Antigravity账户",
+      "searchDescription": "在执行主机上保存并选择本机 agy Google 帐户。",
+      "title": "Antigravity",
+      "keyword": {
+        "antigravity": "反重力",
+        "agy": "阿吉",
+        "google": "谷歌",
+        "accounts": "账户"
+      }
     }
+  },
+  "osDocumentOpen": {
+    "failed": "无法打开文件。"
+  },
+  "terminal": {
+    "sessionSaveFailure": {
+      "title": "无法保存终端会话",
+      "capacity": "保存该终端的设备报告存储空间已满或超出存储配额。该设备上有可用空间，然后重试。",
+      "unknown": "Orca 无法保存最终状态。再试一次。如果这种情况持续存在，请与支持人员共享 Orca 日志，以便我们找出原因。"
+    },
+    "codexTerminalServerIsolationNotice": {
+      "title": "Orca 现在无需共享服务器即可运行 Codex",
+      "description": "这使得代理状态更加可靠。您可以在“设置”中将其重新打开。",
+      "openSettings": "打开设置"
+    },
+    "codexSharedSettingsNotice": {
+      "title": "Orca 中的 Codex 现在使用 ~/.codex",
+      "description": "Codex 可能会再次要求信任文件夹或批准命令。重新添加您仅在 Orca 中添加的所有 MCP 服务器。"
+    },
+    "codexSharedServerBanner": {
+      "title": "此 Codex 与您的其他 Codex 选项卡共享服务器",
+      "body": "会话可能会意外结束，并且代理状态可能会错误。",
+      "openedBeforeUpdateBody": "这个终端是在 Orca 开始为每个 Codex 提供自己的服务器之前打开的。",
+      "oldTerminalDialogTitle": "为什么此 Codex 共享服务器",
+      "oldTerminalDialogRisk": "共享服务器的 Codex 会话可能会一起结束，并且代理状态可能会错误。",
+      "oldTerminalDialogCause": "较旧的终端仍然共享 Codex 服务器。打开一个新终端以在单独的服务器上运行 Codex。",
+      "fix": "使固定",
+      "openNewTerminal": "打开新终端",
+      "dontShowAgain": "不再显示",
+      "dismiss": "关闭",
+      "dialogTitle": "为每个 Codex 选项卡提供自己的服务器",
+      "dialogDescription": "Codex 会话直接在共享一台后台服务器的终端中启动。 Orca 将其启动的 Codex 会话分开保存。当会话共享一台服务器时，关闭一个服务器可能会结束其他服务器，并且代理状态可能会错误。",
+      "copy": "复制",
+      "copied": "已复制",
+      "done": "完成",
+      "step1Title": "关闭 Codex 服务器共享",
+      "step1Note": "这会更改您的 Codex 设置，因此它也适用于 Orca 外部。",
+      "step2Title": "停止正在运行的共享服务器",
+      "undo": "要撤消，请运行 codex features enable daemon_auto_start。",
+      "step2Warning": "关闭共享服务器的所有打开的 Codex 会话",
+      "learnMore": "了解更多",
+      "turnOff": "关",
+      "turningOff": "正在关闭…",
+      "turnedOff": "已关闭",
+      "turnOffFailed": "Orca 无法关闭此功能。",
+      "stopServer": "停止服务器",
+      "stopping": "停止…",
+      "stopped": "已停止",
+      "stopFailed": "Orca 无法停止服务器。",
+      "confirmStopTitle": "停止共享服务器？",
+      "confirmStopDescription": "这将关闭所有共享它的开放 Codex 会话，包括 Orca 之外的会话。",
+      "cancel": "取消",
+      "runs": "跑步"
+    }
+  },
+  "fileSearch": {
+    "failed": "搜索失败。再试一次。"
   }
 }
diff --git a/src/renderer/src/i18n/provider-credit-balance-locales.test.ts b/src/renderer/src/i18n/provider-credit-balance-locales.test.ts
new file mode 100644
index 00000000000..9f2f50f0282
--- /dev/null
+++ b/src/renderer/src/i18n/provider-credit-balance-locales.test.ts
@@ -0,0 +1,95 @@
+import { createInstance } from 'i18next'
+import { describe, expect, it } from 'vitest'
+
+import en from './locales/en.json'
+import enRuntimeRequired from './en-runtime-required.json'
+import es from './locales/es.json'
+import fr from './locales/fr.json'
+import ja from './locales/ja.json'
+import ko from './locales/ko.json'
+import zh from './locales/zh.json'
+
+const catalogs = {
+  es: { catalog: es, compactBalanceMessage: 'saldo 12.50' },
+  fr: { catalog: fr, compactBalanceMessage: 'solde 12.50' },
+  ja: { catalog: ja, compactBalanceMessage: '残高 12.50' },
+  ko: { catalog: ko, compactBalanceMessage: '잔액 12.50' },
+  zh: { catalog: zh, compactBalanceMessage: '余额 12.50' }
+}
+const balanceMessages = [
+  ['StatusBar.4025a6f62f', 'Unlimited'],
+  ['StatusBar.a95969101f', '{{value0}} credits'],
+  ['tooltip.fbc80d8be2', 'Zen balance'],
+  ['tooltip.c03c61f53f', 'Balance'],
+  ['tooltip.f6a27a3c0a', '{{value0}} available'],
+  ['tooltip.7404abbece', 'Usage credits'],
+  ['tooltip.473d45cd0f', 'Balance {{value0}}'],
+  ['tooltip.f21b2ba897', 'Credits'],
+  ['tooltip.56c0d70577', 'Unlimited'],
+  ['tooltip.87b5bda4d3', '{{value0}} credits available'],
+  [
+    'provider.extra.usage.section.apiKeyBalanceUnavailable',
+    'Balance is not included in this usage response.'
+  ]
+] as const
+
+function balanceKey(suffix: string): string {
+  return `auto.components.status.bar.${suffix}`
+}
+
+describe('provider credit balance sparse target catalogs', () => {
+  it.each(Object.entries(catalogs))(
+    '%s omits copied English balance entries',
+    async (locale, { catalog }) => {
+      const instance = createInstance()
+      await instance.init({ lng: locale, resources: { [locale]: { translation: catalog } } })
+
+      for (const [suffix] of balanceMessages) {
+        expect(instance.getResource(locale, 'translation', balanceKey(suffix))).toBeUndefined()
+      }
+    }
+  )
+
+  it.each(Object.entries(catalogs))(
+    '%s falls back and interpolates balance copy at runtime',
+    async (locale, { catalog, compactBalanceMessage }) => {
+      const instance = createInstance()
+      await instance.init({
+        lng: locale,
+        fallbackLng: 'en',
+        resources: { en: { translation: enRuntimeRequired }, [locale]: { translation: catalog } },
+        interpolation: { escapeValue: false }
+      })
+
+      for (const [suffix, defaultValue] of balanceMessages) {
+        expect(instance.t(balanceKey(suffix), { defaultValue, value0: '12.50' })).toBe(
+          defaultValue.replace('{{value0}}', '12.50')
+        )
+      }
+      expect(
+        instance.t(balanceKey('tooltip.87b5bda4d3'), {
+          defaultValue: '{{value0}} credits available',
+          value0: 500
+        })
+      ).toBe('500 credits available')
+      expect(
+        instance.t(balanceKey('StatusBar.4fba7dc1e7'), {
+          defaultValue: '{{value0}} bal',
+          value0: '12.50'
+        })
+      ).toBe(compactBalanceMessage)
+    }
+  )
+
+  it('retains every English source balance message', async () => {
+    const instance = createInstance()
+    await instance.init({ lng: 'en', resources: { en: { translation: en } } })
+
+    for (const [suffix, value] of balanceMessages) {
+      expect(instance.getResource('en', 'translation', balanceKey(suffix))).toBe(value)
+    }
+    expect(instance.getResource('en', 'translation', balanceKey('StatusBar.4fba7dc1e7'))).toBe(
+      '{{value0}} bal'
+    )
+  })
+})
diff --git a/src/renderer/src/lib/agent-launch-caller-permissions.test.ts b/src/renderer/src/lib/agent-launch-caller-permissions.test.ts
index 829932b6e47..0c1b3066f17 100644
--- a/src/renderer/src/lib/agent-launch-caller-permissions.test.ts
+++ b/src/renderer/src/lib/agent-launch-caller-permissions.test.ts
@@ -62,7 +62,7 @@ const cases = callerProfileCases()
 
 async function launch(profile: AgentLaunchCallerProfile) {
   const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
-  return launchAgentInNewTab({ ...profile.args })
+  return launchAgentInNewTab({ requestId: 'request-1', ...profile.args })
 }
 
 describe('agent launch caller arguments and permission bypass', () => {
@@ -116,7 +116,7 @@ describe('agent launch caller arguments and permission bypass', () => {
     async (agent, _mode, bypassFlag) => {
       const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-      launchAgentInNewTab({ agent, worktreeId: 'wt-1' })
+      launchAgentInNewTab({ requestId: 'request-2', agent, worktreeId: 'wt-1' })
 
       expect(queuedStartupCommand(store)).toContain(bypassFlag)
     }
@@ -128,7 +128,7 @@ describe('agent launch caller arguments and permission bypass', () => {
       store.settings = { ...store.settings, agentDefaultArgs: { [agent]: '' } }
       const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-      launchAgentInNewTab({ agent, worktreeId: 'wt-1' })
+      launchAgentInNewTab({ requestId: 'request-3', agent, worktreeId: 'wt-1' })
 
       // A stored empty string owns the key, so it beats the shipped bypass default.
       expect(queuedStartupCommand(store)).not.toContain(bypassFlag)
@@ -138,7 +138,7 @@ describe('agent launch caller arguments and permission bypass', () => {
   it('carries a bypass posture that lives in the environment rather than in argv', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'goose', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-4', agent: 'goose', worktreeId: 'wt-1' })
 
     // Goose has no bypass flag; its default posture is an env var, and a migration that carried
     // only argv would silently downgrade it.
@@ -148,7 +148,12 @@ describe('agent launch caller arguments and permission bypass', () => {
   it('restores the shipped bypass default when a caller passes agentArgs as undefined', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1', agentArgs: undefined })
+    launchAgentInNewTab({
+      requestId: 'request-5',
+      agent: 'codex',
+      worktreeId: 'wt-1',
+      agentArgs: undefined
+    })
 
     // Characterized, not endorsed: an explicit `undefined` is indistinguishable from an omitted
     // key here, so a caller that resolved "apply no saved arguments" to `undefined` gets the
@@ -160,7 +165,12 @@ describe('agent launch caller arguments and permission bypass', () => {
   it('launches without any arguments when a caller passes agentArgs as null', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1', agentArgs: null })
+    launchAgentInNewTab({
+      requestId: 'request-6',
+      agent: 'codex',
+      worktreeId: 'wt-1',
+      agentArgs: null
+    })
 
     expect(queuedStartupCommand(store)).toBe('codex')
     expect(queuedStartupPayload(store)?.agentArgsOverride).toBeNull()
@@ -170,7 +180,12 @@ describe('agent launch caller arguments and permission bypass', () => {
     store.settings = { ...store.settings, agentDefaultArgs: { codex: '--model stored' } }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1', agentArgs: '--model per-launch' })
+    launchAgentInNewTab({
+      requestId: 'request-7',
+      agent: 'codex',
+      worktreeId: 'wt-1',
+      agentArgs: '--model per-launch'
+    })
 
     expect(queuedStartupCommand(store)).toBe("codex '--model' 'per-launch'")
   })
@@ -179,7 +194,7 @@ describe('agent launch caller arguments and permission bypass', () => {
     store.settings = { ...store.settings, agentDefaultEnv: { codex: { CODEX_PROFILE: 'team' } } }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-8', agent: 'codex', worktreeId: 'wt-1' })
 
     const payload = queuedStartupPayload(store)
     expect(payload?.env).toEqual({ CODEX_PROFILE: 'team' })
@@ -200,7 +215,11 @@ describe('agent launch caller arguments and permission bypass', () => {
     }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-9',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
 
     expect(result?.startupPlan.sessionOptions).toEqual({
       model: 'gpt-5.2-codex',
@@ -221,7 +240,11 @@ describe('agent launch caller arguments and permission bypass', () => {
     }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-10',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
 
     expect(result?.startupPlan.sessionOptions).toBeUndefined()
     expect(queuedStartupCommand(store)).not.toContain("'-m'")
diff --git a/src/renderer/src/lib/agent-launch-caller-placement.test.ts b/src/renderer/src/lib/agent-launch-caller-placement.test.ts
index 03db8a68367..9cc4fedab4c 100644
--- a/src/renderer/src/lib/agent-launch-caller-placement.test.ts
+++ b/src/renderer/src/lib/agent-launch-caller-placement.test.ts
@@ -50,7 +50,7 @@ const cases = callerProfileCases()
 
 async function launch(profile: AgentLaunchCallerProfile) {
   const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
-  return launchAgentInNewTab({ ...profile.args })
+  return launchAgentInNewTab({ requestId: 'request-1', ...profile.args })
 }
 
 describe('agent launch caller placement and telemetry', () => {
@@ -138,7 +138,7 @@ describe('agent launch caller placement and telemetry', () => {
   it('creates the tab before queueing its startup command', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-2', agent: 'codex', worktreeId: 'wt-1' })
 
     // Why: the terminal pane snapshots pending startup in useState on first render, so a startup
     // queued after mount is never seen.
@@ -150,7 +150,12 @@ describe('agent launch caller placement and telemetry', () => {
   it('seeds working status for a Command Code prompt that rides argv', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'command-code', worktreeId: 'wt-1', prompt: 'fix the spinner' })
+    launchAgentInNewTab({
+      requestId: 'request-3',
+      agent: 'command-code',
+      worktreeId: 'wt-1',
+      prompt: 'fix the spinner'
+    })
 
     expect(queuedStartupPayload(store)?.initialAgentStatus).toEqual({
       agent: 'command-code',
@@ -161,7 +166,12 @@ describe('agent launch caller placement and telemetry', () => {
   it('leaves initial agent status unset for every other argv prompt launch', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1', prompt: 'fix the spinner' })
+    launchAgentInNewTab({
+      requestId: 'request-4',
+      agent: 'codex',
+      worktreeId: 'wt-1',
+      prompt: 'fix the spinner'
+    })
 
     expect(queuedStartupPayload(store)).not.toHaveProperty('initialAgentStatus')
   })
diff --git a/src/renderer/src/lib/agent-launch-caller-profiles-test-harness.ts b/src/renderer/src/lib/agent-launch-caller-profiles-test-harness.ts
index a988e1673f5..37a39fc35de 100644
--- a/src/renderer/src/lib/agent-launch-caller-profiles-test-harness.ts
+++ b/src/renderer/src/lib/agent-launch-caller-profiles-test-harness.ts
@@ -8,9 +8,10 @@ import type { LaunchAgentInNewTabArgs } from '@/lib/launch-agent-in-new-tab'
  * module graphs: a migration rewrites the funnel's internals, not what a caller hands it, so the
  * observable outcome of each caller's argument shape is the thing that must survive.
  */
+/** Each call site mints its own request id, so a profile carries none. */
 export type CallerLaunchArgs = Omit<
   LaunchAgentInNewTabArgs,
-  'beforeSurfaceOpen' | 'agentSessionLaunchPlan' | 'onPromptDelivered'
+  'beforeSurfaceOpen' | 'agentSessionLaunchPlan' | 'onPromptDelivered' | 'requestId'
 >
 
 export type AgentLaunchCallerProfile = {
diff --git a/src/renderer/src/lib/agent-launch-caller-prompt-transport.test.ts b/src/renderer/src/lib/agent-launch-caller-prompt-transport.test.ts
index 4b03a9867be..ed8d689c90d 100644
--- a/src/renderer/src/lib/agent-launch-caller-prompt-transport.test.ts
+++ b/src/renderer/src/lib/agent-launch-caller-prompt-transport.test.ts
@@ -129,7 +129,7 @@ const cases = callerProfileCases()
 
 async function launch(profile: AgentLaunchCallerProfile) {
   const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
-  return launchAgentInNewTab({ ...profile.args })
+  return launchAgentInNewTab({ requestId: 'request-1', ...profile.args })
 }
 
 describe('agent launch caller prompt transport', () => {
@@ -181,7 +181,11 @@ describe('agent launch caller prompt transport', () => {
     const onPromptDelivered = vi.fn()
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ ...profile.args, onPromptDelivered })
+    const result = launchAgentInNewTab({
+      requestId: 'request-2',
+      ...profile.args,
+      onPromptDelivered
+    })
     await result?.promptDeliveryResult
 
     if (profile.args.prompt === undefined) {
@@ -199,6 +203,7 @@ describe('agent launch caller prompt transport', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-3',
       agent: row.agent,
       worktreeId: 'wt-1',
       prompt: PROMPT,
@@ -226,6 +231,7 @@ describe('agent launch caller prompt transport', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-4',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: PROMPT,
@@ -241,6 +247,7 @@ describe('agent launch caller prompt transport', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-5',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: '   \n  ',
@@ -257,6 +264,7 @@ describe('agent launch caller prompt transport', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-6',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: PROMPT,
diff --git a/src/renderer/src/lib/agent-launch-caller-routing.test.ts b/src/renderer/src/lib/agent-launch-caller-routing.test.ts
index d67258b7a1e..34d8b12e040 100644
--- a/src/renderer/src/lib/agent-launch-caller-routing.test.ts
+++ b/src/renderer/src/lib/agent-launch-caller-routing.test.ts
@@ -90,7 +90,7 @@ const cases = callerProfileCases()
 
 async function launch(profile: AgentLaunchCallerProfile) {
   const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
-  return launchAgentInNewTab({ ...profile.args })
+  return launchAgentInNewTab({ requestId: 'request-1', ...profile.args })
 }
 
 describe('agent launch caller routing', () => {
@@ -200,7 +200,11 @@ describe('agent launch caller routing', () => {
       cancel: vi.fn()
     })
 
-    const result = launchAgentInNewTab({ agent: 'claude', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-2',
+      agent: 'claude',
+      worktreeId: 'wt-1'
+    })
 
     // The server admits the chat before any of it exists here, so the surface is the host's.
     expect(result?.surface.kind).toBe('host-published')
@@ -227,6 +231,7 @@ describe('agent launch caller routing', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-3',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: 'fix the flaky test',
@@ -261,7 +266,11 @@ describe('agent launch caller routing', () => {
     serverReports([])
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'claude', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-4',
+      agent: 'claude',
+      worktreeId: 'wt-1'
+    })
 
     expect(result?.surface).toEqual({ kind: 'host-published' })
     expect(mockLaunchAgentInStructuredNewTab).not.toHaveBeenCalled()
@@ -271,7 +280,12 @@ describe('agent launch caller routing', () => {
     const beforeSurfaceOpen = vi.fn(() => false)
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1', beforeSurfaceOpen })
+    const result = launchAgentInNewTab({
+      requestId: 'request-5',
+      agent: 'codex',
+      worktreeId: 'wt-1',
+      beforeSurfaceOpen
+    })
 
     expect(result).toBeNull()
     expect(beforeSurfaceOpen).toHaveBeenCalledExactlyOnceWith({ kind: 'local-terminal' })
@@ -284,7 +298,12 @@ describe('agent launch caller routing', () => {
     const beforeSurfaceOpen = vi.fn(() => false)
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1', beforeSurfaceOpen })
+    const result = launchAgentInNewTab({
+      requestId: 'request-6',
+      agent: 'codex',
+      worktreeId: 'wt-1',
+      beforeSurfaceOpen
+    })
 
     expect(result).toBeNull()
     expect(beforeSurfaceOpen).toHaveBeenCalledExactlyOnceWith({ kind: 'host-published' })
@@ -296,7 +315,12 @@ describe('agent launch caller routing', () => {
     const beforeSurfaceOpen = vi.fn(() => false)
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1', beforeSurfaceOpen })
+    launchAgentInNewTab({
+      requestId: 'request-7',
+      agent: 'codex',
+      worktreeId: 'wt-1',
+      beforeSurfaceOpen
+    })
 
     // Why: the structured route cannot name its surface before the session id exists, so the
     // funnel wraps the caller's hook and the structured executor decides when to ask.
@@ -314,7 +338,12 @@ describe('agent launch caller routing', () => {
     const beforeSurfaceOpen = vi.fn(() => undefined)
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1', beforeSurfaceOpen })
+    const result = launchAgentInNewTab({
+      requestId: 'request-8',
+      agent: 'codex',
+      worktreeId: 'wt-1',
+      beforeSurfaceOpen
+    })
 
     expect(result?.surface.kind).toBe('local-terminal')
     expect(store.createTab).toHaveBeenCalledTimes(1)
@@ -326,6 +355,7 @@ describe('agent launch caller routing', () => {
     // Why: unbalanced quoting is the real shape behind every caller's "could not build the launch
     // command" toast — the arguments cannot be tokenized, so no surface should be opened at all.
     const result = launchAgentInNewTab({
+      requestId: 'request-9',
       agent: 'codex',
       worktreeId: 'wt-1',
       agentArgs: "--model 'gpt-5.5"
diff --git a/src/renderer/src/lib/agent-launch-request-id.ts b/src/renderer/src/lib/agent-launch-request-id.ts
new file mode 100644
index 00000000000..5caa3807bb5
--- /dev/null
+++ b/src/renderer/src/lib/agent-launch-request-id.ts
@@ -0,0 +1,10 @@
+import { createBrowserUuid } from '@/lib/browser-uuid'
+
+/** Names one user action that starts an agent: a click, a menu pick, a send. Minted once where that
+ *  action is handled and passed down unchanged, so a re-delivery of the action (a double click, a
+ *  caller retrying its own call) is the same request and every other action is a new one. */
+export type AgentLaunchRequestId = string
+
+export function newAgentLaunchRequestId(): AgentLaunchRequestId {
+  return createBrowserUuid()
+}
diff --git a/src/renderer/src/lib/agent-launch-route-connection-fallback.test.ts b/src/renderer/src/lib/agent-launch-route-connection-fallback.test.ts
index 208445bf11c..c87c594c069 100644
--- a/src/renderer/src/lib/agent-launch-route-connection-fallback.test.ts
+++ b/src/renderer/src/lib/agent-launch-route-connection-fallback.test.ts
@@ -41,17 +41,19 @@ describe('launch route transcript readability', () => {
       buildAgentLaunchRouteInput(store, { agent: 'grok', workspace: WORKSPACE })
         .nativeChatTranscriptIsLocalReadable
     ).toBe(true)
-    expect(planAgentSessionLaunch(store, { agent: 'grok', workspace: WORKSPACE }).route).toBe(
-      'legacy-native-chat'
-    )
+    expect(
+      planAgentSessionLaunch(store, { requestId: 'request-1', agent: 'grok', workspace: WORKSPACE })
+        .route
+    ).toBe('legacy-native-chat')
   })
 
   it('keeps a remote repo off native chat through the same fallback', () => {
     const store = storeWithAmbiguousWorktreeRows('build-box')
 
-    expect(planAgentSessionLaunch(store, { agent: 'grok', workspace: WORKSPACE }).route).toBe(
-      'terminal-tui'
-    )
+    expect(
+      planAgentSessionLaunch(store, { requestId: 'request-2', agent: 'grok', workspace: WORKSPACE })
+        .route
+    ).toBe('terminal-tui')
   })
 
   it('has no repo to fall back to when the workspace names none', () => {
@@ -59,6 +61,7 @@ describe('launch route transcript readability', () => {
 
     expect(
       planAgentSessionLaunch(store, {
+        requestId: 'request-3',
         agent: 'grok',
         workspace: { kind: 'git-worktree', worktreeId: WORKTREE_ID }
       }).route
diff --git a/src/renderer/src/lib/agent-launch-route-input.test.ts b/src/renderer/src/lib/agent-launch-route-input.test.ts
index 900a5b1fa42..b78a9c12740 100644
--- a/src/renderer/src/lib/agent-launch-route-input.test.ts
+++ b/src/renderer/src/lib/agent-launch-route-input.test.ts
@@ -53,7 +53,7 @@ import {
 } from './agent-session-launch-plan'
 
 const routeFor = (appStore: AgentLaunchRouteStore, args: AgentLaunchRouteArgs) =>
-  planAgentSessionLaunch(appStore, args).route
+  planAgentSessionLaunch(appStore, { ...args, requestId: 'route-check' }).route
 const structuredFeasibleFor = (appStore: AgentLaunchRouteStore, args: AgentLaunchRouteArgs) =>
   structuredAgentSessionLaunchFeasible(appStore, { ...args, settings: STRUCTURED_SETTINGS })
 
diff --git a/src/renderer/src/lib/agent-session-launch-plan.test.ts b/src/renderer/src/lib/agent-session-launch-plan.test.ts
index d8a634dc578..9e8ba3902fd 100644
--- a/src/renderer/src/lib/agent-session-launch-plan.test.ts
+++ b/src/renderer/src/lib/agent-session-launch-plan.test.ts
@@ -44,6 +44,7 @@ describe('planAgentSessionLaunch', () => {
 
   it('decides the route once, from the builder input, and never again on launch', async () => {
     const plan = planAgentSessionLaunch(store, {
+      requestId: 'request-1',
       agent: 'codex',
       workspace: { kind: 'git-worktree', worktreeId: 'wt-1' },
       prompt: 'Fix it',
@@ -64,10 +65,11 @@ describe('planAgentSessionLaunch', () => {
     expect(mocks.resolveAgentLaunchRoute).toHaveBeenCalledOnce()
   })
 
-  it('hands the settle loop exactly the prompt, mode, resume source, and delivery hook it planned on', async () => {
+  it('hands the settle loop exactly the request, prompt, mode, resume source, and delivery hook it planned on', async () => {
     const onPromptDelivered = vi.fn()
     const resumeFrom = { providerSessionId: 'provider-1' }
     const plan = planAgentSessionLaunch(store, {
+      requestId: 'request-2',
       agent: 'claude',
       workspace: { kind: 'folder', worktreeId: 'folder:ws-1' },
       prompt: 'Review this',
@@ -81,6 +83,7 @@ describe('planAgentSessionLaunch', () => {
       'folder:ws-1',
       'claude',
       {
+        requestId: 'request-2',
         prompt: 'Review this',
         promptDelivery: 'submit-after-ready',
         resumeFrom,
@@ -94,6 +97,7 @@ describe('planAgentSessionLaunch', () => {
 
   it('sends no delivery fields the request did not carry', async () => {
     const plan = planAgentSessionLaunch(store, {
+      requestId: 'request-3',
       agent: 'codex',
       workspace: { kind: 'folder', worktreeId: 'folder:ws-1' }
     })
@@ -102,13 +106,14 @@ describe('planAgentSessionLaunch', () => {
     expect(mocks.beginStructuredAgentLaunchSettlement).toHaveBeenCalledWith(
       'folder:ws-1',
       'codex',
-      { executionHostId: 'local' },
+      { requestId: 'request-3', executionHostId: 'local' },
       hooks
     )
   })
 
   it('returns null for an agent that cannot hold a structured session even on the structured route', async () => {
     const plan = planAgentSessionLaunch(store, {
+      requestId: 'request-4',
       agent: 'gemini',
       workspace: { kind: 'git-worktree', worktreeId: 'wt-1' }
     })
@@ -120,6 +125,7 @@ describe('planAgentSessionLaunch', () => {
 
   it('launches into the workspace created after planning when the target names one', async () => {
     const plan = planAgentSessionLaunch(store, {
+      requestId: 'request-5',
       agent: 'codex',
       workspace: { kind: 'git-worktree', repoId: 'repo-1' },
       prompt: 'Fix it',
@@ -130,13 +136,19 @@ describe('planAgentSessionLaunch', () => {
     expect(mocks.beginStructuredAgentLaunchSettlement).toHaveBeenCalledWith(
       'wt-created',
       'codex',
-      { prompt: 'Fix it', promptDelivery: 'auto-submit', executionHostId: 'local' },
+      {
+        requestId: 'request-5',
+        prompt: 'Fix it',
+        promptDelivery: 'auto-submit',
+        executionHostId: 'local'
+      },
       hooks
     )
   })
 
   it('refuses to launch a prospective workspace that was never created', async () => {
     const plan = planAgentSessionLaunch(store, {
+      requestId: 'request-6',
       agent: 'codex',
       workspace: { kind: 'git-worktree', repoId: 'repo-1' }
     })
@@ -198,6 +210,7 @@ describe('adoptAgentSessionLaunchVerdict', () => {
 
   it('re-enters a persisted verdict without resolving the route again', async () => {
     const plan = adoptAgentSessionLaunchVerdict({
+      requestId: 'request-7',
       route: 'structured-native-chat',
       agent: 'codex',
       prompt: 'Fix it',
@@ -212,13 +225,14 @@ describe('adoptAgentSessionLaunchVerdict', () => {
     expect(mocks.beginStructuredAgentLaunchSettlement).toHaveBeenCalledWith(
       'wt-recovered',
       'codex',
-      { prompt: 'Fix it', promptDelivery: 'draft' },
+      { requestId: 'request-7', prompt: 'Fix it', promptDelivery: 'draft' },
       hooks
     )
   })
 
   it('keeps a non-structured verdict out of the loop', async () => {
     const plan = adoptAgentSessionLaunchVerdict({
+      requestId: 'request-8',
       route: 'terminal-tui',
       agent: 'codex',
       worktreeId: 'wt-1'
diff --git a/src/renderer/src/lib/agent-session-launch-plan.ts b/src/renderer/src/lib/agent-session-launch-plan.ts
index d4fa18551d4..070b147faa9 100644
--- a/src/renderer/src/lib/agent-session-launch-plan.ts
+++ b/src/renderer/src/lib/agent-session-launch-plan.ts
@@ -24,8 +24,11 @@ import {
   type StructuredAgentLaunchSettlement
 } from '@/lib/structured-agent-launch-settlement'
 import type { StructuredAgentLaunchOptions } from '@/lib/structured-agent-session-launch'
+import type { AgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 
 export type AgentSessionLaunchRequest = AgentLaunchRouteArgs & {
+  /** The user action this launch serves, minted where that action is handled. */
+  requestId: AgentLaunchRequestId
   resumeFrom?: StructuredAgentSessionResumeSource
   onPromptDelivered?: () => void
 }
@@ -37,6 +40,8 @@ export type AgentSessionLaunchRequest = AgentLaunchRouteArgs & {
  */
 export type AgentSessionLaunchVerdict = {
   route: AgentLaunchRoute
+  /** The user action this launch serves; a re-entry with this verdict is that same action. */
+  requestId: AgentLaunchRequestId
   agent: TuiAgent
   worktreeId?: string
   /** The host the structured route was decided for; the chat is created there. */
@@ -60,6 +65,8 @@ export type AgentSessionLaunchTarget = {
   executionHostId?: ExecutionHostId
   /** The saved selection that host said create will seed. */
   seedOptions?: Readonly<Record<string, string>>
+  /** The tab group the chat opens in. */
+  groupId?: string
 }
 
 export type AgentSessionLaunchPlan = Readonly<AgentSessionLaunchVerdict> & {
@@ -77,6 +84,7 @@ export type AgentSessionLaunchPlan = Readonly<AgentSessionLaunchVerdict> & {
 
 function structuredLaunchOptions(verdict: AgentSessionLaunchVerdict): StructuredAgentLaunchOptions {
   return {
+    requestId: verdict.requestId,
     ...(verdict.prompt !== undefined ? { prompt: verdict.prompt } : {}),
     ...(verdict.promptDelivery ? { promptDelivery: verdict.promptDelivery } : {}),
     ...(verdict.resumeFrom ? { resumeFrom: verdict.resumeFrom } : {}),
@@ -105,7 +113,8 @@ function beginStructuredPlanLaunch(
       {
         ...structuredLaunchOptions(verdict),
         ...(executionHostId ? { executionHostId } : {}),
-        ...(target?.seedOptions ? { hostSeedOptions: target.seedOptions } : {})
+        ...(target?.seedOptions ? { hostSeedOptions: target.seedOptions } : {}),
+        ...(target?.groupId ? { targetGroupId: target.groupId } : {})
       },
       hooks
     )
@@ -152,6 +161,14 @@ export function structuredAgentSessionLaunchFeasible(
   return structuredAgentLaunchSupported({ ...buildAgentLaunchRouteInput(store, args), settings })
 }
 
+/** The route a launch would take, for a caller that only branches on it and launches nothing. */
+export function resolveAgentSessionLaunchRoute(
+  store: AgentLaunchRouteStore,
+  request: AgentLaunchRouteArgs
+): AgentLaunchRoute {
+  return resolveAgentLaunchRoute(buildAgentLaunchRouteInput(store, request))
+}
+
 /** The one place a launch route is decided. Delivery mode is fixed here too, so the settle loop
  *  later receives exactly the prompt and mode the route was decided on. */
 export function planAgentSessionLaunch(
@@ -164,6 +181,7 @@ export function planAgentSessionLaunch(
     route === 'structured-native-chat' ? parseExecutionHostId(input.executionHostId)?.id : undefined
   return adoptAgentSessionLaunchVerdict({
     route,
+    requestId: request.requestId,
     agent: request.agent,
     ...(executionHostId ? { executionHostId } : {}),
     ...(request.workspace.worktreeId ? { worktreeId: request.workspace.worktreeId } : {}),
diff --git a/src/renderer/src/lib/codex-account-restart-startup.test.ts b/src/renderer/src/lib/codex-account-restart-startup.test.ts
new file mode 100644
index 00000000000..dd0a7ffb78a
--- /dev/null
+++ b/src/renderer/src/lib/codex-account-restart-startup.test.ts
@@ -0,0 +1,160 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { AgentStatusEntry } from '../../../shared/agent-status-types'
+import { useAppStore } from '@/store'
+import { makePaneKey } from '../../../shared/stable-pane-id'
+import type { ProjectExecutionRuntimeResolution } from '../../../shared/project-execution-runtime'
+import type * as localPreflightContext from '@/lib/local-preflight-context'
+import { buildCodexAccountRestartStartup } from './codex-account-restart-startup'
+
+let projectRuntimeContext: ProjectExecutionRuntimeResolution | undefined
+
+vi.mock('@/lib/local-preflight-context', async (importOriginal) => ({
+  ...(await importOriginal<typeof localPreflightContext>()),
+  getLocalProjectExecutionRuntimeContext: () => projectRuntimeContext
+}))
+
+const TAB_ID = 'tab-1'
+const LEAF_ID = '0195f2ce-1111-4000-8000-000000000001'
+const WORKTREE_ID = 'wt1'
+const SESSION_ID = '01a006a6-1d07-70a1-bad5-f9110d5845c0'
+
+function seedAgentStatus(entry: Partial<AgentStatusEntry> | null): void {
+  const paneKey = makePaneKey(TAB_ID, LEAF_ID)
+  useAppStore.setState({
+    agentStatusByPaneKey: entry
+      ? {
+          [paneKey]: {
+            paneKey,
+            tabId: TAB_ID,
+            state: 'done',
+            prompt: '',
+            updatedAt: 1,
+            stateStartedAt: 1,
+            stateHistory: [],
+            ...entry
+          }
+        }
+      : {},
+    agentLaunchConfigByPaneKey: {},
+    sleepingAgentSessionsByPaneKey: {}
+  })
+}
+
+const build = (): ReturnType<typeof buildCodexAccountRestartStartup> =>
+  buildCodexAccountRestartStartup({ tabId: TAB_ID, leafId: LEAF_ID, worktreeId: WORKTREE_ID })
+
+describe('buildCodexAccountRestartStartup', () => {
+  beforeEach(() => {
+    seedAgentStatus(null)
+    projectRuntimeContext = undefined
+  })
+
+  it('names the session so the relaunch continues the conversation', () => {
+    seedAgentStatus({
+      agentType: 'codex',
+      state: 'done',
+      providerSession: { key: 'session_id', id: SESSION_ID }
+    })
+
+    const startup = build()
+
+    expect(startup.command).toContain('resume')
+    expect(startup.command).toContain(SESSION_ID)
+    expect(startup.resumeProviderSession?.id).toBe(SESSION_ID)
+  })
+
+  it('keeps the account-switch marks that make main repin the launch home', () => {
+    seedAgentStatus({
+      agentType: 'codex',
+      state: 'done',
+      providerSession: { key: 'session_id', id: SESSION_ID }
+    })
+
+    const startup = build()
+
+    expect(startup.launchAgent).toBe('codex')
+    expect(startup.startupCommandDelivery).toBe('shell-ready')
+  })
+
+  it('falls back to a bare relaunch when the pane has no Codex session to name', () => {
+    const startup = build()
+
+    expect(startup.command).toBe('codex')
+    expect(startup.resumeProviderSession).toBeUndefined()
+  })
+
+  it('uses the persisted record when the live status entry is gone', () => {
+    seedAgentStatus(null)
+    useAppStore.setState({
+      sleepingAgentSessionsByPaneKey: {
+        [makePaneKey(TAB_ID, LEAF_ID)]: {
+          paneKey: makePaneKey(TAB_ID, LEAF_ID),
+          worktreeId: WORKTREE_ID,
+          prompt: '',
+          state: 'done',
+          capturedAt: 1,
+          updatedAt: 1,
+          agent: 'codex',
+          providerSession: { key: 'session_id', id: SESSION_ID }
+        }
+      }
+    })
+
+    const startup = build()
+
+    expect(startup.command).toContain(SESSION_ID)
+    expect(startup.resumeProviderSession?.id).toBe(SESSION_ID)
+  })
+
+  it('keeps the bare relaunch for a resolved WSL runtime', () => {
+    seedAgentStatus({
+      agentType: 'codex',
+      state: 'done',
+      providerSession: { key: 'session_id', id: SESSION_ID }
+    })
+    projectRuntimeContext = {
+      status: 'resolved',
+      runtime: {
+        kind: 'wsl',
+        hostPlatform: 'wsl',
+        projectId: 'project-1',
+        distro: 'Ubuntu',
+        reason: 'project-override',
+        cacheKey: 'repo-1:wsl:Ubuntu'
+      }
+    }
+
+    const startup = build()
+
+    expect(startup.command).toBe('codex')
+    expect(startup.resumeProviderSession).toBeUndefined()
+  })
+
+  it('falls back when the pane is running another agent', () => {
+    seedAgentStatus({
+      agentType: 'claude',
+      state: 'done',
+      providerSession: { key: 'session_id', id: SESSION_ID }
+    })
+
+    expect(build().command).toBe('codex')
+  })
+  it('does not resume another agent’s sleeping session when Codex has no session yet', () => {
+    seedAgentStatus({ agentType: 'codex' })
+    useAppStore.setState({
+      sleepingAgentSessionsByPaneKey: {
+        [makePaneKey(TAB_ID, LEAF_ID)]: {
+          paneKey: makePaneKey(TAB_ID, LEAF_ID),
+          worktreeId: WORKTREE_ID,
+          prompt: '',
+          state: 'done',
+          capturedAt: 1,
+          updatedAt: 1,
+          agent: 'claude',
+          providerSession: { key: 'session_id', id: SESSION_ID }
+        }
+      }
+    })
+    expect(build().resumeProviderSession).toBeUndefined()
+  })
+})
diff --git a/src/renderer/src/lib/codex-account-restart-startup.ts b/src/renderer/src/lib/codex-account-restart-startup.ts
new file mode 100644
index 00000000000..cf2d09a180d
--- /dev/null
+++ b/src/renderer/src/lib/codex-account-restart-startup.ts
@@ -0,0 +1,98 @@
+import { useAppStore } from '@/store'
+import { buildAgentResumeStartupPlan } from '@/lib/tui-agent-startup'
+import { resolveAgentResumeLaunchTarget } from '@/lib/agent-resume-launch-target'
+import { getExecutionHostIdForWorktree } from '@/lib/worktree-runtime-owner'
+import { getLocalProjectExecutionRuntimeContext } from '@/lib/local-preflight-context'
+import { makePaneKey } from '../../../shared/stable-pane-id'
+import { normalizeAgentProviderSession } from '../../../shared/agent-session-resume'
+import {
+  resolveTuiAgentLaunchArgs,
+  resolveTuiAgentLaunchEnv
+} from '../../../shared/tui-agent-launch-defaults'
+import type {
+  AgentProviderSessionMetadata,
+  SleepingAgentLaunchConfig
+} from '../../../shared/agent-session-resume'
+import { CODEX_ACCOUNT_RESTART_STARTUP } from './codex-session-restart'
+
+export type CodexAccountRestartStartup = {
+  command: string
+  startupCommandDelivery: 'shell-ready'
+  launchAgent: 'codex'
+  env?: Record<string, string>
+  launchConfig?: SleepingAgentLaunchConfig
+  resumeProviderSession?: AgentProviderSessionMetadata
+}
+
+// Capture the session before restart clears the old pane’s status.
+export function buildCodexAccountRestartStartup(args: {
+  tabId: string
+  leafId: string
+  worktreeId: string
+  shellOverride?: string
+}): CodexAccountRestartStartup {
+  const state = useAppStore.getState()
+  const paneKey = makePaneKey(args.tabId, args.leafId)
+  const entry = state.agentStatusByPaneKey[paneKey]
+  const sleeping = state.sleepingAgentSessionsByPaneKey[paneKey]
+  const agentType = entry?.agentType ?? sleeping?.agent
+  if (agentType !== 'codex') {
+    return CODEX_ACCOUNT_RESTART_STARTUP
+  }
+  const providerSession =
+    normalizeAgentProviderSession(entry?.providerSession) ??
+    normalizeAgentProviderSession(
+      sleeping?.agent === 'codex' ? sleeping.providerSession : undefined
+    )
+  if (!providerSession) {
+    return CODEX_ACCOUNT_RESTART_STARTUP
+  }
+  const projectRuntime = getLocalProjectExecutionRuntimeContext(state, args.worktreeId)
+  if (projectRuntime?.status === 'resolved' && projectRuntime.runtime.kind === 'wsl') {
+    return CODEX_ACCOUNT_RESTART_STARTUP
+  }
+  const worktree = state.getKnownWorktreeById(args.worktreeId)
+  const repo = worktree ? state.repos.find((entry) => entry.id === worktree.repoId) : null
+  const launchConfig =
+    (entry ? state.getAgentLaunchConfigForStatusEntry(entry) : undefined) ??
+    (sleeping?.agent === 'codex' ? sleeping.launchConfig : undefined)
+  const resumeTarget = resolveAgentResumeLaunchTarget({
+    projectRuntime,
+    connectionId: repo?.connectionId,
+    executionHostId: getExecutionHostIdForWorktree(state, args.worktreeId),
+    worktreePath: worktree?.path,
+    terminalWindowsShell: state.settings?.terminalWindowsShell,
+    tabShellOverride: args.shellOverride
+  })
+  const startupPlan = buildAgentResumeStartupPlan({
+    agent: 'codex',
+    providerSession,
+    cmdOverrides: state.settings?.agentCmdOverrides ?? {},
+    agentArgs:
+      launchConfig !== undefined
+        ? launchConfig.agentArgs
+        : resolveTuiAgentLaunchArgs('codex', state.settings?.agentDefaultArgs),
+    agentEnv:
+      launchConfig !== undefined
+        ? launchConfig.agentEnv
+        : resolveTuiAgentLaunchEnv('codex', state.settings?.agentDefaultEnv),
+    ...(launchConfig?.agentCommand ? { agentCommand: launchConfig.agentCommand } : {}),
+    ...(launchConfig?.ompResumeFilePath
+      ? { ompResumeFilePath: launchConfig.ompResumeFilePath }
+      : {}),
+    platform: resumeTarget.platform,
+    shell: resumeTarget.shell
+  })
+  if (!startupPlan) {
+    return CODEX_ACCOUNT_RESTART_STARTUP
+  }
+  return {
+    ...CODEX_ACCOUNT_RESTART_STARTUP,
+    command: startupPlan.launchCommand,
+    ...(startupPlan.env ? { env: startupPlan.env } : {}),
+    launchConfig: startupPlan.launchConfig,
+    // Why it rides along: main only repins the launch home for a spawn that
+    // names the session it is resuming, so dropping this drops the account move.
+    resumeProviderSession: providerSession
+  }
+}
diff --git a/src/renderer/src/lib/empty-workspace-default-agent-chat.ts b/src/renderer/src/lib/empty-workspace-default-agent-chat.ts
index 84156f99927..9bd44e4a2f2 100644
--- a/src/renderer/src/lib/empty-workspace-default-agent-chat.ts
+++ b/src/renderer/src/lib/empty-workspace-default-agent-chat.ts
@@ -11,6 +11,7 @@ import {
 import type { AgentDetectionTarget } from '@/hooks/useDetectedAgents'
 import { workspaceKindForWorktreeId } from '@/lib/agent-launch-route-input'
 import { planAgentSessionLaunch } from '@/lib/agent-session-launch-plan'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
 
 // Why bounded: detection only decides chat vs shell, so a slow host must not hold the workspace empty.
@@ -91,7 +92,9 @@ export function openDefaultAgentChatInEmptyWorkspace(
   if (!agent) {
     return null
   }
+  // No user gesture: opening this empty workspace is the one action this chat serves.
   const agentSessionLaunchPlan = planAgentSessionLaunch(state, {
+    requestId: newAgentLaunchRequestId(),
     agent,
     workspace: { kind: workspaceKindForWorktreeId(worktreeId), worktreeId }
   })
diff --git a/src/renderer/src/lib/execute-open-editor-path-move.test.ts b/src/renderer/src/lib/execute-open-editor-path-move.test.ts
index 76c5bbc1c7e..3798a305445 100644
--- a/src/renderer/src/lib/execute-open-editor-path-move.test.ts
+++ b/src/renderer/src/lib/execute-open-editor-path-move.test.ts
@@ -66,7 +66,12 @@ describe('executeOpenEditorPathMove', () => {
       worktreePath: '/repo'
     })
 
-    expect(mocks.renameRuntimePath).toHaveBeenCalledWith(CONTEXT, '/repo/a.md', '/repo/sub/a.md')
+    expect(mocks.renameRuntimePath).toHaveBeenCalledWith(
+      CONTEXT,
+      '/repo/a.md',
+      '/repo/sub/a.md',
+      undefined
+    )
     const moved = useAppStore.getState().openFiles[0]!
     expect(moved.filePath).toBe('/repo/sub/a.md')
     expect(moved.isDirty).toBe(true)
@@ -79,6 +84,24 @@ describe('executeOpenEditorPathMove', () => {
     expect(__activeEditorPathMoveCountForTests()).toBe(0)
   })
 
+  it('declares the moved file as the document for a document-scoped rename', async () => {
+    openDirtyTab()
+
+    await executeOpenEditorPathMove({
+      context: CONTEXT,
+      fromPath: '/repo/a.md',
+      toPath: '/repo/b.md',
+      worktreeId: 'wt-1',
+      worktreePath: '/repo',
+      documentScoped: true
+    })
+
+    expect(mocks.renameRuntimePath).toHaveBeenCalledWith(CONTEXT, '/repo/a.md', '/repo/b.md', {
+      kind: 'document-folder',
+      documentPath: '/repo/a.md'
+    })
+  })
+
   it('resolves the verify gate proactively when no destination watcher event arrives', async () => {
     const DISK_CONTENT = 'the file as it exists on disk\n'
     const id = openDirtyTab()
@@ -180,12 +203,53 @@ describe('executeOpenEditorPathMove', () => {
     ).rejects.toThrow(/retarget/)
 
     // Forward rename then inverse rename to undo the disk move.
-    expect(mocks.renameRuntimePath).toHaveBeenCalledWith(CONTEXT, '/repo/a.md', '/repo/sub/a.md')
-    expect(mocks.renameRuntimePath).toHaveBeenCalledWith(CONTEXT, '/repo/sub/a.md', '/repo/a.md')
+    expect(mocks.renameRuntimePath).toHaveBeenCalledWith(
+      CONTEXT,
+      '/repo/a.md',
+      '/repo/sub/a.md',
+      undefined
+    )
+    expect(mocks.renameRuntimePath).toHaveBeenCalledWith(
+      CONTEXT,
+      '/repo/sub/a.md',
+      '/repo/a.md',
+      undefined
+    )
     // The stranded source session is left intact (not rekeyed).
     expect(useAppStore.getState().openFiles.map((f) => f.id)).toEqual(before)
   })
 
+  it('undoes a document-scoped rename with the renamed file as the document', async () => {
+    openDirtyTab()
+    useAppStore.getState().openFile(
+      {
+        filePath: '/repo/b.md',
+        relativePath: 'b.md',
+        worktreeId: 'wt-1',
+        runtimeEnvironmentId: null,
+        language: 'markdown',
+        mode: 'edit'
+      },
+      { suppressActiveRuntimeFallback: true }
+    )
+
+    await expect(
+      executeOpenEditorPathMove({
+        context: CONTEXT,
+        fromPath: '/repo/a.md',
+        toPath: '/repo/b.md',
+        worktreeId: 'wt-1',
+        worktreePath: '/repo',
+        documentScoped: true
+      })
+    ).rejects.toThrow(/retarget/)
+
+    expect(mocks.renameRuntimePath).toHaveBeenLastCalledWith(CONTEXT, '/repo/b.md', '/repo/a.md', {
+      kind: 'document-folder',
+      documentPath: '/repo/b.md'
+    })
+  })
+
   it('leaves the store untouched and settles the transaction when the rename fails', async () => {
     openDirtyTab()
     const before = useAppStore.getState().openFiles.map((f) => ({ ...f }))
diff --git a/src/renderer/src/lib/execute-open-editor-path-move.ts b/src/renderer/src/lib/execute-open-editor-path-move.ts
index 09f89194296..ca239902770 100644
--- a/src/renderer/src/lib/execute-open-editor-path-move.ts
+++ b/src/renderer/src/lib/execute-open-editor-path-move.ts
@@ -15,6 +15,7 @@ import {
   getExecutionHostIdForWorktree,
   getRuntimeEnvironmentIdForWorktree
 } from '@/lib/worktree-runtime-owner'
+import { documentFolderAccess } from '@/lib/local-file-access'
 
 let moveOperationCounter = 0
 
@@ -31,6 +32,8 @@ export async function executeOpenEditorPathMove(args: {
   toPath: string
   worktreeId: string
   worktreePath: string
+  /** The moved file is a user-named document: main allows any destination, and the move back. */
+  documentScoped?: boolean
 }): Promise<void> {
   const { context, fromPath, toPath, worktreeId, worktreePath } = args
   const operationId = `editor-move-${(moveOperationCounter += 1)}`
@@ -73,7 +76,12 @@ export async function executeOpenEditorPathMove(args: {
   await Promise.all(affected.map((f) => requestEditorSaveQuiesce({ fileId: f.id })))
 
   try {
-    await renameRuntimePath(context, fromPath, toPath)
+    await renameRuntimePath(
+      context,
+      fromPath,
+      toPath,
+      args.documentScoped ? documentFolderAccess(fromPath) : undefined
+    )
   } catch (err) {
     // Rename never landed — release the source suppression immediately.
     for (const subOperationId of ownerSubOps) {
@@ -107,7 +115,12 @@ export async function executeOpenEditorPathMove(args: {
       // still-open source session isn't stranded pointing at a vanished path.
       let rollbackError: unknown
       try {
-        await renameRuntimePath(context, toPath, fromPath)
+        await renameRuntimePath(
+          context,
+          toPath,
+          fromPath,
+          args.documentScoped ? documentFolderAccess(toPath) : undefined
+        )
       } catch (err) {
         rollbackError = err
       }
diff --git a/src/renderer/src/lib/fix-checks-agent-launch.ts b/src/renderer/src/lib/fix-checks-agent-launch.ts
index 1bfa1b78253..5f6131566f4 100644
--- a/src/renderer/src/lib/fix-checks-agent-launch.ts
+++ b/src/renderer/src/lib/fix-checks-agent-launch.ts
@@ -3,6 +3,7 @@ import { getConnectionId } from '@/lib/connection-context'
 import { focusTerminalTabSurface } from '@/lib/focus-terminal-tab-surface'
 import { findGithubPrWorkspaceAttachment } from '@/lib/github-work-item-workspace-attachment'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { launchWorkItemDirect } from '@/lib/launch-work-item-direct'
 import { getLocalProjectExecutionRuntimeContext } from '@/lib/local-preflight-context'
 import { CLIENT_PLATFORM } from '@/lib/new-workspace'
@@ -188,6 +189,7 @@ export async function startFixChecksAgent(args: StartFixChecksAgentArgs): Promis
     }
     let revealFailed = false
     const result = launchAgentInNewTab({
+      requestId: newAgentLaunchRequestId(),
       agent,
       worktreeId: targetWorktreeId,
       groupId: args.groupId ?? targetWorktreeId,
diff --git a/src/renderer/src/lib/ime-composition-keyboard-event.test.ts b/src/renderer/src/lib/ime-composition-keyboard-event.test.ts
index 74c0ec3cf50..901b2e334cf 100644
--- a/src/renderer/src/lib/ime-composition-keyboard-event.test.ts
+++ b/src/renderer/src/lib/ime-composition-keyboard-event.test.ts
@@ -105,27 +105,57 @@ describe('useImeEnterGestureOwnership', () => {
 
   // Regression: IMEs that report Process/229 for EVERY key (Pinyin) armed the carry on
   // each letter. A non-Enter keyup must disarm it, or a later deliberate Enter is eaten.
-  it('expires the carry a frame after a non-Enter keyup so a later deliberate Enter submits', () => {
+  it.each([
+    { key: '1', keyCode: 49 },
+    { key: 'Process', keyCode: 229 }
+  ])(
+    'expires the carry after candidate selection keyup %j so deliberate Enter submits',
+    (release) => {
+      const { result } = renderHook(() => useImeEnterGestureOwnership())
+      result.current.setComposing(true)
+
+      // Pinyin candidate selection: the last composing key is a digit reported as Process/229.
+      expect(
+        result.current.ownsKeyDown(
+          gestureEvent({ key: 'Process', keyCode: 229, isComposing: true })
+        )
+      ).toBe(true)
+      result.current.setComposing(false)
+      let frame: FrameRequestCallback | undefined
+      const raf = vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => {
+        frame = cb
+        return 1
+      })
+      result.current.onKeyUp(gestureEvent(release))
+      frame?.(0)
+      raf.mockRestore()
+
+      const deliberate = gestureEvent({ key: 'Enter', keyCode: 13 })
+      expect(result.current.ownsKeyDown(deliberate)).toBe(false)
+      expect(deliberate.prevented).toBe(false)
+    }
+  )
+
+  it('keeps a newer gesture owned when an older keyup expires', () => {
     const { result } = renderHook(() => useImeEnterGestureOwnership())
-    result.current.setComposing(true)
-
-    // Pinyin candidate selection: the last composing key is a digit reported as Process/229.
-    expect(
-      result.current.ownsKeyDown(gestureEvent({ key: 'Process', keyCode: 229, isComposing: true }))
-    ).toBe(true)
-    result.current.setComposing(false)
-    let frame: FrameRequestCallback | undefined
-    const raf = vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => {
-      frame = cb
-      return 1
+    const frames: FrameRequestCallback[] = []
+    const raf = vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
+      frames.push(callback)
+      return frames.length
     })
-    result.current.onKeyUp(gestureEvent({ key: '1', keyCode: 49 }))
-    frame?.(0)
-    raf.mockRestore()
+    try {
+      const marked = { key: 'Process', keyCode: 229 }
+      result.current.ownsKeyDown(gestureEvent(marked))
+      result.current.onKeyUp(gestureEvent(marked))
+      result.current.ownsKeyDown(gestureEvent(marked))
+      frames[0]?.(0)
 
-    const deliberate = gestureEvent({ key: 'Enter', keyCode: 13 })
-    expect(result.current.ownsKeyDown(deliberate)).toBe(false)
-    expect(deliberate.prevented).toBe(false)
+      const redispatch = gestureEvent({ key: 'Enter', keyCode: 13 })
+      expect(result.current.ownsKeyDown(redispatch)).toBe(true)
+      expect(redispatch.prevented).toBe(true)
+    } finally {
+      raf.mockRestore()
+    }
   })
 
   // Regression: holding Cmd/Ctrl through a composition confirm dropped the chord submit —
diff --git a/src/renderer/src/lib/ime-composition-keyboard-event.ts b/src/renderer/src/lib/ime-composition-keyboard-event.ts
index 2426c7546b7..f5b3f1661d4 100644
--- a/src/renderer/src/lib/ime-composition-keyboard-event.ts
+++ b/src/renderer/src/lib/ime-composition-keyboard-event.ts
@@ -59,7 +59,7 @@ export function useImeEnterGestureOwnership(): {
       isComposing: () => stateRef.current.composing,
       ownsKeyDown: (event: ImeEnterGestureEvent): boolean => {
         const markedEnter =
-          (event.nativeEvent.isComposing || stateRef.current.composing) &&
+          (isImeOwnedKeyboardEvent(event) || stateRef.current.composing) &&
           (isPlainEnter(event) ||
             (event.key === 'Enter' && event.keyCode === 229) ||
             (event.key === 'Process' && event.keyCode === 229))
@@ -67,6 +67,14 @@ export function useImeEnterGestureOwnership(): {
           stateRef.current.pendingEnter = {}
           return true
         }
+        // Continued typing ends the confirmation even when hidden renderers delay the frame.
+        if (
+          !stateRef.current.composing &&
+          !isImeOwnedKeyboardEvent(event) &&
+          !['Enter', 'Shift', 'Control', 'Alt', 'Meta'].includes(event.key)
+        ) {
+          stateRef.current.pendingEnter = null
+        }
         if (
           stateRef.current.pendingEnter &&
           isPlainEnter(event) &&
@@ -83,18 +91,8 @@ export function useImeEnterGestureOwnership(): {
         }
         return false
       },
-      onKeyUp: (event: ImeEnterGestureEvent): void => {
-        // A Process/229 keyup means the IME finished without redispatching, so the
-        // gesture is over immediately.
-        if (event.key === 'Process' && event.keyCode === 229) {
-          stateRef.current.pendingEnter = null
-          return
-        }
-        // Every other keyup expires on the NEXT FRAME, never synchronously. Enter/13
-        // because macOS delivers keyup before the unmarked redispatch; anything else
-        // because IMEs reporting Process/229 on every key (Pinyin candidate selection)
-        // release a non-Enter key, and a Process-only clear left the carry armed and ate
-        // the user's next real Enter.
+      onKeyUp: (): void => {
+        // Any keyup can precede the redispatch, including an IME-owned Process/229 release.
         const pendingEnter = stateRef.current.pendingEnter
         if (pendingEnter) {
           requestAnimationFrame(() => {
diff --git a/src/renderer/src/lib/ime-overlay-escape.test.tsx b/src/renderer/src/lib/ime-overlay-escape.test.tsx
new file mode 100644
index 00000000000..5212e37b9ef
--- /dev/null
+++ b/src/renderer/src/lib/ime-overlay-escape.test.tsx
@@ -0,0 +1,120 @@
+// @vitest-environment happy-dom
+import type { ReactNode } from 'react'
+import { cleanup, fireEvent, render } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { Dialog, DialogContent, DialogTitle } from '@/components/ui/dialog'
+import { Sheet, SheetContent, SheetTitle } from '@/components/ui/sheet'
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuTrigger
+} from '@/components/ui/dropdown-menu'
+import { CommandDialog, CommandInput } from '@/components/ui/command'
+import { ContextMenu, ContextMenuContent, ContextMenuTrigger } from '@/components/ui/context-menu'
+import { Input } from '@/components/ui/input'
+import { handleImeOverlayEscape } from './ime-overlay-escape'
+
+afterEach(cleanup)
+
+type OverlayProps = {
+  children: ReactNode
+  onOpenChange: (open: boolean) => void
+  onEscapeKeyDown: (event: KeyboardEvent) => void
+}
+const overlays = {
+  Dialog: ({ children, onOpenChange, onEscapeKeyDown }: OverlayProps) => (
+    <Dialog open onOpenChange={onOpenChange}>
+      <DialogContent aria-describedby={undefined} onEscapeKeyDown={onEscapeKeyDown}>
+        <DialogTitle>Rename</DialogTitle>
+        {children}
+      </DialogContent>
+    </Dialog>
+  ),
+  Sheet: ({ children, onOpenChange, onEscapeKeyDown }: OverlayProps) => (
+    <Sheet open onOpenChange={onOpenChange}>
+      <SheetContent aria-describedby={undefined} onEscapeKeyDown={onEscapeKeyDown}>
+        <SheetTitle>Rename</SheetTitle>
+        {children}
+      </SheetContent>
+    </Sheet>
+  ),
+  Popover: ({ children, onOpenChange, onEscapeKeyDown }: OverlayProps) => (
+    <Popover open onOpenChange={onOpenChange}>
+      <PopoverTrigger>Open</PopoverTrigger>
+      <PopoverContent onEscapeKeyDown={onEscapeKeyDown}>{children}</PopoverContent>
+    </Popover>
+  ),
+  DropdownMenu: ({ children, onOpenChange, onEscapeKeyDown }: OverlayProps) => (
+    <DropdownMenu open onOpenChange={onOpenChange}>
+      <DropdownMenuTrigger>Open</DropdownMenuTrigger>
+      <DropdownMenuContent onEscapeKeyDown={onEscapeKeyDown}>{children}</DropdownMenuContent>
+    </DropdownMenu>
+  )
+}
+
+describe.each(Object.entries(overlays))('%s IME Escape', (_name, Overlay) => {
+  it.each([{ isComposing: true, keyCode: 27 }, { keyCode: 229 }])(
+    'keeps the overlay open while cancelling a candidate: %j',
+    (marker) => {
+      const changed = vi.fn(),
+        escape = vi.fn()
+      const { getByRole } = render(
+        <Overlay onOpenChange={changed} onEscapeKeyDown={escape}>
+          <Input />
+        </Overlay>
+      )
+      const field = getByRole('textbox')
+      fireEvent.compositionStart(field)
+      fireEvent.keyDown(field, { key: 'Escape', ...marker })
+      expect(changed).not.toHaveBeenCalled()
+      expect(escape).not.toHaveBeenCalled()
+      fireEvent.compositionEnd(field)
+      fireEvent.keyDown(field, { key: 'Escape', keyCode: 27 })
+      expect(escape).toHaveBeenCalledOnce()
+      expect(changed).toHaveBeenCalledExactlyOnceWith(false)
+    }
+  )
+})
+
+it('keeps command dialogs open on IME Escape and dismisses on ordinary Escape', () => {
+  const changed = vi.fn()
+  const { getByRole } = render(
+    <CommandDialog open onOpenChange={changed}>
+      <CommandInput />
+    </CommandDialog>
+  )
+  fireEvent.keyDown(getByRole('combobox'), { key: 'Escape', keyCode: 229 })
+  expect(changed).not.toHaveBeenCalled()
+  fireEvent.keyDown(getByRole('combobox'), { key: 'Escape', keyCode: 27 })
+  expect(changed).toHaveBeenCalledExactlyOnceWith(false)
+})
+
+it('preserves caller cancellation of ordinary Escape', () => {
+  const event = new KeyboardEvent('keydown', { key: 'Escape', cancelable: true })
+  const escape = vi.fn((event: KeyboardEvent) => event.preventDefault())
+  handleImeOverlayEscape(event, escape)
+  expect(escape).toHaveBeenCalledExactlyOnceWith(event)
+  expect(event.defaultPrevented).toBe(true)
+})
+
+it('keeps a context menu field open on IME Escape', () => {
+  const changed = vi.fn(),
+    escape = vi.fn()
+  const { getByRole, getByText } = render(
+    <ContextMenu onOpenChange={changed}>
+      <ContextMenuTrigger>Open menu</ContextMenuTrigger>
+      <ContextMenuContent onEscapeKeyDown={escape}>
+        <Input />
+      </ContextMenuContent>
+    </ContextMenu>
+  )
+  fireEvent.contextMenu(getByText('Open menu'))
+  changed.mockClear()
+  fireEvent.keyDown(getByRole('textbox'), { key: 'Escape', keyCode: 229 })
+  expect(changed).not.toHaveBeenCalled()
+  expect(escape).not.toHaveBeenCalled()
+  fireEvent.keyDown(getByRole('textbox'), { key: 'Escape', keyCode: 27 })
+  expect(escape).toHaveBeenCalledOnce()
+  expect(changed).toHaveBeenCalledExactlyOnceWith(false)
+})
diff --git a/src/renderer/src/lib/ime-overlay-escape.ts b/src/renderer/src/lib/ime-overlay-escape.ts
new file mode 100644
index 00000000000..c1202d6a030
--- /dev/null
+++ b/src/renderer/src/lib/ime-overlay-escape.ts
@@ -0,0 +1,13 @@
+import { isImeOwnedKeyboardEvent } from './ime-composition-keyboard-event'
+
+/** Overlay dismissal runs in document capture, before a text field can stop propagation. */
+export function handleImeOverlayEscape(
+  event: KeyboardEvent,
+  onEscapeKeyDown?: (event: KeyboardEvent) => void
+): void {
+  if (isImeOwnedKeyboardEvent(event)) {
+    event.preventDefault()
+    return
+  }
+  onEscapeKeyDown?.(event)
+}
diff --git a/src/renderer/src/lib/ime-text-field.test.tsx b/src/renderer/src/lib/ime-text-field.test.tsx
new file mode 100644
index 00000000000..f32fc09928e
--- /dev/null
+++ b/src/renderer/src/lib/ime-text-field.test.tsx
@@ -0,0 +1,135 @@
+// @vitest-environment happy-dom
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, fireEvent, render } from '@testing-library/react'
+import { Input } from '@/components/ui/input'
+import { Textarea } from '@/components/ui/textarea'
+import { Command, CommandInput, CommandItem, CommandList } from '@/components/ui/command'
+import { ImeInput, ImeTextarea } from './ime-text-field'
+
+beforeEach(() => vi.useFakeTimers())
+afterEach(() => {
+  cleanup()
+  vi.useRealTimers()
+})
+
+const enter = { key: 'Enter', keyCode: 13 }
+
+describe.each([Input, Textarea, ImeInput, ImeTextarea])('IME text field %s', (Field) => {
+  it.each([
+    { marked: { key: 'Enter', keyCode: 13, isComposing: true }, release: enter },
+    { marked: { key: 'Enter', keyCode: 229 }, release: enter },
+    { marked: { key: 'Process', keyCode: 229 }, release: enter },
+    {
+      marked: { key: 'Process', keyCode: 229 },
+      release: { key: 'Process', keyCode: 229 }
+    }
+  ])(
+    'keeps a marked confirmation and its redispatch out of field and parent actions: %j',
+    ({ marked, release }) => {
+      const action = vi.fn()
+      const parentAction = vi.fn()
+      const { getByRole } = render(
+        <div onKeyDown={parentAction}>
+          <Field onKeyDown={action} />
+        </div>
+      )
+      const field = getByRole('textbox')
+      expect(fireEvent.keyDown(field, marked)).toBe(true)
+      fireEvent.keyUp(field, release)
+      expect(fireEvent.keyDown(field, enter)).toBe(false)
+      expect(action).not.toHaveBeenCalled()
+      expect(parentAction).not.toHaveBeenCalled()
+      vi.advanceTimersByTime(20)
+      fireEvent.keyDown(field, enter)
+      expect(action).toHaveBeenCalledOnce()
+      expect(parentAction).toHaveBeenCalledOnce()
+    }
+  )
+
+  it('guards active composition, preserves lifecycle callbacks, and releases on blur', () => {
+    const action = vi.fn()
+    const start = vi.fn(),
+      end = vi.fn(),
+      blur = vi.fn(),
+      up = vi.fn()
+    const { getByRole } = render(
+      <Field
+        onKeyDown={action}
+        onCompositionStart={start}
+        onCompositionEnd={end}
+        onBlur={blur}
+        onKeyUp={up}
+      />
+    )
+    const field = getByRole('textbox')
+    fireEvent.compositionStart(field)
+    for (const key of ['Enter', 'Escape', 'ArrowDown']) {
+      expect(fireEvent.keyDown(field, { key, keyCode: key === 'Enter' ? 13 : 0 })).toBe(true)
+    }
+    expect(action).not.toHaveBeenCalled()
+    fireEvent.compositionEnd(field)
+    fireEvent.keyUp(field, enter)
+    fireEvent.blur(field)
+    fireEvent.keyDown(field, enter)
+    expect(action).toHaveBeenCalledOnce()
+    for (const callback of [start, end, blur, up]) {
+      expect(callback).toHaveBeenCalledOnce()
+    }
+  })
+
+  it('preserves ordinary keys, Shift+Enter, and modifier submits after a confirmation', () => {
+    const action = vi.fn()
+    const { getByRole } = render(<Field onKeyDown={action} />)
+    const field = getByRole('textbox')
+    fireEvent.keyDown(field, { ...enter, keyCode: 229 })
+    expect(fireEvent.keyDown(field, { ...enter, shiftKey: true })).toBe(true)
+    expect(fireEvent.keyDown(field, { ...enter, ctrlKey: true })).toBe(true)
+    fireEvent.keyDown(field, { key: 'Escape' })
+    fireEvent.keyDown(field, { key: 'a' })
+    expect(action).toHaveBeenCalledTimes(4)
+  })
+
+  it('does not carry ownership into a replaced field', () => {
+    const action = vi.fn()
+    const { getByRole, rerender } = render(<Field key="first" onKeyDown={action} />)
+    fireEvent.compositionStart(getByRole('textbox'))
+    fireEvent.keyDown(getByRole('textbox'), { ...enter, keyCode: 229 })
+    rerender(<Field key="second" onKeyDown={action} />)
+    fireEvent.keyDown(getByRole('textbox'), enter)
+    expect(action).toHaveBeenCalledOnce()
+  })
+
+  it('accepts deliberate Enter after continued typing without waiting for a frame', () => {
+    const action = vi.fn()
+    const { getByRole } = render(<Field onKeyDown={action} />)
+    const field = getByRole('textbox')
+    fireEvent.keyDown(field, { ...enter, keyCode: 229 })
+    fireEvent.keyUp(field, enter)
+    fireEvent.keyDown(field, { key: '.', keyCode: 190 })
+    fireEvent.keyUp(field, { key: '.', keyCode: 190 })
+    fireEvent.keyDown(field, enter)
+    expect(action).toHaveBeenCalledTimes(2)
+  })
+})
+
+it('does not select a command when Enter confirms an IME candidate', () => {
+  const select = vi.fn()
+  const { getByRole } = render(
+    <Command>
+      <CommandInput />
+      <CommandList>
+        <CommandItem value="item" onSelect={select}>
+          Item
+        </CommandItem>
+      </CommandList>
+    </Command>
+  )
+  const field = getByRole('combobox')
+  fireEvent.keyDown(field, { ...enter, keyCode: 229 })
+  fireEvent.keyDown(field, enter)
+  expect(select).not.toHaveBeenCalled()
+  fireEvent.keyUp(field, enter)
+  vi.advanceTimersByTime(20)
+  fireEvent.keyDown(field, enter)
+  expect(select).toHaveBeenCalledOnce()
+})
diff --git a/src/renderer/src/lib/ime-text-field.tsx b/src/renderer/src/lib/ime-text-field.tsx
new file mode 100644
index 00000000000..c00880ae5fa
--- /dev/null
+++ b/src/renderer/src/lib/ime-text-field.tsx
@@ -0,0 +1,47 @@
+import type { ComponentProps, HTMLAttributes } from 'react'
+import {
+  isImeOwnedKeyboardEvent,
+  useImeEnterGestureOwnership
+} from './ime-composition-keyboard-event'
+
+/** Keeps candidate keys out of field actions and bubbling form shortcuts. */
+export function useImeTextFieldProps<T extends HTMLInputElement | HTMLTextAreaElement>(
+  props: HTMLAttributes<T>
+): HTMLAttributes<T> {
+  const ime = useImeEnterGestureOwnership()
+  return {
+    onKeyDown(event) {
+      if (ime.ownsKeyDown(event) || ime.isComposing() || isImeOwnedKeyboardEvent(event)) {
+        event.stopPropagation()
+        return
+      }
+      props.onKeyDown?.(event)
+    },
+    onKeyUp(event) {
+      ime.onKeyUp(event)
+      props.onKeyUp?.(event)
+    },
+    onCompositionStart(event) {
+      ime.setComposing(true)
+      props.onCompositionStart?.(event)
+    },
+    onCompositionEnd(event) {
+      ime.setComposing(false)
+      props.onCompositionEnd?.(event)
+    },
+    onBlur(event) {
+      ime.reset()
+      props.onBlur?.(event)
+    }
+  }
+}
+
+export function ImeInput(props: ComponentProps<'input'>): React.JSX.Element {
+  const imeProps = useImeTextFieldProps<HTMLInputElement>(props)
+  return <input {...props} {...imeProps} />
+}
+
+export function ImeTextarea(props: ComponentProps<'textarea'>): React.JSX.Element {
+  const imeProps = useImeTextFieldProps<HTMLTextAreaElement>(props)
+  return <textarea {...props} {...imeProps} />
+}
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab-cwd.test.ts b/src/renderer/src/lib/launch-agent-in-new-tab-cwd.test.ts
index fe71309d144..3ede1d0394b 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab-cwd.test.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab-cwd.test.ts
@@ -78,6 +78,7 @@ describe('launchAgentInNewTab initial cwd', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-1',
       agent: 'claude',
       worktreeId: 'wt-1',
       initialCwd: '/repo/worktree/packages/app'
@@ -91,6 +92,7 @@ describe('launchAgentInNewTab initial cwd', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-2',
       agent: 'claude',
       worktreeId: 'wt-1',
       groupId: 'group-1',
@@ -113,6 +115,7 @@ describe('launchAgentInNewTab initial cwd', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-3',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: 'continue the unfinished task',
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab-host-resolution.test.ts b/src/renderer/src/lib/launch-agent-in-new-tab-host-resolution.test.ts
index bcb09c1b17c..156b8622ee6 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab-host-resolution.test.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab-host-resolution.test.ts
@@ -92,7 +92,12 @@ function worktreeOn(hostId: string, path: string): StoreWorktree {
 
 async function launchOnLinux(): Promise<void> {
   const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
-  launchAgentInNewTab({ agent: 'claude-agent-teams', worktreeId: 'wt-1', launchPlatform: 'linux' })
+  launchAgentInNewTab({
+    requestId: 'request-1',
+    agent: 'claude-agent-teams',
+    worktreeId: 'wt-1',
+    launchPlatform: 'linux'
+  })
 }
 
 function queuedCommand(): string {
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab-main-surface.test.ts b/src/renderer/src/lib/launch-agent-in-new-tab-main-surface.test.ts
index e4c54e13ae4..c1c311d2731 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab-main-surface.test.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab-main-surface.test.ts
@@ -52,6 +52,7 @@ describe('launchAgentInNewTab main-window surface', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-1',
       agent: 'opencode',
       worktreeId: FLOATING_TERMINAL_WORKTREE_ID
     })
@@ -73,7 +74,11 @@ describe('launchAgentInNewTab main-window surface', () => {
     const store = seedMainWindowOnEditor()
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'opencode', worktreeId: MAIN_WORKTREE_ID })
+    const result = launchAgentInNewTab({
+      requestId: 'request-2',
+      agent: 'opencode',
+      worktreeId: MAIN_WORKTREE_ID
+    })
 
     const tabId = result?.surface.kind === 'local-terminal' ? result.surface.tabId : null
     expect(tabId).not.toBeNull()
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab-placement.test.ts b/src/renderer/src/lib/launch-agent-in-new-tab-placement.test.ts
index 2749b7f2bb8..686cdb44061 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab-placement.test.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab-placement.test.ts
@@ -94,7 +94,7 @@ describe('launchAgentInNewTab terminal tab activation', () => {
   it('shows terminals in the worktree it launched into', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-1', agent: 'codex', worktreeId: 'wt-1' })
 
     expect(mockCreateTab.mock.calls[0]?.[3]).not.toHaveProperty('activate')
     // Why: an unscoped call targets the active worktree — the main window — whatever worktree the
@@ -117,6 +117,7 @@ describe('launchAgentInNewTab terminal tab activation', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-2',
       agent: 'codex',
       worktreeId: FLOATING_TERMINAL_WORKTREE_ID
     })
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab-structured-route.ts b/src/renderer/src/lib/launch-agent-in-new-tab-structured-route.ts
index c4f2a02a4fe..b5ca43f6f56 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab-structured-route.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab-structured-route.ts
@@ -73,6 +73,7 @@ export function launchStructuredAgentFromNewTab(args: {
       const terminal = args.openTerminal(
         adoptAgentSessionLaunchVerdict({
           route: 'terminal-tui',
+          requestId: plan.requestId,
           agent: plan.agent,
           worktreeId: args.worktreeId
         })
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab-structured.test.ts b/src/renderer/src/lib/launch-agent-in-new-tab-structured.test.ts
index ebae8f07d75..1505ca3e99b 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab-structured.test.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab-structured.test.ts
@@ -27,6 +27,7 @@ import { launchAgentInStructuredNewTab } from './launch-agent-in-new-tab-structu
 type Delivery = 'auto-submit' | 'submit-after-ready' | 'draft'
 const structuredPlan = (prompt: string, promptDelivery: Delivery) =>
   adoptAgentSessionLaunchVerdict({
+    requestId: 'request-1',
     route: 'structured-native-chat',
     agent: 'codex',
     worktreeId: 'wt-1',
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab-web-runtime.test.ts b/src/renderer/src/lib/launch-agent-in-new-tab-web-runtime.test.ts
index 24043737367..a78947376a8 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab-web-runtime.test.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab-web-runtime.test.ts
@@ -80,6 +80,7 @@ describe('launchAgentInNewTab paired web runtime', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-1',
       agent: 'claude',
       worktreeId: 'wt-1',
       groupId: 'group-1'
@@ -113,6 +114,7 @@ describe('launchAgentInNewTab paired web runtime', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-2',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'fix the spinner',
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab-windows-quoting.test.ts b/src/renderer/src/lib/launch-agent-in-new-tab-windows-quoting.test.ts
index 63053e0e90a..8704b28ad15 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab-windows-quoting.test.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab-windows-quoting.test.ts
@@ -164,6 +164,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     const prompt = 'x'.repeat(25_000)
 
     launchAgentInNewTab({
+      requestId: 'request-1',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt,
@@ -185,6 +186,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-2',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: "review Bob's change",
@@ -205,6 +207,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-3',
       agent: 'claude',
       worktreeId: 'wt-1',
       launchPlatform: 'win32'
@@ -223,6 +226,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-4',
       agent: 'claude',
       worktreeId: 'wt-1',
       launchPlatform: 'win32'
@@ -241,6 +245,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-5',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'fix the spinner',
@@ -262,6 +267,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-6',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: "review Bob's change",
@@ -282,10 +288,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     store.repos = [{ id: 'repo-1', connectionId: 'ssh-1', path: 'C:\\remote\\repo' }]
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({
-      agent: 'claude',
-      worktreeId: 'wt-1'
-    })
+    launchAgentInNewTab({ requestId: 'request-7', agent: 'claude', worktreeId: 'wt-1' })
 
     expect(mockQueueTabStartupCommand).toHaveBeenCalledWith(
       'tab-1',
@@ -318,6 +321,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-8',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: "review Bob's change",
@@ -357,7 +361,7 @@ describe('launchAgentInNewTab Windows shell quoting', () => {
     }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-9', agent: 'codex', worktreeId: 'wt-1' })
 
     const queued = mockQueueTabStartupCommand.mock.calls.at(-1)?.[1] as { command: string }
     expect(queued.command).toContain(`'don'"'"'t'`)
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab.test.ts b/src/renderer/src/lib/launch-agent-in-new-tab.test.ts
index 375620b9311..adf90ead68b 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab.test.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab.test.ts
@@ -137,6 +137,13 @@ vi.mock('@/runtime/web-runtime-session', () => ({
   isWebTerminalSurfaceTabId: vi.fn(() => false)
 }))
 
+/** One click that launches Command Code in wt-1, a terminal-route agent. */
+const COMMAND_CODE_CLICK = {
+  requestId: 'command-code-click',
+  agent: 'command-code',
+  worktreeId: 'wt-1'
+} as const
+
 describe('launchAgentInNewTab', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -185,10 +192,7 @@ describe('launchAgentInNewTab', () => {
   it('stamps the launched agent on the new tab for immediate provider icon bootstrap', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({
-      agent: 'codex',
-      worktreeId: 'wt-1'
-    })
+    launchAgentInNewTab({ requestId: 'request-1', agent: 'codex', worktreeId: 'wt-1' })
 
     expect(mockCreateTab).toHaveBeenCalledWith('wt-1', undefined, undefined, {
       launchAgent: 'codex'
@@ -204,6 +208,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-2',
       agent: 'codex',
       worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
       launchPlatform: 'win32'
@@ -233,6 +238,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-3',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'large generated prompt',
@@ -271,6 +277,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-4',
       agent: 'grok',
       worktreeId: 'wt-1',
       prompt: 'large generated prompt',
@@ -303,7 +310,7 @@ describe('launchAgentInNewTab', () => {
     store.repos = [{ id: 'repo-1', connectionId: 'ssh-target-1', path: '/repo' }]
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'grok', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-5', agent: 'grok', worktreeId: 'wt-1' })
 
     expect(mockCreateTab).toHaveBeenCalledWith('wt-1', undefined, undefined, {
       launchAgent: 'grok',
@@ -324,6 +331,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-6',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: 'https://github.com/o/r/issues/12',
@@ -356,6 +364,7 @@ describe('launchAgentInNewTab', () => {
 
     const prompt = 'Reproduce first\n\nhttps://github.com/o/r/issues/12'
     launchAgentInNewTab({
+      requestId: 'request-7',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt,
@@ -372,6 +381,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-8',
       agent: 'codex',
       worktreeId: 'wt-1',
       quickCommandLabel: 'Review'
@@ -402,6 +412,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-9',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'Review this diff',
@@ -435,6 +446,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-10',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'Review this diff',
@@ -475,6 +487,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-11',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: 'review before sending',
@@ -512,7 +525,7 @@ describe('launchAgentInNewTab', () => {
     }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-12', agent: 'codex', worktreeId: 'wt-1' })
 
     expect(mockCreateWebRuntimeSessionTerminal).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -538,7 +551,7 @@ describe('launchAgentInNewTab', () => {
     }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-13', agent: 'codex', worktreeId: 'wt-1' })
 
     expect(mockCreateWebRuntimeSessionTerminal).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -565,10 +578,7 @@ describe('launchAgentInNewTab', () => {
     }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({
-      agent: 'claude',
-      worktreeId: 'wt-1'
-    })
+    launchAgentInNewTab({ requestId: 'request-14', agent: 'claude', worktreeId: 'wt-1' })
 
     await Promise.resolve()
     expect(mockToastError).toHaveBeenCalledWith(
@@ -581,8 +591,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
-      agent: 'command-code',
-      worktreeId: 'wt-1',
+      ...COMMAND_CODE_CLICK,
       prompt: 'fix the spinner'
     })
 
@@ -602,6 +611,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-16',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt: 'review this before sending',
@@ -616,6 +626,7 @@ describe('launchAgentInNewTab', () => {
     const prompt = 'x'.repeat(25_000)
 
     const result = launchAgentInNewTab({
+      requestId: 'request-17',
       agent: 'claude',
       worktreeId: 'wt-1',
       prompt,
@@ -652,6 +663,7 @@ describe('launchAgentInNewTab', () => {
 
     try {
       const result = launchAgentInNewTab({
+        requestId: 'request-18',
         agent: 'claude',
         worktreeId: 'wt-1',
         prompt,
@@ -672,8 +684,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
-      agent: 'command-code',
-      worktreeId: 'wt-1',
+      ...COMMAND_CODE_CLICK,
       prompt: 'large generated prompt',
       promptDelivery: 'submit-after-ready'
     })
@@ -734,8 +745,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
-      agent: 'command-code',
-      worktreeId: 'wt-1',
+      ...COMMAND_CODE_CLICK,
       prompt: 'pending prompt',
       promptDelivery: 'submit-after-ready'
     })
@@ -761,8 +771,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
-      agent: 'command-code',
-      worktreeId: 'wt-1',
+      ...COMMAND_CODE_CLICK,
       prompt: 'large generated prompt',
       promptDelivery: 'submit-after-ready'
     })
@@ -784,8 +793,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
-      agent: 'command-code',
-      worktreeId: 'wt-1',
+      ...COMMAND_CODE_CLICK,
       prompt: 'large generated prompt',
       promptDelivery: 'submit-after-ready'
     })
@@ -809,8 +817,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
-      agent: 'command-code',
-      worktreeId: 'wt-1',
+      ...COMMAND_CODE_CLICK,
       prompt: 'large generated prompt',
       promptDelivery: 'submit-after-ready'
     })
@@ -831,8 +838,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
-      agent: 'command-code',
-      worktreeId: 'wt-1',
+      ...COMMAND_CODE_CLICK,
       prompt: 'large generated prompt',
       promptDelivery: 'submit-after-ready'
     })
@@ -853,8 +859,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
-      agent: 'command-code',
-      worktreeId: 'wt-1',
+      ...COMMAND_CODE_CLICK,
       prompt: 'large generated prompt',
       promptDelivery: 'submit-after-ready'
     })
@@ -870,6 +875,7 @@ describe('launchAgentInNewTab', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     launchAgentInNewTab({
+      requestId: 'request-26',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'large generated prompt',
diff --git a/src/renderer/src/lib/launch-agent-in-new-tab.ts b/src/renderer/src/lib/launch-agent-in-new-tab.ts
index eff738dde7f..87ddca84bd2 100644
--- a/src/renderer/src/lib/launch-agent-in-new-tab.ts
+++ b/src/renderer/src/lib/launch-agent-in-new-tab.ts
@@ -31,8 +31,19 @@ import {
   planAgentSessionLaunch,
   type AgentSessionLaunchPlan
 } from '@/lib/agent-session-launch-plan'
+import type { AgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 
-export type LaunchAgentInNewTabArgs = {
+/** The user action this launch serves: minted where that action is handled, or carried by the
+ *  route the caller already planned for it. */
+type LaunchAgentInNewTabRequest =
+  | { requestId: AgentLaunchRequestId; agentSessionLaunchPlan?: undefined }
+  | {
+      /** Keeps a preflighted route authoritative across workspace creation. */
+      agentSessionLaunchPlan: AgentSessionLaunchPlan
+      requestId?: undefined
+    }
+
+export type LaunchAgentInNewTabArgs = LaunchAgentInNewTabRequest & {
   agent: TuiAgent
   worktreeId: string
   /** Tab group the user launched from; keeps split-group launches in that pane instead of the active group. */
@@ -58,8 +69,6 @@ export type LaunchAgentInNewTabArgs = {
    * terminal route, whose readiness signal the client watches itself.
    */
   onPromptDeliveryUnconfirmed?: () => void
-  /** Keeps a preflighted route authoritative across workspace creation. */
-  agentSessionLaunchPlan?: AgentSessionLaunchPlan
   /** The launch seeds a workspace being opened, so its PTY spawn must not reshuffle Recent. */
   pendingActivationSpawn?: boolean
   /** Lets a workspace reveal itself before the selected surface opens. */
@@ -115,7 +124,6 @@ function launchAgentInNewTabInternal(args: LaunchAgentInNewTabArgs): LaunchAgent
     launchPlatform,
     onPromptDelivered,
     onPromptDeliveryUnconfirmed,
-    agentSessionLaunchPlan,
     pendingActivationSpawn,
     beforeSurfaceOpen
   } = args
@@ -171,16 +179,18 @@ function launchAgentInNewTabInternal(args: LaunchAgentInNewTabArgs): LaunchAgent
   // Why first: a structured chat is created on whichever runtime owns the workspace, a paired
   // server included, so only a non-structured route falls through to the host-published terminal.
   const plan =
-    agentSessionLaunchPlan ??
-    planAgentSessionLaunch(store, {
-      agent,
-      workspace: { kind: workspaceKind, worktreeId },
-      prompt: trimmedPrompt,
-      promptDelivery: viewModePromptDelivery,
-      tuiCustomization: { cwd: initialCwd },
-      initialSessionOptions: startupPlan.sessionOptions,
-      onPromptDelivered
-    })
+    args.requestId === undefined
+      ? args.agentSessionLaunchPlan
+      : planAgentSessionLaunch(store, {
+          requestId: args.requestId,
+          agent,
+          workspace: { kind: workspaceKind, worktreeId },
+          prompt: trimmedPrompt,
+          promptDelivery: viewModePromptDelivery,
+          tuiCustomization: { cwd: initialCwd },
+          initialSessionOptions: startupPlan.sessionOptions,
+          onPromptDelivered
+        })
   if (plan?.route === 'structured-native-chat') {
     const structured = launchStructuredAgentFromNewTab({
       plan,
@@ -192,6 +202,7 @@ function launchAgentInNewTabInternal(args: LaunchAgentInNewTabArgs): LaunchAgent
         launchAgentInNewTabInternal({
           ...args,
           beforeSurfaceOpen: undefined,
+          requestId: undefined,
           agentSessionLaunchPlan: terminalPlan
         })
     })
diff --git a/src/renderer/src/lib/launch-agent-session-continuation.ts b/src/renderer/src/lib/launch-agent-session-continuation.ts
index 5656eddca04..6d6861411c2 100644
--- a/src/renderer/src/lib/launch-agent-session-continuation.ts
+++ b/src/renderer/src/lib/launch-agent-session-continuation.ts
@@ -2,6 +2,7 @@ import { toast } from 'sonner'
 import { getAgentLabel } from '@/lib/agent-catalog'
 import { getConnectionIdFromState } from '@/lib/connection-context'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import { getRuntimeEnvironmentIdForWorktree } from '@/lib/worktree-runtime-owner'
 import { useAppStore } from '@/store'
 import { isTuiAgentEnabled } from '../../../shared/tui-agent-selection'
@@ -84,6 +85,7 @@ export async function launchAgentSessionContinuation({
   // could vanish silently (#22479).
   let deliveryUnconfirmed = false
   const result = launchAgentInNewTab({
+    requestId: newAgentLaunchRequestId(),
     agent,
     worktreeId,
     ...(groupId ? { groupId } : {}),
diff --git a/src/renderer/src/lib/launch-agent-structured-chat-guard.test.ts b/src/renderer/src/lib/launch-agent-structured-chat-guard.test.ts
index 25f66d4af23..64d748ec858 100644
--- a/src/renderer/src/lib/launch-agent-structured-chat-guard.test.ts
+++ b/src/renderer/src/lib/launch-agent-structured-chat-guard.test.ts
@@ -101,6 +101,7 @@ const store = {
   allWorktrees: vi.fn(() => store.worktreesByRepo['repo-1']),
   tabsByWorktree: { 'wt-1': [{ id: 'tab-1' }] },
   unifiedTabsByWorktree: emptyUnifiedTabsByWorktree,
+  activeGroupIdByWorktree: {},
   openFiles: [] as { id: string; worktreeId: string }[],
   browserTabsByWorktree: {} as Record<string, { id: string }[]>,
   tabBarOrderByWorktree: {} as Record<string, string[]>,
@@ -255,7 +256,11 @@ describe('structured chat adoption guard on the launch path', () => {
     const { launchAgentInNewTab, shouldQueueTerminalFocusAfterMenuClose } =
       await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-1',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
 
     expect(result).toMatchObject({
       surface: {
@@ -295,7 +300,11 @@ describe('structured chat adoption guard on the launch path', () => {
     }
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-2',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
 
     expect(result).toMatchObject({
       surface: { kind: 'local-agent-session', sessionId: 'codex-session-1' }
@@ -313,7 +322,11 @@ describe('structured chat adoption guard on the launch path', () => {
   it('takes the structured path for Claude, naming Claude as the create provider', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'claude', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-3',
+      agent: 'claude',
+      worktreeId: 'wt-1'
+    })
 
     expect(result).toMatchObject({
       surface: { kind: 'local-agent-session', sessionId: 'codex-session-1' }
@@ -331,7 +344,7 @@ describe('structured chat adoption guard on the launch path', () => {
   it('keeps a native-chat agent with no structured adapter on the terminal-backed path', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'openclaude', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-4', agent: 'openclaude', worktreeId: 'wt-1' })
 
     expect(mockCreateStructuredCodexSessionLaunchIntent).not.toHaveBeenCalled()
     expect(mockCreateTab).toHaveBeenCalled()
@@ -343,8 +356,8 @@ describe('structured chat adoption guard on the launch path', () => {
       hostCapabilities = capabilities
       const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-      launchAgentInNewTab({ agent: 'claude', worktreeId: 'wt-1' })
-      launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+      launchAgentInNewTab({ requestId: 'request-5', agent: 'claude', worktreeId: 'wt-1' })
+      launchAgentInNewTab({ requestId: 'request-6', agent: 'codex', worktreeId: 'wt-1' })
 
       expect(mockCreateStructuredCodexSessionLaunchIntent).not.toHaveBeenCalled()
       expect(mockCreateTab).toHaveBeenCalledTimes(2)
@@ -357,7 +370,11 @@ describe('structured chat adoption guard on the launch path', () => {
     store.settings.openAgentTabsInChatByDefault = false
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-7',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
 
     expect(result?.surface).toEqual({ kind: 'local-terminal', tabId: 'tab-1' })
     expect(mockLaunchStructuredCodexSession).not.toHaveBeenCalled()
@@ -376,7 +393,11 @@ describe('structured chat adoption guard on the launch path', () => {
     mockLaunchStructuredCodexSession.mockRejectedValueOnce(refusal)
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const result = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    const result = launchAgentInNewTab({
+      requestId: 'request-8',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
 
     expect(result).toMatchObject({
       surface: { kind: 'local-agent-session', sessionId: 'codex-session-1' },
@@ -404,6 +425,7 @@ describe('structured chat adoption guard on the launch path', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-9',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'start this task',
@@ -421,7 +443,7 @@ describe('structured chat adoption guard on the launch path', () => {
     expect(mockPasteDraftWhenAgentReady).not.toHaveBeenCalled()
   })
 
-  it('coalesces repeated structured launches for one worktree while the host is starting', async () => {
+  it('coalesces one action delivered twice for one worktree while the host is starting', async () => {
     let resolveLaunch!: (receipt: { sessionId: string; fence: number }) => void
     mockLaunchStructuredCodexSession.mockImplementationOnce(
       () =>
@@ -429,8 +451,16 @@ describe('structured chat adoption guard on the launch path', () => {
     )
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const first = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
-    const second = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    const first = launchAgentInNewTab({
+      requestId: 'double-click',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
+    const second = launchAgentInNewTab({
+      requestId: 'double-click',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
 
     expect(first).toMatchObject({ surface: { kind: 'local-agent-session' } })
     expect(second).toMatchObject({ surface: { kind: 'local-agent-session' } })
@@ -450,10 +480,10 @@ describe('structured chat adoption guard on the launch path', () => {
     })
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'double-click', agent: 'codex', worktreeId: 'wt-1' })
     await vi.waitFor(() => expect(mockRefreshLocalStructuredSessionTabs).toHaveBeenCalledTimes(1))
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'double-click', agent: 'codex', worktreeId: 'wt-1' })
 
     expect(mockLaunchStructuredCodexSession).toHaveBeenCalledTimes(1)
     store.unifiedTabsByWorktree['wt-1'] = [
@@ -471,7 +501,7 @@ describe('structured chat adoption guard on the launch path', () => {
     await vi.waitFor(() => expect(mockToastError).not.toHaveBeenCalled())
   })
 
-  it('does not create a sibling when post-create visibility proof is unknown', async () => {
+  it('re-checks a chat whose visibility proof is unknown through its own Retry, with its own intent', async () => {
     store.unifiedTabsByWorktree = {}
     const firstIntent = structuredLaunchIntent('wt-1', 'codex-session-1')
     const secondIntent = structuredLaunchIntent('wt-1', 'codex-session-2')
@@ -505,7 +535,11 @@ describe('structured chat adoption guard on the launch path', () => {
       ])
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    const unknown = launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    const unknown = launchAgentInNewTab({
+      requestId: 'request-14',
+      agent: 'codex',
+      worktreeId: 'wt-1'
+    })
     await expect(unknown?.structuredSettlement).resolves.toEqual({
       kind: 'visibility-unknown',
       sessionId: firstIntent.sessionId
@@ -519,7 +553,9 @@ describe('structured chat adoption guard on the launch path', () => {
     )
     expect(mockToastError).not.toHaveBeenCalled()
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    // A new launch would open a new chat; the unconfirmed one is re-checked by its own Retry.
+    const { retryStructuredAgentSessionLaunch } = await import('./structured-agent-session-launch')
+    expect(retryStructuredAgentSessionLaunch('wt-1', firstIntent.sessionId)).toBe(true)
     await vi.waitFor(() => expect(mockRefreshLocalStructuredSessionTabs).toHaveBeenCalledTimes(3))
 
     expect(mockCreateStructuredCodexSessionLaunchIntent).toHaveBeenCalledTimes(1)
@@ -538,7 +574,7 @@ describe('structured chat adoption guard on the launch path', () => {
         groupId: 'group-1'
       }
     ]
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-15', agent: 'codex', worktreeId: 'wt-1' })
     await vi.waitFor(() => expect(mockLaunchStructuredCodexSession).toHaveBeenCalledTimes(3))
     expect(mockCreateStructuredCodexSessionLaunchIntent).toHaveBeenCalledTimes(2)
     expect(mockLaunchStructuredCodexSession).toHaveBeenCalledTimes(3)
@@ -549,6 +585,7 @@ describe('structured chat adoption guard on the launch path', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-16',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'start this task'
@@ -572,6 +609,7 @@ describe('structured chat adoption guard on the launch path', () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
     const result = launchAgentInNewTab({
+      requestId: 'request-17',
       agent: 'codex',
       worktreeId: 'wt-1',
       prompt: 'large generated prompt',
@@ -589,7 +627,7 @@ describe('structured chat adoption guard on the launch path', () => {
     store.repos = [{ id: 'repo-1', connectionId: 'ssh-a', path: '/repo' }]
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-18', agent: 'codex', worktreeId: 'wt-1' })
 
     expect(mockCreateTab).toHaveBeenCalledWith('wt-1', undefined, undefined, {
       launchAgent: 'codex',
@@ -602,7 +640,7 @@ describe('structured chat adoption guard on the launch path', () => {
     store.repos = [{ id: 'repo-1', connectionId: 'runtime-ssh-a', path: '/repo' }]
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
-    launchAgentInNewTab({ agent: 'codex', worktreeId: 'wt-1' })
+    launchAgentInNewTab({ requestId: 'request-19', agent: 'codex', worktreeId: 'wt-1' })
 
     expect(mockCreateTab).toHaveBeenCalledWith('wt-1', undefined, undefined, {
       launchAgent: 'codex',
diff --git a/src/renderer/src/lib/launch-work-item-direct-agent-routing.test.ts b/src/renderer/src/lib/launch-work-item-direct-agent-routing.test.ts
index 56e29c01b90..f92407a8fa8 100644
--- a/src/renderer/src/lib/launch-work-item-direct-agent-routing.test.ts
+++ b/src/renderer/src/lib/launch-work-item-direct-agent-routing.test.ts
@@ -16,6 +16,7 @@ import { adoptAgentSessionLaunchVerdict } from './agent-session-launch-plan'
 import { beginDirectWorkItemStructuredLaunch } from './launch-work-item-direct-agent-routing'
 
 const structuredPlan: AgentSessionLaunchPlan = adoptAgentSessionLaunchVerdict({
+  requestId: 'request-1',
   route: 'structured-native-chat',
   agent: 'codex',
   worktreeId: 'worktree-1',
@@ -69,7 +70,10 @@ describe('beginDirectWorkItemStructuredLaunch', () => {
   it('skips structured opening for non-structured routes', () => {
     expect(
       beginDirectWorkItemStructuredLaunch({
-        plan: adoptAgentSessionLaunchVerdict({ ...structuredPlan, route: 'legacy-native-chat' }),
+        plan: adoptAgentSessionLaunchVerdict({
+          ...structuredPlan,
+          route: 'legacy-native-chat'
+        }),
         primaryTabId: null,
         beforeOpen: vi.fn()
       })
diff --git a/src/renderer/src/lib/launch-work-item-direct-route-preparation.ts b/src/renderer/src/lib/launch-work-item-direct-route-preparation.ts
index 96ea10d91ec..3dddd4276b4 100644
--- a/src/renderer/src/lib/launch-work-item-direct-route-preparation.ts
+++ b/src/renderer/src/lib/launch-work-item-direct-route-preparation.ts
@@ -7,6 +7,7 @@ import type {
   AgentSessionLaunchPlan,
   planAgentSessionLaunch
 } from '@/lib/agent-session-launch-plan'
+import type { AgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import {
   buildDirectWorkItemStartup,
   resolveDirectWorkItemAgent
@@ -39,6 +40,8 @@ export async function prepareDirectWorkItemAgentLaunch(args: {
   launchPlatform?: NodeJS.Platform
   repoProjectRuntime?: Parameters<typeof buildDirectWorkItemStartup>[0]['repoProjectRuntime']
   planLaunch: typeof planAgentSessionLaunch
+  /** The start action this launch serves. */
+  requestId: AgentLaunchRequestId
 }): Promise<DirectWorkItemAgentLaunchPreparation> {
   const launchConnectionId = getConnectionId(args.worktreeId) ?? args.repoConnectionId
   const agentSelection = await resolveDirectWorkItemAgent({
@@ -93,6 +96,7 @@ export async function prepareDirectWorkItemAgentLaunch(args: {
     effectiveAgent === null
       ? null
       : args.planLaunch(args.latestStore, {
+          requestId: args.requestId,
           agent: effectiveAgent,
           workspace: { kind: 'git-worktree', worktreeId: args.worktreeId, repoId: args.repoId },
           prompt: args.draftContent,
diff --git a/src/renderer/src/lib/launch-work-item-direct.ts b/src/renderer/src/lib/launch-work-item-direct.ts
index a3b9ec2f4c2..dba04c50c1f 100644
--- a/src/renderer/src/lib/launch-work-item-direct.ts
+++ b/src/renderer/src/lib/launch-work-item-direct.ts
@@ -40,6 +40,7 @@ import {
   planAgentSessionLaunch,
   type AgentSessionLaunchPlan
 } from '@/lib/agent-session-launch-plan'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 
 /**
  * "Use" flow: create the workspace, activate it, launch the default agent,
@@ -214,7 +215,8 @@ export async function launchWorkItemDirect(args: LaunchWorkItemDirectArgs): Prom
       promptDelivery,
       launchPlatform: args.launchPlatform,
       repoProjectRuntime,
-      planLaunch: planAgentSessionLaunch
+      planLaunch: planAgentSessionLaunch,
+      requestId: newAgentLaunchRequestId()
     })
     if (launchPreparation.unavailable) {
       activateAndRevealWorktree(worktreeId, {
diff --git a/src/renderer/src/lib/local-file-access.test.ts b/src/renderer/src/lib/local-file-access.test.ts
new file mode 100644
index 00000000000..a1a8a90dd5a
--- /dev/null
+++ b/src/renderer/src/lib/local-file-access.test.ts
@@ -0,0 +1,307 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import type { Repo } from '../../../shared/repo-types'
+import type { Worktree } from '../../../shared/worktree/types'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../shared/constants'
+import { folderWorkspaceKey } from '../../../shared/workspace-scope'
+import { useAppStore } from '@/store'
+import { editorTabDocumentFolderAccess, editorTabFileAccess } from './local-file-access'
+
+const initialState = useAppStore.getInitialState()
+
+function makeRepo(overrides: Partial<Repo> & { id: string; path: string }): Repo {
+  return { displayName: 'repo', badgeColor: '#000', addedAt: 0, ...overrides }
+}
+
+function makeWorktree(overrides: Partial<Worktree> & { id: string; repoId: string }): Worktree {
+  return {
+    path: '/Users/me/project',
+    head: 'abc123',
+    branch: 'refs/heads/main',
+    isBare: false,
+    isMainWorktree: true,
+    displayName: 'project',
+    comment: '',
+    linkedIssue: null,
+    linkedPR: null,
+    linkedLinearIssue: null,
+    isArchived: false,
+    isUnread: false,
+    isPinned: false,
+    sortOrder: 0,
+    lastActivityAt: 0,
+    ...overrides
+  }
+}
+
+const localWorktreeId = 'repo-local::/Users/me/project'
+
+type TabFileAccessFields = Parameters<typeof editorTabFileAccess>[1]
+
+function accessKind(file: TabFileAccessFields): string | undefined {
+  return editorTabFileAccess(useAppStore.getState(), file)?.kind
+}
+
+describe('editorTabFileAccess', () => {
+  beforeEach(() => {
+    useAppStore.setState({
+      repos: [
+        makeRepo({ id: 'repo-local', path: '/Users/me/project' }),
+        makeRepo({ id: 'repo-ssh', path: '/work/project', connectionId: 'ssh-1' })
+      ],
+      worktreesByRepo: {
+        'repo-local': [makeWorktree({ id: localWorktreeId, repoId: 'repo-local' })]
+      }
+    })
+  })
+
+  afterEach(() => {
+    useAppStore.setState(initialState, true)
+  })
+
+  it.each<[string, TabFileAccessFields, string | undefined]>([
+    [
+      'a floating-workspace tab stored relative to ~',
+      {
+        filePath: '/Users/me/notes.txt',
+        relativePath: 'notes.txt',
+        worktreeId: FLOATING_TERMINAL_WORKTREE_ID
+      },
+      'user-file'
+    ],
+    [
+      'a local tab stored by absolute path',
+      { filePath: '/tmp/audit.md', relativePath: '/tmp/audit.md', worktreeId: localWorktreeId },
+      'user-file'
+    ],
+    [
+      'a project link opened by its absolute path because it leads out of the project',
+      {
+        filePath: '/Users/me/project/docs/link.md',
+        relativePath: '/Users/me/project/docs/link.md',
+        worktreeId: localWorktreeId
+      },
+      'user-file'
+    ],
+    [
+      'an AI Vault log tab in an SSH workspace',
+      {
+        filePath: '/Users/me/.codex/session.jsonl',
+        relativePath: '/Users/me/.codex/session.jsonl',
+        worktreeId: 'repo-ssh::/work/project',
+        readOnly: true,
+        liveTail: true
+      },
+      'user-file'
+    ],
+    [
+      'a project tab, which stays inside its root',
+      { filePath: '/Users/me/project/a.ts', relativePath: 'a.ts', worktreeId: localWorktreeId },
+      undefined
+    ],
+    [
+      'an absolute tab owned by an SSH workspace',
+      { filePath: '/work/x.md', relativePath: '/work/x.md', worktreeId: 'repo-ssh::/work/project' },
+      undefined
+    ],
+    [
+      'an absolute tab pinned to an SSH host',
+      {
+        filePath: '/work/x.md',
+        relativePath: '/work/x.md',
+        worktreeId: localWorktreeId,
+        externalSshTargetId: 'ssh-1'
+      },
+      undefined
+    ],
+    [
+      'a floating tab owned by a remote runtime',
+      {
+        filePath: '/Users/me/notes.txt',
+        relativePath: 'notes.txt',
+        worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
+        runtimeEnvironmentId: 'runtime-1'
+      },
+      undefined
+    ],
+    [
+      'an absolute tab whose owner has not loaded',
+      {
+        filePath: '/work/x.md',
+        relativePath: '/work/x.md',
+        worktreeId: 'repo-missing::/work/other'
+      },
+      undefined
+    ],
+    [
+      'an absolute tab in a folder workspace with an unknown host',
+      {
+        filePath: '/home/remote/notes.md',
+        relativePath: '/home/remote/notes.md',
+        worktreeId: folderWorkspaceKey('fw-missing')
+      },
+      undefined
+    ]
+  ])('%s', (_label, file, expected) => {
+    expect(accessKind(file)).toBe(expected)
+  })
+})
+
+describe('editorTabDocumentFolderAccess', () => {
+  beforeEach(() => {
+    useAppStore.setState({
+      repos: [
+        makeRepo({ id: 'repo-local', path: '/Users/me/project' }),
+        makeRepo({ id: 'repo-ssh', path: '/work/project', connectionId: 'ssh-1' })
+      ],
+      worktreesByRepo: {
+        'repo-local': [makeWorktree({ id: localWorktreeId, repoId: 'repo-local' })]
+      }
+    })
+  })
+
+  afterEach(() => {
+    useAppStore.setState(initialState, true)
+  })
+
+  it('declares the file itself for writes on a local user-named tab', () => {
+    expect(
+      editorTabDocumentFolderAccess(useAppStore.getState(), {
+        filePath: '/Users/me/notes.md',
+        relativePath: 'notes.md',
+        worktreeId: FLOATING_TERMINAL_WORKTREE_ID
+      })
+    ).toEqual({ kind: 'document-folder', documentPath: '/Users/me/notes.md' })
+  })
+
+  it.each<[string, TabFileAccessFields]>([
+    [
+      'a project tab',
+      { filePath: '/Users/me/project/a.md', relativePath: 'a.md', worktreeId: localWorktreeId }
+    ],
+    [
+      'an absolute tab owned by an SSH workspace',
+      { filePath: '/work/x.md', relativePath: '/work/x.md', worktreeId: 'repo-ssh::/work/project' }
+    ],
+    [
+      'an AI Vault log tab',
+      {
+        filePath: '/Users/me/.codex/session.jsonl',
+        relativePath: '/Users/me/.codex/session.jsonl',
+        worktreeId: 'repo-ssh::/work/project',
+        readOnly: true,
+        liveTail: true
+      }
+    ]
+  ])('grants no folder writes to %s', (_label, file) => {
+    expect(editorTabDocumentFolderAccess(useAppStore.getState(), file)).toBeUndefined()
+  })
+})
+
+// Why a ratchet: a content-driven reader that adopted user-file would bring back the round-1 leak.
+// These scans only see the two ways a renderer file can produce user-file today, by name and by
+// pattern: building user-file access directly, and opening a tab the tab rule reads as user-named. They
+// cannot see a decision laundered through props or a helper, so they are a tripwire for review, not
+// a proof; a branded user-named path type is the follow-up that would make it one.
+const USER_NAMED_ACCESS_IMPORTERS = [
+  'components/browser-pane/describe-page/browser-artifact-upload.ts',
+  'components/native-chat/use-native-chat-external-attachments.ts',
+  'components/sidebar/useSidebarProjectDrop.ts',
+  'hooks/composer-state/attachment-drop-state.ts',
+  'lib/local-file-access.ts',
+  'lib/user-opened-local-path.ts'
+]
+
+// Files whose openFile call can store relativePath === filePath (read and saved as user-named by
+// the tab rule) or open a floating-workspace tab. The scan matches by value, so a few listed files
+// only look like it (their relativePath is genuinely relative); review each new entry by hand.
+// Files that build write access beside an opened document; each must derive it from the tab rule.
+const DOCUMENT_FOLDER_ACCESS_BUILDERS = [
+  'components/editor/editor-header-file-rename.ts',
+  'components/editor/rich-markdown-image-insert.ts',
+  'components/tab-bar/EditorFileTab.tsx',
+  'lib/execute-open-editor-path-move.ts',
+  'lib/local-file-access.ts'
+]
+
+const USER_NAMED_TAB_OPENERS = [
+  'components/browser-pane/navigate/navigate-browser-page-url.ts',
+  'components/editor/markdown-preview-link-actions.ts',
+  'components/floating-terminal/use-floating-terminal-create-actions.ts',
+  'components/right-sidebar/ai-vault-session-log-open.ts',
+  'components/right-sidebar/source-control/notes/use-note-opening.ts',
+  'components/right-sidebar/useFileExplorerHandlers.ts',
+  'components/settings/KeybindingsFileActions.tsx',
+  'components/tab-bar/tab-create-entry-absolute-file.ts',
+  'components/terminal-pane/terminal-file-open-routing.ts',
+  'hooks/useGlobalFileDrop.ts',
+  'lib/floating-workspace-tab-creation.ts',
+  'lib/open-document-in-floating-workspace.ts',
+  'store/slices/editor/actions/markdown-link-action.ts'
+]
+
+function collectSourceFiles(dir: string): string[] {
+  return readdirSync(dir).flatMap((entry) => {
+    const full = join(dir, entry)
+    if (statSync(full).isDirectory()) {
+      return collectSourceFiles(full)
+    }
+    return /\.tsx?$/.test(entry) &&
+      !/\.test\.tsx?$/.test(entry) &&
+      !/test-(harness|fixture)/.test(entry)
+      ? [full]
+      : []
+  })
+}
+
+function opensUserNamedTabs(source: string): boolean {
+  if (!/\bopenFile\(/.test(source)) {
+    return false
+  }
+  if (source.includes('FLOATING_TERMINAL_WORKTREE_ID')) {
+    return true
+  }
+  const filePathValues = [...source.matchAll(/\bfilePath:\s*([\w.]+)/g)]
+    .map((match) => match[1])
+    .filter((value) => value !== 'string')
+  if (/\bfilePath,/.test(source)) {
+    filePathValues.push('filePath')
+  }
+  const relativePathValues = [
+    ...source.matchAll(/\brelativePath(?::|\s*=)\s*([\s\S]*?)(?:,\s*\n|\n\s*[})])/g)
+  ].map((match) => match[1])
+  return relativePathValues.some((value) =>
+    filePathValues.some((filePath) =>
+      new RegExp(`(^|[^\\w.])${filePath.replace(/\./g, '\\.')}($|[^\\w.])`).test(value)
+    )
+  )
+}
+
+function rendererFilesMatching(test: (source: string) => boolean): string[] {
+  const rendererRoot = resolve(__dirname, '..')
+  return collectSourceFiles(rendererRoot)
+    .filter((file) => test(readFileSync(file, 'utf8')))
+    .map((file) => relative(rendererRoot, file).split('\\').join('/'))
+    .sort()
+}
+
+describe('user-named file access ratchet', () => {
+  it('lists every file that builds user-file access', () => {
+    expect(
+      rendererFilesMatching((source) => /\buserNamedFileAccess\b|kind: 'user-file'/.test(source))
+    ).toEqual(USER_NAMED_ACCESS_IMPORTERS)
+  })
+
+  it('lists every file that builds document-folder write access', () => {
+    expect(
+      rendererFilesMatching((source) =>
+        /\b(editorTab)?[dD]ocumentFolderAccess\b|kind: 'document-folder'/.test(source)
+      )
+    ).toEqual(DOCUMENT_FOLDER_ACCESS_BUILDERS)
+  })
+
+  it('lists every file that can open a tab read as user-named', () => {
+    expect(rendererFilesMatching(opensUserNamedTabs)).toEqual(USER_NAMED_TAB_OPENERS)
+  })
+})
diff --git a/src/renderer/src/lib/local-file-access.ts b/src/renderer/src/lib/local-file-access.ts
new file mode 100644
index 00000000000..d93b1d30e84
--- /dev/null
+++ b/src/renderer/src/lib/local-file-access.ts
@@ -0,0 +1,89 @@
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../shared/constants'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
+import { settingsForRuntimeOwner } from '@/runtime/runtime-client-target'
+import type { OpenFile } from '@/store/slices/editor'
+import type { AppState } from '@/store/types'
+import { getConnectionIdForFile } from './connection-context'
+
+const USER_FILE_ACCESS: LocalFileAccess = { kind: 'user-file' }
+const CHAT_IMAGE_ACCESS: LocalFileAccess = { kind: 'chat-image' }
+
+/** For a path the user named by a gesture (click, drop, typed path); never for document content. */
+export function userNamedFileAccess(): LocalFileAccess {
+  return USER_FILE_ACCESS
+}
+
+/**
+ * For an image a chat transcript or composer shows. Main reads any local image file in place, by
+ * its real type, and refuses network shares, so it is safe for content no one clicked.
+ */
+export function chatImageAccess(): LocalFileAccess {
+  return CHAT_IMAGE_ACCESS
+}
+
+/**
+ * For acting on a document the user opened: renaming it (to any path the user typed) or inserting
+ * an image next to it, which main keeps inside the document's own folder.
+ */
+export function documentFolderAccess(documentPath: string): LocalFileAccess {
+  return { kind: 'document-folder', documentPath }
+}
+
+/** For a file a document's content references; main limits it to the document's roots or folder. */
+export function documentResourceAccess(documentPath: string): LocalFileAccess {
+  return { kind: 'document-resource', documentPath }
+}
+
+type EditorTabAccessFile = Pick<
+  OpenFile,
+  | 'filePath'
+  | 'relativePath'
+  | 'worktreeId'
+  | 'runtimeEnvironmentId'
+  | 'externalSshTargetId'
+  | 'readOnly'
+  | 'liveTail'
+>
+
+/**
+ * The file access a persisted editor tab reads and saves with. A tab the user opened outside its owner's
+ * root (a floating-workspace tab, or one stored with an absolute path) is user-named, so it reads
+ * the same before and after a restart; every other tab stays inside its project root.
+ */
+export function editorTabFileAccess(
+  state: Pick<AppState, 'settings'>,
+  file: EditorTabAccessFile
+): LocalFileAccess | undefined {
+  // Why: AI Vault logs are client-local files the user opened, whatever the worktree's host.
+  if (file.readOnly === true && file.liveTail === true) {
+    return USER_FILE_ACCESS
+  }
+  const runtimeOwner = settingsForRuntimeOwner(state.settings, file.runtimeEnvironmentId)
+  if (file.externalSshTargetId?.trim() || runtimeOwner?.activeRuntimeEnvironmentId?.trim()) {
+    return undefined
+  }
+  const outsideOwnerRoot =
+    file.worktreeId === FLOATING_TERMINAL_WORKTREE_ID || file.relativePath === file.filePath
+  // Why null only: an SSH, ambiguous or not-yet-loaded owner may mean the path lives on another host.
+  if (!outsideOwnerRoot || getConnectionIdForFile(file.worktreeId, file.filePath) !== null) {
+    return undefined
+  }
+  return USER_FILE_ACCESS
+}
+
+/**
+ * The write access for acting on an open tab's file (rename, image insert) when the tab is
+ * user-named, else none, so project tabs keep their project checks.
+ */
+export function editorTabDocumentFolderAccess(
+  state: Pick<AppState, 'settings'>,
+  file: EditorTabAccessFile
+): LocalFileAccess | undefined {
+  // Why: a read-only tab (an AI Vault log, possibly in an SSH workspace) is never written.
+  if (file.readOnly === true) {
+    return undefined
+  }
+  return editorTabFileAccess(state, file)?.kind === 'user-file'
+    ? documentFolderAccess(file.filePath)
+    : undefined
+}
diff --git a/src/renderer/src/lib/new-agent-prompt-outcome.test.ts b/src/renderer/src/lib/new-agent-prompt-outcome.test.ts
new file mode 100644
index 00000000000..3430019ee2b
--- /dev/null
+++ b/src/renderer/src/lib/new-agent-prompt-outcome.test.ts
@@ -0,0 +1,235 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { RuntimeMobileSessionTabsResult } from '../../../shared/runtime-session-contracts'
+import type { StructuredAgentSessionLaunchIntent } from '@/lib/launch-structured-agent-session'
+
+const mocks = vi.hoisted(() => ({
+  callStructuredAgentSession: vi.fn(),
+  createIntent: vi.fn(),
+  launch: vi.fn()
+}))
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), message: vi.fn() } }))
+
+vi.mock('@/lib/launch-structured-agent-session', () => {
+  class StructuredAgentSessionCreateRefusalError extends Error {}
+  return {
+    createStructuredAgentSessionLaunchIntent: mocks.createIntent,
+    retryStructuredAgentSessionLaunchIntent: (intent: unknown) => intent,
+    restoreStructuredAgentSessionLaunchIntent: vi.fn(),
+    abandonStructuredAgentSessionLaunchIntent: vi.fn(),
+    launchStructuredAgentSession: mocks.launch,
+    StructuredAgentSessionCreateRefusalError
+  }
+})
+
+vi.mock('@/runtime/local-structured-session-tabs-sync', () => ({
+  refreshLocalStructuredSessionTabs: vi.fn()
+}))
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.callStructuredAgentSession
+}))
+
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({
+      unifiedTabsByWorktree: {},
+      seedNativeChatLaunchDraft: vi.fn(),
+      clearNativeChatLaunchDraft: vi.fn()
+    }),
+    subscribe: () => () => undefined
+  }
+}))
+
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+
+vi.mock('@/lib/agent-catalog', () => ({
+  getAgentLabel: () => 'Codex',
+  getAgentCatalog: () => [{ id: 'codex', label: 'Codex' }]
+}))
+
+import { StructuredAgentSessionCreateRefusalError } from '@/lib/launch-structured-agent-session'
+import { refreshLocalStructuredSessionTabs } from '@/runtime/local-structured-session-tabs-sync'
+import {
+  mutateStructuredAgentSessionLaunchPrompt,
+  readOutbox
+} from '@/components/native-chat/structured-agent-session-outbox-storage'
+import {
+  cancelStructuredAgentLaunch,
+  getStructuredAgentSessionLaunchLifecycle,
+  retryStructuredAgentSessionLaunch,
+  startStructuredAgentLaunch
+} from './structured-agent-session-launch'
+import { resetStructuredAgentLaunchPersistenceForTests } from './structured-agent-session-launch-persistence'
+import { resetStructuredAgentLaunchRegistryForTests } from './structured-agent-session-launch-registry'
+import {
+  holdNotesForSend,
+  isNoteInFlight,
+  resetNotesInFlightForTests
+} from './notes-send-in-flight'
+import { newAgentPromptOutcome } from './new-agent-prompt-outcome'
+
+const WORKTREE_ID = 'wt-notes-new-agent'
+const NOTES = 'review notes'
+
+function launchIntent(sessionId: string): StructuredAgentSessionLaunchIntent {
+  return {
+    worktreeId: WORKTREE_ID,
+    sessionId,
+    executionHostId: 'local',
+    target: { kind: 'local' },
+    agent: 'codex',
+    params: {
+      envelope: {
+        sessionId,
+        clientOperationId: `operation-${sessionId}`,
+        expectedRuntimeFence: null,
+        payloadFingerprint: `fingerprint-${sessionId}`
+      },
+      worktree: `id:${WORKTREE_ID}`,
+      agent: 'codex'
+    }
+  }
+}
+
+function published(sessionId: string): RuntimeMobileSessionTabsResult {
+  return {
+    worktree: WORKTREE_ID,
+    publicationEpoch: 'epoch-1',
+    snapshotVersion: 1,
+    activeGroupId: null,
+    activeTabId: null,
+    activeTabType: null,
+    tabs: [
+      {
+        type: 'agent-session',
+        id: 'tab-1',
+        title: 'Codex',
+        sessionId,
+        agent: 'codex',
+        isActive: false
+      }
+    ]
+  }
+}
+
+async function settle(): Promise<void> {
+  for (let i = 0; i < 20; i += 1) {
+    await Promise.resolve()
+  }
+}
+
+const chat = launchIntent('session-notes')
+
+/** What the notes menu does with a "New agent" pick: the launch, then the hold on its outcome. */
+function sendNotesToNewAgent(options: { paired?: boolean } = {}) {
+  const onDelivered = vi.fn()
+  const launch = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+    requestId: 'request-1',
+    prompt: NOTES,
+    promptDelivery: 'submit-after-ready'
+  })
+  holdNotesForSend(
+    ['note-a'],
+    newAgentPromptOutcome({
+      prompt: NOTES,
+      ...(options.paired ? {} : { sessionId: launch.sessionId }),
+      delivery: launch.promptDeliveryResult!
+    }),
+    onDelivered
+  )
+  return { launch, onDelivered }
+}
+
+/** A start the host refused outright: the chat shows it failed, with Retry. */
+async function failTheStart(): Promise<void> {
+  await settle()
+  expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, chat.sessionId)).toBe('failed')
+}
+
+describe('notes sent to a new agent', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    localStorage.clear()
+    resetStructuredAgentLaunchPersistenceForTests()
+    resetStructuredAgentLaunchRegistryForTests()
+    resetNotesInFlightForTests()
+    mocks.createIntent.mockReturnValue(chat)
+    vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([published(chat.sessionId)])
+    mocks.callStructuredAgentSession.mockResolvedValue({
+      ok: true,
+      value: { submission: { dispatchState: 'accepted' } }
+    })
+  })
+
+  it('leaves the shelf once the new chat delivers them', async () => {
+    mocks.launch.mockResolvedValue({ sessionId: chat.sessionId, fence: 1 })
+    const { onDelivered } = sendNotesToNewAgent()
+    expect(isNoteInFlight('note-a')).toBe(true)
+
+    await settle()
+
+    expect(onDelivered).toHaveBeenCalledOnce()
+    expect(isNoteInFlight('note-a')).toBe(false)
+  })
+
+  it('stay held, not resendable, while a failed chat keeps them for its Retry', async () => {
+    mocks.launch.mockRejectedValue(new StructuredAgentSessionCreateRefusalError('unsupported'))
+    const { onDelivered } = sendNotesToNewAgent()
+    await failTheStart()
+
+    expect(readOutbox(chat.sessionId)).toHaveLength(1)
+    expect(isNoteInFlight('note-a')).toBe(true)
+    expect(onDelivered).not.toHaveBeenCalled()
+  })
+
+  it("leave the shelf when that chat's Retry delivers them", async () => {
+    mocks.launch.mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('unsupported'))
+    const { onDelivered } = sendNotesToNewAgent()
+    await failTheStart()
+    mocks.launch.mockResolvedValue({ sessionId: chat.sessionId, fence: 1 })
+
+    expect(retryStructuredAgentSessionLaunch(WORKTREE_ID, chat.sessionId)).toBe(true)
+    await settle()
+    // The open chat's own send accepts the staged prompt, as every dispatch does.
+    const [entry] = readOutbox(chat.sessionId)
+    mutateStructuredAgentSessionLaunchPrompt(chat.sessionId, entry.clientMessageId, () => null)
+    await settle()
+
+    expect(onDelivered).toHaveBeenCalledOnce()
+    expect(isNoteInFlight('note-a')).toBe(false)
+  })
+
+  it('come back to the shelf when the failed chat is closed', async () => {
+    mocks.launch.mockRejectedValue(new StructuredAgentSessionCreateRefusalError('unsupported'))
+    const { onDelivered } = sendNotesToNewAgent()
+    await failTheStart()
+
+    cancelStructuredAgentLaunch(WORKTREE_ID, chat.sessionId)
+    await settle()
+
+    expect(isNoteInFlight('note-a')).toBe(false)
+    expect(onDelivered).not.toHaveBeenCalled()
+  })
+
+  it('come back when a chat still starting is closed, without waiting on its create', async () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    const { onDelivered } = sendNotesToNewAgent()
+
+    cancelStructuredAgentLaunch(WORKTREE_ID, chat.sessionId)
+    await settle()
+
+    expect(isNoteInFlight('note-a')).toBe(false)
+    expect(onDelivered).not.toHaveBeenCalled()
+  })
+
+  it("stay held by a paired server's failed chat, found once its start settles", async () => {
+    mocks.launch.mockRejectedValue(new StructuredAgentSessionCreateRefusalError('unsupported'))
+    sendNotesToNewAgent({ paired: true })
+    await failTheStart()
+
+    expect(isNoteInFlight('note-a')).toBe(true)
+  })
+})
diff --git a/src/renderer/src/lib/new-agent-prompt-outcome.ts b/src/renderer/src/lib/new-agent-prompt-outcome.ts
new file mode 100644
index 00000000000..8fff9022213
--- /dev/null
+++ b/src/renderer/src/lib/new-agent-prompt-outcome.ts
@@ -0,0 +1,62 @@
+import type { StructuredAgentSessionOutboxEntry } from '../../../shared/structured-agent-session-outbox'
+import { getStructuredAgentSessionOutbox } from '@/components/native-chat/structured-agent-session-outbox-storage'
+import { watchStructuredAgentSessionOutboxEntry } from '@/components/native-chat/structured-agent-session-outbox-entry-watch'
+import { structuredLaunchStates } from './structured-agent-session-launch-registry'
+
+export type NewAgentPromptOutcome = { delivered: boolean }
+
+function stagedLaunchPrompt(
+  sessionId: string,
+  text: string
+): StructuredAgentSessionOutboxEntry | undefined {
+  return getStructuredAgentSessionOutbox(sessionId).findLast(
+    (entry) =>
+      entry.source === 'launch' &&
+      entry.body.blocks.some((block) => block.type === 'text' && block.text === text)
+  )
+}
+
+/** A failed or unconfirmed chat keeps its prompt staged for its own Retry or re-check. */
+function stagedInAnyLaunch(text: string): StructuredAgentSessionOutboxEntry | undefined {
+  let found: StructuredAgentSessionOutboxEntry | undefined
+  for (const state of structuredLaunchStates()) {
+    found = stagedLaunchPrompt(state.intent.sessionId, text) ?? found
+  }
+  return found
+}
+
+function outcomeOf(entry: StructuredAgentSessionOutboxEntry): Promise<NewAgentPromptOutcome> {
+  return new Promise((resolve) => {
+    watchStructuredAgentSessionOutboxEntry(entry, (removal) =>
+      resolve({ delivered: removal === 'spent' })
+    )
+  })
+}
+
+/**
+ * Settles once a new agent's prompt is sent on (delivered) or thrown away with its chat. A chat's
+ * staged prompt is the authority, so a Retry or re-check that sends it later still counts, and a
+ * failed start does not hand the text back while that chat still holds it.
+ */
+export function newAgentPromptOutcome(args: {
+  prompt: string
+  sessionId?: string
+  delivery: Promise<{ delivered: boolean }>
+}): Promise<NewAgentPromptOutcome> {
+  const text = args.prompt.trim()
+  const staged = args.sessionId ? stagedLaunchPrompt(args.sessionId, text) : undefined
+  if (staged) {
+    return outcomeOf(staged)
+  }
+  // A paired server's chat exists only once it is admitted, so look again after the start.
+  const afterStart = (
+    delivered: boolean
+  ): Promise<NewAgentPromptOutcome> | NewAgentPromptOutcome => {
+    const kept = delivered ? undefined : stagedInAnyLaunch(text)
+    return kept ? outcomeOf(kept) : { delivered }
+  }
+  return args.delivery.then(
+    (result) => afterStart(result.delivered),
+    () => afterStart(false)
+  )
+}
diff --git a/src/renderer/src/lib/notes-send-in-flight.ts b/src/renderer/src/lib/notes-send-in-flight.ts
new file mode 100644
index 00000000000..cd50f23dc7d
--- /dev/null
+++ b/src/renderer/src/lib/notes-send-in-flight.ts
@@ -0,0 +1,96 @@
+import { useSyncExternalStore } from 'react'
+import type { DiffCommentDeliverySnapshot } from '@/store/slices/diffComments'
+
+// Why: notes handed to a send leave the next send at once and come back only if that delivery
+// fails, as a submitted composer clears and restores on error. Delivered notes are still removed
+// by their owner; a hold lives only until its delivery settles.
+const holds = new Map<unknown, number>()
+const listeners = new Set<() => void>()
+let version = 0
+
+function changed(): void {
+  version += 1
+  for (const listener of listeners) {
+    listener()
+  }
+}
+
+function reportsDelivered(result: unknown): boolean {
+  return typeof result === 'object' && result !== null && 'delivered' in result
+    ? result.delivered === true
+    : false
+}
+
+/** Takes `keys` out of the next send until `delivered` settles, whatever its result. A result that
+ *  reports delivery also runs `onDelivered`, for a send whose own callback can no longer fire
+ *  (a Retry of a failed new chat). */
+export function holdNotesForSend(
+  keys: readonly unknown[],
+  delivered: Promise<unknown>,
+  onDelivered?: () => void
+): void {
+  if (keys.length === 0) {
+    return
+  }
+  // Registered before the release, so delivered notes are gone before they could show again.
+  void delivered.then(
+    (result) => {
+      if (reportsDelivered(result)) {
+        onDelivered?.()
+      }
+    },
+    () => undefined
+  )
+  for (const key of keys) {
+    holds.set(key, (holds.get(key) ?? 0) + 1)
+  }
+  changed()
+  const release = (): void => {
+    for (const key of keys) {
+      const count = (holds.get(key) ?? 1) - 1
+      if (count > 0) {
+        holds.set(key, count)
+      } else {
+        holds.delete(key)
+      }
+    }
+    changed()
+  }
+  void delivered.then(release, release)
+}
+
+export function isNoteInFlight(key: unknown): boolean {
+  return holds.has(key)
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener)
+  return () => listeners.delete(listener)
+}
+
+function getVersion(): number {
+  return version
+}
+
+/** Changes whenever a hold starts or ends, for memos that filter by `isNoteInFlight`. */
+export function useNotesInFlightVersion(): number {
+  return useSyncExternalStore(subscribe, getVersion, getVersion)
+}
+
+/** A note's identity for delivery: an edit makes it a new pending note, as for its removal. */
+export function diffCommentSendKey(note: DiffCommentDeliverySnapshot): string {
+  return JSON.stringify([
+    note.id,
+    note.body,
+    note.filePath,
+    note.lineNumber,
+    note.startLine ?? null,
+    note.selectedText ?? null,
+    note.source ?? null
+  ])
+}
+
+export function resetNotesInFlightForTests(): void {
+  holds.clear()
+  changed()
+}
diff --git a/src/renderer/src/lib/onboarding-folder-agent-launch.ts b/src/renderer/src/lib/onboarding-folder-agent-launch.ts
index a7af4cbc496..3ae37582360 100644
--- a/src/renderer/src/lib/onboarding-folder-agent-launch.ts
+++ b/src/renderer/src/lib/onboarding-folder-agent-launch.ts
@@ -6,6 +6,7 @@ import {
   planAgentSessionLaunch,
   type AgentSessionLaunchPlan
 } from '@/lib/agent-session-launch-plan'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import {
   buildDismissedOnboardingFolderAgentStartup,
   type OnboardingFolderAgentStartup
@@ -39,7 +40,9 @@ export function resolveDismissedOnboardingFolderAgentLaunch(args: {
   if (!startup || !agent) {
     return { agent: null, plan: null }
   }
+  // Resolved once per added folder: adding it is the one action this chat serves.
   const plan = planAgentSessionLaunch(args.store, {
+    requestId: newAgentLaunchRequestId(),
     agent,
     workspace: { kind: 'folder', executionHostId: args.executionHostId },
     initialSessionOptions: startup.sessionOptions
diff --git a/src/renderer/src/lib/pending-worktree-creation.ts b/src/renderer/src/lib/pending-worktree-creation.ts
index 1e703df742f..8460d917f05 100644
--- a/src/renderer/src/lib/pending-worktree-creation.ts
+++ b/src/renderer/src/lib/pending-worktree-creation.ts
@@ -1,3 +1,5 @@
+import type { ExecutionHostId } from '../../../shared/execution-host'
+import type { FolderWorkspaceLinkedTask } from '../../../shared/folder-workspace-types'
 import type { TuiAgent } from '../../../shared/tui-agent'
 import type { WorkspaceSource as WorkspaceCreateTelemetrySource } from '../../../shared/workspace-source'
 import type {
@@ -24,15 +26,12 @@ export type WorktreeCreationPhase = 'preparing' | 'provisioning-vm' | 'fetching'
 
 export type WorktreeCreationProgressMode = 'stepped' | 'indeterminate'
 
-/**
- * Everything needed to run a worktree create in the background and reproduce it
- * verbatim on retry. Captured at the composer's submit cut point — after all
- * interactive preflight (trust/setup decisions) has resolved — so the modal can
- * close immediately and the work outlives it. Must stay plain-serializable
- * (no closures/refs) so a pending entry can hold it for the panel's Retry.
- */
+/** Serializable creation intent, including any script checks deferred until
+ * after the composer closes. Retained by the pending panel for Retry. */
 export type WorktreeCreationRequest = {
   repoId: string
+  /** Execution owner retained after script preparation, including retries. */
+  executionHostId?: ExecutionHostId
   /** Source host/account that produced the linked task. Kept separate from the
    *  run context so Retry does not infer provider ownership from the run host. */
   taskSourceContext?: TaskSourceContext | null
@@ -71,6 +70,16 @@ export type WorktreeCreationRequest = {
   baseBranch?: string
   compareBaseRef?: string
   setupDecision: SetupDecision
+  /** Inspect and confirm scripts on the captured host after the composer closes. */
+  hookPreparation?: {
+    executionHostId?: ExecutionHostId
+    confirmVmRecipe?: boolean
+    issueCommand?: {
+      provider: FolderWorkspaceLinkedTask['provider'] | null
+      issueNumber: number
+      artifactUrl: string | null
+    }
+  }
   sparseCheckout?: CreateSparseCheckoutRequest
   telemetrySource?: WorkspaceCreateTelemetrySource
   linkedIssue?: number
diff --git a/src/renderer/src/lib/remap-open-editor-tabs-for-path-change.ts b/src/renderer/src/lib/remap-open-editor-tabs-for-path-change.ts
index 645ad60ce99..fcac9a33584 100644
--- a/src/renderer/src/lib/remap-open-editor-tabs-for-path-change.ts
+++ b/src/renderer/src/lib/remap-open-editor-tabs-for-path-change.ts
@@ -165,6 +165,10 @@ function getUpdatedRelativePath({
   initiatingWorktreeId: string | undefined
   initiatingWorktreePath: string
 }): string {
+  // Why: a tab stored by its full path is user-named (editorTabFileAccess); keep it that way.
+  if (relativePath === filePath) {
+    return updatedPath
+  }
   const worktreeRelative = relativePathInsideRoot(initiatingWorktreePath, filePath)
   // Both sides fold on the same flavor (the file's own absolute path) so the
   // comparison stays consistent and a legal POSIX backslash isn't mistaken for a
diff --git a/src/renderer/src/lib/rename-file.ts b/src/renderer/src/lib/rename-file.ts
index 71161349e13..bfadcc41fd9 100644
--- a/src/renderer/src/lib/rename-file.ts
+++ b/src/renderer/src/lib/rename-file.ts
@@ -30,6 +30,8 @@ type RenameFileArgs = {
   operationOwner?: FileExplorerOperationOwner
   /** refresh the parent directory in the explorer tree, if caller tracks one */
   refreshDir?: (dirPath: string) => Promise<void>
+  /** The file is an open user-named document, so the rename (and its Undo) may go anywhere. */
+  documentScoped?: boolean
 }
 
 /**
@@ -76,7 +78,8 @@ export async function renameFileOnDisk(args: RenameFileArgs): Promise<void> {
       fromPath: oldPath,
       toPath: newPath,
       worktreeId,
-      worktreePath
+      worktreePath,
+      documentScoped: args.documentScoped
     })
     commitFileExplorerOp({
       undo: async () => {
@@ -86,7 +89,8 @@ export async function renameFileOnDisk(args: RenameFileArgs): Promise<void> {
           fromPath: newPath,
           toPath: oldPath,
           worktreeId,
-          worktreePath
+          worktreePath,
+          documentScoped: args.documentScoped
         })
         if (refreshDir) {
           await refreshDir(parentDir)
@@ -99,7 +103,8 @@ export async function renameFileOnDisk(args: RenameFileArgs): Promise<void> {
           fromPath: oldPath,
           toPath: newPath,
           worktreeId,
-          worktreePath
+          worktreePath,
+          documentScoped: args.documentScoped
         })
         if (refreshDir) {
           await refreshDir(parentDir)
diff --git a/src/renderer/src/lib/rename-user-named-tab-access.test.ts b/src/renderer/src/lib/rename-user-named-tab-access.test.ts
new file mode 100644
index 00000000000..d7a70867173
--- /dev/null
+++ b/src/renderer/src/lib/rename-user-named-tab-access.test.ts
@@ -0,0 +1,232 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as RuntimeFileClient from '@/runtime/runtime-file-client'
+import type * as EditorAutosave from '@/components/editor/editor-autosave'
+
+const mocks = vi.hoisted(() => ({ renameRuntimePath: vi.fn(), writeRuntimeFile: vi.fn() }))
+vi.mock('@/runtime/runtime-file-client', async (importOriginal) => {
+  const actual = await importOriginal<typeof RuntimeFileClient>()
+  return {
+    ...actual,
+    renameRuntimePath: mocks.renameRuntimePath,
+    writeRuntimeFile: mocks.writeRuntimeFile
+  }
+})
+vi.mock('@/components/editor/editor-autosave', async (importOriginal) => {
+  const actual = await importOriginal<typeof EditorAutosave>()
+  return { ...actual, requestEditorSaveQuiesce: vi.fn().mockResolvedValue(undefined) }
+})
+
+import { useAppStore } from '@/store'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../shared/constants'
+import type { Repo } from '../../../shared/repo-types'
+import type { Worktree } from '../../../shared/worktree/types'
+import {
+  clearFileExplorerUndoHistory,
+  redoFileExplorer,
+  undoFileExplorer
+} from '@/components/right-sidebar/fileExplorerUndoRedo'
+import { createEditorSaveQueue } from '@/components/editor/editor-save-queue'
+import { editorTabDocumentFolderAccess, editorTabFileAccess } from './local-file-access'
+import { renameFileOnDisk } from './rename-file'
+
+const PROJECT = '/Users/me/project'
+const WT = `repo-local::${PROJECT}`
+const repo: Repo = {
+  id: 'repo-local',
+  path: PROJECT,
+  displayName: 'project',
+  badgeColor: '#000',
+  addedAt: 0
+}
+const worktree: Worktree = {
+  id: WT,
+  repoId: 'repo-local',
+  path: PROJECT,
+  head: 'a',
+  branch: 'refs/heads/main',
+  isBare: false,
+  isMainWorktree: true,
+  displayName: 'project',
+  comment: '',
+  linkedIssue: null,
+  linkedPR: null,
+  linkedLinearIssue: null,
+  isArchived: false,
+  isUnread: false,
+  isPinned: false,
+  sortOrder: 0,
+  lastActivityAt: 0
+}
+
+const documentFolder = (documentPath: string) => ({ kind: 'document-folder', documentPath })
+
+function openUserNamedTab(filePath: string, worktreeId: string): void {
+  useAppStore.getState().openFile(
+    {
+      filePath,
+      relativePath: filePath,
+      worktreeId,
+      runtimeEnvironmentId: null,
+      language: 'markdown',
+      mode: 'edit'
+    },
+    { suppressActiveRuntimeFallback: true }
+  )
+}
+
+function onlyTab() {
+  const tabs = useAppStore.getState().openFiles
+  expect(tabs).toHaveLength(1)
+  return tabs[0]!
+}
+
+// Why each check: reads and the next rename/image insert derive access from the tab, and a restart
+// restores the same filePath/relativePath, so access must survive on the stored fields alone.
+async function expectUserNamedAt(filePath: string): Promise<void> {
+  const tab = onlyTab()
+  expect(tab.filePath).toBe(filePath)
+  expect(tab.relativePath).toBe(filePath)
+  const state = useAppStore.getState()
+  expect(editorTabFileAccess(state, tab)).toEqual({ kind: 'user-file' })
+  expect(editorTabDocumentFolderAccess(state, tab)).toEqual(documentFolder(filePath))
+  const restored = {
+    filePath: tab.filePath,
+    relativePath: tab.relativePath,
+    worktreeId: tab.worktreeId,
+    runtimeEnvironmentId: tab.runtimeEnvironmentId
+  }
+  expect(editorTabFileAccess(state, restored)).toEqual({ kind: 'user-file' })
+
+  mocks.writeRuntimeFile.mockClear()
+  await createEditorSaveQueue(useAppStore).queueSave(tab, 'edited', 'user')
+  expect(mocks.writeRuntimeFile).toHaveBeenCalledWith(expect.anything(), filePath, 'edited', {
+    kind: 'user-file'
+  })
+}
+
+async function renameTab(newName: string, worktreePath: string): Promise<void> {
+  const tab = onlyTab()
+  await renameFileOnDisk({
+    oldPath: tab.filePath,
+    newName,
+    worktreeId: tab.worktreeId,
+    worktreePath,
+    operationOwner: { kind: 'local' },
+    documentScoped: editorTabDocumentFolderAccess(useAppStore.getState(), tab) !== undefined
+  })
+}
+
+function renameCalls(): unknown[][] {
+  return mocks.renameRuntimePath.mock.calls.map((call) => call.slice(1))
+}
+
+beforeEach(() => {
+  useAppStore.setState(useAppStore.getInitialState(), true)
+  useAppStore.setState({ repos: [repo], worktreesByRepo: { 'repo-local': [worktree] } })
+  clearFileExplorerUndoHistory()
+  mocks.renameRuntimePath.mockReset().mockResolvedValue(undefined)
+  mocks.writeRuntimeFile.mockReset().mockResolvedValue(undefined)
+  vi.stubGlobal('window', {
+    setTimeout,
+    clearTimeout,
+    dispatchEvent: vi.fn()
+  })
+})
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('renaming a floating-workspace document, then Undo and Redo', () => {
+  const NOTE = '/home/me/notes/note.md'
+
+  // Why the moved file is the document on Undo: main widens a rename only from the opened document.
+  it.each([
+    ['another outside folder', '../other/note.md', '/home/me/notes/../other/note.md'],
+    [
+      'a project',
+      '../../../Users/me/project/note.md',
+      '/home/me/notes/../../../Users/me/project/note.md'
+    ],
+    ['a subfolder', 'archive/note.md', '/home/me/notes/archive/note.md']
+  ])('moves it into %s and keeps it user-named', async (_, newName, moved) => {
+    openUserNamedTab(NOTE, FLOATING_TERMINAL_WORKTREE_ID)
+
+    await renameTab(newName, '/home/me/notes')
+    await expectUserNamedAt(moved)
+    expect(await undoFileExplorer()).toBe(true)
+    await expectUserNamedAt(NOTE)
+    expect(await redoFileExplorer()).toBe(true)
+    await expectUserNamedAt(moved)
+
+    expect(renameCalls()).toEqual([
+      [NOTE, moved, documentFolder(NOTE)],
+      [moved, NOTE, documentFolder(moved)],
+      [NOTE, moved, documentFolder(NOTE)]
+    ])
+  })
+})
+
+describe('renaming a tab opened by its full path in a project workspace', () => {
+  it.each([
+    ['to another outside name', '/tmp/notes.md', 'notes2.md', '/tmp/notes2.md'],
+    ['into its own project', '/Users/me/notes.md', 'project/notes.md', `${PROJECT}/notes.md`],
+    [
+      'out of its own project',
+      `${PROJECT}/docs/plan.md`,
+      '../../plan.md',
+      `${PROJECT}/docs/../../plan.md`
+    ]
+  ])('keeps it user-named %s, after Undo too', async (_, original, newName, moved) => {
+    openUserNamedTab(original, WT)
+
+    await renameTab(newName, PROJECT)
+    await expectUserNamedAt(moved)
+    expect(await undoFileExplorer()).toBe(true)
+    await expectUserNamedAt(original)
+
+    expect(renameCalls()).toEqual([
+      [original, moved, documentFolder(original)],
+      [moved, original, documentFolder(moved)]
+    ])
+  })
+
+  it('keeps a full-path tab user-named when its project folder is moved', async () => {
+    const link = `${PROJECT}/docs/link.md`
+    openUserNamedTab(link, WT)
+
+    await renameFileOnDisk({
+      oldPath: `${PROJECT}/docs`,
+      newName: 'notes',
+      worktreeId: WT,
+      worktreePath: PROJECT,
+      operationOwner: { kind: 'local' }
+    })
+
+    await expectUserNamedAt(`${PROJECT}/notes/link.md`)
+    expect(renameCalls()).toEqual([[`${PROJECT}/docs`, `${PROJECT}/notes`, undefined]])
+  })
+
+  it('still recomputes a project tab project-relative, with no declared access', async () => {
+    useAppStore.getState().openFile(
+      {
+        filePath: `${PROJECT}/docs/plan.md`,
+        relativePath: 'docs/plan.md',
+        worktreeId: WT,
+        runtimeEnvironmentId: null,
+        language: 'markdown',
+        mode: 'edit'
+      },
+      { suppressActiveRuntimeFallback: true }
+    )
+
+    await renameTab('plan2.md', PROJECT)
+
+    const tab = onlyTab()
+    expect(tab.relativePath).toBe('docs/plan2.md')
+    expect(editorTabFileAccess(useAppStore.getState(), tab)).toBeUndefined()
+    expect(renameCalls()).toEqual([
+      [`${PROJECT}/docs/plan.md`, `${PROJECT}/docs/plan2.md`, undefined]
+    ])
+  })
+})
diff --git a/src/renderer/src/lib/run-quick-command-in-new-tab.test.ts b/src/renderer/src/lib/run-quick-command-in-new-tab.test.ts
index 8ed19648702..f6f850ff0ef 100644
--- a/src/renderer/src/lib/run-quick-command-in-new-tab.test.ts
+++ b/src/renderer/src/lib/run-quick-command-in-new-tab.test.ts
@@ -141,6 +141,7 @@ describe('runQuickCommandInNewTab', () => {
 
     expect(result).toEqual({ tabId: 'tab-agent' })
     expect(mocks.launchAgentInNewTab).toHaveBeenCalledWith({
+      requestId: expect.any(String),
       agent: 'codex',
       prompt: 'Review this diff',
       worktreeId: 'repo::worktree',
@@ -173,6 +174,7 @@ describe('runQuickCommandInNewTab', () => {
     })
 
     expect(mocks.launchAgentInNewTab).toHaveBeenCalledWith({
+      requestId: expect.any(String),
       agent: 'opencode2',
       prompt: 'Review this diff',
       promptDelivery: 'submit-after-ready',
@@ -228,6 +230,7 @@ describe('runQuickCommandInNewTab', () => {
 
     expect(result).toEqual({ tabId: 'tab-agent' })
     expect(mocks.launchAgentInNewTab).toHaveBeenCalledWith({
+      requestId: expect.any(String),
       agent: 'codex',
       prompt: 'Review this diff',
       worktreeId: 'repo::worktree',
diff --git a/src/renderer/src/lib/run-quick-command-in-new-tab.ts b/src/renderer/src/lib/run-quick-command-in-new-tab.ts
index 8ab42b2223d..99a709c40b0 100644
--- a/src/renderer/src/lib/run-quick-command-in-new-tab.ts
+++ b/src/renderer/src/lib/run-quick-command-in-new-tab.ts
@@ -1,6 +1,7 @@
 import { useAppStore } from '@/store'
 import { reconcileTabOrder } from '@/components/tab-bar/reconcile-order'
 import { launchAgentInNewTab } from '@/lib/launch-agent-in-new-tab'
+import { newAgentLaunchRequestId } from '@/lib/agent-launch-request-id'
 import {
   flattenTerminalQuickCommand,
   isTerminalAgentQuickCommand,
@@ -65,6 +66,7 @@ export function runQuickCommandInNewTab({
       return null
     }
     const result = launchAgentInNewTab({
+      requestId: newAgentLaunchRequestId(),
       agent: command.agent,
       prompt: command.prompt,
       worktreeId,
diff --git a/src/renderer/src/lib/screen-submit-shortcut.test.ts b/src/renderer/src/lib/screen-submit-shortcut.test.ts
index 859bf79fc3e..ccceac05463 100644
--- a/src/renderer/src/lib/screen-submit-shortcut.test.ts
+++ b/src/renderer/src/lib/screen-submit-shortcut.test.ts
@@ -66,4 +66,19 @@ describe('screen submit shortcut', () => {
       })
     ).toBe(false)
   })
+
+  it.each(['Macintosh', 'Linux', 'Windows NT'])(
+    'ignores keyCode-only IME chords on %s',
+    (platform) => {
+      setUserAgent(platform)
+      const chord = {
+        key: 'Enter',
+        metaKey: platform === 'Macintosh',
+        ctrlKey: platform !== 'Macintosh'
+      }
+      expect(isScreenSubmitShortcut({ ...chord, keyCode: 229 })).toBe(false)
+      expect(isScreenSubmitShortcut({ ...chord, nativeEvent: { keyCode: 229 } })).toBe(false)
+      expect(isScreenSubmitShortcut(chord)).toBe(true)
+    }
+  )
 })
diff --git a/src/renderer/src/lib/screen-submit-shortcut.ts b/src/renderer/src/lib/screen-submit-shortcut.ts
index 1d6e73acc78..51a77c4bbfc 100644
--- a/src/renderer/src/lib/screen-submit-shortcut.ts
+++ b/src/renderer/src/lib/screen-submit-shortcut.ts
@@ -1,3 +1,4 @@
+import { isImeOwnedKeyboardEvent } from './ime-composition-keyboard-event'
 import { getShortcutPlatform } from './shortcut-platform'
 
 type ScreenSubmitShortcutEvent = {
@@ -6,14 +7,16 @@ type ScreenSubmitShortcutEvent = {
   ctrlKey?: boolean
   metaKey?: boolean
   shiftKey?: boolean
+  keyCode?: number
   isComposing?: boolean
   nativeEvent?: {
+    keyCode?: number
     isComposing?: boolean
   }
 }
 
 export function isScreenSubmitShortcut(event: ScreenSubmitShortcutEvent): boolean {
-  if (event.isComposing || event.nativeEvent?.isComposing) {
+  if (isImeOwnedKeyboardEvent(event)) {
     return false
   }
   if (event.key !== 'Enter' || event.altKey || event.shiftKey) {
diff --git a/src/renderer/src/lib/structured-agent-launch-settlement.test.ts b/src/renderer/src/lib/structured-agent-launch-settlement.test.ts
index dcc829e26fc..815d2708db0 100644
--- a/src/renderer/src/lib/structured-agent-launch-settlement.test.ts
+++ b/src/renderer/src/lib/structured-agent-launch-settlement.test.ts
@@ -65,9 +65,15 @@ describe('settleStructuredAgentLaunch', () => {
     const onStructuredReady = vi.fn()
 
     await expect(
-      settleStructuredAgentLaunch('worktree-1', 'codex', { prompt: 'Fix' }, { onStructuredReady })
+      settleStructuredAgentLaunch(
+        'worktree-1',
+        'codex',
+        { requestId: 'request-1', prompt: 'Fix' },
+        { onStructuredReady }
+      )
     ).resolves.toEqual({ kind: 'structured', sessionId: 'session-1', promptDeliveryResult })
     expect(mocks.startStructuredAgentLaunch).toHaveBeenCalledWith('worktree-1', 'codex', {
+      requestId: 'request-1',
       prompt: 'Fix'
     })
     expect(onStructuredReady).toHaveBeenCalledWith('session-1')
@@ -81,7 +87,12 @@ describe('settleStructuredAgentLaunch', () => {
       })
     })
 
-    const handle = beginStructuredAgentLaunchSettlement('worktree-1', 'codex', {}, {})
+    const handle = beginStructuredAgentLaunchSettlement(
+      'worktree-1',
+      'codex',
+      { requestId: 'request-2' },
+      {}
+    )
 
     expect(handle.sessionId).toBe('session-1')
     resolveLaunch({ sessionId: 'session-1', fence: 1 })
@@ -95,7 +106,9 @@ describe('settleStructuredAgentLaunch', () => {
     const error = new StructuredAgentSessionCreateRefusalError('unsupported')
     fakeLaunch({ launchResult: Promise.reject(error) })
 
-    await expect(settleStructuredAgentLaunch('worktree-1', 'codex', {}, {})).resolves.toEqual({
+    await expect(
+      settleStructuredAgentLaunch('worktree-1', 'codex', { requestId: 'request-3' }, {})
+    ).resolves.toEqual({
       kind: 'failed',
       error
     })
@@ -107,7 +120,9 @@ describe('settleStructuredAgentLaunch', () => {
       visibilityUnknown: true
     })
 
-    await expect(settleStructuredAgentLaunch('worktree-1', 'codex', {}, {})).resolves.toEqual({
+    await expect(
+      settleStructuredAgentLaunch('worktree-1', 'codex', { requestId: 'request-4' }, {})
+    ).resolves.toEqual({
       kind: 'visibility-unknown',
       sessionId: 'session-1'
     })
@@ -118,7 +133,9 @@ describe('settleStructuredAgentLaunch', () => {
     const error = new Error('boom')
     const { releaseCallerAfterUnknownOutcome } = fakeLaunch({ launchResult: Promise.reject(error) })
 
-    await expect(settleStructuredAgentLaunch('worktree-1', 'codex', {}, {})).resolves.toEqual({
+    await expect(
+      settleStructuredAgentLaunch('worktree-1', 'codex', { requestId: 'request-5' }, {})
+    ).resolves.toEqual({
       kind: 'failed',
       error
     })
@@ -133,7 +150,7 @@ describe('settleStructuredAgentLaunch', () => {
       settleStructuredAgentLaunch(
         'worktree-1',
         'codex',
-        {},
+        { requestId: 'request-6' },
         {
           onStructuredReady,
           signal: fakeCancellation(true).signal
@@ -151,7 +168,7 @@ describe('settleStructuredAgentLaunch', () => {
       settleStructuredAgentLaunch(
         'worktree-1',
         'codex',
-        {},
+        { requestId: 'request-7' },
         {
           signal: fakeCancellation(true).signal
         }
@@ -172,7 +189,7 @@ describe('settleStructuredAgentLaunch', () => {
     const settlement = settleStructuredAgentLaunch(
       'worktree-1',
       'codex',
-      {},
+      { requestId: 'request-8' },
       { onStructuredReady, signal: cancellation.signal }
     )
     expect(mocks.cancelStructuredAgentLaunch).not.toHaveBeenCalled()
@@ -197,7 +214,7 @@ describe('settleStructuredAgentLaunch', () => {
     const settlement = settleStructuredAgentLaunch(
       'worktree-1',
       'codex',
-      {},
+      { requestId: 'request-9' },
       { signal: cancellation.signal }
     )
     expect(mocks.cancelStructuredAgentLaunch).toHaveBeenCalledExactlyOnceWith(
@@ -213,7 +230,12 @@ describe('settleStructuredAgentLaunch', () => {
     const cancellation = fakeCancellation()
 
     await expect(
-      settleStructuredAgentLaunch('worktree-1', 'codex', {}, { signal: cancellation.signal })
+      settleStructuredAgentLaunch(
+        'worktree-1',
+        'codex',
+        { requestId: 'request-10' },
+        { signal: cancellation.signal }
+      )
     ).resolves.toEqual({ kind: 'structured', sessionId: 'session-1' })
     expect(mocks.cancelStructuredAgentLaunch).not.toHaveBeenCalled()
     expect(cancellation.removeEventListener).toHaveBeenCalledOnce()
diff --git a/src/renderer/src/lib/structured-agent-launch-settlement.ts b/src/renderer/src/lib/structured-agent-launch-settlement.ts
index 9815f71b48a..69c3a58ddff 100644
--- a/src/renderer/src/lib/structured-agent-launch-settlement.ts
+++ b/src/renderer/src/lib/structured-agent-launch-settlement.ts
@@ -7,6 +7,7 @@ import {
   type StructuredAgentLaunchOptions
 } from '@/lib/structured-agent-session-launch'
 import type { StructuredPromptDeliveryResult } from '@/lib/structured-agent-session-launch-prompt'
+import { findIdleEmptyStructuredChat } from '@/lib/structured-agent-session-idle-empty-chat'
 
 export type StructuredAgentLaunchSettlement =
   | {
@@ -101,6 +102,30 @@ export function beginStructuredAgentLaunchSettlement(
   options: StructuredAgentLaunchOptions,
   hooks: StructuredAgentLaunchHooks
 ): StructuredAgentLaunchHandle {
+  // A new chat with nothing to say reuses an empty published one open here (the launch joins an
+  // empty starting one); the reused chat is not this caller's to cancel.
+  const idle =
+    options.resumeFrom || options.prompt?.trim()
+      ? undefined
+      : findIdleEmptyStructuredChat(
+          worktreeId,
+          agent,
+          options.executionHostId,
+          options.targetGroupId
+        )
+  if (idle) {
+    return {
+      ...idle,
+      settlement: Promise.resolve().then((): StructuredAgentLaunchSettlement => {
+        if (hooks.signal?.aborted) {
+          return { kind: 'cancelled', sessionId: idle.sessionId }
+        }
+        hooks.onStructuredReady?.(idle.sessionId)
+        return { kind: 'structured', sessionId: idle.sessionId }
+      }),
+      cancel: () => {}
+    }
+  }
   const launch = startStructuredAgentLaunch(worktreeId, agent, options)
   return {
     sessionId: launch.sessionId,
diff --git a/src/renderer/src/lib/structured-agent-session-chat-tab-group.ts b/src/renderer/src/lib/structured-agent-session-chat-tab-group.ts
new file mode 100644
index 00000000000..89a6bd8cb9a
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-chat-tab-group.ts
@@ -0,0 +1,12 @@
+import { structuredAgentSessionTabId } from '../../../shared/structured-agent-session-projection'
+import { useAppStore } from '@/store'
+
+/** The tab group a chat's tab sits in, if it has one in this workspace. */
+export function structuredChatTabGroupId(
+  worktreeId: string,
+  sessionId: string
+): string | undefined {
+  const tabId = structuredAgentSessionTabId(sessionId)
+  return useAppStore.getState().unifiedTabsByWorktree[worktreeId]?.find((tab) => tab.id === tabId)
+    ?.groupId
+}
diff --git a/src/renderer/src/lib/structured-agent-session-empty-chat-reuse.test.ts b/src/renderer/src/lib/structured-agent-session-empty-chat-reuse.test.ts
new file mode 100644
index 00000000000..9f4f2b0c459
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-empty-chat-reuse.test.ts
@@ -0,0 +1,492 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { RuntimeMobileSessionTabsResult } from '../../../shared/runtime-session-contracts'
+import type { Tab, TabGroup } from '../../../shared/tab-types'
+import type { AgentSessionStatusSummary } from '../../../shared/agent-session-wire'
+import type { StructuredAgentSessionLaunchIntent } from '@/lib/launch-structured-agent-session'
+
+const mocks = vi.hoisted(() => ({
+  createIntent: vi.fn(),
+  launch: vi.fn(),
+  callStructuredAgentSession: vi.fn(),
+  refreshTabs: vi.fn(),
+  activateTab: vi.fn(),
+  focusGroup: vi.fn(),
+  statusBySession: new Map<string, AgentSessionStatusSummary['status']>(),
+  liveSessions: new Set<string>()
+}))
+
+type StoreState = {
+  unifiedTabsByWorktree: Record<string, Tab[]>
+  groupsByWorktree: Record<string, TabGroup[]>
+  activeGroupIdByWorktree: Record<string, string>
+  nativeChatLaunchDraftByTabId: Record<string, { text: string; adopted?: boolean }>
+}
+/** A workspace split into a left (active) and a right tab group. */
+function emptyStoreState(): StoreState {
+  const group = (id: string): TabGroup => ({
+    id,
+    worktreeId: 'wt-reuse',
+    activeTabId: null,
+    tabOrder: []
+  })
+  return {
+    unifiedTabsByWorktree: {},
+    groupsByWorktree: { 'wt-reuse': [group('group-left'), group('group-right')] },
+    activeGroupIdByWorktree: { 'wt-reuse': 'group-left' },
+    nativeChatLaunchDraftByTabId: {}
+  }
+}
+const store = vi.hoisted((): { state: StoreState } => ({ state: emptyStoreState() }))
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), info: vi.fn(), message: vi.fn() } }))
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+vi.mock('@/lib/agent-catalog', () => ({
+  getAgentLabel: () => 'Codex',
+  getAgentCatalog: () => [{ id: 'codex', label: 'Codex' }]
+}))
+vi.mock('@/lib/launch-structured-agent-session', () => {
+  class StructuredAgentSessionCreateRefusalError extends Error {}
+  class StructuredAgentSessionOwnerUnresolvedError extends Error {}
+  return {
+    createStructuredAgentSessionLaunchIntent: mocks.createIntent,
+    retryStructuredAgentSessionLaunchIntent: vi.fn(),
+    abandonStructuredAgentSessionLaunchIntent: vi.fn(),
+    launchStructuredAgentSession: mocks.launch,
+    StructuredAgentSessionCreateRefusalError,
+    StructuredAgentSessionOwnerUnresolvedError
+  }
+})
+vi.mock('@/runtime/local-structured-session-tabs-sync', () => ({
+  refreshLocalStructuredSessionTabs: mocks.refreshTabs
+}))
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.callStructuredAgentSession
+}))
+vi.mock('@/runtime/structured-agent-session-status-feed', () => ({
+  getStructuredAgentSessionStatusFeed: () => ({
+    getSessionObservation: (sessionId: string) =>
+      mocks.liveSessions.has(sessionId) ? 'live' : 'unverifiable',
+    getSnapshot: () =>
+      new Map(
+        [...mocks.statusBySession].map(([sessionId, status]) => [sessionId, { sessionId, status }])
+      )
+  })
+}))
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({
+      ...store.state,
+      createUnifiedTab: (
+        worktreeId: string,
+        contentType: Tab['contentType'],
+        init: { targetGroupId?: string }
+      ) => {
+        const groupId =
+          init.targetGroupId ?? store.state.activeGroupIdByWorktree[worktreeId] ?? 'group-left'
+        // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the launch passes the agent-session fields a structured tab carries.
+        const tab = { ...init, contentType, worktreeId, groupId, createdAt: 1 } as Tab
+        store.state.unifiedTabsByWorktree[worktreeId] = [
+          ...(store.state.unifiedTabsByWorktree[worktreeId] ?? []),
+          tab
+        ]
+        return tab
+      },
+      activateTab: mocks.activateTab,
+      focusGroup: mocks.focusGroup,
+      setActiveTabType: vi.fn(),
+      seedNativeChatLaunchDraft: vi.fn(),
+      clearNativeChatLaunchDraft: vi.fn()
+    }),
+    subscribe: () => () => undefined
+  }
+}))
+
+import {
+  appendStructuredAgentSessionOutboxMessage,
+  readOutbox
+} from '@/components/native-chat/structured-agent-session-outbox-storage'
+import {
+  appendNativeChatAttachmentCache,
+  clearNativeChatAttachmentCacheForTests
+} from '@/components/native-chat/use-native-chat-composer-attachments'
+import {
+  clearNativeChatDraftCacheForTests,
+  writeNativeChatDraftCache
+} from '@/components/native-chat/native-chat-draft-cache'
+import {
+  structuredAgentSessionPaneKey,
+  structuredAgentSessionTabId
+} from '../../../shared/structured-agent-session-projection'
+import { adoptAgentSessionLaunchVerdict } from './agent-session-launch-plan'
+import {
+  beginStructuredAgentSessionProvisionalLaunch,
+  type StructuredAgentSessionProvisionalLaunch
+} from './structured-agent-session-provisional-tab'
+import { getStructuredAgentSessionLaunchLifecycle } from './structured-agent-session-launch'
+import { resetStructuredAgentLaunchPersistenceForTests } from './structured-agent-session-launch-persistence'
+import { resetStructuredAgentLaunchRegistryForTests } from './structured-agent-session-launch-registry'
+
+const WORKTREE_ID = 'wt-reuse'
+
+function launchIntent(
+  sessionId: string,
+  worktreeId = WORKTREE_ID
+): StructuredAgentSessionLaunchIntent {
+  return {
+    worktreeId,
+    sessionId,
+    executionHostId: 'local',
+    target: { kind: 'local' },
+    agent: 'codex',
+    params: {
+      envelope: {
+        sessionId,
+        clientOperationId: `operation-${sessionId}`,
+        expectedRuntimeFence: null,
+        payloadFingerprint: `fingerprint-${sessionId}`
+      },
+      worktree: `id:${worktreeId}`,
+      agent: 'codex'
+    }
+  }
+}
+
+function published(...sessionIds: string[]): RuntimeMobileSessionTabsResult[] {
+  return [WORKTREE_ID, 'wt-other'].map((worktree) => ({
+    worktree,
+    publicationEpoch: 'epoch-1',
+    snapshotVersion: 1,
+    activeGroupId: null,
+    activeTabId: null,
+    activeTabType: null,
+    tabs: sessionIds.map((sessionId) => ({
+      type: 'agent-session',
+      id: `tab-${sessionId}`,
+      title: 'Codex',
+      sessionId,
+      agent: 'codex',
+      isActive: false
+    }))
+  }))
+}
+
+const first = launchIntent('session-first')
+const second = launchIntent('session-second')
+
+/** A pick from the + menu, new-tab search or the new-agent shortcut: its own action, no text. */
+function pick(
+  requestId: string,
+  overrides: {
+    agent?: 'claude' | 'codex'
+    worktreeId?: string
+    prompt?: string
+    /** The split the pick was made in; none means the workspace's active group. */
+    group?: string
+  } = {}
+): Exclude<StructuredAgentSessionProvisionalLaunch, { sessionId: null }> {
+  const launch = beginStructuredAgentSessionProvisionalLaunch({
+    plan: adoptAgentSessionLaunchVerdict({
+      route: 'structured-native-chat',
+      requestId,
+      agent: overrides.agent ?? 'codex',
+      worktreeId: overrides.worktreeId ?? WORKTREE_ID,
+      executionHostId: 'local',
+      ...(overrides.prompt
+        ? { prompt: overrides.prompt, promptDelivery: 'submit-after-ready' as const }
+        : {})
+    }),
+    hooks: {},
+    ...(overrides.group ? { targetGroupId: overrides.group } : {})
+  })
+  if (!launch || launch.sessionId === null) {
+    throw new Error('expected a local chat')
+  }
+  return launch
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 20; i += 1) {
+    await Promise.resolve()
+  }
+}
+
+/** The first chat published and its host's journal holds no request. */
+async function publishIdle(sessionId: string): Promise<void> {
+  await flush()
+  expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, sessionId)).toBeNull()
+  mocks.liveSessions.add(sessionId)
+  mocks.statusBySession.set(sessionId, null)
+}
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  localStorage.clear()
+  clearNativeChatDraftCacheForTests()
+  clearNativeChatAttachmentCacheForTests()
+  resetStructuredAgentLaunchPersistenceForTests()
+  resetStructuredAgentLaunchRegistryForTests()
+  mocks.statusBySession.clear()
+  mocks.liveSessions.clear()
+  store.state = emptyStoreState()
+  mocks.createIntent
+    .mockReturnValueOnce(first)
+    .mockReturnValueOnce(second)
+    .mockReturnValueOnce(launchIntent('session-third'))
+  mocks.launch.mockImplementation((intent: StructuredAgentSessionLaunchIntent) =>
+    Promise.resolve({ sessionId: intent.sessionId, fence: 1 })
+  )
+  mocks.refreshTabs.mockResolvedValue(published(first.sessionId, second.sessionId))
+  mocks.callStructuredAgentSession.mockResolvedValue({
+    ok: true,
+    value: { submission: { dispatchState: 'accepted' } }
+  })
+})
+
+describe('a second "new chat" with no text', () => {
+  it('focuses the empty chat still starting instead of opening another', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    const firstPick = pick('plus-pick-1')
+    const secondPick = pick('plus-pick-2')
+
+    expect(secondPick.sessionId).toBe(firstPick.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+    expect(store.state.unifiedTabsByWorktree[WORKTREE_ID]).toHaveLength(1)
+    expect(mocks.activateTab).toHaveBeenCalledWith(structuredAgentSessionTabId(first.sessionId), {
+      worktreeId: WORKTREE_ID
+    })
+  })
+
+  it('focuses the empty chat that published and sits idle, and reports that session', async () => {
+    pick('plus-pick-1')
+    await publishIdle(first.sessionId)
+
+    const secondPick = pick('plus-pick-2')
+
+    expect(secondPick.sessionId).toBe(first.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+    expect(mocks.activateTab).toHaveBeenCalledWith(structuredAgentSessionTabId(first.sessionId), {
+      worktreeId: WORKTREE_ID
+    })
+    await expect(secondPick.settlement).resolves.toEqual({
+      kind: 'structured',
+      sessionId: first.sessionId
+    })
+  })
+
+  it('opens a new chat when the idle chat has a typed draft', async () => {
+    pick('plus-pick-1')
+    await publishIdle(first.sessionId)
+    const tabId = structuredAgentSessionTabId(first.sessionId)
+    writeNativeChatDraftCache(structuredAgentSessionPaneKey(tabId, first.sessionId), 'half a q')
+
+    expect(pick('plus-pick-2').sessionId).toBe(second.sessionId)
+  })
+
+  it('opens a new chat when the idle chat has an image in its composer', async () => {
+    pick('plus-pick-1')
+    await publishIdle(first.sessionId)
+    const tabId = structuredAgentSessionTabId(first.sessionId)
+    appendNativeChatAttachmentCache(structuredAgentSessionPaneKey(tabId, first.sessionId), [
+      { id: 'shot', path: '/tmp/shot.png' }
+    ])
+
+    expect(pick('plus-pick-2').sessionId).toBe(second.sessionId)
+  })
+
+  it('opens a new chat when the idle chat holds a launch draft its composer has not taken', async () => {
+    pick('plus-pick-1')
+    await publishIdle(first.sessionId)
+    store.state.nativeChatLaunchDraftByTabId[structuredAgentSessionTabId(first.sessionId)] = {
+      text: 'PR context'
+    }
+
+    expect(pick('plus-pick-2').sessionId).toBe(second.sessionId)
+  })
+
+  it('opens a new chat when its host holds a sent message', async () => {
+    pick('plus-pick-1')
+    await publishIdle(first.sessionId)
+    mocks.statusBySession.set(first.sessionId, 'idle')
+
+    expect(pick('plus-pick-2').sessionId).toBe(second.sessionId)
+  })
+
+  it('opens a new chat when its host cannot be heard from', async () => {
+    pick('plus-pick-1')
+    await publishIdle(first.sessionId)
+    mocks.liveSessions.clear()
+
+    expect(pick('plus-pick-2').sessionId).toBe(second.sessionId)
+  })
+
+  it('opens a new chat when the starting chat has a message queued', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    const firstPick = pick('plus-pick-1')
+    appendStructuredAgentSessionOutboxMessage(firstPick.sessionId, 'my own question')
+
+    expect(pick('plus-pick-2').sessionId).toBe(second.sessionId)
+  })
+
+  it('never reuses a chat whose start failed', async () => {
+    const { StructuredAgentSessionCreateRefusalError } =
+      await import('@/lib/launch-structured-agent-session')
+    mocks.launch.mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('refused'))
+    pick('plus-pick-1')
+    await flush()
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, first.sessionId)).toBe('failed')
+    mocks.liveSessions.add(first.sessionId)
+    mocks.statusBySession.set(first.sessionId, null)
+
+    expect(pick('plus-pick-2').sessionId).toBe(second.sessionId)
+  })
+
+  it('never reuses a chat whose start is unconfirmed', async () => {
+    mocks.launch.mockRejectedValueOnce(new Error('answer lost'))
+    mocks.refreshTabs.mockResolvedValue(published())
+    pick('plus-pick-1')
+    await flush()
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, first.sessionId)).toBe(
+      'visibility-unknown'
+    )
+    mocks.liveSessions.add(first.sessionId)
+    mocks.statusBySession.set(first.sessionId, null)
+
+    expect(pick('plus-pick-2').sessionId).toBe(second.sessionId)
+  })
+
+  it("never reuses another agent's or another workspace's idle empty chat", async () => {
+    mocks.createIntent
+      .mockReset()
+      .mockReturnValueOnce(first)
+      .mockReturnValueOnce({ ...second, agent: 'claude' })
+      .mockReturnValueOnce(launchIntent('session-third', 'wt-other'))
+    pick('plus-pick-1')
+    await publishIdle(first.sessionId)
+
+    expect(pick('claude-pick', { agent: 'claude' }).sessionId).toBe(second.sessionId)
+    expect(pick('other-pick', { worktreeId: 'wt-other' }).sessionId).toBe('session-third')
+  })
+
+  it("never reuses another agent's or another workspace's starting empty chat", async () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    mocks.createIntent
+      .mockReset()
+      .mockReturnValueOnce(first)
+      .mockReturnValueOnce({ ...second, agent: 'claude' })
+      .mockReturnValueOnce(launchIntent('session-third', 'wt-other'))
+    pick('plus-pick-1')
+
+    expect(pick('claude-pick', { agent: 'claude' }).sessionId).toBe(second.sessionId)
+    expect(pick('other-pick', { worktreeId: 'wt-other' }).sessionId).toBe('session-third')
+  })
+})
+
+describe('a second "new chat" with no text in another split', () => {
+  function tabOf(sessionId: string): Tab | undefined {
+    return store.state.unifiedTabsByWorktree[WORKTREE_ID]?.find(
+      (tab) => tab.id === structuredAgentSessionTabId(sessionId)
+    )
+  }
+
+  it('opens a new chat in its own split beside an idle empty one, and focus stays there', async () => {
+    pick('plus-pick-1', { group: 'group-left' })
+    await publishIdle(first.sessionId)
+
+    const right = pick('plus-pick-2', { group: 'group-right' })
+
+    expect(right.sessionId).toBe(second.sessionId)
+    expect(tabOf(second.sessionId)?.groupId).toBe('group-right')
+    expect(mocks.focusGroup).not.toHaveBeenCalled()
+    expect(mocks.activateTab).not.toHaveBeenCalled()
+  })
+
+  it('reuses the idle empty chat in the split it was picked in', async () => {
+    pick('plus-pick-1', { group: 'group-right' })
+    await publishIdle(first.sessionId)
+
+    expect(pick('plus-pick-2', { group: 'group-right' }).sessionId).toBe(first.sessionId)
+    expect(mocks.focusGroup).toHaveBeenCalledWith(WORKTREE_ID, 'group-right')
+  })
+
+  it('opens a new chat in its own split beside a starting empty one', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    pick('plus-pick-1', { group: 'group-left' })
+
+    const right = pick('plus-pick-2', { group: 'group-right' })
+
+    expect(right.sessionId).toBe(second.sessionId)
+    expect(tabOf(second.sessionId)?.groupId).toBe('group-right')
+    expect(mocks.focusGroup).not.toHaveBeenCalled()
+  })
+
+  it('reuses the starting empty chat in the split it was picked in', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    const firstPick = pick('plus-pick-1', { group: 'group-right' })
+
+    expect(pick('plus-pick-2', { group: 'group-right' }).sessionId).toBe(firstPick.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+  })
+
+  // The dashboard and other callers name no group: the workspace's active one is where they open.
+  it('treats a pick that names no split as made in the active one', async () => {
+    pick('plus-pick-1', { group: 'group-right' })
+    await publishIdle(first.sessionId)
+
+    expect(pick('dashboard-pick').sessionId).toBe(second.sessionId)
+    expect(tabOf(second.sessionId)?.groupId).toBe('group-left')
+    store.state.activeGroupIdByWorktree[WORKTREE_ID] = 'group-right'
+    expect(pick('dashboard-pick-2').sessionId).toBe(first.sessionId)
+  })
+})
+
+describe('a "new chat" with text', () => {
+  it('opens its own chat beside an idle empty one', async () => {
+    pick('plus-pick-1')
+    await publishIdle(first.sessionId)
+
+    const notes = pick('notes-send', { prompt: 'review notes' })
+
+    expect(notes.sessionId).toBe(second.sessionId)
+    await expect(notes.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+  })
+
+  it('opens its own chat in its own split beside an empty chat starting in another', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    const blank = pick('plus-pick-1', { group: 'group-left' })
+
+    const notes = pick('notes-send', { prompt: 'review notes', group: 'group-right' })
+
+    expect(notes.sessionId).toBe(second.sessionId)
+    expect(
+      store.state.unifiedTabsByWorktree[WORKTREE_ID]?.find(
+        (tab) => tab.entityId === second.sessionId
+      )?.groupId
+    ).toBe('group-right')
+    expect(mocks.focusGroup).not.toHaveBeenCalled()
+    expect(readOutbox(blank.sessionId)).toEqual([])
+    expect(readOutbox(second.sessionId).map((entry) => entry.body.blocks)).toEqual([
+      [{ type: 'text', text: 'review notes' }]
+    ])
+  })
+
+  it('takes an empty chat starting in its own split', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    const blank = pick('plus-pick-1', { group: 'group-right' })
+
+    expect(pick('notes-send', { prompt: 'review notes', group: 'group-right' }).sessionId).toBe(
+      blank.sessionId
+    )
+  })
+
+  it('takes an empty chat still starting, as before', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+    const blank = pick('plus-pick-1')
+
+    expect(pick('notes-send', { prompt: 'review notes' }).sessionId).toBe(blank.sessionId)
+  })
+})
diff --git a/src/renderer/src/lib/structured-agent-session-idle-empty-chat.ts b/src/renderer/src/lib/structured-agent-session-idle-empty-chat.ts
new file mode 100644
index 00000000000..45d7970217e
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-idle-empty-chat.ts
@@ -0,0 +1,74 @@
+import type { AgentSessionHandleProvider } from '../../../shared/agent-session-provider-handle'
+import type { ExecutionHostId } from '../../../shared/execution-host'
+import type { Tab } from '../../../shared/tab-types'
+import { useAppStore } from '@/store'
+import {
+  structuredAgentSessionOwnerForTab,
+  structuredAgentSessionTargetForHost
+} from '@/runtime/structured-agent-session-owner'
+import { getStructuredAgentSessionStatusFeed } from '@/runtime/structured-agent-session-status-feed'
+import { getStructuredAgentSessionLaunchLifecycle } from './structured-agent-session-launch-registry'
+import { isStructuredLaunchChatEmpty } from './structured-agent-session-launch-empty-chat'
+
+export type IdleEmptyStructuredChat = { sessionId: string; executionHostId: ExecutionHostId }
+
+/** Published, and its host's journal holds no request (a null status). A resumed chat's journal
+ *  holds the imported conversation, so it never reads as empty. */
+function hostHoldsNoRequest(tab: Tab, executionHostId: ExecutionHostId): boolean {
+  const lifecycle = getStructuredAgentSessionLaunchLifecycle(tab.worktreeId, tab.entityId)
+  const target = structuredAgentSessionTargetForHost(executionHostId)
+  if ((lifecycle !== null && lifecycle !== 'published') || !target) {
+    return false
+  }
+  const feed = getStructuredAgentSessionStatusFeed(target)
+  // Why live only: a summary cached across a lost stream may predate a message the host took.
+  return (
+    feed.getSessionObservation(tab.entityId) === 'live' &&
+    feed.getSnapshot().get(tab.entityId)?.status === null
+  )
+}
+
+/** A launch draft its composer has not taken in yet (a chat opened in the background). */
+function holdsUnadoptedLaunchDraft(tabId: string): boolean {
+  const draft = useAppStore.getState().nativeChatLaunchDraftByTabId[tabId]
+  return Boolean(draft && !draft.adopted && !draft.resolved && draft.text.trim())
+}
+
+/** An open chat for `agent` in this workspace's `groupId` (else any group) that nothing was ever
+ *  sent into and whose composer is untouched. Prefers the group's active tab, else the newest. */
+export function findIdleEmptyStructuredChat(
+  worktreeId: string,
+  agent: AgentSessionHandleProvider,
+  executionHostId?: ExecutionHostId,
+  groupId?: string
+): IdleEmptyStructuredChat | undefined {
+  const state = useAppStore.getState()
+  const candidates: (IdleEmptyStructuredChat & { tab: Tab })[] = []
+  for (const tab of state.unifiedTabsByWorktree[worktreeId] ?? []) {
+    const owner =
+      tab.contentType === 'agent-session' && tab.agentSessionAgent === agent
+        ? structuredAgentSessionOwnerForTab(state, tab)
+        : null
+    if (
+      owner &&
+      (!groupId || tab.groupId === groupId) &&
+      (!executionHostId || owner === executionHostId) &&
+      hostHoldsNoRequest(tab, owner) &&
+      isStructuredLaunchChatEmpty(tab.entityId) &&
+      !holdsUnadoptedLaunchDraft(tab.id)
+    ) {
+      candidates.push({ sessionId: tab.entityId, executionHostId: owner, tab })
+    }
+  }
+  if (candidates.length === 0) {
+    return undefined
+  }
+  const focusGroupId = groupId ?? state.activeGroupIdByWorktree[worktreeId]
+  const focusedTabId = state.groupsByWorktree[worktreeId]?.find(
+    (group) => group.id === focusGroupId
+  )?.activeTabId
+  const chosen =
+    candidates.find((candidate) => candidate.tab.id === focusedTabId) ??
+    candidates.toSorted((a, b) => a.tab.createdAt - b.tab.createdAt).at(-1)
+  return chosen && { sessionId: chosen.sessionId, executionHostId: chosen.executionHostId }
+}
diff --git a/src/renderer/src/lib/structured-agent-session-launch-after-failure.test.ts b/src/renderer/src/lib/structured-agent-session-launch-after-failure.test.ts
new file mode 100644
index 00000000000..e048d02da04
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-launch-after-failure.test.ts
@@ -0,0 +1,261 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { RuntimeMobileSessionTabsResult } from '../../../shared/runtime-session-contracts'
+import type { StructuredAgentSessionLaunchIntent } from '@/lib/launch-structured-agent-session'
+
+const mocks = vi.hoisted(() => ({
+  abandonIntent: vi.fn(),
+  callStructuredAgentSession: vi.fn(),
+  createIntent: vi.fn(),
+  retryIntent: vi.fn(),
+  restoreIntent: vi.fn(),
+  launch: vi.fn(),
+  seedDraft: vi.fn(),
+  clearDraft: vi.fn()
+}))
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), message: vi.fn() } }))
+
+vi.mock('@/lib/launch-structured-agent-session', () => {
+  class StructuredAgentSessionCreateRefusalError extends Error {}
+  return {
+    createStructuredAgentSessionLaunchIntent: mocks.createIntent,
+    retryStructuredAgentSessionLaunchIntent: mocks.retryIntent,
+    restoreStructuredAgentSessionLaunchIntent: mocks.restoreIntent,
+    abandonStructuredAgentSessionLaunchIntent: mocks.abandonIntent,
+    launchStructuredAgentSession: mocks.launch,
+    StructuredAgentSessionCreateRefusalError
+  }
+})
+
+vi.mock('@/runtime/local-structured-session-tabs-sync', () => ({
+  refreshLocalStructuredSessionTabs: vi.fn()
+}))
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.callStructuredAgentSession
+}))
+
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({
+      unifiedTabsByWorktree: {},
+      seedNativeChatLaunchDraft: mocks.seedDraft,
+      clearNativeChatLaunchDraft: mocks.clearDraft
+    }),
+    subscribe: () => () => undefined
+  }
+}))
+
+vi.mock('@/i18n/i18n', () => ({
+  translate: (_key: string, fallback: string) => fallback
+}))
+
+vi.mock('@/lib/agent-catalog', () => ({
+  getAgentLabel: () => 'Codex',
+  getAgentCatalog: () => [{ id: 'codex', label: 'Codex' }]
+}))
+
+import { StructuredAgentSessionCreateRefusalError } from '@/lib/launch-structured-agent-session'
+import { refreshLocalStructuredSessionTabs } from '@/runtime/local-structured-session-tabs-sync'
+import {
+  cancelStructuredAgentLaunch,
+  getStructuredAgentLaunchStatus,
+  getStructuredAgentSessionLaunchLifecycle,
+  retryStructuredAgentSessionLaunch,
+  startStructuredAgentLaunch
+} from './structured-agent-session-launch'
+import { readOutbox } from '@/components/native-chat/structured-agent-session-outbox-storage'
+import { resetStructuredAgentLaunchPersistenceForTests } from './structured-agent-session-launch-persistence'
+import { resetStructuredAgentLaunchRegistryForTests } from './structured-agent-session-launch-registry'
+
+type Receipt = { sessionId: string; fence: number }
+
+const WORKTREE_ID = 'wt-after-failure'
+
+function launchIntent(sessionId: string): StructuredAgentSessionLaunchIntent {
+  return {
+    worktreeId: WORKTREE_ID,
+    sessionId,
+    executionHostId: 'local',
+    target: { kind: 'local' },
+    agent: 'codex',
+    params: {
+      envelope: {
+        sessionId,
+        clientOperationId: `operation-${sessionId}`,
+        expectedRuntimeFence: null,
+        payloadFingerprint: `fingerprint-${sessionId}`
+      },
+      worktree: `id:${WORKTREE_ID}`,
+      agent: 'codex'
+    }
+  }
+}
+
+function publishedSnapshot(...sessionIds: string[]): RuntimeMobileSessionTabsResult {
+  return {
+    worktree: WORKTREE_ID,
+    publicationEpoch: 'epoch-1',
+    snapshotVersion: 1,
+    activeGroupId: null,
+    activeTabId: null,
+    activeTabType: null,
+    tabs: sessionIds.map((sessionId) => ({
+      type: 'agent-session' as const,
+      id: `tab-${sessionId}`,
+      title: 'Codex',
+      sessionId,
+      agent: 'codex' as const,
+      isActive: false
+    }))
+  }
+}
+
+async function flushLaunchSettlement(): Promise<void> {
+  for (let i = 0; i < 20; i += 1) {
+    await Promise.resolve()
+  }
+}
+
+const failed = launchIntent('session-failed')
+const fresh = launchIntent('session-new')
+
+async function refuseFirstLaunch(): Promise<void> {
+  mocks.createIntent.mockReturnValueOnce(failed).mockReturnValueOnce(fresh)
+  mocks.launch.mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('unsupported'))
+  startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-1', prompt: 'first task' })
+  await flushLaunchSettlement()
+  expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, failed.sessionId)).toBe('failed')
+}
+
+describe('a new launch after a failed one', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    localStorage.clear()
+    resetStructuredAgentLaunchPersistenceForTests()
+    resetStructuredAgentLaunchRegistryForTests()
+    mocks.retryIntent.mockImplementation((intent: StructuredAgentSessionLaunchIntent) => ({
+      ...intent,
+      params: {
+        ...intent.params,
+        envelope: { ...intent.params.envelope, clientOperationId: 'retried-operation' }
+      }
+    }))
+    mocks.restoreIntent.mockImplementation((args: { sessionId: string }) =>
+      launchIntent(args.sessionId)
+    )
+    vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
+      publishedSnapshot(failed.sessionId, fresh.sessionId)
+    ])
+    mocks.callStructuredAgentSession.mockResolvedValue({
+      ok: true,
+      page: { fence: 1 },
+      value: { submission: { dispatchState: 'accepted' } }
+    })
+  })
+
+  it('opens a new chat that sends its own prompt instead of restarting the failed one', async () => {
+    await refuseFirstLaunch()
+    // Why: the + menu and new-tab search disable an agent only while its launch reads pending.
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('idle')
+
+    mocks.launch.mockResolvedValueOnce({ sessionId: fresh.sessionId, fence: 1 })
+    const notes = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'request-2',
+      prompt: 'review notes',
+      promptDelivery: 'submit-after-ready'
+    })
+
+    expect(notes.sessionId).toBe(fresh.sessionId)
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('pending')
+    await expect(notes.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(mocks.retryIntent).not.toHaveBeenCalled()
+    expect(mocks.callStructuredAgentSession).toHaveBeenCalledWith(
+      { kind: 'local' },
+      'agentSession.send',
+      expect.objectContaining({
+        envelope: expect.objectContaining({ sessionId: fresh.sessionId }),
+        body: expect.objectContaining({ blocks: [{ type: 'text', text: 'review notes' }] })
+      })
+    )
+    // The failed chat keeps its own preserved prompt for its own Retry.
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, failed.sessionId)).toBe('failed')
+    expect(readOutbox(failed.sessionId)).toEqual([
+      expect.objectContaining({
+        body: expect.objectContaining({ blocks: [{ type: 'text', text: 'first task' }] })
+      })
+    ])
+  })
+
+  it('retries the failed chat beside an in-flight new launch without taking it over', async () => {
+    await refuseFirstLaunch()
+    let resolveFresh!: (receipt: Receipt) => void
+    let rejectRetry!: (error: unknown) => void
+    mocks.launch
+      .mockImplementationOnce(() => new Promise<Receipt>((resolve) => (resolveFresh = resolve)))
+      .mockImplementationOnce(
+        () => new Promise<Receipt>((_resolve, reject) => (rejectRetry = reject))
+      )
+    const next = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+
+    expect(retryStructuredAgentSessionLaunch(WORKTREE_ID, failed.sessionId)).toBe(true)
+    expect(mocks.launch.mock.calls[2]?.[0]).toMatchObject({ sessionId: failed.sessionId })
+    // A re-delivery of the new pick joins the new launch, not the retried chat.
+    expect(
+      startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' }).sessionId
+    ).toBe(fresh.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledTimes(2)
+
+    // Closing the retried chat leaves the new launch registered and starting.
+    rejectRetry(new StructuredAgentSessionCreateRefusalError('unsupported'))
+    await flushLaunchSettlement()
+    expect(cancelStructuredAgentLaunch(WORKTREE_ID, failed.sessionId)).toBe(true)
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, fresh.sessionId)).toBe('pending')
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('pending')
+
+    resolveFresh({ sessionId: fresh.sessionId, fence: 1 })
+    await expect(next.launchResult).resolves.toEqual({ sessionId: fresh.sessionId, fence: 1 })
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('idle')
+  })
+
+  it('restores a failed chat after reload without unregistering a newer launch', async () => {
+    await refuseFirstLaunch()
+    // Reload: the registry is memory; the failed record is what survives.
+    resetStructuredAgentLaunchRegistryForTests()
+    let resolveFresh!: (receipt: Receipt) => void
+    mocks.launch
+      .mockImplementationOnce(() => new Promise<Receipt>((resolve) => (resolveFresh = resolve)))
+      .mockResolvedValueOnce({ sessionId: failed.sessionId, fence: 1 })
+    const next = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-5' })
+
+    expect(retryStructuredAgentSessionLaunch(WORKTREE_ID, failed.sessionId)).toBe(true)
+    await flushLaunchSettlement()
+
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, failed.sessionId)).toBeNull()
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, fresh.sessionId)).toBe('pending')
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('pending')
+    resolveFresh({ sessionId: fresh.sessionId, fence: 1 })
+    await expect(next.launchResult).resolves.toEqual({ sessionId: fresh.sessionId, fence: 1 })
+  })
+
+  it('reads a failed resume as not starting, so resuming again opens a new chat', async () => {
+    const resumeFrom = { providerSessionId: 'provider-1' }
+    mocks.createIntent.mockReturnValueOnce(failed).mockReturnValueOnce(fresh)
+    mocks.launch
+      .mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('unsupported'))
+      .mockResolvedValueOnce({ sessionId: fresh.sessionId, fence: 1 })
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-6', resumeFrom })
+    await flushLaunchSettlement()
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('idle')
+
+    expect(
+      startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-7', resumeFrom })
+        .sessionId
+    ).toBe(fresh.sessionId)
+  })
+})
diff --git a/src/renderer/src/lib/structured-agent-session-launch-callers.ts b/src/renderer/src/lib/structured-agent-session-launch-callers.ts
index b3ce31f1a6b..b131ede7391 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-callers.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-callers.ts
@@ -4,8 +4,12 @@ import type { StructuredAgentSessionOutboxEntry } from '../../../shared/structur
 import type { StructuredAgentSessionResumeSource } from '../../../shared/structured-agent-session-create'
 import type { RuntimeClientTarget } from '@/runtime/runtime-client-target'
 import type { ExecutionHostId } from '../../../shared/execution-host'
+import type { StructuredLaunchAttempt } from './structured-agent-session-launch-request'
+import type { AgentLaunchRequestId } from './agent-launch-request-id'
 
 export type StructuredAgentLaunchOptions = {
+  /** The user action this start serves; only a re-delivery of it joins its chat. */
+  requestId: AgentLaunchRequestId
   prompt?: string
   promptDelivery?: 'auto-submit' | 'submit-after-ready' | 'draft'
   onPromptDelivered?: () => void
@@ -16,6 +20,8 @@ export type StructuredAgentLaunchOptions = {
   executionHostId?: ExecutionHostId
   /** The saved selection a paired host reported it will seed; read only by the starting caller. */
   hostSeedOptions?: Readonly<Record<string, string>>
+  /** The tab group the chat opens in; a request with no text reuses an empty chat only there. */
+  targetGroupId?: string
 }
 
 export type StructuredLaunchCaller = {
@@ -24,14 +30,18 @@ export type StructuredLaunchCaller = {
 
 export type StructuredLaunchCallerGroup = {
   outcome: 'pending' | 'published' | 'failed' | 'unknown' | 'cancelled'
+  attempt: StructuredLaunchAttempt
   entries: Set<StructuredLaunchCaller>
   promptDeliveryResults: Set<Promise<StructuredPromptDeliveryResult>>
   onSettled: () => void
 }
 
-export function createStructuredLaunchCallerGroup(): StructuredLaunchCallerGroup {
+export function createStructuredLaunchCallerGroup(
+  attempt: StructuredLaunchAttempt
+): StructuredLaunchCallerGroup {
   return {
     outcome: 'pending',
+    attempt,
     entries: new Set(),
     promptDeliveryResults: new Set(),
     onSettled: () => {}
diff --git a/src/renderer/src/lib/structured-agent-session-launch-cancellation.test.ts b/src/renderer/src/lib/structured-agent-session-launch-cancellation.test.ts
index f63b985586c..7ed9b0b4ec0 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-cancellation.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-cancellation.test.ts
@@ -82,6 +82,7 @@ describe('structured launch cancellation retirement', () => {
       promptDelivery: 'auto-submit',
       callers: {
         outcome: 'pending',
+        attempt: { kind: 'first', requestId: 'plus-pick', blank: true, stagedEntry: null },
         entries: new Set(),
         promptDeliveryResults: new Set(),
         onSettled: () => undefined
@@ -161,6 +162,7 @@ describe('structured launch cancellation retirement', () => {
       promptDelivery: 'auto-submit',
       callers: {
         outcome: 'pending',
+        attempt: { kind: 'first', requestId: 'plus-pick', blank: true, stagedEntry: null },
         entries: new Set(),
         promptDeliveryResults: new Set(),
         onSettled: () => undefined
diff --git a/src/renderer/src/lib/structured-agent-session-launch-close-race.test.ts b/src/renderer/src/lib/structured-agent-session-launch-close-race.test.ts
index 9c27384d5a9..a696ea5abb5 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-close-race.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-close-race.test.ts
@@ -159,7 +159,7 @@ describe('a close that races a structured launch', () => {
       () => new Promise((resolve) => (resolveRefresh = resolve))
     )
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-1' })
     await vi.waitFor(() => expect(refreshLocalStructuredSessionTabs).toHaveBeenCalledOnce())
     expect(cancelStructuredAgentLaunch(worktreeId, intent.sessionId)).toBe(true)
     expect(hasStructuredAgentSessionLaunchCancellationTombstone(worktreeId, intent.sessionId)).toBe(
@@ -177,7 +177,7 @@ describe('a close that races a structured launch', () => {
     expect(toast.error).not.toHaveBeenCalled()
   })
 
-  it('discards every coalesced prompt when a close cancels the launch', async () => {
+  it("discards a repeated request's one staged prompt when a close cancels the launch", async () => {
     const worktreeId = 'wt-close-coalesced-prompts'
     const intent = launchIntent(worktreeId)
     let resolveRefresh!: (snapshots: RuntimeMobileSessionTabsResult[]) => void
@@ -187,10 +187,16 @@ describe('a close that races a structured launch', () => {
       () => new Promise((resolve) => (resolveRefresh = resolve))
     )
 
-    startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'first prompt' })
-    startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'second prompt' })
+    startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'first prompt'
+    })
+    startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'first prompt'
+    })
     await vi.waitFor(() => expect(refreshLocalStructuredSessionTabs).toHaveBeenCalledOnce())
-    expect(readOutbox(intent.sessionId)).toHaveLength(2)
+    expect(readOutbox(intent.sessionId)).toHaveLength(1)
 
     expect(cancelStructuredAgentLaunch(worktreeId, intent.sessionId)).toBe(true)
     expect(readOutbox(intent.sessionId)).toEqual([])
@@ -210,7 +216,7 @@ describe('a close that races a structured launch', () => {
       .mockResolvedValueOnce([])
       .mockImplementationOnce(() => new Promise((resolve) => (resolveRetryRefresh = resolve)))
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-4' })
     await vi.waitFor(() => expect(refreshLocalStructuredSessionTabs).toHaveBeenCalledTimes(2))
     expect(cancelStructuredAgentLaunch(worktreeId, intent.sessionId)).toBe(true)
     resolveRetryRefresh([])
diff --git a/src/renderer/src/lib/structured-agent-session-launch-different-request.test.ts b/src/renderer/src/lib/structured-agent-session-launch-different-request.test.ts
new file mode 100644
index 00000000000..253a91c85bf
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-launch-different-request.test.ts
@@ -0,0 +1,567 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { RuntimeMobileSessionTabsResult } from '../../../shared/runtime-session-contracts'
+import type { StructuredAgentSessionLaunchIntent } from '@/lib/launch-structured-agent-session'
+
+const mocks = vi.hoisted(() => ({
+  abandonIntent: vi.fn(),
+  callStructuredAgentSession: vi.fn(),
+  createIntent: vi.fn(),
+  retryIntent: vi.fn(),
+  restoreIntent: vi.fn(),
+  launch: vi.fn(),
+  seedDraft: vi.fn(),
+  clearDraft: vi.fn()
+}))
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), message: vi.fn() } }))
+
+vi.mock('@/lib/launch-structured-agent-session', () => {
+  class StructuredAgentSessionCreateRefusalError extends Error {}
+  return {
+    createStructuredAgentSessionLaunchIntent: mocks.createIntent,
+    retryStructuredAgentSessionLaunchIntent: mocks.retryIntent,
+    restoreStructuredAgentSessionLaunchIntent: mocks.restoreIntent,
+    abandonStructuredAgentSessionLaunchIntent: mocks.abandonIntent,
+    launchStructuredAgentSession: mocks.launch,
+    StructuredAgentSessionCreateRefusalError
+  }
+})
+
+vi.mock('@/runtime/local-structured-session-tabs-sync', () => ({
+  refreshLocalStructuredSessionTabs: vi.fn()
+}))
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.callStructuredAgentSession
+}))
+
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({
+      unifiedTabsByWorktree: {},
+      seedNativeChatLaunchDraft: mocks.seedDraft,
+      clearNativeChatLaunchDraft: mocks.clearDraft
+    }),
+    subscribe: () => () => undefined
+  }
+}))
+
+vi.mock('@/i18n/i18n', () => ({
+  translate: (_key: string, fallback: string) => fallback
+}))
+
+vi.mock('@/lib/agent-catalog', () => ({
+  getAgentLabel: () => 'Codex',
+  getAgentCatalog: () => [{ id: 'codex', label: 'Codex' }]
+}))
+
+import { refreshLocalStructuredSessionTabs } from '@/runtime/local-structured-session-tabs-sync'
+import {
+  appendStructuredAgentSessionOutboxMessage,
+  readOutbox
+} from '@/components/native-chat/structured-agent-session-outbox-storage'
+import {
+  clearNativeChatDraftCacheForTests,
+  readNativeChatDraftCache,
+  writeNativeChatDraftCache
+} from '@/components/native-chat/native-chat-draft-cache'
+import {
+  structuredAgentSessionPaneKey,
+  structuredAgentSessionTabId
+} from '../../../shared/structured-agent-session-projection'
+import { StructuredAgentSessionCreateRefusalError } from '@/lib/launch-structured-agent-session'
+import {
+  getStructuredAgentSessionLaunchLifecycle,
+  startStructuredAgentLaunch
+} from './structured-agent-session-launch'
+import { resetStructuredAgentLaunchPersistenceForTests } from './structured-agent-session-launch-persistence'
+import { resetStructuredAgentLaunchRegistryForTests } from './structured-agent-session-launch-registry'
+
+const WORKTREE_ID = 'wt-different-request'
+
+function launchIntent(sessionId: string): StructuredAgentSessionLaunchIntent {
+  return {
+    worktreeId: WORKTREE_ID,
+    sessionId,
+    executionHostId: 'local',
+    target: { kind: 'local' },
+    agent: 'codex',
+    params: {
+      envelope: {
+        sessionId,
+        clientOperationId: `operation-${sessionId}`,
+        expectedRuntimeFence: null,
+        payloadFingerprint: `fingerprint-${sessionId}`
+      },
+      worktree: `id:${WORKTREE_ID}`,
+      agent: 'codex'
+    }
+  }
+}
+
+function publishedSnapshot(...sessionIds: string[]): RuntimeMobileSessionTabsResult {
+  return {
+    worktree: WORKTREE_ID,
+    publicationEpoch: 'epoch-1',
+    snapshotVersion: 1,
+    activeGroupId: null,
+    activeTabId: null,
+    activeTabType: null,
+    tabs: sessionIds.map((sessionId) => ({
+      type: 'agent-session',
+      id: `tab-${sessionId}`,
+      title: 'Codex',
+      sessionId,
+      agent: 'codex',
+      isActive: false
+    }))
+  }
+}
+
+const first = launchIntent('session-first')
+const second = launchIntent('session-second')
+
+/** Every `agentSession.send` as [session, text]. */
+function sends(): [string, string][] {
+  return mocks.callStructuredAgentSession.mock.calls
+    .filter((call) => call[1] === 'agentSession.send')
+    .map((call) => [call[2].envelope.sessionId, call[2].body.blocks[0].text])
+}
+
+describe('a different action while the first chat is still starting', () => {
+  let resolveFirstLaunch!: (receipt: { sessionId: string; fence: number }) => void
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    localStorage.clear()
+    resetStructuredAgentLaunchPersistenceForTests()
+    resetStructuredAgentLaunchRegistryForTests()
+    mocks.createIntent.mockReturnValueOnce(first).mockReturnValueOnce(second)
+    mocks.launch.mockImplementation((intent: StructuredAgentSessionLaunchIntent) =>
+      intent.sessionId === first.sessionId
+        ? new Promise((resolve) => (resolveFirstLaunch = resolve))
+        : Promise.resolve({ sessionId: intent.sessionId, fence: 1 })
+    )
+    vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
+      publishedSnapshot(first.sessionId, second.sessionId)
+    ])
+    mocks.callStructuredAgentSession.mockResolvedValue({
+      ok: true,
+      value: { submission: { dispatchState: 'accepted' } }
+    })
+  })
+
+  it('opens a new chat with its own text while the first create is in flight', async () => {
+    const checkA = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-check-a-click',
+      prompt: 'Fix check A',
+      promptDelivery: 'submit-after-ready'
+    })
+    const checkB = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-check-b-click',
+      prompt: 'Fix check B',
+      promptDelivery: 'submit-after-ready'
+    })
+
+    expect(checkB.sessionId).toBe(second.sessionId)
+    await expect(checkB.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    resolveFirstLaunch({ sessionId: first.sessionId, fence: 1 })
+    await expect(checkA.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(sends()).toEqual([
+      [second.sessionId, 'Fix check B'],
+      [first.sessionId, 'Fix check A']
+    ])
+  })
+
+  it('opens a new chat with its own text while the first chat is still sending its text', async () => {
+    let resolveFirstSend!: (result: unknown) => void
+    mocks.callStructuredAgentSession.mockImplementationOnce(
+      () => new Promise((resolve) => (resolveFirstSend = resolve))
+    )
+    const checkA = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-check-a-click',
+      prompt: 'Fix check A',
+      promptDelivery: 'submit-after-ready'
+    })
+    resolveFirstLaunch({ sessionId: first.sessionId, fence: 1 })
+    await vi.waitFor(() => expect(sends()).toEqual([[first.sessionId, 'Fix check A']]))
+
+    const checkB = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-check-b-click',
+      prompt: 'Fix check B',
+      promptDelivery: 'submit-after-ready'
+    })
+
+    expect(checkB.sessionId).toBe(second.sessionId)
+    await expect(checkB.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    resolveFirstSend({ ok: true, value: { submission: { dispatchState: 'accepted' } } })
+    await expect(checkA.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(sends()).toEqual([
+      [first.sessionId, 'Fix check A'],
+      [second.sessionId, 'Fix check B']
+    ])
+  })
+
+  it('opens two chats for two actions with identical text', async () => {
+    const firstClick = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click-1',
+      prompt: 'Fix check A',
+      promptDelivery: 'submit-after-ready'
+    })
+    const secondClick = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click-2',
+      prompt: 'Fix check A',
+      promptDelivery: 'submit-after-ready'
+    })
+    resolveFirstLaunch({ sessionId: first.sessionId, fence: 1 })
+
+    expect(secondClick.sessionId).toBe(second.sessionId)
+    for (const click of [firstClick, secondClick]) {
+      await expect(click.promptDeliveryResult).resolves.toEqual({
+        delivered: true,
+        failureNotified: false
+      })
+    }
+    expect(sends()).toEqual(
+      expect.arrayContaining([
+        [first.sessionId, 'Fix check A'],
+        [second.sessionId, 'Fix check A']
+      ])
+    )
+    expect(sends()).toHaveLength(2)
+  })
+})
+
+describe('one action delivered twice while its chat is still starting', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    localStorage.clear()
+    resetStructuredAgentLaunchPersistenceForTests()
+    resetStructuredAgentLaunchRegistryForTests()
+    mocks.createIntent.mockReturnValueOnce(first).mockReturnValueOnce(second)
+    vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
+      publishedSnapshot(first.sessionId, second.sessionId)
+    ])
+    mocks.callStructuredAgentSession.mockResolvedValue({
+      ok: true,
+      value: { submission: { dispatchState: 'accepted' } }
+    })
+  })
+
+  it('makes one chat from a double click with no text', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+
+    const pick = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'pick' })
+    const again = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'pick',
+      promptDelivery: 'submit-after-ready'
+    })
+
+    expect(again.sessionId).toBe(pick.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+  })
+
+  it('makes one chat and sends its text once while the create is in flight', async () => {
+    let resolveLaunch!: (receipt: { sessionId: string; fence: number }) => void
+    mocks.launch.mockImplementation(() => new Promise((resolve) => (resolveLaunch = resolve)))
+    const onFirstDelivered = vi.fn()
+    const onRepeatDelivered = vi.fn()
+
+    const click = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click',
+      prompt: 'Fix check A',
+      promptDelivery: 'submit-after-ready',
+      onPromptDelivered: onFirstDelivered
+    })
+    const repeat = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click',
+      prompt: 'Fix check A',
+      promptDelivery: 'submit-after-ready',
+      onPromptDelivered: onRepeatDelivered
+    })
+    resolveLaunch({ sessionId: first.sessionId, fence: 1 })
+
+    expect(repeat.sessionId).toBe(click.sessionId)
+    for (const caller of [click, repeat]) {
+      await expect(caller.promptDeliveryResult).resolves.toEqual({
+        delivered: true,
+        failureNotified: false
+      })
+    }
+    expect(sends()).toEqual([[first.sessionId, 'Fix check A']])
+    expect(onFirstDelivered).toHaveBeenCalledOnce()
+    expect(onRepeatDelivered).toHaveBeenCalledOnce()
+  })
+
+  // "Fix with AI" builds its text from logs fetched at click time; a re-delivery of that one click
+  // can carry newer logs and is still the same request.
+  it("makes one chat that sends the first delivery's text once when a re-delivery carries other text", async () => {
+    let resolveLaunch!: (receipt: { sessionId: string; fence: number }) => void
+    mocks.launch.mockImplementation(() => new Promise((resolve) => (resolveLaunch = resolve)))
+
+    const click = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click',
+      prompt: 'Fix check A (logs at 10:00)',
+      promptDelivery: 'submit-after-ready'
+    })
+    const redelivery = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click',
+      prompt: 'Fix check A (logs at 10:01)',
+      promptDelivery: 'submit-after-ready'
+    })
+    resolveLaunch({ sessionId: first.sessionId, fence: 1 })
+
+    expect(redelivery.sessionId).toBe(click.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+    for (const caller of [click, redelivery]) {
+      await expect(caller.promptDeliveryResult).resolves.toEqual({
+        delivered: true,
+        failureNotified: false
+      })
+    }
+    expect(sends()).toEqual([[first.sessionId, 'Fix check A (logs at 10:00)']])
+    expect(readOutbox(first.sessionId)).toEqual([])
+  })
+
+  it('seeds a repeated draft once', () => {
+    mocks.launch.mockImplementation(() => new Promise(() => undefined))
+
+    const click = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'continue-click',
+      prompt: 'PR context',
+      promptDelivery: 'draft'
+    })
+    const repeat = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'continue-click',
+      prompt: 'PR context',
+      promptDelivery: 'draft'
+    })
+
+    expect(repeat.sessionId).toBe(click.sessionId)
+    expect(mocks.seedDraft).toHaveBeenCalledOnce()
+  })
+
+  it('opens a new chat for a click after the start failed', async () => {
+    mocks.launch
+      .mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('refused'))
+      .mockImplementation(() => new Promise(() => undefined))
+
+    const failed = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click-1',
+      prompt: 'Fix check A',
+      promptDelivery: 'submit-after-ready'
+    })
+    await expect(failed.launchResult).rejects.toBeInstanceOf(
+      StructuredAgentSessionCreateRefusalError
+    )
+    const reclick = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click-2',
+      prompt: 'Fix check A',
+      promptDelivery: 'submit-after-ready'
+    })
+
+    expect(reclick.sessionId).toBe(second.sessionId)
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, first.sessionId)).toBe('failed')
+    expect(readOutbox(second.sessionId).map((entry) => entry.body.blocks)).toEqual([
+      [{ type: 'text', text: 'Fix check A' }]
+    ])
+  })
+})
+
+describe('an empty chat still starting', () => {
+  let resolveFirstLaunch!: (receipt: { sessionId: string; fence: number }) => void
+  const third = launchIntent('session-third')
+  const notesSend = {
+    requestId: 'notes-send',
+    prompt: 'review notes',
+    promptDelivery: 'submit-after-ready'
+  } as const
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    localStorage.clear()
+    resetStructuredAgentLaunchPersistenceForTests()
+    resetStructuredAgentLaunchRegistryForTests()
+    mocks.createIntent
+      .mockReturnValueOnce(first)
+      .mockReturnValueOnce(second)
+      .mockReturnValueOnce(third)
+    clearNativeChatDraftCacheForTests()
+    mocks.launch.mockImplementation((intent: StructuredAgentSessionLaunchIntent) =>
+      intent.sessionId === first.sessionId
+        ? new Promise((resolve) => (resolveFirstLaunch = resolve))
+        : Promise.resolve({ sessionId: intent.sessionId, fence: 1 })
+    )
+    vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
+      publishedSnapshot(first.sessionId, second.sessionId, third.sessionId)
+    ])
+    mocks.callStructuredAgentSession.mockResolvedValue({
+      ok: true,
+      value: { submission: { dispatchState: 'accepted' } }
+    })
+  })
+
+  it('takes notes sent to a new agent instead of opening a second chat', async () => {
+    const blank = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+
+    const notes = startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+    resolveFirstLaunch({ sessionId: first.sessionId, fence: 1 })
+
+    expect(notes.sessionId).toBe(blank.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+    await expect(notes.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(sends()).toEqual([[first.sessionId, 'review notes']])
+  })
+
+  it('opens a new chat for any other action once its notes claimed it', async () => {
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+
+    const fix = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'fix-click',
+      prompt: 'Fix check B',
+      promptDelivery: 'submit-after-ready'
+    })
+    // The pick that opened the empty chat is now the notes' chat, not the pick's.
+    const pick = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+
+    expect(fix.sessionId).toBe(second.sessionId)
+    expect(pick.sessionId).toBe(third.sessionId)
+    await expect(fix.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(sends()).toEqual([[second.sessionId, 'Fix check B']])
+  })
+
+  it('delivers the claiming text the way its own request asked', async () => {
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'plus-pick',
+      promptDelivery: 'draft'
+    })
+    const notes = startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+    resolveFirstLaunch({ sessionId: first.sessionId, fence: 1 })
+
+    await expect(notes.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(sends()).toEqual([[first.sessionId, 'review notes']])
+    expect(mocks.seedDraft).not.toHaveBeenCalled()
+  })
+
+  it('sends the claiming notes once when that send is delivered twice', async () => {
+    const blank = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+    const notes = startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+    const again = startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+    resolveFirstLaunch({ sessionId: first.sessionId, fence: 1 })
+
+    expect(again.sessionId).toBe(blank.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+    for (const caller of [notes, again]) {
+      await expect(caller.promptDeliveryResult).resolves.toEqual({
+        delivered: true,
+        failureNotified: false
+      })
+    }
+    expect(sends()).toEqual([[first.sessionId, 'review notes']])
+  })
+
+  it('opens a new chat for a second notes send with the same text', async () => {
+    const blank = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+    const secondSend = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      ...notesSend,
+      requestId: 'notes-send-2'
+    })
+
+    expect(secondSend.sessionId).toBe(second.sessionId)
+    expect(secondSend.sessionId).not.toBe(blank.sessionId)
+    await expect(secondSend.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(sends()).toEqual([[second.sessionId, 'review notes']])
+  })
+
+  it('leaves a chat its user already sent into to them, and opens a new chat for the notes', async () => {
+    const blank = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+    appendStructuredAgentSessionOutboxMessage(blank.sessionId, 'my own question')
+
+    const notes = startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+
+    expect(notes.sessionId).toBe(second.sessionId)
+    await expect(notes.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(sends()).toEqual([[second.sessionId, 'review notes']])
+    expect(readOutbox(blank.sessionId).map((entry) => entry.body.blocks)).toEqual([
+      [{ type: 'text', text: 'my own question' }]
+    ])
+  })
+
+  it('leaves a chat its user is typing into to them, and opens a new chat for the notes', async () => {
+    const blank = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+    const paneKey = structuredAgentSessionPaneKey(
+      structuredAgentSessionTabId(blank.sessionId),
+      blank.sessionId
+    )
+    writeNativeChatDraftCache(paneKey, 'half a question')
+
+    const notes = startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+
+    expect(notes.sessionId).toBe(second.sessionId)
+    await expect(notes.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(readOutbox(blank.sessionId)).toEqual([])
+    expect(readNativeChatDraftCache(paneKey)).toBe('half a question')
+  })
+
+  it('opens a new chat that shows the failure when the claiming text cannot be saved', async () => {
+    const blank = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' })
+    const storageFailure = vi.spyOn(localStorage, 'setItem').mockImplementation(() => {
+      throw new Error('storage unavailable')
+    })
+    const notes = startStructuredAgentLaunch(WORKTREE_ID, 'codex', notesSend)
+    storageFailure.mockRestore()
+
+    // The new chat fails with its Retry line, the failure the caller is told was shown.
+    expect(notes.sessionId).toBe(second.sessionId)
+    await expect(notes.launchResult).rejects.toBeInstanceOf(
+      StructuredAgentSessionCreateRefusalError
+    )
+    await expect(notes.promptDeliveryResult).resolves.toEqual({
+      delivered: false,
+      failureNotified: true
+    })
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, second.sessionId)).toBe('failed')
+    // No claim was recorded: the empty chat is still the pick's, and still claimable.
+    expect(
+      startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'plus-pick' }).sessionId
+    ).toBe(blank.sessionId)
+    expect(
+      startStructuredAgentLaunch(WORKTREE_ID, 'codex', { ...notesSend, requestId: 'notes-retry' })
+        .sessionId
+    ).toBe(blank.sessionId)
+  })
+})
diff --git a/src/renderer/src/lib/structured-agent-session-launch-empty-chat.ts b/src/renderer/src/lib/structured-agent-session-launch-empty-chat.ts
new file mode 100644
index 00000000000..57efb3fedc8
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-launch-empty-chat.ts
@@ -0,0 +1,18 @@
+import {
+  structuredAgentSessionPaneKey,
+  structuredAgentSessionTabId
+} from '../../../shared/structured-agent-session-projection'
+import { getStructuredAgentSessionOutbox } from '@/components/native-chat/structured-agent-session-outbox-storage'
+import { readNativeChatDraftCache } from '@/components/native-chat/native-chat-draft-cache'
+import { readNativeChatAttachmentCache } from '@/components/native-chat/use-native-chat-composer-attachments'
+
+/** A starting chat is empty until its user sends into it or puts text or images in its composer;
+ *  after that it is theirs, and another request never goes into it. */
+export function isStructuredLaunchChatEmpty(sessionId: string): boolean {
+  const paneKey = structuredAgentSessionPaneKey(structuredAgentSessionTabId(sessionId), sessionId)
+  return (
+    getStructuredAgentSessionOutbox(sessionId).length === 0 &&
+    readNativeChatDraftCache(paneKey).trim() === '' &&
+    readNativeChatAttachmentCache(paneKey).length === 0
+  )
+}
diff --git a/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts b/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts
index 10ebbc8fd89..5ba2668962d 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts
@@ -94,7 +94,7 @@ async function settle(sessionId: string): Promise<void> {
 }
 
 function launch(): string {
-  const started = startStructuredAgentLaunch(WORKTREE, 'codex')
+  const started = startStructuredAgentLaunch(WORKTREE, 'codex', { requestId: 'request-1' })
   void started.launchResult.catch(() => undefined)
   return started.sessionId
 }
diff --git a/src/renderer/src/lib/structured-agent-session-launch-holders.ts b/src/renderer/src/lib/structured-agent-session-launch-holders.ts
new file mode 100644
index 00000000000..2b9b62a1473
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-launch-holders.ts
@@ -0,0 +1,87 @@
+import {
+  launchStateLifecycle,
+  structuredLaunchStates,
+  type StructuredLaunchState
+} from './structured-agent-session-launch-registry'
+import type {
+  StructuredLaunchAttempt,
+  StructuredLaunchRequest
+} from './structured-agent-session-launch-request'
+import type { AgentLaunchRequestId } from './agent-launch-request-id'
+import { isStructuredLaunchChatEmpty } from './structured-agent-session-launch-empty-chat'
+import { structuredChatTabGroupId } from './structured-agent-session-chat-tab-group'
+
+// Why: coalescing stops one user action delivered twice (a double click) racing into two chats. Any
+// other action, a failed or unconfirmed launch, or a Retry/re-check of one is not that race: a new
+// start opens a new chat carrying its own text. A resume keeps holding: the host refuses a second
+// adoption.
+function holdsLaunchIdentity(
+  state: StructuredLaunchState,
+  requestId?: AgentLaunchRequestId
+): boolean {
+  const lifecycle = launchStateLifecycle(state)
+  if (lifecycle === 'failed' || lifecycle === 'cancelled') {
+    return false
+  }
+  if (state.intent.params.resumeFrom) {
+    return true
+  }
+  const { attempt } = state.callers
+  return (
+    lifecycle !== 'visibility-unknown' &&
+    attempt.kind === 'first' &&
+    (requestId === undefined || attempt.requestId === requestId)
+  )
+}
+
+/** Launches a start of `requestId` would join; without it, every new start's own create. */
+export function structuredLaunchesHoldingIdentity(
+  matches: (identity: string) => boolean,
+  requestId?: AgentLaunchRequestId
+): StructuredLaunchState[] {
+  return [...structuredLaunchStates()].filter(
+    (state) => matches(state.identity) && holdsLaunchIdentity(state, requestId)
+  )
+}
+
+/** A blank first attempt (a + pick, the empty-workspace default) still starting, which its user has
+ *  not sent or typed into. A resume is never empty. */
+function emptyStructuredLaunchAttempt(
+  state: StructuredLaunchState
+): Extract<StructuredLaunchAttempt, { kind: 'first' }> | undefined {
+  const { attempt } = state.callers
+  return !state.intent.params.resumeFrom &&
+    attempt.kind === 'first' &&
+    attempt.blank &&
+    isStructuredLaunchChatEmpty(state.intent.sessionId)
+    ? attempt
+    : undefined
+}
+
+/** The first request with text claims an empty starting chat once; from then on it is that
+ *  request's chat. */
+export function claimableStructuredLaunchAttempt(
+  state: StructuredLaunchState,
+  request: StructuredLaunchRequest
+): Extract<StructuredLaunchAttempt, { kind: 'first' }> | undefined {
+  return request.hasText ? emptyStructuredLaunchAttempt(state) : undefined
+}
+
+/** The launch a new start of `request` joins: one it re-delivers, else an empty starting chat in the
+ *  tab group it opens in, which a request with text claims and one without reuses. The newest wins. */
+export function getJoinableStructuredLaunchState(
+  identity: string,
+  request: StructuredLaunchRequest
+): StructuredLaunchState | undefined {
+  const matches = (candidate: string): boolean => candidate === identity
+  return (
+    structuredLaunchesHoldingIdentity(matches, request.id).at(-1) ??
+    structuredLaunchesHoldingIdentity(matches).findLast(
+      (state) =>
+        emptyStructuredLaunchAttempt(state) &&
+        (!request.groupId ||
+          structuredChatTabGroupId(state.intent.worktreeId, state.intent.sessionId) ===
+            request.groupId)
+    )
+  )
+}
diff --git a/src/renderer/src/lib/structured-agent-session-launch-join-delivery.test.ts b/src/renderer/src/lib/structured-agent-session-launch-join-delivery.test.ts
index c597c552262..a810264db66 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-join-delivery.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-join-delivery.test.ts
@@ -137,7 +137,9 @@ describe('coalesced launch delivery mode', () => {
     established: StructuredAgentLaunchOptions
     joining: StructuredAgentLaunchOptions
   }) {
-    const intent = launchIntent(args.worktreeId, args.sessionId)
+    const base = launchIntent(args.worktreeId, args.sessionId)
+    const { resumeFrom } = args.established
+    const intent = resumeFrom ? { ...base, params: { ...base.params, resumeFrom } } : base
     let resolveLaunch!: (receipt: { sessionId: string; fence: number }) => void
     mocks.createIntent.mockReturnValueOnce(intent)
     mocks.launch.mockImplementation(
@@ -155,13 +157,19 @@ describe('coalesced launch delivery mode', () => {
     return { intent, joiner }
   }
 
-  it('keeps a joiner as a draft when the launch it joined established no mode', async () => {
-    // The onboarding folder launch establishes an identity carrying neither prompt nor mode.
+  // Only a resume joins a launch started by a different request; a new start opens its own chat.
+  it('keeps a resume joiner as a draft when the launch it joined established no mode', async () => {
+    const resumeFrom = { providerSessionId: 'provider-unset-delivery' }
     const { intent, joiner } = await coalesce({
       worktreeId: 'wt-unset-delivery-mode',
       sessionId: 'unset-delivery-session',
-      established: {},
-      joining: { prompt: 'PR context', promptDelivery: 'draft' }
+      established: { requestId: 'resume-click', resumeFrom },
+      joining: {
+        requestId: 'another-resume-click',
+        resumeFrom,
+        prompt: 'PR context',
+        promptDelivery: 'draft'
+      }
     })
 
     // Why: an unset established mode must not read as submit; the joiner never consented to send.
diff --git a/src/renderer/src/lib/structured-agent-session-launch-options.test.ts b/src/renderer/src/lib/structured-agent-session-launch-options.test.ts
index a3a6a174fb3..2d7e6e418ad 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-options.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-options.test.ts
@@ -188,7 +188,10 @@ describe('picks made while a chat launches', () => {
   it('applies them against the receipt fence before the first turn and before publishing', async () => {
     const created = deferred<{ sessionId: string; fence: number }>()
     mocks.launch.mockReturnValue(created.promise)
-    const launch = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { prompt: 'first turn' })
+    const launch = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'request-1',
+      prompt: 'first turn'
+    })
 
     const modelPick = holdStructuredAgentSessionLaunchOption(SESSION_ID, 'model', 'gpt-picked')
     holdStructuredAgentSessionLaunchOption(SESSION_ID, 'effort', 'high')
@@ -224,7 +227,7 @@ describe('picks made while a chat launches', () => {
 
   it('applies a pick made while the earlier ones are being applied', async () => {
     mocks.launch.mockResolvedValue({ sessionId: SESSION_ID, fence: 1 })
-    const launch = startStructuredAgentLaunch(WORKTREE_ID, 'codex')
+    const launch = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-2' })
     holdStructuredAgentSessionLaunchOption(SESSION_ID, 'model', 'gpt-picked')
     await settle()
     expect(setOptionReplies).toHaveLength(1)
@@ -241,7 +244,10 @@ describe('picks made while a chat launches', () => {
 
   it('reports a refused pick to its picker and publishes all the same', async () => {
     mocks.launch.mockResolvedValue({ sessionId: SESSION_ID, fence: 1 })
-    const launch = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { prompt: 'first turn' })
+    const launch = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'request-3',
+      prompt: 'first turn'
+    })
     const pick = holdStructuredAgentSessionLaunchOption(SESSION_ID, 'model', 'gpt-missing')
     await settle()
     setOptionReplies[0]!.resolve({
@@ -269,7 +275,7 @@ describe('picks made while a chat launches', () => {
 
   it('reports a refusal the host threw as its fact, never the bare code it carries as a message', async () => {
     mocks.launch.mockResolvedValue({ sessionId: SESSION_ID, fence: 1 })
-    startStructuredAgentLaunch(WORKTREE_ID, 'codex')
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-4' })
     const pick = holdStructuredAgentSessionLaunchOption(SESSION_ID, 'model', 'gpt-missing')
     await settle()
     setOptionReplies[0]!.resolve(
@@ -306,7 +312,7 @@ describe('picks made while a chat launches', () => {
     mocks.launch
       .mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('unsupported'))
       .mockResolvedValueOnce({ sessionId: SESSION_ID, fence: 2 })
-    startStructuredAgentLaunch(WORKTREE_ID, 'codex')
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-5' })
     holdStructuredAgentSessionLaunchOption(SESSION_ID, 'model', 'gpt-picked')
     await settle()
     expect(lifecycle()).toBe('failed')
@@ -327,7 +333,7 @@ describe('picks made while a chat launches', () => {
   it('discards them when the tab closes before the launch publishes', async () => {
     const created = deferred<{ sessionId: string; fence: number }>()
     mocks.launch.mockReturnValue(created.promise)
-    startStructuredAgentLaunch(WORKTREE_ID, 'codex')
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-6' })
     holdStructuredAgentSessionLaunchOption(SESSION_ID, 'model', 'gpt-picked')
 
     cancelStructuredAgentLaunch(WORKTREE_ID, SESSION_ID)
@@ -340,7 +346,7 @@ describe('picks made while a chat launches', () => {
 
   it('folds an accepted pick into what the launch reports it runs', async () => {
     mocks.launch.mockResolvedValue({ sessionId: SESSION_ID, fence: 1 })
-    startStructuredAgentLaunch(WORKTREE_ID, 'codex')
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-7' })
     holdStructuredAgentSessionLaunchOption(SESSION_ID, 'effort', 'high')
     await settle()
     const seen: unknown[] = []
diff --git a/src/renderer/src/lib/structured-agent-session-launch-registry.ts b/src/renderer/src/lib/structured-agent-session-launch-registry.ts
index 622fc58b379..9d21852b2fb 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-registry.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-registry.ts
@@ -43,19 +43,17 @@ export type StructuredAgentSessionLaunchLifecycle =
   | 'published'
   | 'cancelled'
 
-const pendingStructuredLaunchesByIdentity = new Map<string, StructuredLaunchState>()
 const structuredLaunchesBySessionId = new Map<string, StructuredLaunchState>()
 const structuredLaunchListeners = new Set<() => void>()
 
 export function resetStructuredAgentLaunchRegistryForTests(): void {
-  pendingStructuredLaunchesByIdentity.clear()
   structuredLaunchesBySessionId.clear()
   structuredLaunchListeners.clear()
   resetStructuredAgentLaunchCancellationForTests()
 }
 
 export function notifyStructuredLaunchListeners(): void {
-  for (const state of pendingStructuredLaunchesByIdentity.values()) {
+  for (const state of structuredLaunchesBySessionId.values()) {
     persistStructuredLaunchState(state)
   }
   for (const listener of structuredLaunchListeners) {
@@ -80,10 +78,6 @@ export function structuredLaunchIdentity(
     : `${agent}:${worktreeId}`
 }
 
-export function getStructuredLaunchState(identity: string): StructuredLaunchState | undefined {
-  return pendingStructuredLaunchesByIdentity.get(identity)
-}
-
 export function getStructuredLaunchStateBySessionId(
   sessionId: string
 ): StructuredLaunchState | undefined {
@@ -91,19 +85,15 @@ export function getStructuredLaunchStateBySessionId(
 }
 
 export function setStructuredLaunchState(state: StructuredLaunchState): void {
-  pendingStructuredLaunchesByIdentity.set(state.identity, state)
   structuredLaunchesBySessionId.set(state.intent.sessionId, state)
   persistStructuredLaunchState(state)
 }
 
 export function deleteStructuredLaunchStateIfCurrent(state: StructuredLaunchState): boolean {
-  if (pendingStructuredLaunchesByIdentity.get(state.identity) !== state) {
+  if (structuredLaunchesBySessionId.get(state.intent.sessionId) !== state) {
     return false
   }
-  pendingStructuredLaunchesByIdentity.delete(state.identity)
-  if (structuredLaunchesBySessionId.get(state.intent.sessionId) === state) {
-    structuredLaunchesBySessionId.delete(state.intent.sessionId)
-  }
+  structuredLaunchesBySessionId.delete(state.intent.sessionId)
   deleteStructuredAgentLaunchRecord(state.intent.sessionId)
   return true
 }
@@ -124,10 +114,12 @@ export function getPersistedStructuredAgentLaunchRecord(
 }
 
 export function structuredLaunchStates(): IterableIterator<StructuredLaunchState> {
-  return pendingStructuredLaunchesByIdentity.values()
+  return structuredLaunchesBySessionId.values()
 }
 
-function launchStateLifecycle(state: StructuredLaunchState): StructuredAgentSessionLaunchLifecycle {
+export function launchStateLifecycle(
+  state: StructuredLaunchState
+): StructuredAgentSessionLaunchLifecycle {
   if (state.cancelled || state.callers.outcome === 'cancelled') {
     return 'cancelled'
   }
@@ -314,20 +306,3 @@ export function retireAbsentStructuredAgentSessionLaunchCancellationTombstones(
   }
   return changed
 }
-
-export function getStructuredAgentLaunchStatus(
-  worktreeId: string,
-  agent: AgentSessionHandleProvider
-): StructuredAgentLaunchStatus {
-  // Any launch for this pair, including adopted conversations, means a chat is starting here.
-  const states = [
-    getStructuredLaunchState(structuredLaunchIdentity(worktreeId, agent)),
-    ...[...pendingStructuredLaunchesByIdentity.entries()]
-      .filter(([identity]) => identity.startsWith(`${agent}:${worktreeId}:resume:`))
-      .map(([, state]) => state)
-  ].filter((state): state is StructuredLaunchState => Boolean(state))
-  if (states.length === 0) {
-    return 'idle'
-  }
-  return states.some((state) => state.visibilityUnknown) ? 'unknown' : 'pending'
-}
diff --git a/src/renderer/src/lib/structured-agent-session-launch-reload.ts b/src/renderer/src/lib/structured-agent-session-launch-reload.ts
index 3ac9394a89c..35379324faa 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-reload.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-reload.ts
@@ -42,7 +42,8 @@ export function restorePersistedStructuredLaunchState(
     }
     throw error
   }
-  const callers: StructuredLaunchCallerGroup = createStructuredLaunchCallerGroup()
+  // Only a Retry or re-check restarts a restored launch.
+  const callers: StructuredLaunchCallerGroup = createStructuredLaunchCallerGroup({ kind: 'retry' })
   const state: StructuredLaunchState = {
     identity: structuredLaunchIdentity(worktreeId, record.agent, record.resumeFrom),
     intent,
diff --git a/src/renderer/src/lib/structured-agent-session-launch-request.ts b/src/renderer/src/lib/structured-agent-session-launch-request.ts
new file mode 100644
index 00000000000..f200b81d7ad
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-launch-request.ts
@@ -0,0 +1,42 @@
+import type { StructuredAgentSessionOutboxEntry } from '../../../shared/structured-agent-session-outbox'
+import type { AgentLaunchRequestId } from './agent-launch-request-id'
+
+/** What a new start brings: the user action it serves, whether it carries text, and the tab group
+ *  it opens in. */
+export type StructuredLaunchRequest = {
+  id: AgentLaunchRequestId
+  hasText: boolean
+  groupId?: string
+}
+
+/** A new start's own create keeps its request and the text it staged; a Retry or re-check of an
+ *  existing chat is no request of its own. */
+export type StructuredLaunchAttempt =
+  | {
+      kind: 'first'
+      requestId: AgentLaunchRequestId
+      /** The request carried no text: the chat is blank until something claims it. */
+      blank: boolean
+      stagedEntry: StructuredAgentSessionOutboxEntry | null
+    }
+  | { kind: 'retry' }
+
+export function structuredLaunchRequest(options: {
+  requestId: AgentLaunchRequestId
+  prompt?: string
+  targetGroupId?: string
+}): StructuredLaunchRequest {
+  return {
+    id: options.requestId,
+    hasText: (options.prompt?.trim() ?? '') !== '',
+    ...(options.targetGroupId ? { groupId: options.targetGroupId } : {})
+  }
+}
+
+/** The first attempt `requestId` re-delivers, whose text is already staged or seeded. */
+export function repeatedStructuredLaunchAttempt(
+  attempt: StructuredLaunchAttempt,
+  requestId: AgentLaunchRequestId
+): Extract<StructuredLaunchAttempt, { kind: 'first' }> | undefined {
+  return attempt.kind === 'first' && attempt.requestId === requestId ? attempt : undefined
+}
diff --git a/src/renderer/src/lib/structured-agent-session-launch-resume-identity.test.ts b/src/renderer/src/lib/structured-agent-session-launch-resume-identity.test.ts
index 4240aeff216..ac634b4eac1 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-resume-identity.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-resume-identity.test.ts
@@ -80,8 +80,9 @@ describe('a launch that adopts a conversation is its own identity', () => {
     // A joining caller is handed the EXISTING intent and contributes only its prompt, so joining
     // here would silently drop the adoption and open a blank chat instead.
     const worktreeId = 'wt-resume-vs-blank'
-    const blank = startStructuredAgentLaunch(worktreeId, 'codex')
+    const blank = startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-1' })
     const resume = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-2',
       resumeFrom: { providerSessionId: 'thread-1' }
     })
 
@@ -100,9 +101,10 @@ describe('a launch that adopts a conversation is its own identity', () => {
   it('does not hand a blank launch the resume already pending for the same worktree', async () => {
     const worktreeId = 'wt-blank-vs-resume'
     const resume = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-3',
       resumeFrom: { providerSessionId: 'thread-1' }
     })
-    const blank = startStructuredAgentLaunch(worktreeId, 'codex')
+    const blank = startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-4' })
 
     await flushLaunchDispatch()
 
@@ -113,9 +115,11 @@ describe('a launch that adopts a conversation is its own identity', () => {
   it('keeps two resumes of different rows apart', async () => {
     const worktreeId = 'wt-two-rows'
     const first = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-5',
       resumeFrom: { providerSessionId: 'thread-1' }
     })
     const second = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-6',
       resumeFrom: { providerSessionId: 'thread-2' }
     })
 
@@ -131,8 +135,14 @@ describe('a launch that adopts a conversation is its own identity', () => {
   it('coalesces a duplicate click on the same row', async () => {
     const worktreeId = 'wt-same-row-twice'
     const resumeFrom = { providerSessionId: 'thread-1' }
-    const first = startStructuredAgentLaunch(worktreeId, 'codex', { resumeFrom })
-    const second = startStructuredAgentLaunch(worktreeId, 'codex', { resumeFrom })
+    const first = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-7',
+      resumeFrom
+    })
+    const second = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-8',
+      resumeFrom
+    })
 
     await flushLaunchDispatch()
 
@@ -142,8 +152,14 @@ describe('a launch that adopts a conversation is its own identity', () => {
 
   it('keeps the same row apart across worktrees and agents', async () => {
     const resumeFrom = { providerSessionId: 'thread-1' }
-    const here = startStructuredAgentLaunch('wt-here', 'codex', { resumeFrom })
-    const there = startStructuredAgentLaunch('wt-there', 'codex', { resumeFrom })
+    const here = startStructuredAgentLaunch('wt-here', 'codex', {
+      requestId: 'request-9',
+      resumeFrom
+    })
+    const there = startStructuredAgentLaunch('wt-there', 'codex', {
+      requestId: 'request-10',
+      resumeFrom
+    })
 
     await flushLaunchDispatch()
 
@@ -157,6 +173,7 @@ describe('a launch that adopts a conversation is its own identity', () => {
     expect(getStructuredAgentLaunchStatus(worktreeId, 'codex')).toBe('idle')
 
     startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-11',
       resumeFrom: { providerSessionId: 'thread-1' }
     })
 
diff --git a/src/renderer/src/lib/structured-agent-session-launch-status.ts b/src/renderer/src/lib/structured-agent-session-launch-status.ts
index 6ae37ff6553..64d42bab136 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-status.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-status.ts
@@ -1,17 +1,23 @@
-import { useSyncExternalStore } from 'react'
 import type { AgentSessionHandleProvider } from '../../../shared/agent-session-provider-handle'
+import { structuredLaunchesHoldingIdentity } from './structured-agent-session-launch-holders'
 import {
-  getStructuredAgentLaunchStatus,
-  subscribeStructuredAgentLaunchStatus
+  structuredLaunchIdentity,
+  type StructuredAgentLaunchStatus
 } from './structured-agent-session-launch-registry'
 
-export function useStructuredAgentLaunchStatus(
+/** Whether a chat for this pair is being created here: its own first create, or an adoption. */
+export function getStructuredAgentLaunchStatus(
   worktreeId: string,
   agent: AgentSessionHandleProvider
-): ReturnType<typeof getStructuredAgentLaunchStatus> {
-  return useSyncExternalStore(
-    subscribeStructuredAgentLaunchStatus,
-    () => getStructuredAgentLaunchStatus(worktreeId, agent),
-    () => 'idle'
+): StructuredAgentLaunchStatus {
+  // Any launch holding an identity for this pair, adopted conversations included, is starting here.
+  // A failed chat is not, nor an unconfirmed or retried blank one: a new launch opens its own chat.
+  const identity = structuredLaunchIdentity(worktreeId, agent)
+  const states = structuredLaunchesHoldingIdentity(
+    (candidate) => candidate === identity || candidate.startsWith(`${identity}:resume:`)
   )
+  if (states.length === 0) {
+    return 'idle'
+  }
+  return states.some((state) => state.visibilityUnknown) ? 'unknown' : 'pending'
 }
diff --git a/src/renderer/src/lib/structured-agent-session-launch-unconfirmed-or-retried.test.ts b/src/renderer/src/lib/structured-agent-session-launch-unconfirmed-or-retried.test.ts
new file mode 100644
index 00000000000..96b3b3f53ff
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-launch-unconfirmed-or-retried.test.ts
@@ -0,0 +1,329 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { RuntimeMobileSessionTabsResult } from '../../../shared/runtime-session-contracts'
+import type { StructuredAgentSessionLaunchIntent } from '@/lib/launch-structured-agent-session'
+
+const mocks = vi.hoisted(() => ({
+  abandonIntent: vi.fn(),
+  callStructuredAgentSession: vi.fn(),
+  createIntent: vi.fn(),
+  retryIntent: vi.fn(),
+  restoreIntent: vi.fn(),
+  launch: vi.fn(),
+  seedDraft: vi.fn(),
+  clearDraft: vi.fn(),
+  toastError: vi.fn()
+}))
+
+vi.mock('sonner', () => ({ toast: { error: mocks.toastError, message: vi.fn() } }))
+
+vi.mock('@/lib/launch-structured-agent-session', () => {
+  class StructuredAgentSessionCreateRefusalError extends Error {}
+  return {
+    createStructuredAgentSessionLaunchIntent: mocks.createIntent,
+    retryStructuredAgentSessionLaunchIntent: mocks.retryIntent,
+    restoreStructuredAgentSessionLaunchIntent: mocks.restoreIntent,
+    abandonStructuredAgentSessionLaunchIntent: mocks.abandonIntent,
+    launchStructuredAgentSession: mocks.launch,
+    StructuredAgentSessionCreateRefusalError
+  }
+})
+
+vi.mock('@/runtime/local-structured-session-tabs-sync', () => ({
+  refreshLocalStructuredSessionTabs: vi.fn()
+}))
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.callStructuredAgentSession
+}))
+
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({
+      unifiedTabsByWorktree: {},
+      seedNativeChatLaunchDraft: mocks.seedDraft,
+      clearNativeChatLaunchDraft: mocks.clearDraft
+    }),
+    subscribe: () => () => undefined
+  }
+}))
+
+vi.mock('@/i18n/i18n', () => ({
+  translate: (_key: string, fallback: string) => fallback
+}))
+
+vi.mock('@/lib/agent-catalog', () => ({
+  getAgentLabel: () => 'Codex',
+  getAgentCatalog: () => [{ id: 'codex', label: 'Codex' }]
+}))
+
+vi.mock('@/lib/focus-terminal-tab-surface', () => ({ focusTerminalTabSurface: vi.fn() }))
+
+// The structured route hands the launch's own delivery result back unchanged.
+vi.mock('@/lib/launch-agent-in-new-tab', async () => {
+  const launch = await import('./structured-agent-session-launch')
+  return {
+    launchAgentInNewTab: (args: {
+      requestId: string
+      worktreeId: string
+      prompt: string
+      promptDelivery: 'auto-submit' | 'draft' | 'submit-after-ready'
+    }) => {
+      const started = launch.startStructuredAgentLaunch(args.worktreeId, 'codex', {
+        requestId: args.requestId,
+        prompt: args.prompt,
+        promptDelivery: args.promptDelivery
+      })
+      return {
+        surface: { kind: 'agent-session', sessionId: started.sessionId },
+        ...(started.promptDeliveryResult
+          ? { promptDeliveryResult: started.promptDeliveryResult }
+          : {})
+      }
+    }
+  }
+})
+
+import { StructuredAgentSessionCreateRefusalError } from '@/lib/launch-structured-agent-session'
+import { refreshLocalStructuredSessionTabs } from '@/runtime/local-structured-session-tabs-sync'
+import { runSourceControlAgentActionStart } from '@/components/right-sidebar/runSourceControlAgentActionStart'
+import {
+  getStructuredAgentLaunchStatus,
+  getStructuredAgentSessionLaunchLifecycle,
+  retryStructuredAgentSessionLaunch,
+  startStructuredAgentLaunch
+} from './structured-agent-session-launch'
+import { resetStructuredAgentLaunchPersistenceForTests } from './structured-agent-session-launch-persistence'
+import { resetStructuredAgentLaunchRegistryForTests } from './structured-agent-session-launch-registry'
+
+const WORKTREE_ID = 'wt-unconfirmed-or-retried'
+
+function launchIntent(sessionId: string): StructuredAgentSessionLaunchIntent {
+  return {
+    worktreeId: WORKTREE_ID,
+    sessionId,
+    executionHostId: 'local',
+    target: { kind: 'local' },
+    agent: 'codex',
+    params: {
+      envelope: {
+        sessionId,
+        clientOperationId: `operation-${sessionId}`,
+        expectedRuntimeFence: null,
+        payloadFingerprint: `fingerprint-${sessionId}`
+      },
+      worktree: `id:${WORKTREE_ID}`,
+      agent: 'codex'
+    }
+  }
+}
+
+function publishedSnapshot(sessionId: string): RuntimeMobileSessionTabsResult {
+  return {
+    worktree: WORKTREE_ID,
+    publicationEpoch: 'epoch-1',
+    snapshotVersion: 1,
+    activeGroupId: null,
+    activeTabId: null,
+    activeTabType: null,
+    tabs: [
+      {
+        type: 'agent-session',
+        id: `tab-${sessionId}`,
+        title: 'Codex',
+        sessionId,
+        agent: 'codex',
+        isActive: false
+      }
+    ]
+  }
+}
+
+async function flushLaunchSettlement(): Promise<void> {
+  for (let i = 0; i < 20; i += 1) {
+    await Promise.resolve()
+  }
+}
+
+const unconfirmed = launchIntent('session-unconfirmed')
+const fresh = launchIntent('session-new')
+const resumeFrom = { providerSessionId: 'provider-1' }
+
+/** The create's answer is lost and inventory never shows the chat: it stays unconfirmed. */
+async function leaveFirstLaunchUnconfirmed(options: { resume?: boolean } = {}): Promise<void> {
+  mocks.createIntent
+    .mockReturnValueOnce(
+      options.resume
+        ? { ...unconfirmed, params: { ...unconfirmed.params, resumeFrom } }
+        : unconfirmed
+    )
+    .mockReturnValueOnce(fresh)
+  startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+    requestId: 'request-1',
+    prompt: 'first task',
+    ...(options.resume ? { resumeFrom } : {})
+  })
+  await flushLaunchSettlement()
+  expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, unconfirmed.sessionId)).toBe(
+    'visibility-unknown'
+  )
+}
+
+function expectSentTo(sessionId: string, text: string): void {
+  expect(mocks.callStructuredAgentSession).toHaveBeenCalledWith(
+    { kind: 'local' },
+    'agentSession.send',
+    expect.objectContaining({
+      envelope: expect.objectContaining({ sessionId }),
+      body: expect.objectContaining({ blocks: [{ type: 'text', text }] })
+    })
+  )
+}
+
+describe('a new start beside an unconfirmed or retried chat', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    localStorage.clear()
+    resetStructuredAgentLaunchPersistenceForTests()
+    resetStructuredAgentLaunchRegistryForTests()
+    mocks.retryIntent.mockImplementation((intent: StructuredAgentSessionLaunchIntent) => intent)
+    mocks.restoreIntent.mockImplementation((args: { sessionId: string }) =>
+      launchIntent(args.sessionId)
+    )
+    mocks.launch.mockImplementation((intent: StructuredAgentSessionLaunchIntent) =>
+      intent.sessionId === fresh.sessionId
+        ? Promise.resolve({ sessionId: fresh.sessionId, fence: 1 })
+        : Promise.reject(new Error('response lost'))
+    )
+    vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
+      publishedSnapshot(fresh.sessionId)
+    ])
+    mocks.callStructuredAgentSession.mockResolvedValue({
+      ok: true,
+      page: { fence: 1 },
+      value: { submission: { dispatchState: 'accepted' } }
+    })
+  })
+
+  it('starts a source-control agent in a new chat and reports success only once its text is sent', async () => {
+    await leaveFirstLaunchUnconfirmed()
+    const onLaunched = vi.fn()
+
+    const started = await runSourceControlAgentActionStart({
+      selectedAgent: 'codex',
+      trimmedCommandInput: 'Fix the failing check',
+      agentArgs: '',
+      agentArgsApply: false,
+      commandTemplate: '{basePrompt}',
+      saveTargetValue: 'none',
+      actionId: 'resolveComments',
+      settings: null,
+      repo: null,
+      worktreeId: WORKTREE_ID,
+      promptDelivery: 'submit-after-ready',
+      launchSource: 'source_control_recovery',
+      onLaunched,
+      onClose: vi.fn()
+    })
+
+    expect(started).toBe(true)
+    expect(onLaunched).toHaveBeenCalledOnce()
+    expect(mocks.createIntent).toHaveBeenCalledTimes(2)
+    expectSentTo(fresh.sessionId, 'Fix the failing check')
+    expect(mocks.toastError).not.toHaveBeenCalled()
+  })
+
+  it('sends notes to a new chat while another chat is unconfirmed', async () => {
+    await leaveFirstLaunchUnconfirmed()
+
+    const notes = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'request-2',
+      prompt: 'review notes',
+      promptDelivery: 'submit-after-ready'
+    })
+
+    expect(notes.sessionId).toBe(fresh.sessionId)
+    await expect(notes.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expectSentTo(fresh.sessionId, 'review notes')
+    // The unconfirmed chat is left for its own re-check.
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE_ID, unconfirmed.sessionId)).toBe(
+      'visibility-unknown'
+    )
+  })
+
+  it("opens a new chat with its text, not a draft, while a restored chat's Retry is in flight", async () => {
+    const failed = launchIntent('session-failed')
+    mocks.createIntent.mockReturnValueOnce(failed).mockReturnValueOnce(fresh)
+    mocks.launch.mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('unsupported'))
+    startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'request-3',
+      prompt: 'first task'
+    })
+    await flushLaunchSettlement()
+    // Reload: the registry is memory; the failed record is what survives.
+    resetStructuredAgentLaunchRegistryForTests()
+    mocks.launch.mockImplementationOnce(() => new Promise(() => undefined))
+    expect(retryStructuredAgentSessionLaunch(WORKTREE_ID, failed.sessionId)).toBe(true)
+    mocks.seedDraft.mockClear()
+
+    const next = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'request-4',
+      prompt: 'fix it',
+      promptDelivery: 'submit-after-ready'
+    })
+
+    expect(next.sessionId).toBe(fresh.sessionId)
+    await expect(next.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expectSentTo(fresh.sessionId, 'fix it')
+    expect(mocks.seedDraft).not.toHaveBeenCalled()
+  })
+
+  it('opens a new chat from a + menu pick while another chat is unconfirmed', async () => {
+    await leaveFirstLaunchUnconfirmed()
+    // Why: the + menu disables an agent only while a pick would join a start in flight.
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('idle')
+
+    const pick = startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-5' })
+
+    expect(pick.sessionId).toBe(fresh.sessionId)
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('pending')
+    // No re-check of the unconfirmed chat: only its own two create attempts and the new one.
+    expect(mocks.launch).toHaveBeenCalledTimes(3)
+    await expect(pick.launchResult).resolves.toEqual({ sessionId: fresh.sessionId, fence: 1 })
+  })
+
+  it('still coalesces one action delivered twice racing for one chat', async () => {
+    mocks.createIntent.mockReturnValueOnce(fresh)
+    mocks.launch.mockImplementationOnce(() => new Promise(() => undefined))
+
+    const first = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'double-click',
+      prompt: 'one'
+    })
+    const second = startStructuredAgentLaunch(WORKTREE_ID, 'codex', {
+      requestId: 'double-click',
+      prompt: 'one'
+    })
+
+    expect(second.sessionId).toBe(first.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+  })
+
+  it('still re-checks an unconfirmed resume instead of adopting its conversation twice', async () => {
+    await leaveFirstLaunchUnconfirmed({ resume: true })
+    expect(getStructuredAgentLaunchStatus(WORKTREE_ID, 'codex')).toBe('unknown')
+
+    expect(
+      startStructuredAgentLaunch(WORKTREE_ID, 'codex', { requestId: 'request-8', resumeFrom })
+        .sessionId
+    ).toBe(unconfirmed.sessionId)
+    expect(mocks.createIntent).toHaveBeenCalledOnce()
+  })
+})
diff --git a/src/renderer/src/lib/structured-agent-session-launch.test.ts b/src/renderer/src/lib/structured-agent-session-launch.test.ts
index 5d2362b63a0..5e5e8f0b3e4 100644
--- a/src/renderer/src/lib/structured-agent-session-launch.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch.test.ts
@@ -184,6 +184,7 @@ describe('startStructuredAgentLaunch', () => {
     ])
 
     const launch = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-1',
       prompt: 'PR #19423 — review this change',
       promptDelivery: 'draft'
     })
@@ -213,6 +214,7 @@ describe('startStructuredAgentLaunch', () => {
     const sixtyLineDraft = Array.from({ length: 60 }, (_, i) => `line ${i + 1}`).join('\n')
 
     const launch = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-2',
       prompt: sixtyLineDraft,
       promptDelivery: 'draft'
     })
@@ -234,6 +236,7 @@ describe('startStructuredAgentLaunch', () => {
     mocks.launch.mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('refused'))
 
     const launch = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-3',
       prompt: 'review this',
       promptDelivery: 'draft'
     })
@@ -256,6 +259,7 @@ describe('startStructuredAgentLaunch', () => {
     vi.mocked(launchAndReconcile).mockRejectedValueOnce(new Error('boom'))
 
     const launch = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-4',
       prompt: 'review this',
       promptDelivery: 'draft'
     })
@@ -278,6 +282,7 @@ describe('startStructuredAgentLaunch', () => {
     )
 
     startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-5',
       prompt: 'review this',
       promptDelivery: 'draft'
     })
@@ -304,7 +309,7 @@ describe('startStructuredAgentLaunch', () => {
       value: { submission: { dispatchState: 'accepted' } }
     })
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-6' })
     await flushLaunchSettlement()
 
     expect(mocks.launch).toHaveBeenCalledOnce()
@@ -324,8 +329,8 @@ describe('startStructuredAgentLaunch', () => {
       publishedSnapshot(worktreeId, `codex-session-${worktreeId}`)
     ])
 
-    const claude = startStructuredAgentLaunch(worktreeId, 'claude')
-    const codex = startStructuredAgentLaunch(worktreeId, 'codex')
+    const claude = startStructuredAgentLaunch(worktreeId, 'claude', { requestId: 'request-7' })
+    const codex = startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-8' })
     await flushLaunchSettlement()
 
     expect(mocks.createIntent).toHaveBeenNthCalledWith(
@@ -358,7 +363,9 @@ describe('startStructuredAgentLaunch', () => {
     const worktreeId = 'wt-claude-refused'
     mocks.launch.mockRejectedValue(new StructuredAgentSessionCreateRefusalError('unsupported'))
 
-    const { sessionId } = startStructuredAgentLaunch(worktreeId, 'claude')
+    const { sessionId } = startStructuredAgentLaunch(worktreeId, 'claude', {
+      requestId: 'request-9'
+    })
     await flushLaunchSettlement()
     expect(getStructuredAgentSessionLaunchLifecycle(worktreeId, sessionId)).toBe('failed')
 
@@ -388,7 +395,7 @@ describe('startStructuredAgentLaunch', () => {
       publishedSnapshot(worktreeId, intent.sessionId)
     ])
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-10' })
     await flushLaunchSettlement()
 
     expect(mocks.launch).toHaveBeenCalledOnce()
@@ -415,8 +422,8 @@ describe('startStructuredAgentLaunch', () => {
       value: { submission: { dispatchState: 'accepted' } }
     })
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'double-click' })
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'double-click' })
 
     expect(mocks.createIntent).toHaveBeenCalledOnce()
     expect(mocks.launch).toHaveBeenCalledOnce()
@@ -425,7 +432,7 @@ describe('startStructuredAgentLaunch', () => {
     expect(toast.error).not.toHaveBeenCalled()
   })
 
-  it('delivers a prompt from a coalesced caller after the shared launch settles', async () => {
+  it("delivers a repeated request's prompt once, to both callers, after the shared launch settles", async () => {
     const worktreeId = 'wt-coalesced-prompt'
     const intent = launchIntent(worktreeId)
     let resolveLaunch: (receipt: { sessionId: string; fence: number }) => void = () => {}
@@ -442,16 +449,29 @@ describe('startStructuredAgentLaunch', () => {
       ok: true,
       value: { submission: { dispatchState: 'accepted' } }
     })
-    startStructuredAgentLaunch(worktreeId, 'codex')
-    const second = startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'second prompt' })
+    const first = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'second prompt'
+    })
+    const second = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'second prompt'
+    })
 
     resolveLaunch({ sessionId: intent.sessionId, fence: 1 })
-    await expect(second.promptDeliveryResult).resolves.toEqual({
-      delivered: true,
-      failureNotified: false
-    })
+    for (const caller of [first, second]) {
+      await expect(caller.promptDeliveryResult).resolves.toEqual({
+        delivered: true,
+        failureNotified: false
+      })
+    }
     await flushLaunchSettlement()
 
+    expect(second.sessionId).toBe(first.sessionId)
+    expect(
+      mocks.callStructuredAgentSession.mock.calls.filter((call) => call[1] === 'agentSession.send')
+    ).toHaveLength(1)
+
     expect(mocks.callStructuredAgentSession).toHaveBeenCalledWith(
       { kind: 'local' },
       'agentSession.send',
@@ -467,48 +487,73 @@ describe('startStructuredAgentLaunch', () => {
     const worktreeId = 'wt-coalesced-prompt-reservation'
     const intent = launchIntent(worktreeId)
     let resolveLaunch!: (receipt: { sessionId: string; fence: number }) => void
-    let resolveDelivery!: (result: {
-      ok: true
-      value: { submission: { dispatchState: 'accepted' } }
-    }) => void
+    const pendingSends: ((result: unknown) => void)[] = []
     mocks.createIntent.mockReturnValue(intent)
     mocks.launch.mockImplementationOnce(() => new Promise((resolve) => (resolveLaunch = resolve)))
     vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
       publishedSnapshot(worktreeId, intent.sessionId)
     ])
-    mocks.callStructuredAgentSession.mockImplementationOnce(
-      () => new Promise((resolve) => (resolveDelivery = resolve))
+    // Every send waits, so a second send of the repeated text would show up below.
+    mocks.callStructuredAgentSession.mockImplementation(
+      () => new Promise((resolve) => pendingSends.push(resolve))
     )
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
-    const coalesced = startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'second prompt' })
+    startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'second prompt'
+    })
+    const coalesced = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'second prompt'
+    })
     resolveLaunch({ sessionId: intent.sessionId, fence: 1 })
     await vi.waitFor(() => expect(mocks.callStructuredAgentSession).toHaveBeenCalledOnce())
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    const whileSending = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'second prompt'
+    })
     expect(mocks.createIntent).toHaveBeenCalledOnce()
     expect(mocks.launch).toHaveBeenCalledOnce()
 
-    resolveDelivery({ ok: true, value: { submission: { dispatchState: 'accepted' } } })
-    await expect(coalesced.promptDeliveryResult).resolves.toEqual({
-      delivered: true,
-      failureNotified: false
-    })
+    await flushLaunchSettlement()
+    for (const resolve of pendingSends) {
+      resolve({ ok: true, value: { submission: { dispatchState: 'accepted' } } })
+    }
+    for (const caller of [coalesced, whileSending]) {
+      await expect(caller.promptDeliveryResult).resolves.toEqual({
+        delivered: true,
+        failureNotified: false
+      })
+    }
+    expect(mocks.callStructuredAgentSession).toHaveBeenCalledOnce()
   })
 
-  it('keeps one launch identity per worktree while the outcome is unknown', async () => {
+  it('opens a new chat for a new start while an earlier outcome is unknown', async () => {
     const worktreeId = 'wt-unknown-different-prompts'
     const intent = launchIntent(worktreeId)
     mocks.createIntent.mockReturnValueOnce(intent)
     mocks.launch.mockRejectedValue(new Error('offline'))
     vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([])
 
-    startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'first prompt' })
+    startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-18',
+      prompt: 'first prompt'
+    })
     await flushLaunchSettlement()
-    startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'second prompt' })
+    const second = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-19',
+      prompt: 'second prompt'
+    })
     await flushLaunchSettlement()
 
-    expect(mocks.createIntent).toHaveBeenCalledOnce()
+    expect(mocks.createIntent).toHaveBeenCalledTimes(2)
+    expect(second.sessionId).not.toBe(intent.sessionId)
+    expect(readOutbox(second.sessionId)).toEqual([
+      expect.objectContaining({
+        body: expect.objectContaining({ blocks: [{ type: 'text', text: 'second prompt' }] })
+      })
+    ])
   })
 
   it('reconciles a host commit when the create reply is lost', async () => {
@@ -520,7 +565,7 @@ describe('startStructuredAgentLaunch', () => {
       publishedSnapshot(worktreeId, intent.sessionId)
     ])
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-20' })
     await flushLaunchSettlement()
 
     expect(mocks.createIntent).toHaveBeenCalledOnce()
@@ -538,7 +583,7 @@ describe('startStructuredAgentLaunch', () => {
     const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
 
     try {
-      startStructuredAgentLaunch(worktreeId, 'codex')
+      startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-21' })
       await flushLaunchSettlement()
 
       expect(getStructuredAgentSessionLaunchLifecycle(worktreeId, intent.sessionId)).toBe(
@@ -562,7 +607,7 @@ describe('startStructuredAgentLaunch', () => {
       .mockResolvedValueOnce([])
       .mockResolvedValueOnce([publishedSnapshot(worktreeId, intent.sessionId)])
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-22' })
     await flushLaunchSettlement()
 
     expect(mocks.launch).toHaveBeenCalledTimes(2)
@@ -572,20 +617,22 @@ describe('startStructuredAgentLaunch', () => {
     expect(toast.error).not.toHaveBeenCalled()
   })
 
-  it('keeps an unresolved identity reserved until inventory reconciles it', async () => {
+  // Why a resume: the host refuses a second adoption of the conversation, so a new resume re-checks.
+  it('keeps an unresolved resume identity reserved until inventory reconciles it', async () => {
     const worktreeId = 'wt-still-unknown'
+    const resumeFrom = { providerSessionId: 'provider-still-unknown' }
     const intent = launchIntent(worktreeId)
-    mocks.createIntent.mockReturnValueOnce(intent)
+    mocks.createIntent.mockReturnValueOnce({ ...intent, params: { ...intent.params, resumeFrom } })
     mocks.launch.mockRejectedValue(new Error('offline'))
     vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([])
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-23', resumeFrom })
     await flushLaunchSettlement()
 
     vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
       publishedSnapshot(worktreeId, intent.sessionId)
     ])
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-24', resumeFrom })
     await flushLaunchSettlement()
 
     expect(mocks.createIntent).toHaveBeenCalledOnce()
@@ -600,15 +647,20 @@ describe('startStructuredAgentLaunch', () => {
     mocks.launch.mockRejectedValue(new Error('offline'))
     vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([])
 
-    const first = startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'only once' })
+    const first = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-25',
+      prompt: 'only once'
+    })
     await expect(first.launchResult).rejects.toThrow('offline')
     expect(first.releaseCallerAfterUnknownOutcome()).toBe(true)
 
     vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
       publishedSnapshot(worktreeId, intent.sessionId)
     ])
-    const retry = startStructuredAgentLaunch(worktreeId, 'codex')
-    await expect(retry.launchResult).resolves.toEqual({ sessionId: intent.sessionId, fence: 1 })
+    // The chat's own Retry re-checks it; a new start would open a new chat instead.
+    expect(retryStructuredAgentSessionLaunch(worktreeId, intent.sessionId)).toBe(true)
+    await flushLaunchSettlement()
+    expect(getStructuredAgentSessionLaunchLifecycle(worktreeId, intent.sessionId)).toBeNull()
 
     expect(readOutbox(intent.sessionId)).toEqual([
       expect.objectContaining({
@@ -633,7 +685,7 @@ describe('startStructuredAgentLaunch', () => {
     )
     vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([])
 
-    const launch = startStructuredAgentLaunch(worktreeId, 'codex')
+    const launch = startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-26' })
 
     await expect(launch.launchResult).rejects.toMatchObject({
       code: 'agent_session_operation_unknown'
@@ -655,9 +707,9 @@ describe('startStructuredAgentLaunch', () => {
       publishedSnapshot(worktreeId, first.sessionId)
     ])
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-27' })
     await flushLaunchSettlement()
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    expect(retryStructuredAgentSessionLaunch(worktreeId, first.sessionId)).toBe(true)
     await flushLaunchSettlement()
 
     expect(mocks.createIntent).toHaveBeenCalledOnce()
@@ -670,34 +722,6 @@ describe('startStructuredAgentLaunch', () => {
     expect(toast.error).not.toHaveBeenCalled()
   })
 
-  it('does not stage the preserved launch prompt again on retry', async () => {
-    const worktreeId = 'wt-refused-prompt-retry'
-    const intent = launchIntent(worktreeId, 'session-refused-prompt-retry')
-    mocks.createIntent.mockReturnValueOnce(intent)
-    mocks.launch
-      .mockRejectedValueOnce(new StructuredAgentSessionCreateRefusalError('unsupported'))
-      .mockResolvedValueOnce({ sessionId: intent.sessionId, fence: 1 })
-    vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
-      publishedSnapshot(worktreeId, intent.sessionId)
-    ])
-
-    startStructuredAgentLaunch(worktreeId, 'codex', {
-      prompt: 'only once',
-      promptDelivery: 'draft'
-    })
-    await flushLaunchSettlement()
-    expect(readOutbox(intent.sessionId)).toEqual([])
-
-    const retry = startStructuredAgentLaunch(worktreeId, 'codex', {
-      prompt: 'only once',
-      promptDelivery: 'draft'
-    })
-    await expect(retry.launchResult).resolves.toEqual({ sessionId: intent.sessionId, fence: 1 })
-
-    expect(readOutbox(intent.sessionId)).toEqual([])
-    expect(mocks.seedDraft).toHaveBeenCalledOnce()
-  })
-
   // A paired server's create seeds from its settings at create time, which its probe reports.
   it("shows the seed a paired server's probe reports on a retry, not the first admission's", async () => {
     const worktreeId = 'wt-paired-retry-seed'
@@ -717,7 +741,7 @@ describe('startStructuredAgentLaunch', () => {
         }
       )
 
-    startStructuredAgentLaunch(worktreeId, 'codex')
+    startStructuredAgentLaunch(worktreeId, 'codex', { requestId: 'request-28' })
     await flushLaunchSettlement()
     expect(getStructuredAgentSessionLaunchSelection(intent.sessionId)?.seed).toEqual({
       model: 'gpt-5.5'
@@ -748,6 +772,7 @@ describe('startStructuredAgentLaunch', () => {
     ])
 
     startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-29',
       resumeFrom: { providerSessionId: 'provider-session-1' }
     })
     await flushLaunchSettlement()
@@ -766,7 +791,10 @@ describe('startStructuredAgentLaunch', () => {
       throw new Error('storage unavailable')
     })
 
-    const result = startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'start this task' })
+    const result = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'request-30',
+      prompt: 'start this task'
+    })
 
     await expect(result.launchResult).rejects.toBeInstanceOf(
       StructuredAgentSessionCreateRefusalError
@@ -781,7 +809,7 @@ describe('startStructuredAgentLaunch', () => {
     storageFailure.mockRestore()
   })
 
-  it('reports every coalesced prompt as undelivered after refusal', async () => {
+  it("reports a repeated request's prompt as undelivered to both callers after refusal", async () => {
     const worktreeId = 'wt-refused-coalesced-prompts'
     const intent = launchIntent(worktreeId)
     let rejectLaunch!: (error: unknown) => void
@@ -790,9 +818,15 @@ describe('startStructuredAgentLaunch', () => {
       () => new Promise((_resolve, reject) => (rejectLaunch = reject))
     )
 
-    const first = startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'first prompt' })
-    const second = startStructuredAgentLaunch(worktreeId, 'codex', { prompt: 'second prompt' })
-    expect(readOutbox(intent.sessionId)).toHaveLength(2)
+    const first = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'first prompt'
+    })
+    const second = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'double-click',
+      prompt: 'first prompt'
+    })
+    expect(readOutbox(intent.sessionId)).toHaveLength(1)
 
     rejectLaunch(new StructuredAgentSessionCreateRefusalError('unsupported'))
     await expect(first.launchResult).rejects.toBeInstanceOf(
@@ -806,41 +840,46 @@ describe('startStructuredAgentLaunch', () => {
       delivered: false,
       failureNotified: true
     })
-    expect(readOutbox(intent.sessionId)).toHaveLength(2)
+    expect(readOutbox(intent.sessionId)).toHaveLength(1)
   })
 
-  it('delivers a coalesced caller the way the launch it joined already decided', async () => {
+  it('keeps a drafted chat out of a second action that sends the same text', async () => {
     const worktreeId = 'wt-coalesced-delivery-mode'
-    const intent = launchIntent(worktreeId, 'coalesced-delivery-session')
-    let resolveLaunch!: (receipt: { sessionId: string; fence: number }) => void
-    mocks.createIntent.mockReturnValueOnce(intent)
-    mocks.launch.mockImplementation(
-      () =>
-        new Promise<{ sessionId: string; fence: number }>((resolve) => (resolveLaunch = resolve))
+    const drafted = launchIntent(worktreeId, 'coalesced-delivery-session')
+    const sent = launchIntent(worktreeId, 'sent-delivery-session')
+    mocks.createIntent.mockReturnValueOnce(drafted).mockReturnValueOnce(sent)
+    mocks.launch.mockImplementation((intent: StructuredAgentSessionLaunchIntent) =>
+      Promise.resolve({ sessionId: intent.sessionId, fence: 1 })
     )
     vi.mocked(refreshLocalStructuredSessionTabs).mockResolvedValue([
-      publishedSnapshot(worktreeId, intent.sessionId)
+      publishedSnapshot(worktreeId, drafted.sessionId),
+      publishedSnapshot(worktreeId, sent.sessionId)
     ])
+    mocks.callStructuredAgentSession.mockResolvedValue({
+      ok: true,
+      value: { submission: { dispatchState: 'accepted' } }
+    })
 
     startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'continue-click',
       prompt: 'PR #1 context',
       promptDelivery: 'draft'
     })
-    const joiner = startStructuredAgentLaunch(worktreeId, 'codex', {
+    const other = startStructuredAgentLaunch(worktreeId, 'codex', {
+      requestId: 'fix-click',
       prompt: 'PR #1 context',
       promptDelivery: 'auto-submit'
     })
-    resolveLaunch({ sessionId: intent.sessionId, fence: 1 })
-    await flushLaunchSettlement()
 
-    // Why: the first caller's seed is already in the composer, so submitting the joiner's copy
-    // would show the user the text AND send it.
-    expect(readOutbox(intent.sessionId)).toEqual([])
-    expect(joiner.promptDeliveryResult).toBeUndefined()
-    expect(
-      mocks.callStructuredAgentSession.mock.calls.some((call) => call[1] === 'agentSession.send')
-    ).toBe(false)
-    expect(mocks.seedDraft).toHaveBeenLastCalledWith(
+    // Why: two actions are two chats, whatever their text; neither lands in the other's chat.
+    expect(other.sessionId).toBe(sent.sessionId)
+    await expect(other.promptDeliveryResult).resolves.toEqual({
+      delivered: true,
+      failureNotified: false
+    })
+    expect(readOutbox(drafted.sessionId)).toEqual([])
+    expect(mocks.seedDraft).toHaveBeenCalledOnce()
+    expect(mocks.seedDraft).toHaveBeenCalledWith(
       expect.objectContaining({
         tabId: 'structured-agent-session-coalesced-delivery-session',
         text: 'PR #1 context'
diff --git a/src/renderer/src/lib/structured-agent-session-launch.ts b/src/renderer/src/lib/structured-agent-session-launch.ts
index 5dd33c729ec..b80d299e7d4 100644
--- a/src/renderer/src/lib/structured-agent-session-launch.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch.ts
@@ -29,7 +29,6 @@ import * as launchDraft from './structured-agent-session-launch-draft'
 import {
   deleteStructuredLaunchStateIfCurrent,
   getStructuredAgentSessionLaunchLifecycle,
-  getStructuredLaunchState,
   getStructuredLaunchStateBySessionId,
   markStructuredAgentSessionLaunchCancelled,
   notifyStructuredLaunchListeners,
@@ -38,12 +37,20 @@ import {
   type StructuredLaunchState
 } from './structured-agent-session-launch-registry'
 import { restorePersistedStructuredLaunchState } from './structured-agent-session-launch-reload'
+import {
+  claimableStructuredLaunchAttempt,
+  getJoinableStructuredLaunchState
+} from './structured-agent-session-launch-holders'
 import { applyStructuredLaunchHeldOptions } from './structured-agent-session-launch-options'
 import { trackLaunchSettlement } from './structured-agent-session-launch-outcome-tracking'
+import {
+  repeatedStructuredLaunchAttempt,
+  structuredLaunchRequest,
+  type StructuredLaunchRequest
+} from './structured-agent-session-launch-request'
 
 export type { StructuredAgentLaunchOptions, StructuredAgentLaunchReceipt }
 export {
-  getStructuredAgentLaunchStatus,
   getStructuredAgentSessionLaunchLifecycle,
   getStructuredAgentSessionLaunchResumes,
   hasStructuredAgentSessionLaunchCancellationTombstone,
@@ -56,7 +63,7 @@ export {
   type StructuredAgentLaunchStatus,
   type StructuredAgentSessionLaunchLifecycle
 } from './structured-agent-session-launch-registry'
-export { useStructuredAgentLaunchStatus } from './structured-agent-session-launch-status'
+export * from './structured-agent-session-launch-status'
 export { useStructuredAgentSessionLaunchSelection } from './structured-agent-session-launch-options'
 
 type StructuredLaunchStateResult = {
@@ -125,7 +132,7 @@ function adoptPairedHostSeed(
 }
 
 function resetStructuredLaunchCallers(state: StructuredLaunchState): void {
-  state.callers = createStructuredLaunchCallerGroup()
+  state.callers = createStructuredLaunchCallerGroup({ kind: 'retry' })
   state.callers.onSettled = () => maybeCleanupLaunchState(state)
 }
 
@@ -149,39 +156,66 @@ function restartStructuredLaunchState(state: StructuredLaunchState): void {
   notifyStructuredLaunchListeners()
 }
 
+function joinStructuredLaunchState(
+  existing: StructuredLaunchState,
+  agent: AgentSessionHandleProvider,
+  options: StructuredAgentLaunchOptions,
+  request: StructuredLaunchRequest
+): StructuredLaunchStateResult | undefined {
+  // A re-delivery of the same action (a double click) shares the text it staged, so it is sent once.
+  const repeat = repeatedStructuredLaunchAttempt(existing.callers.attempt, request.id)
+  // An empty chat takes the first text sent to it, delivered the way that request asked.
+  const claim = repeat ? undefined : claimableStructuredLaunchAttempt(existing, request)
+  const retrying = existing.visibilityUnknown
+  const joined = joinLaunchDelivery(
+    options,
+    claim ? options.promptDelivery : existing.promptDelivery
+  )
+  // Why: an unconfirmed launch keeps its draft/outbox, so a recheck must not stage it twice.
+  const text = retrying || repeat ? '' : outboxPromptText(joined)
+  const stagedPrompt = text
+    ? enqueueStructuredAgentSessionLaunchPrompt(existing.intent.sessionId, text)
+    : (repeat?.stagedEntry ?? null)
+  // An unstaged claim stays unclaimed: the new launch it falls to reports the failure.
+  if (claim && text && !stagedPrompt) {
+    return undefined
+  }
+  if (retrying) {
+    restartStructuredLaunchState(existing)
+  }
+  if (claim) {
+    existing.promptDelivery = options.promptDelivery
+    Object.assign(claim, { requestId: request.id, blank: false, stagedEntry: stagedPrompt })
+  }
+  if (!retrying && !repeat) {
+    launchDraft.seedStructuredAgentLaunchDraft(existing.intent.sessionId, agent, joined)
+  }
+  // A re-delivery waits on the text its action staged, if any, and never stages its own.
+  const { prompt: _retryPrompt, ...joinedWithoutPrompt } = joined
+  const callerOptions = retrying || (repeat && !repeat.stagedEntry) ? joinedWithoutPrompt : joined
+  return {
+    state: existing,
+    caller: addStructuredLaunchCaller({
+      group: existing.callers,
+      launchResult: existing.promise,
+      target: existing.intent.target,
+      options: callerOptions,
+      stagedEntry: stagedPrompt
+    })
+  }
+}
+
 function structuredAgentLaunchState(
   worktreeId: string,
   agent: AgentSessionHandleProvider,
   options: StructuredAgentLaunchOptions
 ): StructuredLaunchStateResult {
   const identity = structuredLaunchIdentity(worktreeId, agent, options.resumeFrom)
-  const existing = getStructuredLaunchState(identity)
-  if (existing) {
-    const retrying = existing.visibilityUnknown || existing.callers.outcome === 'failed'
-    if (retrying) {
-      restartStructuredLaunchState(existing)
-    }
-    const joined = joinLaunchDelivery(options, existing.promptDelivery)
-    // Why: failed launches keep their draft/outbox, so a retry must not stage the same prompt twice.
-    const text = retrying ? '' : outboxPromptText(joined)
-    const stagedPrompt = text
-      ? enqueueStructuredAgentSessionLaunchPrompt(existing.intent.sessionId, text)
-      : null
-    if (!retrying) {
-      launchDraft.seedStructuredAgentLaunchDraft(existing.intent.sessionId, agent, joined)
-    }
-    const { prompt: _retryPrompt, ...joinedWithoutPrompt } = joined
-    const callerOptions = retrying ? joinedWithoutPrompt : joined
-    return {
-      state: existing,
-      caller: addStructuredLaunchCaller({
-        group: existing.callers,
-        launchResult: existing.promise,
-        target: existing.intent.target,
-        options: callerOptions,
-        stagedEntry: stagedPrompt
-      })
-    }
+  const request = structuredLaunchRequest(options)
+  const existing = getJoinableStructuredLaunchState(identity, request)
+  const joined = existing && joinStructuredLaunchState(existing, agent, options, request)
+  if (joined) {
+    return joined
   }
 
   const intent = createStructuredAgentSessionLaunchIntent(
@@ -196,7 +230,12 @@ function structuredAgentLaunchState(
     ? enqueueStructuredAgentSessionLaunchPrompt(intent.sessionId, text)
     : null
   launchDraft.seedStructuredAgentLaunchDraft(intent.sessionId, agent, options)
-  const callers = createStructuredLaunchCallerGroup()
+  const callers = createStructuredLaunchCallerGroup({
+    kind: 'first',
+    requestId: request.id,
+    blank: !request.hasText,
+    stagedEntry: stagedPrompt
+  })
   const state: StructuredLaunchState = {
     identity,
     intent,
@@ -250,7 +289,7 @@ export function cancelStructuredAgentLaunch(worktreeId: string, sessionId: strin
 export function startStructuredAgentLaunch(
   worktreeId: string,
   agent: AgentSessionHandleProvider,
-  options: StructuredAgentLaunchOptions = {}
+  options: StructuredAgentLaunchOptions
 ): StructuredAgentLaunchResult {
   const { state, caller } = structuredAgentLaunchState(worktreeId, agent, options)
   return {
diff --git a/src/renderer/src/lib/structured-agent-session-paired-admission.test.ts b/src/renderer/src/lib/structured-agent-session-paired-admission.test.ts
index 40f522bd2ed..a8df010234f 100644
--- a/src/renderer/src/lib/structured-agent-session-paired-admission.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-paired-admission.test.ts
@@ -29,7 +29,7 @@ import { beginStructuredAgentSessionProvisionalLaunch } from './structured-agent
 import { beginDirectWorkItemStructuredLaunch } from './launch-work-item-direct-agent-routing'
 import type { AiVaultSession } from '../../../shared/ai-vault-types'
 import { resumeAiVaultSessionInNewChat } from '@/components/right-sidebar/ai-vault-session-resume-in-chat-launch'
-import { getStructuredAgentLaunchStatus } from './structured-agent-session-launch-registry'
+import { getStructuredAgentLaunchStatus } from './structured-agent-session-launch-status'
 import { getStructuredAgentSessionLaunchSelection } from './structured-agent-session-launch-options'
 import { peekWebSessionFocusIntent } from '@/runtime/web-session-focus-intent'
 
@@ -38,6 +38,7 @@ const INITIAL_SETTINGS = useAppStore.getState().settings
 
 function pairedPlan(overrides: { resumeFrom?: { providerSessionId: string } } = {}) {
   return adoptAgentSessionLaunchVerdict({
+    requestId: 'request-1',
     route: 'structured-native-chat',
     agent: 'claude',
     worktreeId: WORKTREE,
@@ -149,7 +150,7 @@ describe('a structured chat launch on a paired server', () => {
     // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: resume reads only the id fields the preparation mock ignores.
     const session = { id: 'vault-1', sessionId: 'provider-1' } as AiVaultSession
 
-    await resumeAiVaultSessionInNewChat(session, 'claude', WORKTREE)
+    await resumeAiVaultSessionInNewChat(session, 'claude', WORKTREE, 'resume-click')
 
     await vi.waitFor(() => expect(mocks.toastError).toHaveBeenCalled())
     await new Promise((resolve) => setTimeout(resolve, 0))
diff --git a/src/renderer/src/lib/structured-agent-session-paired-admission.ts b/src/renderer/src/lib/structured-agent-session-paired-admission.ts
index fe14eae025c..4e52f2fe31d 100644
--- a/src/renderer/src/lib/structured-agent-session-paired-admission.ts
+++ b/src/renderer/src/lib/structured-agent-session-paired-admission.ts
@@ -111,6 +111,7 @@ export async function openDeclinedStructuredLaunchTerminal(args: {
     ...(args.plan.onPromptDelivered ? { onPromptDelivered: args.plan.onPromptDelivered } : {}),
     agentSessionLaunchPlan: adoptAgentSessionLaunchVerdict({
       route: 'terminal-tui',
+      requestId: args.plan.requestId,
       agent: args.plan.agent,
       worktreeId: args.worktreeId
     })
diff --git a/src/renderer/src/lib/structured-agent-session-provisional-tab.test.ts b/src/renderer/src/lib/structured-agent-session-provisional-tab.test.ts
index beae204167a..e5a75c23743 100644
--- a/src/renderer/src/lib/structured-agent-session-provisional-tab.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-provisional-tab.test.ts
@@ -11,6 +11,7 @@ vi.mock('@/store', () => ({
   useAppStore: {
     getState: () => ({
       unifiedTabsByWorktree: {},
+      activeGroupIdByWorktree: {},
       createUnifiedTab: mocks.createUnifiedTab,
       setActiveTabType: vi.fn()
     })
diff --git a/src/renderer/src/lib/structured-agent-session-provisional-tab.ts b/src/renderer/src/lib/structured-agent-session-provisional-tab.ts
index 665779a75cc..1d61a35f72d 100644
--- a/src/renderer/src/lib/structured-agent-session-provisional-tab.ts
+++ b/src/renderer/src/lib/structured-agent-session-provisional-tab.ts
@@ -152,11 +152,15 @@ export function beginStructuredAgentSessionProvisionalLaunch(
 }
 
 function beginLocalProvisionalLaunch(args: ProvisionalLaunchArgs): LocalProvisionalLaunch | null {
-  const handle = args.plan.begin(args.hooks, args.target)
+  const worktreeId = args.target?.worktreeId ?? args.plan.worktreeId
+  // The group the tab opens in: the caller's, else the workspace's active one.
+  const groupId =
+    args.targetGroupId ??
+    (worktreeId ? useAppStore.getState().activeGroupIdByWorktree[worktreeId] : undefined)
+  const handle = args.plan.begin(args.hooks, groupId ? { ...args.target, groupId } : args.target)
   if (!handle) {
     return null
   }
-  const worktreeId = args.target?.worktreeId ?? args.plan.worktreeId
   if (!worktreeId || (args.plan.agent !== 'claude' && args.plan.agent !== 'codex')) {
     throw new Error('A provisional structured launch needs its workspace and provider.')
   }
diff --git a/src/renderer/src/lib/user-opened-local-path.test.ts b/src/renderer/src/lib/user-opened-local-path.test.ts
new file mode 100644
index 00000000000..a00a0e37a94
--- /dev/null
+++ b/src/renderer/src/lib/user-opened-local-path.test.ts
@@ -0,0 +1,101 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../shared/constants'
+import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
+
+const mocks = vi.hoisted(() => ({ statRuntimePath: vi.fn() }))
+
+vi.mock('@/runtime/runtime-file-client', () => ({
+  isRemoteRuntimeFileOperation: () => false,
+  statRuntimePath: mocks.statRuntimePath
+}))
+
+import { statUserOpenedPath } from './user-opened-local-path'
+
+const project: RuntimeFileOperationArgs = {
+  settings: null,
+  worktreeId: 'repo::/repo',
+  worktreePath: '/repo'
+}
+
+/** Main's answers: a contained stat (no declared access) only sees paths that stay in the project. */
+function answer(containedOk: boolean, userNamedOk: boolean, isDirectory = false): void {
+  mocks.statRuntimePath.mockImplementation(
+    async (_context: unknown, _path: string, access?: { kind: string }) => {
+      if (access ? !userNamedOk : !containedOk) {
+        throw new Error(
+          access
+            ? 'ENOENT: no such file'
+            : 'Access denied: path resolves outside allowed directories.'
+        )
+      }
+      return { size: 1, isDirectory, mtime: 1 }
+    }
+  )
+}
+
+describe('statUserOpenedPath', () => {
+  beforeEach(() => {
+    mocks.statRuntimePath.mockReset()
+  })
+
+  it('keeps a project file that stays in the project contained', async () => {
+    answer(true, true)
+
+    await expect(statUserOpenedPath(project, '/repo/src/a.ts')).resolves.toEqual({
+      isDirectory: false,
+      escapesWorktree: false
+    })
+    expect(mocks.statRuntimePath).toHaveBeenCalledTimes(1)
+    expect(mocks.statRuntimePath).toHaveBeenCalledWith(project, '/repo/src/a.ts')
+  })
+
+  it.each([false, true])(
+    'reports a project link that leads out of the project (directory: %s)',
+    async (isDirectory) => {
+      answer(false, true, isDirectory)
+
+      await expect(statUserOpenedPath(project, '/repo/link')).resolves.toEqual({
+        isDirectory,
+        escapesWorktree: true
+      })
+      expect(mocks.statRuntimePath).toHaveBeenLastCalledWith(project, '/repo/link', {
+        kind: 'user-file'
+      })
+    }
+  )
+
+  it.each(['ENOENT: no such file or directory', 'Remote connection dropped'])(
+    'surfaces a project check that fails with %s instead of opening it as named',
+    async (message) => {
+      mocks.statRuntimePath.mockRejectedValue(new Error(message))
+
+      await expect(statUserOpenedPath(project, '/repo/gone.md')).rejects.toThrow(message)
+      expect(mocks.statRuntimePath).toHaveBeenCalledTimes(1)
+    }
+  )
+
+  it('reports the project error when the path is missing everywhere', async () => {
+    answer(false, false)
+
+    await expect(statUserOpenedPath(project, '/repo/gone.md')).rejects.toThrow('Access denied')
+  })
+
+  it.each([
+    ['outside the project', project, '/tmp/notes.md'],
+    [
+      'in the floating workspace, whose folder is not a project',
+      { ...project, worktreeId: FLOATING_TERMINAL_WORKTREE_ID, worktreePath: '/Users/me' },
+      '/Users/me/notes.md'
+    ]
+  ])('checks a path %s once, as user-named', async (_label, context, filePath) => {
+    answer(false, true)
+
+    await expect(statUserOpenedPath(context, filePath)).resolves.toEqual({
+      isDirectory: false,
+      escapesWorktree: false
+    })
+    expect(mocks.statRuntimePath).toHaveBeenCalledExactlyOnceWith(context, filePath, {
+      kind: 'user-file'
+    })
+  })
+})
diff --git a/src/renderer/src/lib/user-opened-local-path.ts b/src/renderer/src/lib/user-opened-local-path.ts
new file mode 100644
index 00000000000..c6ef7d5632b
--- /dev/null
+++ b/src/renderer/src/lib/user-opened-local-path.ts
@@ -0,0 +1,52 @@
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../shared/constants'
+import { isPathOutsideAllowedDirectoriesError } from '../../../shared/local-file-access'
+import {
+  isRemoteRuntimeFileOperation,
+  statRuntimePath,
+  type RuntimeFileOperationArgs
+} from '@/runtime/runtime-file-client'
+import { userNamedFileAccess } from './local-file-access'
+import { isPathInsideWorktree } from './terminal-links'
+
+export type UserOpenedPathStat = {
+  isDirectory: boolean
+  /** The path sits in the project but resolves outside it, e.g. through a symlink. */
+  escapesWorktree: boolean
+}
+
+/**
+ * Stats a path the user opened by a gesture. A local path inside the worktree is checked against
+ * the project root first; if only the user-named check passes, the path leads out of the project,
+ * and the caller must open it as an external file rather than a project one.
+ */
+export async function statUserOpenedPath(
+  context: RuntimeFileOperationArgs,
+  filePath: string
+): Promise<UserOpenedPathStat> {
+  // Why the floating workspace is skipped: its folder (~ by default) is not a project root.
+  const insideLocalWorktree =
+    context.worktreeId !== FLOATING_TERMINAL_WORKTREE_ID &&
+    !context.connectionId &&
+    !isRemoteRuntimeFileOperation(context, filePath) &&
+    Boolean(context.worktreePath && isPathInsideWorktree(filePath, context.worktreePath))
+  if (!insideLocalWorktree) {
+    const stat = await statRuntimePath(context, filePath, userNamedFileAccess())
+    return { isDirectory: stat.isDirectory, escapesWorktree: false }
+  }
+  try {
+    const stat = await statRuntimePath(context, filePath)
+    return { isDirectory: stat.isDirectory, escapesWorktree: false }
+  } catch (containedError) {
+    // Why only this refusal: a missing file or a dropped connection is not a link out of the project.
+    if (!isPathOutsideAllowedDirectoriesError(containedError)) {
+      throw containedError
+    }
+    let stat: Awaited<ReturnType<typeof statRuntimePath>>
+    try {
+      stat = await statRuntimePath(context, filePath, userNamedFileAccess())
+    } catch {
+      throw containedError
+    }
+    return { isDirectory: stat.isDirectory, escapesWorktree: true }
+  }
+}
diff --git a/src/renderer/src/lib/worktree-creation-flow-execute.ts b/src/renderer/src/lib/worktree-creation-flow-execute.ts
index 4a707a43a14..76ed411c67b 100644
--- a/src/renderer/src/lib/worktree-creation-flow-execute.ts
+++ b/src/renderer/src/lib/worktree-creation-flow-execute.ts
@@ -1,3 +1,4 @@
+import { prepareWorktreeCreationHooks } from '@/lib/worktree-creation-hook-preparation'
 import { toast } from 'sonner'
 import { useAppStore } from '@/store'
 import { activateAndRevealWorktree, type ActivateAndRevealResult } from '@/lib/worktree-activation'
@@ -49,7 +50,13 @@ export async function executeWorktreeCreation(
   creationId: string,
   request: WorktreeCreationRequest
 ): Promise<void> {
-  const preparedRequest = await prepareRequestForCreate(creationId, request)
+  const trustedRequest = request.hookPreparation
+    ? await prepareWorktreeCreationHooks(creationId, request)
+    : request
+  if (!trustedRequest) {
+    return
+  }
+  const preparedRequest = await prepareRequestForCreate(creationId, trustedRequest)
   if (!preparedRequest) {
     return
   }
@@ -89,6 +96,8 @@ export async function executeWorktreeCreation(
         preparedRequest.linkedGiteaPR,
         preparedRequest.compareBaseRef,
         {
+          executionHostId:
+            preparedRequest.workspaceRunContext?.hostId ?? preparedRequest.executionHostId,
           ...(preparedRequest.nameWasGenerated ? { nameWasGenerated: true } : {}),
           ...(preparedRequest.displayNameKind
             ? { displayNameKind: preparedRequest.displayNameKind }
diff --git a/src/renderer/src/lib/worktree-creation-flow-startup.ts b/src/renderer/src/lib/worktree-creation-flow-startup.ts
index c1268d34a29..4418cb21ed3 100644
--- a/src/renderer/src/lib/worktree-creation-flow-startup.ts
+++ b/src/renderer/src/lib/worktree-creation-flow-startup.ts
@@ -46,5 +46,8 @@ export function getWorktreeCreationIndeterminate(request: WorktreeCreationReques
 export function getInitialWorktreeCreationPhase(
   request: WorktreeCreationRequest
 ): WorktreeCreationPhase {
+  if (request.hookPreparation) {
+    return 'preparing'
+  }
   return request.ephemeralVmRecipe && !request.ephemeralVmRuntimeId ? 'provisioning-vm' : 'fetching'
 }
diff --git a/src/renderer/src/lib/worktree-creation-flow.ts b/src/renderer/src/lib/worktree-creation-flow.ts
index 7acc177e35f..35e1c309580 100644
--- a/src/renderer/src/lib/worktree-creation-flow.ts
+++ b/src/renderer/src/lib/worktree-creation-flow.ts
@@ -63,12 +63,7 @@ function revealPendingCreation(
   store.setSidebarOpen(true)
 }
 
-/**
- * Kick off a worktree create in the background. The caller (the composer) has
- * already resolved every interactive decision into `request`, so this returns
- * immediately and the work outlives the now-closed modal. Progress and errors
- * surface on the pending creation's sidebar row and content panel.
- */
+/** Start creation without blocking the composer; the pending panel owns preparation and errors. */
 export function runBackgroundWorktreeCreation(request: WorktreeCreationRequest): string {
   const store = useAppStore.getState()
   const existingCreationId = findPendingLinkedWorkItemCreationId(
@@ -138,10 +133,7 @@ export function retryBackgroundWorktreeCreation(creationId: string): void {
   store.updatePendingWorktreeCreation(creationId, {
     status: 'creating',
     startedAt: Date.now(),
-    phase:
-      entry.request.ephemeralVmRecipe && !entry.request.ephemeralVmRuntimeId
-        ? 'provisioning-vm'
-        : 'fetching',
+    phase: getInitialWorktreeCreationPhase(entry.request),
     error: undefined,
     provisioningLog: undefined
   })
diff --git a/src/renderer/src/lib/worktree-creation-hook-flow.test.ts b/src/renderer/src/lib/worktree-creation-hook-flow.test.ts
new file mode 100644
index 00000000000..e9e2312510c
--- /dev/null
+++ b/src/renderer/src/lib/worktree-creation-hook-flow.test.ts
@@ -0,0 +1,139 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { PendingWorktreeCreation, WorktreeCreationRequest } from './pending-worktree-creation'
+
+const pendingWorktreeCreations: Record<string, PendingWorktreeCreation> = {}
+const store = {
+  pendingWorktreeCreations,
+  activeView: 'terminal',
+  activePendingCreationId: 'creation-1',
+  settings: null,
+  beginPendingWorktreeCreation: vi.fn((entry: PendingWorktreeCreation) => {
+    store.pendingWorktreeCreations[entry.creationId] = entry
+  }),
+  updatePendingWorktreeCreation: vi.fn((id: string, patch: Partial<PendingWorktreeCreation>) => {
+    const entry = store.pendingWorktreeCreations[id]
+    if (entry) {
+      store.pendingWorktreeCreations[id] = { ...entry, ...patch }
+    }
+  }),
+  removePendingWorktreeCreation: vi.fn((id: string) => {
+    delete store.pendingWorktreeCreations[id]
+  }),
+  setActiveView: vi.fn(),
+  setSidebarOpen: vi.fn(),
+  setActivePendingWorktreeCreation: vi.fn(),
+  createWorktree: vi.fn(() => new Promise(() => {}))
+}
+vi.mock('@/store', () => ({ useAppStore: { getState: () => store } }))
+vi.mock('@/lib/browser-uuid', () => ({ createBrowserUuid: () => 'creation-1' }))
+vi.mock('@/lib/ensure-hooks-confirmed', () => ({
+  ensureHooksConfirmed: vi.fn(),
+  readAndConfirmRuntimeIssueCommand: vi.fn()
+}))
+vi.mock('sonner', () => ({ toast: { error: vi.fn() } }))
+
+import { ensureHooksConfirmed } from './ensure-hooks-confirmed'
+import {
+  runBackgroundWorktreeCreation,
+  retryBackgroundWorktreeCreation
+} from './worktree-creation-flow'
+
+function makeRequest(overrides: Partial<WorktreeCreationRequest> = {}): WorktreeCreationRequest {
+  return {
+    repoId: 'repo-1',
+    name: 'feature',
+    setupDecision: 'inherit',
+    agent: null,
+    worktreeCreateProgressMode: 'stepped',
+    pendingFirstAgentMessageRename: false,
+    note: '',
+    startupPlan: null,
+    quickPrompt: '',
+    quickTelemetry: null,
+    ...overrides
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  store.pendingWorktreeCreations = {}
+})
+
+async function flushAsyncWorktreeCreation(): Promise<void> {
+  await Promise.resolve()
+  await Promise.resolve()
+}
+
+describe('background script preparation', () => {
+  it('shows preparation immediately and waits for trust before creating', async () => {
+    const trust = Promise.withResolvers<'run' | 'skip'>()
+    vi.mocked(ensureHooksConfirmed).mockReturnValueOnce(trust.promise)
+    const request = makeRequest({ hookPreparation: { executionHostId: 'ssh:remote-1' } })
+
+    runBackgroundWorktreeCreation(request)
+
+    expect(store.pendingWorktreeCreations['creation-1']).toMatchObject({
+      phase: 'preparing',
+      loaderVisible: true,
+      status: 'creating',
+      request
+    })
+    expect(store.createWorktree).not.toHaveBeenCalled()
+    expect(ensureHooksConfirmed).toHaveBeenCalledWith(
+      expect.any(Function),
+      'repo-1',
+      'setup',
+      'ssh:remote-1',
+      undefined,
+      expect.any(Function)
+    )
+
+    trust.resolve('run')
+    await vi.waitFor(() => expect(store.createWorktree).toHaveBeenCalledOnce())
+    expect(store.pendingWorktreeCreations['creation-1'].phase).toBe('fetching')
+    expect(store.createWorktree.mock.calls[0]).toContainEqual(
+      expect.objectContaining({ executionHostId: 'ssh:remote-1' })
+    )
+  })
+
+  it('does not create after cancellation during slow script inspection', async () => {
+    const trust = Promise.withResolvers<'run' | 'skip'>()
+    vi.mocked(ensureHooksConfirmed).mockReturnValueOnce(trust.promise)
+    runBackgroundWorktreeCreation(makeRequest({ hookPreparation: { executionHostId: 'local' } }))
+
+    store.removePendingWorktreeCreation('creation-1')
+    trust.resolve('run')
+    await flushAsyncWorktreeCreation()
+    expect(store.createWorktree).not.toHaveBeenCalled()
+  })
+
+  it('keeps refused scripts disabled when creating the worktree', async () => {
+    vi.mocked(ensureHooksConfirmed).mockResolvedValueOnce('skip')
+    runBackgroundWorktreeCreation(
+      makeRequest({
+        setupDecision: 'run',
+        hookPreparation: { executionHostId: 'local' }
+      })
+    )
+    await vi.waitFor(() => expect(store.createWorktree).toHaveBeenCalledOnce())
+    expect(store.pendingWorktreeCreations['creation-1'].request.setupDecision).toBe('skip')
+  })
+
+  it('retries failed preparation on the captured host', async () => {
+    vi.mocked(ensureHooksConfirmed).mockRejectedValueOnce(new Error('inspection failed'))
+    runBackgroundWorktreeCreation(
+      makeRequest({ hookPreparation: { executionHostId: 'runtime:host-1' } })
+    )
+    await vi.waitFor(() =>
+      expect(store.pendingWorktreeCreations['creation-1'].status).toBe('error')
+    )
+    expect(store.createWorktree).not.toHaveBeenCalled()
+
+    const trust = Promise.withResolvers<'run' | 'skip'>()
+    vi.mocked(ensureHooksConfirmed).mockReturnValueOnce(trust.promise)
+    retryBackgroundWorktreeCreation('creation-1')
+    expect(store.pendingWorktreeCreations['creation-1'].phase).toBe('preparing')
+    trust.resolve('run')
+    await vi.waitFor(() => expect(store.createWorktree).toHaveBeenCalledOnce())
+  })
+})
diff --git a/src/renderer/src/lib/worktree-creation-hook-preparation.test.ts b/src/renderer/src/lib/worktree-creation-hook-preparation.test.ts
new file mode 100644
index 00000000000..17dbf32b8de
--- /dev/null
+++ b/src/renderer/src/lib/worktree-creation-hook-preparation.test.ts
@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { PendingWorktreeCreation, WorktreeCreationRequest } from './pending-worktree-creation'
+
+const mocks = vi.hoisted(() => ({
+  ensureHooksConfirmed: vi.fn(),
+  readAndConfirmRuntimeIssueCommand: vi.fn(),
+  buildTrustedComposerIssueCommand: vi.fn()
+}))
+vi.mock('./ensure-hooks-confirmed', () => mocks)
+vi.mock('./composer-issue-command', () => mocks)
+
+const pendingWorktreeCreations: Record<string, PendingWorktreeCreation> = {}
+const store = {
+  pendingWorktreeCreations,
+  updatePendingWorktreeCreation: vi.fn(),
+  removePendingWorktreeCreation: vi.fn()
+}
+vi.mock('@/store', () => ({ useAppStore: { getState: () => store } }))
+
+import { prepareWorktreeCreationHooks } from './worktree-creation-hook-preparation'
+
+function makeRequest(): WorktreeCreationRequest {
+  return {
+    repoId: 'repo-1',
+    name: 'issue-42',
+    agent: null,
+    setupDecision: 'run',
+    pendingFirstAgentMessageRename: false,
+    note: '',
+    startupPlan: null,
+    quickPrompt: '',
+    quickTelemetry: null,
+    hookPreparation: {
+      executionHostId: 'ssh:remote-1',
+      issueCommand: { provider: 'github', issueNumber: 42, artifactUrl: 'https://example.test/42' }
+    }
+  }
+}
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  const request = makeRequest()
+  store.pendingWorktreeCreations = {
+    'creation-1': {
+      creationId: 'creation-1',
+      phase: 'preparing',
+      status: 'creating',
+      startedAt: 0,
+      indeterminate: false,
+      loaderVisible: true,
+      request
+    }
+  }
+  mocks.ensureHooksConfirmed.mockResolvedValue('run')
+})
+
+describe('worktree script preparation', () => {
+  it('reads and confirms issue commands on the selected host before advancing', async () => {
+    const read = Promise.withResolvers<{ template: string; trustDecision: 'run' }>()
+    mocks.readAndConfirmRuntimeIssueCommand.mockReturnValue(read.promise)
+    mocks.buildTrustedComposerIssueCommand.mockReturnValue({ command: 'issue 42' })
+    const preparing = prepareWorktreeCreationHooks('creation-1', makeRequest())
+    await vi.waitFor(() => expect(mocks.readAndConfirmRuntimeIssueCommand).toHaveBeenCalled())
+    expect(store.updatePendingWorktreeCreation).not.toHaveBeenCalled()
+    expect(mocks.readAndConfirmRuntimeIssueCommand).toHaveBeenCalledWith(
+      store,
+      'repo-1',
+      'ssh:remote-1',
+      expect.any(Function)
+    )
+    read.resolve({ template: 'issue {{number}}', trustDecision: 'run' })
+    expect(await preparing).toMatchObject({
+      issueCommand: { command: 'issue 42' },
+      executionHostId: 'ssh:remote-1',
+      hookPreparation: undefined
+    })
+    expect(mocks.buildTrustedComposerIssueCommand).toHaveBeenCalledWith({
+      enabled: true,
+      provider: 'github',
+      issueNumber: 42,
+      artifactUrl: 'https://example.test/42',
+      template: 'issue {{number}}',
+      trustDecision: 'run'
+    })
+  })
+
+  it('does not inspect issue commands when setup trust was refused', async () => {
+    mocks.ensureHooksConfirmed.mockResolvedValue('skip')
+    expect(await prepareWorktreeCreationHooks('creation-1', makeRequest())).toMatchObject({
+      setupDecision: 'skip'
+    })
+    expect(mocks.readAndConfirmRuntimeIssueCommand).not.toHaveBeenCalled()
+  })
+
+  it('does not advance after cancelling an issue-command confirmation', async () => {
+    const read = Promise.withResolvers<{ template: string; trustDecision: 'run' }>()
+    mocks.readAndConfirmRuntimeIssueCommand.mockReturnValue(read.promise)
+    const preparing = prepareWorktreeCreationHooks('creation-1', makeRequest())
+    await vi.waitFor(() => expect(mocks.readAndConfirmRuntimeIssueCommand).toHaveBeenCalled())
+    delete store.pendingWorktreeCreations['creation-1']
+    read.resolve({ template: 'issue {{number}}', trustDecision: 'run' })
+    expect(await preparing).toBeNull()
+    expect(store.updatePendingWorktreeCreation).not.toHaveBeenCalled()
+  })
+
+  it('removes the preparation when the VM recipe is refused', async () => {
+    mocks.ensureHooksConfirmed.mockResolvedValueOnce('run').mockResolvedValueOnce('skip')
+    const request = makeRequest()
+    request.hookPreparation = { executionHostId: 'ssh:remote-1', confirmVmRecipe: true }
+    expect(await prepareWorktreeCreationHooks('creation-1', request)).toBeNull()
+    expect(mocks.ensureHooksConfirmed).toHaveBeenLastCalledWith(
+      expect.any(Function),
+      'repo-1',
+      'vmRecipe',
+      'ssh:remote-1',
+      undefined,
+      expect.any(Function)
+    )
+    expect(store.removePendingWorktreeCreation).toHaveBeenCalledWith('creation-1')
+    expect(store.updatePendingWorktreeCreation).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/lib/worktree-creation-hook-preparation.ts b/src/renderer/src/lib/worktree-creation-hook-preparation.ts
new file mode 100644
index 00000000000..4132e3fa898
--- /dev/null
+++ b/src/renderer/src/lib/worktree-creation-hook-preparation.ts
@@ -0,0 +1,73 @@
+import { useAppStore } from '@/store'
+import type { WorktreeCreationRequest } from './pending-worktree-creation'
+import { ensureHooksConfirmed, readAndConfirmRuntimeIssueCommand } from './ensure-hooks-confirmed'
+import { buildTrustedComposerIssueCommand } from './composer-issue-command'
+import { getInitialWorktreeCreationPhase } from './worktree-creation-flow-startup'
+
+export async function prepareWorktreeCreationHooks(
+  creationId: string,
+  request: WorktreeCreationRequest
+): Promise<WorktreeCreationRequest | null> {
+  const preparation = request.hookPreparation
+  if (!preparation) {
+    return request
+  }
+
+  const isCancelled = (): boolean => !useAppStore.getState().pendingWorktreeCreations[creationId]
+  const confirmHook = (kind: 'setup' | 'vmRecipe'): Promise<'run' | 'skip'> =>
+    ensureHooksConfirmed(
+      useAppStore.getState,
+      request.repoId,
+      kind,
+      preparation.executionHostId,
+      undefined,
+      isCancelled
+    )
+  const trustDecision = await confirmHook('setup')
+  if (isCancelled()) {
+    return null
+  }
+
+  let issueCommand = request.issueCommand
+  if (preparation.issueCommand && preparation.executionHostId && trustDecision !== 'skip') {
+    const confirmed = await readAndConfirmRuntimeIssueCommand(
+      useAppStore.getState(),
+      request.repoId,
+      preparation.executionHostId,
+      isCancelled
+    )
+    if (isCancelled()) {
+      return null
+    }
+    issueCommand = buildTrustedComposerIssueCommand({
+      ...preparation.issueCommand,
+      enabled: true,
+      template: confirmed.template,
+      trustDecision: confirmed.trustDecision
+    })
+  }
+
+  if (preparation.confirmVmRecipe) {
+    const decision = await confirmHook('vmRecipe')
+    if (isCancelled()) {
+      return null
+    }
+    if (decision === 'skip') {
+      useAppStore.getState().removePendingWorktreeCreation(creationId)
+      return null
+    }
+  }
+
+  const prepared: WorktreeCreationRequest = {
+    ...request,
+    hookPreparation: undefined,
+    executionHostId: request.executionHostId ?? preparation.executionHostId,
+    setupDecision: trustDecision === 'skip' ? 'skip' : request.setupDecision,
+    issueCommand
+  }
+  useAppStore.getState().updatePendingWorktreeCreation(creationId, {
+    request: prepared,
+    phase: getInitialWorktreeCreationPhase(prepared)
+  })
+  return prepared
+}
diff --git a/src/renderer/src/lib/worktree-creation-structured-session.ts b/src/renderer/src/lib/worktree-creation-structured-session.ts
index 6149a155441..7c3e6d940b6 100644
--- a/src/renderer/src/lib/worktree-creation-structured-session.ts
+++ b/src/renderer/src/lib/worktree-creation-structured-session.ts
@@ -62,6 +62,8 @@ export async function launchStructuredWorktreeSession(
   // keeps a retry from re-resolving against a host that has changed since.
   const plan = adoptAgentSessionLaunchVerdict({
     route: args.agentLaunchRoute,
+    // One create is one user action: a retry of it re-delivers the same request.
+    requestId: args.creationId,
     agent,
     prompt: args.request.launchDraftPrompt ?? args.request.quickPrompt,
     ...(args.request.promptDelivery ? { promptDelivery: args.request.promptDelivery } : {})
diff --git a/src/renderer/src/runtime/mobile-markdown-bridge.test.ts b/src/renderer/src/runtime/mobile-markdown-bridge.test.ts
index e039cc515eb..8597316794f 100644
--- a/src/renderer/src/runtime/mobile-markdown-bridge.test.ts
+++ b/src/renderer/src/runtime/mobile-markdown-bridge.test.ts
@@ -7,6 +7,7 @@ import {
 import { attachEditorAutosaveController } from '../components/editor/editor-autosave-controller'
 import { registerPendingEditorFlush } from '../components/editor/editor-pending-flush'
 import { useAppStore } from '../store'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../shared/constants'
 import { attachMobileMarkdownBridge } from './mobile-markdown-bridge'
 import {
   cleanupMobileMarkdownBridgeHarness,
@@ -63,6 +64,56 @@ describe('mobile markdown bridge', () => {
     }
   })
 
+  it('reads a restored floating-workspace tab for a paired client as user-named', async () => {
+    useAppStore.getState().openFile({
+      filePath: '/Users/me/notes.md',
+      relativePath: 'notes.md',
+      worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
+      language: 'markdown',
+      mode: 'edit'
+    })
+    const tabId = useAppStore.getState().openFiles[0]?.id ?? ''
+    const readFile = vi.fn().mockResolvedValue({ content: '# notes', isBinary: false })
+    setupWindow({ readFile })
+    const detach = attachMobileMarkdownBridge()
+
+    try {
+      const response = await sendRequest({
+        id: 'read-floating',
+        operation: 'read',
+        worktreeId: FLOATING_TERMINAL_WORKTREE_ID,
+        tabId
+      })
+
+      expect(response).toMatchObject({ ok: true, result: { content: '# notes', source: 'file' } })
+      expect(readFile).toHaveBeenCalledWith(
+        expect.objectContaining({ filePath: '/Users/me/notes.md', access: { kind: 'user-file' } })
+      )
+    } finally {
+      detach()
+    }
+  })
+
+  it('reads a project tab for a paired client inside its root', async () => {
+    openMarkdownFile()
+    const readFile = vi.fn().mockResolvedValue({ content: 'disk', isBinary: false })
+    setupWindow({ readFile })
+    const detach = attachMobileMarkdownBridge()
+
+    try {
+      await sendRequest({
+        id: 'read-project',
+        operation: 'read',
+        worktreeId: 'wt-1',
+        tabId: 'tab-md'
+      })
+
+      expect(readFile.mock.calls[0]?.[0]).not.toHaveProperty('access')
+    } finally {
+      detach()
+    }
+  })
+
   it('rejects save when a clean file changed after mobile read', async () => {
     openMarkdownFile()
     const writeFile = vi.fn().mockResolvedValue(undefined)
diff --git a/src/renderer/src/runtime/mobile-markdown-bridge.ts b/src/renderer/src/runtime/mobile-markdown-bridge.ts
index c51a7656843..ef26415f9b1 100644
--- a/src/renderer/src/runtime/mobile-markdown-bridge.ts
+++ b/src/renderer/src/runtime/mobile-markdown-bridge.ts
@@ -7,6 +7,7 @@ import {
 } from '@/components/editor/editor-autosave'
 import { flushPendingEditorChange } from '@/components/editor/editor-pending-flush'
 import { getConnectionIdForFile } from '@/lib/connection-context'
+import { editorTabFileAccess } from '@/lib/local-file-access'
 import { useAppStore } from '@/store'
 import type { OpenFile } from '@/store/slices/editor'
 import { readRuntimeFileContent } from './runtime-file-client'
@@ -243,14 +244,15 @@ async function readCurrentContent(
 async function readFileContent(file: OpenFile): Promise<string> {
   const connectionId = getConnectionIdForFile(file.worktreeId, file.filePath) ?? undefined
   const state = useAppStore.getState()
-  const result = (await readRuntimeFileContent({
+  const result: FileContent = await readRuntimeFileContent({
     settings: settingsForRuntimeOwner(state.settings, file.runtimeEnvironmentId),
     filePath: file.filePath,
     relativePath: file.relativePath,
     worktreeId: file.worktreeId,
     connectionId,
-    expectedExternalSshTargetId: file.externalSshTargetId
-  })) as FileContent
+    expectedExternalSshTargetId: file.externalSshTargetId,
+    access: editorTabFileAccess(state, file)
+  })
   if (result.isBinary) {
     throw new Error('binary_file')
   }
diff --git a/src/renderer/src/runtime/remote-runtime-snapshot-outcome.test.ts b/src/renderer/src/runtime/remote-runtime-snapshot-outcome.test.ts
index 1d903d5bd52..a233c2d7dfe 100644
--- a/src/renderer/src/runtime/remote-runtime-snapshot-outcome.test.ts
+++ b/src/renderer/src/runtime/remote-runtime-snapshot-outcome.test.ts
@@ -189,7 +189,8 @@ describe('remote terminal snapshot outcome reasons', () => {
         rows: 24,
         seq: 0,
         source: undefined,
-        pendingEscapeTailAnsi: undefined
+        pendingEscapeTailAnsi: undefined,
+        carriesNormalBuffer: true
       }
     })
     await expect(stream.serializeBuffer({ scrollbackRows: 100 })).resolves.toMatchObject({
diff --git a/src/renderer/src/runtime/remote-runtime-terminal-binary-snapshots.ts b/src/renderer/src/runtime/remote-runtime-terminal-binary-snapshots.ts
index 6928267a12a..2a3a24af8b5 100644
--- a/src/renderer/src/runtime/remote-runtime-terminal-binary-snapshots.ts
+++ b/src/renderer/src/runtime/remote-runtime-terminal-binary-snapshots.ts
@@ -84,7 +84,9 @@ export abstract class RemoteRuntimeTerminalBinarySnapshots extends RemoteRuntime
               kittyKeyboardFlags: info?.kittyKeyboardFlags,
               alternateScreen: info?.alternateScreen,
               terminalOwner: info?.terminalOwner,
-              pendingEscapeTailAnsi: info?.pendingEscapeTailAnsi
+              pendingEscapeTailAnsi: info?.pendingEscapeTailAnsi,
+              // The host folds the normal buffer into `data` (see terminal-snapshot-publication.ts).
+              carriesNormalBuffer: true
             }
           })
           clearPendingSnapshotRequest(stream)
diff --git a/src/renderer/src/runtime/remote-runtime-terminal-multiplexer-types.ts b/src/renderer/src/runtime/remote-runtime-terminal-multiplexer-types.ts
index 4b3a94aaf97..a8632c132a8 100644
--- a/src/renderer/src/runtime/remote-runtime-terminal-multiplexer-types.ts
+++ b/src/renderer/src/runtime/remote-runtime-terminal-multiplexer-types.ts
@@ -76,6 +76,8 @@ export type RemoteRuntimeSnapshotImage = {
   kittyKeyboardFlags?: number
   alternateScreen?: boolean
   terminalOwner?: 'shell'
+  /** `data` starts on the normal buffer and enters alt itself. */
+  carriesNormalBuffer?: boolean
 }
 
 /** Transient causes the host itself reported: a request reached it and it declined to serialize now. */
@@ -133,13 +135,9 @@ export type RemoteRuntimeMultiplexedTerminal = {
   resize: (cols: number, rows: number) => boolean
   claimViewport: (cols: number, rows: number) => boolean
   setOutputPaused: (paused: boolean) => boolean
-  serializeBuffer: (opts?: { scrollbackRows?: number }) => Promise<{
-    data: string
-    cols: number
-    rows: number
-    seq?: number
-    source?: 'headless' | 'renderer'
-  } | null>
+  serializeBuffer: (opts?: {
+    scrollbackRows?: number
+  }) => Promise<RemoteRuntimeSnapshotImage | null>
   // Why: same request as serializeBuffer, but keeps the host's reason for an absent buffer instead of collapsing it to null.
   serializeBufferOutcome: (opts?: {
     scrollbackRows?: number
diff --git a/src/renderer/src/runtime/remote-runtime-terminal-snapshot-controller.ts b/src/renderer/src/runtime/remote-runtime-terminal-snapshot-controller.ts
index e7f3eda6218..10fb18dff91 100644
--- a/src/renderer/src/runtime/remote-runtime-terminal-snapshot-controller.ts
+++ b/src/renderer/src/runtime/remote-runtime-terminal-snapshot-controller.ts
@@ -18,6 +18,7 @@ import {
 } from './remote-runtime-terminal-snapshot-state'
 import type {
   RemoteRuntimeMultiplexedTerminalState,
+  RemoteRuntimeSnapshotImage,
   RemoteRuntimeSnapshotOutcome
 } from './remote-runtime-terminal-multiplexer-types'
 
@@ -135,13 +136,7 @@ export abstract class RemoteRuntimeTerminalSnapshotController extends RemoteRunt
   protected async requestSnapshot(
     stream: RemoteRuntimeMultiplexedTerminalState,
     opts?: { scrollbackRows?: number }
-  ): Promise<{
-    data: string
-    cols: number
-    rows: number
-    seq?: number
-    source?: 'headless' | 'renderer'
-  } | null> {
+  ): Promise<RemoteRuntimeSnapshotImage | null> {
     const outcome = await this.requestSnapshotOutcome(stream, opts)
     // Why: the concurrent-request guard used to reject before the outcome existed; keep that contract for legacy callers.
     if (
diff --git a/src/renderer/src/runtime/runtime-file-client-test-harness.ts b/src/renderer/src/runtime/runtime-file-client-test-harness.ts
index 321c6abe6d1..8da795d1d98 100644
--- a/src/renderer/src/runtime/runtime-file-client-test-harness.ts
+++ b/src/renderer/src/runtime/runtime-file-client-test-harness.ts
@@ -34,6 +34,7 @@ export type RuntimeSubscribeStub = Mock<
 >
 
 export const fsReadFile: PreloadStub = vi.fn()
+export const fsReadFileChunk: PreloadStub = vi.fn()
 export const fsWriteFile: PreloadStub = vi.fn()
 export const fsOnChanged: PreloadStub = vi.fn()
 export const fsCopy: PreloadStub = vi.fn()
@@ -68,6 +69,7 @@ export function installRuntimeFileClientEnvironment(): void {
     clearLegacyQuickOpenInventoryCacheForTests()
     replaceRuntimeEnvironmentRevisions([])
     fsReadFile.mockReset()
+    fsReadFileChunk.mockReset()
     fsWriteFile.mockReset()
     fsOnChanged.mockReset()
     fsCopy.mockReset()
@@ -115,6 +117,7 @@ export function installRuntimeFileClientEnvironment(): void {
       api: {
         fs: {
           readFile: fsReadFile,
+          readFileChunk: fsReadFileChunk,
           writeFile: fsWriteFile,
           onFsChanged: fsOnChanged,
           copy: fsCopy,
diff --git a/src/renderer/src/runtime/runtime-file-client-types.ts b/src/renderer/src/runtime/runtime-file-client-types.ts
index 6525fc7e357..9fe3f342bfc 100644
--- a/src/renderer/src/runtime/runtime-file-client-types.ts
+++ b/src/renderer/src/runtime/runtime-file-client-types.ts
@@ -1,4 +1,5 @@
 import type { GlobalSettings } from '../../../shared/global-settings-types'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
 
 export type RuntimeReadableFileContent = {
   content: string
@@ -16,6 +17,8 @@ export type RuntimeFileReadArgs = {
   connectionId?: string
   expectedExternalSshTargetId?: string
   includeLocalLogMetadata?: boolean
+  /** File access of the local fallback read; remote reads stay root-relative. */
+  access?: LocalFileAccess
 }
 
 export type RuntimeFileOperationArgs = {
diff --git a/src/renderer/src/runtime/runtime-file-import-client.ts b/src/renderer/src/runtime/runtime-file-import-client.ts
index 2aebfbcfa8c..7bb142cc33a 100644
--- a/src/renderer/src/runtime/runtime-file-import-client.ts
+++ b/src/renderer/src/runtime/runtime-file-import-client.ts
@@ -21,12 +21,19 @@ import {
 } from './runtime-file-upload-client'
 import { getActiveRuntimeTarget } from './runtime-rpc-client'
 import { toRuntimeWorktreeSelector } from './runtime-worktree-selector'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
+import { localAccess } from './runtime-file-read-client'
 
 export async function importExternalPathsToRuntime(
   context: RuntimeFileOperationArgs,
   sourcePaths: string[],
   destinationDir: string,
-  options?: { ensureDestinationDir?: boolean; assertCurrent?: () => void }
+  options?: {
+    ensureDestinationDir?: boolean
+    assertCurrent?: () => void
+    /** Local imports only; remote destinations stay root-relative. */
+    access?: LocalFileAccess
+  }
 ): Promise<{ results: ImportItemResult[] }> {
   const target = getActiveRuntimeTarget(context.settings)
   if (target.kind !== 'environment' || !context.worktreeId || !context.worktreePath) {
@@ -35,7 +42,8 @@ export async function importExternalPathsToRuntime(
         sourcePaths,
         destDir: destinationDir,
         connectionId: context.connectionId,
-        ensureDir: options?.ensureDestinationDir
+        ensureDir: options?.ensureDestinationDir,
+        ...localAccess(context.connectionId, options?.access)
       })
     )
   }
diff --git a/src/renderer/src/runtime/runtime-file-metadata-client.ts b/src/renderer/src/runtime/runtime-file-metadata-client.ts
index e9d2e867b77..e89c2c1e299 100644
--- a/src/renderer/src/runtime/runtime-file-metadata-client.ts
+++ b/src/renderer/src/runtime/runtime-file-metadata-client.ts
@@ -3,6 +3,8 @@ import type { RuntimeFileOperationArgs } from './runtime-file-client-types'
 import { assertLocalFilesystemFallbackAllowed, getRemoteFileArgs } from './runtime-file-routing'
 import { callRuntimeRpc, getActiveRuntimeTarget } from './runtime-rpc-client'
 import { toRuntimeWorktreeSelector } from './runtime-worktree-selector'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
+import { localAccess } from './runtime-file-read-client'
 
 export async function listRuntimeMarkdownDocuments(
   context: RuntimeFileOperationArgs,
@@ -25,14 +27,16 @@ export async function listRuntimeMarkdownDocuments(
 
 export async function statRuntimePath(
   context: RuntimeFileOperationArgs,
-  absolutePath: string
+  absolutePath: string,
+  access?: LocalFileAccess
 ): Promise<{ size: number; isDirectory: boolean; mtime: number }> {
   const remoteArgs = getRemoteFileArgs(context, absolutePath)
   if (!remoteArgs) {
     assertLocalFilesystemFallbackAllowed(context)
     return window.api.fs.stat({
       filePath: absolutePath,
-      connectionId: context.connectionId
+      connectionId: context.connectionId,
+      ...localAccess(context.connectionId, access)
     })
   }
   return callRuntimeRpc<{ size: number; isDirectory: boolean; mtime: number }>(
diff --git a/src/renderer/src/runtime/runtime-file-mutation-client.ts b/src/renderer/src/runtime/runtime-file-mutation-client.ts
index b2a358a5200..dbb0c55f7b9 100644
--- a/src/renderer/src/runtime/runtime-file-mutation-client.ts
+++ b/src/renderer/src/runtime/runtime-file-mutation-client.ts
@@ -11,6 +11,8 @@ import {
 } from './runtime-file-routing'
 import { callRuntimeFileMutation } from './runtime-file-mutation-rpc'
 import { toRuntimeWorktreeSelector } from './runtime-worktree-selector'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
+import { localAccess } from './runtime-file-read-client'
 
 export async function readRuntimeDirectory(
   context: RuntimeFileOperationArgs,
@@ -32,13 +34,19 @@ export async function readRuntimeDirectory(
 export async function writeRuntimeFile(
   context: RuntimeFileOperationArgs,
   filePath: string,
-  content: string
+  content: string,
+  access?: LocalFileAccess
 ): Promise<void> {
   const remoteArgs = getRemoteFileArgs(context, filePath)
   if (!remoteArgs) {
     assertLocalFilesystemFallbackAllowed(context)
     await window.api.fs.writeFile(
-      withSshMutationExpectation(context, { filePath, content, connectionId: context.connectionId })
+      withSshMutationExpectation(context, {
+        filePath,
+        content,
+        connectionId: context.connectionId,
+        ...localAccess(context.connectionId, access)
+      })
     )
     return
   }
@@ -88,14 +96,20 @@ export async function createRuntimePath(
 export async function renameRuntimePath(
   context: RuntimeFileOperationArgs,
   oldPath: string,
-  newPath: string
+  newPath: string,
+  access?: LocalFileAccess
 ): Promise<void> {
   const oldRemoteArgs = getRemoteFileArgs(context, oldPath)
   const newRelativePath = getRelativePathInsideWorktree(context.worktreePath, newPath)
   if (!oldRemoteArgs || newRelativePath === null) {
     assertLocalFilesystemFallbackAllowed(context)
     await window.api.fs.rename(
-      withSshMutationExpectation(context, { oldPath, newPath, connectionId: context.connectionId })
+      withSshMutationExpectation(context, {
+        oldPath,
+        newPath,
+        connectionId: context.connectionId,
+        ...localAccess(context.connectionId, access)
+      })
     )
     return
   }
diff --git a/src/renderer/src/runtime/runtime-file-range-client.test.ts b/src/renderer/src/runtime/runtime-file-range-client.test.ts
new file mode 100644
index 00000000000..7b8c9aa937d
--- /dev/null
+++ b/src/renderer/src/runtime/runtime-file-range-client.test.ts
@@ -0,0 +1,161 @@
+import { describe, expect, it } from 'vitest'
+import { readRuntimeFileRange, statRuntimeReadTarget } from './runtime-file-range-client'
+import {
+  readEditorCsvFileContent,
+  CSV_PAGED_PREVIEW_BYTES
+} from '../components/editor/csv/csv-file-content'
+import {
+  fsReadFile,
+  fsReadFileChunk,
+  fsStat,
+  runtimeEnvironmentCall,
+  installRuntimeFileClientEnvironment
+} from './runtime-file-client-test-harness'
+
+installRuntimeFileClientEnvironment()
+const localArgs = {
+  settings: null,
+  filePath: '/repo/large.csv',
+  relativePath: 'large.csv',
+  worktreeId: 'folder:workspace'
+}
+const snapshot = { size: 100 * 1024 * 1024, isDirectory: false, mtime: 123 }
+
+describe('CSV range routing', () => {
+  it('preserves local file access for metadata and chunk reads', async () => {
+    const access = { kind: 'user-file' } as const
+    fsStat.mockResolvedValue(snapshot)
+    fsReadFileChunk.mockResolvedValue({ contentBase64: 'YWJj', bytesRead: 3, eof: false })
+    await statRuntimeReadTarget({ ...localArgs, access })
+    await readRuntimeFileRange({ ...localArgs, access }, 0, 3)
+    expect(fsStat).toHaveBeenCalledWith({
+      filePath: localArgs.filePath,
+      connectionId: undefined,
+      access
+    })
+    expect(fsReadFileChunk).toHaveBeenCalledWith({
+      filePath: localArgs.filePath,
+      connectionId: undefined,
+      offset: 0,
+      length: 3,
+      access
+    })
+  })
+  it('uses bounded local reads and preserves explicit SSH ownership', async () => {
+    fsReadFileChunk.mockResolvedValue({ contentBase64: 'YWJj', bytesRead: 3, eof: false })
+    expect(await readRuntimeFileRange(localArgs, 100, 3)).toEqual(new Uint8Array([97, 98, 99]))
+    await readRuntimeFileRange(
+      { ...localArgs, connectionId: 'ssh-1', expectedExternalSshTargetId: 'ssh-1' },
+      100,
+      3
+    )
+    expect(fsReadFileChunk).toHaveBeenLastCalledWith({
+      filePath: localArgs.filePath,
+      connectionId: 'ssh-1',
+      access: undefined,
+      offset: 100,
+      length: 3
+    })
+    expect(fsReadFile).not.toHaveBeenCalled()
+  })
+  it('routes paired folder workspaces through the existing host chunk RPC', async () => {
+    runtimeEnvironmentCall.mockResolvedValue({
+      id: 'chunk',
+      ok: true,
+      result: { contentBase64: 'YWJj', bytesRead: 3, eof: false }
+    })
+    await readRuntimeFileRange(
+      { ...localArgs, settings: { activeRuntimeEnvironmentId: 'env-1' } },
+      10,
+      3
+    )
+    expect(runtimeEnvironmentCall).toHaveBeenCalledWith(
+      expect.objectContaining({
+        selector: 'env-1',
+        method: 'files.readChunk',
+        params: {
+          worktree: 'id:folder:workspace',
+          relativePath: 'large.csv',
+          offset: 10,
+          length: 3
+        }
+      })
+    )
+    expect(fsReadFileChunk).not.toHaveBeenCalled()
+  })
+  it('does not substitute a local file for an unavailable or changed remote owner', async () => {
+    await expect(
+      readRuntimeFileRange(
+        { ...localArgs, settings: { activeRuntimeEnvironmentId: 'env-1' }, worktreeId: undefined },
+        0,
+        3
+      )
+    ).rejects.toThrow('owning')
+    await expect(
+      readRuntimeFileRange(
+        { ...localArgs, connectionId: 'ssh-2', expectedExternalSshTargetId: 'ssh-1' },
+        0,
+        3
+      )
+    ).rejects.toThrow('host changes')
+    await expect(
+      statRuntimeReadTarget({
+        ...localArgs,
+        settings: { activeRuntimeEnvironmentId: 'env-1' },
+        relativePath: '/other/large.csv'
+      })
+    ).rejects.toThrow('outside')
+    expect(fsReadFileChunk).not.toHaveBeenCalled()
+    expect(fsStat).not.toHaveBeenCalled()
+  })
+  it('asks old hosts to update without attempting a whole-file fallback', async () => {
+    runtimeEnvironmentCall.mockResolvedValue({
+      id: 'chunk',
+      ok: false,
+      error: { code: 'method_not_found', message: 'Unknown method' }
+    })
+    await expect(
+      readRuntimeFileRange(
+        { ...localArgs, settings: { activeRuntimeEnvironmentId: 'env-1' } },
+        0,
+        3
+      )
+    ).rejects.toThrow('newer Orca server')
+    expect(fsReadFile).not.toHaveBeenCalled()
+    expect(fsReadFileChunk).not.toHaveBeenCalled()
+  })
+  it('rejects invalid requests and corrupt or stalled responses', async () => {
+    await expect(readRuntimeFileRange(localArgs, -1, 3)).rejects.toThrow('position')
+    await expect(readRuntimeFileRange(localArgs, 0, 256 * 1024 + 1)).rejects.toThrow('limit')
+    expect(fsReadFileChunk).not.toHaveBeenCalled()
+    for (const result of [
+      { contentBase64: '', bytesRead: 0 },
+      { contentBase64: 'YWJj', bytesRead: 2 },
+      { contentBase64: 'YWJj', bytesRead: 3 }
+    ]) {
+      fsReadFileChunk.mockResolvedValue(result)
+      await expect(readRuntimeFileRange(localArgs, 0, 2)).rejects.toThrow('invalid CSV chunk')
+    }
+  })
+})
+
+describe('CSV file admission', () => {
+  it('never reads a large CSV into the editable content cache', async () => {
+    fsStat.mockResolvedValue(snapshot)
+    expect(await readEditorCsvFileContent(localArgs)).toEqual({
+      content: '',
+      isBinary: false,
+      csvPreview: { readArgs: localArgs, snapshot }
+    })
+    expect(fsReadFile).not.toHaveBeenCalled()
+  })
+  it('keeps small files editable and preserves existing dirty drafts', async () => {
+    fsStat.mockResolvedValue({ ...snapshot, size: CSV_PAGED_PREVIEW_BYTES - 1 })
+    fsReadFile.mockResolvedValue({ content: 'a,b\n1,2', isBinary: false })
+    expect((await readEditorCsvFileContent(localArgs)).csvPreview).toBeUndefined()
+    fsStat.mockClear()
+    await readEditorCsvFileContent(localArgs, false)
+    expect(fsStat).not.toHaveBeenCalled()
+    expect(fsReadFile).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/src/renderer/src/runtime/runtime-file-range-client.ts b/src/renderer/src/runtime/runtime-file-range-client.ts
new file mode 100644
index 00000000000..bc04820d45a
--- /dev/null
+++ b/src/renderer/src/runtime/runtime-file-range-client.ts
@@ -0,0 +1,92 @@
+import type { RuntimeFileReadChunkResult } from '../../../shared/runtime-types'
+import { validateFileRangeRequest } from '../../../shared/file-range-read'
+import type { RuntimeFileReadArgs } from './runtime-file-client-types'
+import { assertExternalSshReadOwnership, canReadRelativeRuntimeFile } from './runtime-file-routing'
+import { callRuntimeRpc, getActiveRuntimeTarget, RuntimeRpcCallError } from './runtime-rpc-client'
+import { toRuntimeWorktreeSelector } from './runtime-worktree-selector'
+
+function rangeReadTarget(args: RuntimeFileReadArgs) {
+  assertExternalSshReadOwnership(args.settings, args.connectionId, args.expectedExternalSshTargetId)
+  const target = getActiveRuntimeTarget(args.settings)
+  if (target.kind !== 'environment') {
+    return null
+  }
+  if (!args.worktreeId) {
+    throw new Error('Remote file has no owning runtime worktree')
+  }
+  if (!canReadRelativeRuntimeFile(args.relativePath)) {
+    throw new Error('Remote file is outside the owning runtime worktree')
+  }
+  return {
+    target,
+    worktree: toRuntimeWorktreeSelector(args.worktreeId),
+    relativePath: args.relativePath
+  }
+}
+
+export type RuntimeFileSnapshot = { size: number; isDirectory: boolean; mtime: number }
+
+export async function statRuntimeReadTarget(
+  args: RuntimeFileReadArgs
+): Promise<RuntimeFileSnapshot> {
+  const remote = rangeReadTarget(args)
+  if (!remote) {
+    return window.api.fs.stat({
+      filePath: args.filePath,
+      connectionId: args.connectionId,
+      access: args.access
+    })
+  }
+  return callRuntimeRpc<RuntimeFileSnapshot>(
+    remote.target,
+    'files.stat',
+    {
+      worktree: remote.worktree,
+      relativePath: remote.relativePath
+    },
+    { timeoutMs: 15_000 }
+  )
+}
+
+export async function readRuntimeFileRange(
+  args: RuntimeFileReadArgs,
+  offset: number,
+  length: number
+): Promise<Uint8Array<ArrayBuffer>> {
+  validateFileRangeRequest(offset, length)
+  const remote = rangeReadTarget(args)
+  let result: RuntimeFileReadChunkResult
+  try {
+    result = remote
+      ? await callRuntimeRpc<RuntimeFileReadChunkResult>(
+          remote.target,
+          'files.readChunk',
+          {
+            worktree: remote.worktree,
+            relativePath: remote.relativePath,
+            offset,
+            length
+          },
+          { timeoutMs: 60_000 }
+        )
+      : await window.api.fs.readFileChunk({
+          filePath: args.filePath,
+          connectionId: args.connectionId,
+          access: args.access,
+          offset,
+          length
+        })
+  } catch (error) {
+    if (error instanceof RuntimeRpcCallError && error.code === 'method_not_found') {
+      throw new Error(
+        'Large CSV previews require a newer Orca server. Update the server and retry.'
+      )
+    }
+    throw error
+  }
+  const bytes = Uint8Array.from(atob(result.contentBase64), (character) => character.charCodeAt(0))
+  if (bytes.length !== result.bytesRead || bytes.length > length || bytes.length === 0) {
+    throw new Error('File changed or returned an invalid CSV chunk. Reload the preview.')
+  }
+  return bytes
+}
diff --git a/src/renderer/src/runtime/runtime-file-read-client.ts b/src/renderer/src/runtime/runtime-file-read-client.ts
index 40b74611c67..f0559975291 100644
--- a/src/renderer/src/runtime/runtime-file-read-client.ts
+++ b/src/renderer/src/runtime/runtime-file-read-client.ts
@@ -17,6 +17,7 @@ import {
   hasRemoteRuntimeOwner
 } from './runtime-file-routing'
 import { toRuntimeWorktreeSelector } from './runtime-worktree-selector'
+import type { LocalFileAccess } from '../../../shared/local-file-access'
 
 const REMOTE_DOWNLOAD_CHUNK_BYTES = 384 * 1024
 const REMOTE_DOWNLOAD_UPDATE_REQUIRED_MESSAGE =
@@ -24,6 +25,14 @@ const REMOTE_DOWNLOAD_UPDATE_REQUIRED_MESSAGE =
 
 type RemoteFileDownloadArgs = NonNullable<ReturnType<typeof getRemoteFileArgs>>
 
+// Why local only: an SSH read is the remote host's to check, and its relay never sees this field.
+export function localAccess(
+  connectionId: string | undefined,
+  access: LocalFileAccess | undefined
+): { access?: LocalFileAccess } {
+  return access && !connectionId ? { access } : {}
+}
+
 export async function readRuntimeFileContent({
   settings,
   filePath,
@@ -31,15 +40,18 @@ export async function readRuntimeFileContent({
   worktreeId,
   connectionId,
   expectedExternalSshTargetId,
-  includeLocalLogMetadata
+  includeLocalLogMetadata,
+  access
 }: RuntimeFileReadArgs): Promise<RuntimeReadableFileContent> {
   assertExternalSshReadOwnership(settings, connectionId, expectedExternalSshTargetId)
   const target = getActiveRuntimeTarget(settings)
-  if (target.kind !== 'environment') {
-    return window.api.fs.readFile({ filePath, connectionId, includeLocalLogMetadata })
-  }
-  if (!worktreeId) {
-    return window.api.fs.readFile({ filePath, connectionId, includeLocalLogMetadata })
+  if (target.kind !== 'environment' || !worktreeId) {
+    return window.api.fs.readFile({
+      filePath,
+      connectionId,
+      includeLocalLogMetadata,
+      ...localAccess(connectionId, access)
+    })
   }
   if (!canReadRelativeRuntimeFile(relativePath)) {
     throw new Error('Remote file is outside the owning runtime worktree')
@@ -78,7 +90,8 @@ export async function readRuntimeFileContent({
 
 export async function readRuntimeFilePreview(
   context: RuntimeFileOperationArgs,
-  filePath: string
+  filePath: string,
+  access?: LocalFileAccess
 ): Promise<RuntimeFilePreviewResult> {
   assertExternalSshReadOwnership(
     context.settings,
@@ -90,7 +103,11 @@ export async function readRuntimeFilePreview(
     if (hasRemoteRuntimeOwner(context)) {
       throw new Error('Remote file is outside the owning runtime worktree')
     }
-    return window.api.fs.readFile({ filePath, connectionId: context.connectionId })
+    return window.api.fs.readFile({
+      filePath,
+      connectionId: context.connectionId,
+      ...localAccess(context.connectionId, access)
+    })
   }
   return callRuntimeRpc<RuntimeFilePreviewResult>(
     remoteArgs.target,
diff --git a/src/renderer/src/runtime/runtime-jira-client.test.ts b/src/renderer/src/runtime/runtime-jira-client.test.ts
index 89d2cd4713e..5718f8cfff3 100644
--- a/src/renderer/src/runtime/runtime-jira-client.test.ts
+++ b/src/renderer/src/runtime/runtime-jira-client.test.ts
@@ -6,6 +6,7 @@ import {
   jiraGetIssue,
   jiraIssueComments,
   jiraListAssignableUsers,
+  jiraListAssignableUsersForProject,
   jiraLookupIssueSummary,
   jiraReadStatus,
   jiraSearchIssues,
@@ -24,6 +25,7 @@ type RuntimeSubscribeCallbacks = Parameters<typeof window.api.runtimeEnvironment
 const jiraSearchIssuesLocal = vi.fn()
 const jiraListAssignableUsersLocal = vi.fn()
 const jiraSearchUsersLocal = vi.fn()
+const jiraProjectUsersLocal = vi.fn()
 const jiraCreateIssueLocal = vi.fn()
 const jiraReadStatusLocal = vi.fn()
 const jiraLookupIssueSummaryLocal = vi.fn()
@@ -36,6 +38,7 @@ beforeEach(() => {
   jiraSearchIssuesLocal.mockReset()
   jiraListAssignableUsersLocal.mockReset()
   jiraSearchUsersLocal.mockReset()
+  jiraProjectUsersLocal.mockReset()
   jiraCreateIssueLocal.mockReset()
   jiraReadStatusLocal.mockReset()
   jiraLookupIssueSummaryLocal.mockReset()
@@ -51,6 +54,7 @@ beforeEach(() => {
         searchIssues: jiraSearchIssuesLocal,
         listAssignableUsers: jiraListAssignableUsersLocal,
         searchUsers: jiraSearchUsersLocal,
+        listAssignableUsersForProject: jiraProjectUsersLocal,
         createIssue: jiraCreateIssueLocal
       },
       runtimeEnvironments: {
@@ -332,6 +336,54 @@ describe('runtime Jira client search bounds', () => {
     )
   })
 
+  it('uses project-scoped search locally and rejects oversized queries before IPC', async () => {
+    jiraProjectUsersLocal.mockResolvedValue([])
+    await jiraListAssignableUsersForProject(null, '100', 'Ada', 'site-1')
+    expect(jiraProjectUsersLocal).toHaveBeenCalledWith({
+      projectIdOrKey: '100',
+      query: 'Ada',
+      siteId: 'site-1'
+    })
+    await jiraListAssignableUsersForProject(null, '100', 'x'.repeat(20_000), 'site-1')
+    expect(jiraProjectUsersLocal).toHaveBeenCalledTimes(1)
+  })
+
+  it('falls back to site-wide remote search only when the host supports user fields', async () => {
+    runtimeCall.mockImplementation(async (args: { method: string }) =>
+      args.method === 'status.get'
+        ? createCompatibleRuntimeStatusResponse()
+        : { id: 'rpc-1', ok: true, result: [], _meta: { runtimeId: 'remote-runtime' } }
+    )
+    await jiraListAssignableUsersForProject(
+      { activeRuntimeEnvironmentId: 'env-1' },
+      '100',
+      'Ada',
+      'site-1'
+    )
+    expect(runtimeCall).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: 'jira.searchUsers',
+        selector: 'env-1',
+        params: { query: 'Ada', siteId: 'site-1' }
+      })
+    )
+    expect(jiraProjectUsersLocal).not.toHaveBeenCalled()
+    clearRuntimeCompatibilityCacheForTests()
+    runtimeCall.mockReset().mockResolvedValue(createRuntimeStatusWithoutJiraUserFieldsCapability())
+    await expect(
+      jiraListAssignableUsersForProject(
+        { activeRuntimeEnvironmentId: 'env-1' },
+        '100',
+        'Ada',
+        'site-1'
+      )
+    ).resolves.toEqual([])
+    expect(runtimeCall).toHaveBeenCalledTimes(1)
+    expect(runtimeCall).not.toHaveBeenCalledWith(
+      expect.objectContaining({ method: 'jira.searchUsers' })
+    )
+  })
+
   it('streams image-bearing issue and comment payloads from remote runtimes', async () => {
     runtimeSubscribe.mockImplementation(
       async (args: RuntimeSubscribeArgs, callbacks: RuntimeSubscribeCallbacks) => {
diff --git a/src/renderer/src/runtime/runtime-jira-client.ts b/src/renderer/src/runtime/runtime-jira-client.ts
index f3388a95291..2d931414b18 100644
--- a/src/renderer/src/runtime/runtime-jira-client.ts
+++ b/src/renderer/src/runtime/runtime-jira-client.ts
@@ -25,6 +25,7 @@ export { jiraLookupIssueSummary, jiraReadStatus } from './runtime-jira-summary-c
 export {
   jiraCreateIssue,
   jiraListAssignableUsers,
+  jiraListAssignableUsersForProject,
   jiraSearchUsers
 } from './runtime-jira-user-fields-client'
 export type { RuntimeJiraSettings } from './runtime-jira-target'
diff --git a/src/renderer/src/runtime/runtime-jira-user-fields-client.ts b/src/renderer/src/runtime/runtime-jira-user-fields-client.ts
index 8b595fb1a97..4ac1bec36e2 100644
--- a/src/renderer/src/runtime/runtime-jira-user-fields-client.ts
+++ b/src/renderer/src/runtime/runtime-jira-user-fields-client.ts
@@ -49,6 +49,27 @@ export async function jiraListAssignableUsers(
     : window.api.jira.listAssignableUsers(args)
 }
 
+// Remote hosts lack project search; use their capability-gated site search.
+export async function jiraListAssignableUsersForProject(
+  settings: RuntimeJiraSettings,
+  projectIdOrKey: string,
+  query?: string,
+  siteId?: string | null
+): Promise<JiraUser[]> {
+  if (!isRuntimeProviderSearchQueryWithinLimit(query)) {
+    return []
+  }
+  const target = getJiraRuntimeTarget(settings)
+  if (target.kind === 'environment') {
+    return jiraSearchUsers(settings, query, siteId)
+  }
+  return window.api.jira.listAssignableUsersForProject({
+    projectIdOrKey,
+    query,
+    siteId: siteId ?? undefined
+  })
+}
+
 export async function jiraSearchUsers(
   settings: RuntimeJiraSettings,
   query?: string,
diff --git a/src/renderer/src/runtime/structured-agent-session-client.test.ts b/src/renderer/src/runtime/structured-agent-session-client.test.ts
index cc1b738ace9..19e89d83ecb 100644
--- a/src/renderer/src/runtime/structured-agent-session-client.test.ts
+++ b/src/renderer/src/runtime/structured-agent-session-client.test.ts
@@ -123,6 +123,30 @@ describe('callStructuredAgentSession rewind capability', () => {
   })
 })
 
+describe('callStructuredAgentSession timeouts', () => {
+  const target = { kind: 'environment', environmentId: 'env-1' } as const
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    mocks.call.mockResolvedValue({ origin: 'unknown' })
+  })
+
+  // A waiting read lasts as long as the host's listing, which outlasts the default 15 s.
+  it('gives a model catalog read longer than the slowest host listing', async () => {
+    const params = { agent: 'claude', sessionId: 'session-1', waitForListing: true }
+    await callStructuredAgentSession(target, 'agentSession.modelCatalog', params)
+    const [, , , options] = mocks.call.mock.calls[0]!
+    expect(options.timeoutMs).toBeGreaterThan(80_000)
+  })
+
+  it('leaves other reads on the default timeout', async () => {
+    await callStructuredAgentSession(target, 'agentSession.options', { sessionId: 'session-1' })
+    expect(mocks.call).toHaveBeenCalledExactlyOnceWith(target, 'agentSession.options', {
+      sessionId: 'session-1'
+    })
+  })
+})
+
 describe('subscribeStructuredAgentSession', () => {
   beforeEach(() => {
     vi.clearAllMocks()
diff --git a/src/renderer/src/runtime/structured-agent-session-client.ts b/src/renderer/src/runtime/structured-agent-session-client.ts
index 634781b9388..d0e2aca691c 100644
--- a/src/renderer/src/runtime/structured-agent-session-client.ts
+++ b/src/renderer/src/runtime/structured-agent-session-client.ts
@@ -85,6 +85,13 @@ export async function readStructuredAgentSessionConversationOutline(
   )
 }
 
+const STRUCTURED_AGENT_SESSION_METHOD_TIMEOUT_MS: ReadonlyMap<string, number> = new Map([
+  ['agentSession.conversationCommand', 195_000],
+  // A waiting catalog read lasts as long as the host's listing: Claude's is 60 s, after up to 15 s
+  // for an account switch to settle and 5 s of login-shell environment.
+  ['agentSession.modelCatalog', 90_000]
+])
+
 export async function callStructuredAgentSession<TResult>(
   target: RuntimeClientTarget,
   method: string,
@@ -100,9 +107,10 @@ export async function callStructuredAgentSession<TResult>(
   ) {
     throw new Error('Rewinding requires a newer Orca server. Update the server and try again.')
   }
-  return method === 'agentSession.conversationCommand'
-    ? callRuntimeRpc<TResult>(target, method, params, { timeoutMs: 195_000 })
-    : callRuntimeRpc<TResult>(target, method, params)
+  const timeoutMs = STRUCTURED_AGENT_SESSION_METHOD_TIMEOUT_MS.get(method)
+  return timeoutMs === undefined
+    ? callRuntimeRpc<TResult>(target, method, params)
+    : callRuntimeRpc<TResult>(target, method, params, { timeoutMs })
 }
 
 async function subscribeStructuredAgentSessionMethod<TEvent>(
diff --git a/src/renderer/src/store/index.ts b/src/renderer/src/store/index.ts
index e2527d265bc..307e5ee67ab 100644
--- a/src/renderer/src/store/index.ts
+++ b/src/renderer/src/store/index.ts
@@ -54,6 +54,7 @@ import {
   registerWorkspaceHttpLinkBrowserOpener
 } from '@/lib/http-link-routing'
 import { installStoreListenerCensus } from './store-listener-census'
+import { installSettledSortEpoch } from './settled-sort-epoch'
 import { withReactCommitCascadeWriteProbe } from './react-commit-cascade-write-probe'
 import { withStoreIdentityChurnProbe } from './store-identity-churn-probe'
 import {
@@ -73,6 +74,8 @@ const withDevelopmentStoreProbes = (createState: StateCreator<AppState, [], []>)
 export const useAppStore = create<AppState>()(
   withDevelopmentStoreProbes(
     withReactCommitCascadeWriteProbe((...a) => {
+      // Why first: settling inside the bump's own notify means hook subscribers never see it unsettled.
+      installSettledSortEpoch(a[2])
       // Why: the inner api is only reachable here, before create() copies subscribe onto the hook.
       installStoreListenerCensus(a[2])
       return {
diff --git a/src/renderer/src/store/settled-sort-epoch.test.ts b/src/renderer/src/store/settled-sort-epoch.test.ts
new file mode 100644
index 00000000000..a3a9cbe812e
--- /dev/null
+++ b/src/renderer/src/store/settled-sort-epoch.test.ts
@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useAppStore } from './index'
+import { SORT_SETTLE_MS } from './settled-sort-epoch'
+import { applyWebSessionTabsStorePatch } from '@/runtime/web-session-tabs-sync/store-patch'
+import { makeWorktree } from '@/components/worktree-jump-palette-test-fixtures'
+
+const initialState = useAppStore.getInitialState()
+
+function bump(): void {
+  useAppStore.setState((s) => ({ sortEpoch: s.sortEpoch + 1 }))
+}
+
+function settled(): boolean {
+  const { sortEpoch, settledSortEpoch } = useAppStore.getState()
+  return settledSortEpoch === sortEpoch
+}
+
+describe('settledSortEpoch', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    useAppStore.setState(initialState, true)
+  })
+
+  afterEach(() => {
+    useAppStore.setState(initialState, true)
+    vi.useRealTimers()
+  })
+
+  it('settles a bump only after the settle window, with no component mounted', () => {
+    useAppStore.setState({ sortBy: 'smart' })
+    bump()
+    expect(settled()).toBe(false)
+    vi.advanceTimersByTime(SORT_SETTLE_MS - 1)
+    expect(settled()).toBe(false)
+    vi.advanceTimersByTime(1)
+    expect(settled()).toBe(true)
+    expect(vi.getTimerCount()).toBe(0)
+  })
+
+  it('settles Manual bumps in the same write', () => {
+    useAppStore.setState({ sortBy: 'manual' })
+    bump()
+    expect(settled()).toBe(true)
+    expect(vi.getTimerCount()).toBe(0)
+  })
+
+  it('settles a web session sync patch that bumps sortEpoch', () => {
+    useAppStore.setState({ sortBy: 'recent' })
+    applyWebSessionTabsStorePatch(
+      (s) => ({ agentStatusEpoch: s.agentStatusEpoch + 1, sortEpoch: s.sortEpoch + 1 }),
+      { frames: [] }
+    )
+    expect(settled()).toBe(false)
+    vi.advanceTimersByTime(SORT_SETTLE_MS)
+    expect(settled()).toBe(true)
+  })
+
+  it('treats an add that skipped its bump as structural on the next bump', () => {
+    useAppStore.setState({ sortBy: 'recent' })
+    useAppStore.setState({ worktreesByRepo: { 'repo-1': [makeWorktree('a', 'A')] } })
+    expect(vi.getTimerCount()).toBe(0)
+    bump()
+    expect(settled()).toBe(true)
+  })
+
+  it('settles a pending bump when a row arrives without its own bump', () => {
+    useAppStore.setState({ sortBy: 'recent' })
+    bump()
+    expect(settled()).toBe(false)
+    useAppStore.setState({ worktreesByRepo: { 'repo-1': [makeWorktree('a', 'A')] } })
+    expect(settled()).toBe(true)
+    expect(vi.getTimerCount()).toBe(0)
+  })
+
+  it('ignores archived rows when detecting adds and removes', () => {
+    useAppStore.setState((s) => ({
+      sortBy: 'recent',
+      worktreesByRepo: { 'repo-1': [makeWorktree('a', 'A')] },
+      sortEpoch: s.sortEpoch + 1
+    }))
+    expect(settled()).toBe(true)
+    useAppStore.setState((s) => ({
+      worktreesByRepo: {
+        'repo-1': [makeWorktree('a', 'A'), makeWorktree('b', 'B', { isArchived: true })]
+      },
+      sortEpoch: s.sortEpoch + 1
+    }))
+    expect(settled()).toBe(false)
+  })
+
+  it('clears a pending settle when the store is reset', () => {
+    useAppStore.setState({ sortBy: 'recent' })
+    bump()
+    expect(vi.getTimerCount()).toBe(1)
+    useAppStore.setState(initialState, true)
+    expect(vi.getTimerCount()).toBe(0)
+  })
+})
diff --git a/src/renderer/src/store/settled-sort-epoch.ts b/src/renderer/src/store/settled-sort-epoch.ts
new file mode 100644
index 00000000000..0e505aeae21
--- /dev/null
+++ b/src/renderer/src/store/settled-sort-epoch.ts
@@ -0,0 +1,64 @@
+/**
+ * Maintains `settledSortEpoch`: the sortEpoch the sidebar sort actually reads.
+ *
+ * Why in the store: the sidebar used to mirror sortEpoch into React state from an
+ * effect, adding a nested update per bump; bursts of flushSync bumps stacked those
+ * into "Maximum update depth exceeded" (React #185). A store listener sees every
+ * write path — slice actions and runtime patches such as the web session sync — so
+ * the settled value stays correct without any component mounted.
+ */
+import type { StoreApi } from 'zustand'
+import type { AppState } from './types'
+import { getIndexedAllWorktrees } from './worktree-repo-index'
+
+// Why: time-decaying scores would make rows jump on every bump; coalesce a burst into one re-sort.
+export const SORT_SETTLE_MS = 3_000
+
+function countLiveWorktrees(worktreesByRepo: AppState['worktreesByRepo']): number {
+  let count = 0
+  for (const worktree of getIndexedAllWorktrees(worktreesByRepo)) {
+    if (!worktree.isArchived) {
+      count++
+    }
+  }
+  return count
+}
+
+/** Call once from inside the store's state creator, passing its `api`. */
+export function installSettledSortEpoch(
+  api: Pick<StoreApi<AppState>, 'setState' | 'subscribe'>
+): void {
+  let timer: ReturnType<typeof setTimeout> | undefined
+  // Why a baseline from the last bump (not the previous write): a row change that skipped
+  // its bump (stale-host purge) must not re-sort on its own.
+  let liveWorktreeCountAtLastBump = 0
+
+  const settle = (): void => api.setState((s) => ({ settledSortEpoch: s.sortEpoch }))
+
+  api.subscribe((state, previous) => {
+    const epochChanged = state.sortEpoch !== previous.sortEpoch
+    let structuralChange = false
+    // Why also on row writes: a bump-less add during a pending window must still settle now.
+    if (epochChanged || state.worktreesByRepo !== previous.worktreesByRepo) {
+      const count = countLiveWorktrees(state.worktreesByRepo)
+      structuralChange = count !== liveWorktreeCountAtLastBump
+      if (epochChanged) {
+        liveWorktreeCountAtLastBump = count
+      }
+    }
+    if (state.settledSortEpoch === state.sortEpoch) {
+      // Why: any write that lands settled — settle() itself or a store reset — retires the pending timer.
+      clearTimeout(timer)
+      return
+    }
+    // Why: adds/removes, Manual (direct manipulation), and a mode switch never wait out the window.
+    if (structuralChange || state.sortBy === 'manual' || state.sortBy !== previous.sortBy) {
+      settle()
+      return
+    }
+    if (epochChanged) {
+      clearTimeout(timer)
+      timer = setTimeout(settle, SORT_SETTLE_MS)
+    }
+  })
+}
diff --git a/src/renderer/src/store/slices/editor-markdown-link-activation.test.ts b/src/renderer/src/store/slices/editor-markdown-link-activation.test.ts
index 005ac4b9972..f5d005c8e13 100644
--- a/src/renderer/src/store/slices/editor-markdown-link-activation.test.ts
+++ b/src/renderer/src/store/slices/editor-markdown-link-activation.test.ts
@@ -33,7 +33,6 @@ describe('createEditorSlice activateMarkdownLink', () => {
   const openUrlMock = vi.fn()
   const openFileUriMock = vi.fn()
   const pathExistsMock = vi.fn()
-  const authorizeExternalPathMock = vi.fn()
   const fsStatMock = vi.fn()
   const runtimeEnvironmentCallMock = vi.fn()
   const runtimeEnvironmentTransportCallMock = vi.fn()
@@ -45,7 +44,6 @@ describe('createEditorSlice activateMarkdownLink', () => {
     openFileUriMock.mockReset()
     pathExistsMock.mockReset()
     pathExistsMock.mockResolvedValue(true)
-    authorizeExternalPathMock.mockReset()
     fsStatMock.mockReset()
     fsStatMock.mockImplementation(async ({ filePath }: { filePath: string }) => {
       const exists = await pathExistsMock(filePath)
@@ -78,7 +76,6 @@ describe('createEditorSlice activateMarkdownLink', () => {
         pathExists: pathExistsMock
       },
       fs: {
-        authorizeExternalPath: authorizeExternalPathMock,
         stat: fsStatMock
       },
       runtimeEnvironments: {
@@ -558,14 +555,13 @@ describe('createEditorSlice activateMarkdownLink', () => {
     expect(openFileUriMock).not.toHaveBeenCalled()
   })
 
-  it('opens explicit file URLs outside the worktree in Orca after authorizing them', async () => {
+  it('opens explicit file URLs outside the worktree in Orca as user-named tabs', async () => {
     const store = createEditorStore()
     await store.getState().activateMarkdownLink('file:///tmp/image.png', {
       sourceFilePath: '/repo/docs/note.md',
       worktreeId: 'wt-1',
       worktreeRoot: '/repo'
     })
-    expect(authorizeExternalPathMock).toHaveBeenCalledWith({ targetPath: '/tmp/image.png' })
     expect(store.getState().openFiles).toEqual([
       expect.objectContaining({
         filePath: '/tmp/image.png',
@@ -621,7 +617,6 @@ describe('createEditorSlice activateMarkdownLink', () => {
       worktreeRoot: '/repo'
     })
 
-    expect(authorizeExternalPathMock).not.toHaveBeenCalled()
     expect(store.getState().openFiles).toEqual([])
     expect(toastErrorMock).toHaveBeenCalledWith(
       'Opening remote paths in the local OS is not available.'
diff --git a/src/renderer/src/store/slices/editor/actions/editor-draft-state.ts b/src/renderer/src/store/slices/editor/actions/editor-draft-state.ts
index dc650ab750a..c857af23713 100644
--- a/src/renderer/src/store/slices/editor/actions/editor-draft-state.ts
+++ b/src/renderer/src/store/slices/editor/actions/editor-draft-state.ts
@@ -10,6 +10,7 @@ export type EditorDraftState = {
   // Why: drafts live in the store (not a hidden mounted EditorPanel, #300) so the editor UI can unmount without losing edits.
   editorDrafts: Record<string, string>
   setEditorDraft: (fileId: string, content: string) => void
+  setCsvPreviewOnly: (fileId: string, enabled: boolean) => void
   clearEditorDraft: (fileId: string) => void
   clearEditorDrafts: (fileIds: string[]) => void
   markdownViewMode: Record<string, MarkdownViewMode>
@@ -32,6 +33,20 @@ export type EditorDraftState = {
 export function createEditorDraftState(set: EditorSet, _get: EditorGet): EditorDraftState {
   return {
     editorDrafts: {},
+    setCsvPreviewOnly: (fileId, enabled) =>
+      set((state) => {
+        const file = state.openFiles.find((candidate) => candidate.id === fileId)
+        if (!file || Boolean(file.csvPreviewOnly) === enabled) {
+          return state
+        }
+        return {
+          openFiles: state.openFiles.map((candidate) =>
+            candidate.id === fileId
+              ? { ...candidate, csvPreviewOnly: enabled || undefined }
+              : candidate
+          )
+        }
+      }),
     setEditorDraft: (fileId, content) =>
       set((s) => {
         if (s.editorDrafts[fileId] === content) {
@@ -39,7 +54,7 @@ export function createEditorDraftState(set: EditorSet, _get: EditorGet): EditorD
         }
         // Why: read-only tabs must never accrue a draft — it seeds dirty/autosave/hot-exit restore that could overwrite an agent transcript.
         const file = s.openFiles.find((f) => f.id === fileId)
-        if (file?.readOnly === true) {
+        if (file?.readOnly === true || file?.csvPreviewOnly === true) {
           return s
         }
         return { editorDrafts: { ...s.editorDrafts, [fileId]: content } }
diff --git a/src/renderer/src/store/slices/editor/actions/markdown-link-action.ts b/src/renderer/src/store/slices/editor/actions/markdown-link-action.ts
index 17af9ca5211..435173e0e98 100644
--- a/src/renderer/src/store/slices/editor/actions/markdown-link-action.ts
+++ b/src/renderer/src/store/slices/editor/actions/markdown-link-action.ts
@@ -86,8 +86,6 @@ export function createMarkdownLinkAction(
             showLocalPathOpenBlockedToast()
             return
           }
-          // Why: markdown file:// links need the same user-gesture authorization terminal links get, so external paths (e.g. /tmp screenshots) can open in Orca.
-          await window.api.fs.authorizeExternalPath({ targetPath: target.absolutePath })
         } else {
           let stats: { isDirectory: boolean }
           try {
diff --git a/src/renderer/src/store/slices/editor/actions/open-file-mutations.ts b/src/renderer/src/store/slices/editor/actions/open-file-mutations.ts
index 2d69a7a6261..853a14e77fe 100644
--- a/src/renderer/src/store/slices/editor/actions/open-file-mutations.ts
+++ b/src/renderer/src/store/slices/editor/actions/open-file-mutations.ts
@@ -76,7 +76,7 @@ export function createOpenFileMutations(
           return s
         }
         // Why: read-only tabs can never become dirty; hard no-op any stray change/save callback that reached here.
-        if (file.readOnly === true) {
+        if (file.readOnly === true || file.csvPreviewOnly === true) {
           return s
         }
         const needsPreviewClear = dirty && file.isPreview
diff --git a/src/renderer/src/store/slices/editor/types/open-file.ts b/src/renderer/src/store/slices/editor/types/open-file.ts
index b9c43a33bf8..0f096127b29 100644
--- a/src/renderer/src/store/slices/editor/types/open-file.ts
+++ b/src/renderer/src/store/slices/editor/types/open-file.ts
@@ -142,6 +142,8 @@ export type OpenFile = {
   mirroredFromRuntimeSession?: boolean
   /** Why: orthogonal to `mode` — an edit-mode tab that must never accept edits/autosave/rename (AI Vault View Log). Persisted only when true. */
   readOnly?: boolean
+  /** Transient: paged CSV data must never become an editable buffer. */
+  csvPreviewOnly?: boolean
   /** Why: explicit live tail, only meaningful for a read-only local log. */
   liveTail?: boolean
   mode: 'edit' | 'diff' | 'conflict-review' | 'markdown-preview' | 'check-details'
diff --git a/src/renderer/src/store/slices/jira-connection-actions.ts b/src/renderer/src/store/slices/jira-connection-actions.ts
index 635b1a6a9cf..8eab27c758e 100644
--- a/src/renderer/src/store/slices/jira-connection-actions.ts
+++ b/src/renderer/src/store/slices/jira-connection-actions.ts
@@ -1,3 +1,4 @@
+import { shallow } from 'zustand/shallow'
 import {
   jiraConnect,
   jiraDisconnect,
@@ -39,9 +40,12 @@ function hasJiraStatusChanged(
   return (
     previous.connected !== next.connected ||
     previous.credentialError !== next.credentialError ||
-    previous.viewer?.email !== next.viewer?.email ||
+    previous.credentialProtection !== next.credentialProtection ||
+    previous.activeSiteId !== next.activeSiteId ||
+    !shallow(previous.viewer, next.viewer) ||
     getSelectedJiraSiteId(previous) !== getSelectedJiraSiteId(next) ||
-    (previous.sites?.length ?? 0) !== (next.sites?.length ?? 0)
+    (previous.sites?.length ?? 0) !== (next.sites?.length ?? 0) ||
+    (previous.sites ?? []).some((site, index) => !shallow(site, next.sites?.[index]))
   )
 }
 
@@ -67,12 +71,10 @@ export function createJiraConnectionActions(
           return
         }
         const previous = get().jiraStatus
-        if (hasJiraStatusChanged(previous, status)) {
+        if (get().jiraStatusContextKey !== contextKey || hasJiraStatusChanged(previous, status)) {
           set((state) => jiraStatusUpdate(state, contextKey, status))
         } else if (!get().jiraStatusChecked) {
           set({ jiraStatusChecked: true, jiraStatusContextKey: contextKey })
-        } else if (get().jiraStatusContextKey !== contextKey) {
-          set({ jiraStatusContextKey: contextKey })
         }
       } catch {
         if (
diff --git a/src/renderer/src/store/slices/jira-connection-identity.test.ts b/src/renderer/src/store/slices/jira-connection-identity.test.ts
new file mode 100644
index 00000000000..8540953ec44
--- /dev/null
+++ b/src/renderer/src/store/slices/jira-connection-identity.test.ts
@@ -0,0 +1,81 @@
+import { create } from 'zustand'
+import { beforeEach, expect, it, vi } from 'vitest'
+import type { AppState } from '../types'
+import type { JiraConnectionStatus } from '../../../../shared/jira-types'
+import { createJiraSlice } from './jira'
+
+const jiraStatus = vi.hoisted(() => vi.fn())
+vi.mock('@/runtime/runtime-jira-client', () => ({ jiraStatus }))
+
+function createTestStore() {
+  return create<AppState>()((...args) => {
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: Connection reads use only settings and the fully initialized Jira slice.
+    return { settings: null, ...createJiraSlice(...args) } as AppState
+  })
+}
+
+function status(accountId: string): JiraConnectionStatus {
+  return {
+    connected: true,
+    viewer: { accountId, email: 'same@example.com', displayName: 'Same name' },
+    selectedSiteId: 'all',
+    activeSiteId: 'site-a',
+    sites: [
+      {
+        id: 'site-a',
+        accountId,
+        email: 'same@example.com',
+        displayName: 'Same name',
+        siteUrl: 'https://jira.example'
+      }
+    ]
+  }
+}
+
+beforeEach(() => jiraStatus.mockReset())
+
+it('replaces status when the provider context changes even if its visible values are identical', async () => {
+  const store = createTestStore()
+  const previous = status('account-a')
+  const next = status('account-a')
+  store.setState({
+    jiraStatus: previous,
+    jiraStatusChecked: true,
+    jiraStatusContextKey: 'old-host'
+  })
+  jiraStatus.mockResolvedValue(next)
+  await store.getState().checkJiraConnection()
+  expect(store.getState().jiraStatus).toBe(next)
+  expect(store.getState().jiraStatusContextKey).toBe('local#0')
+})
+
+it.each(['viewer', 'site', 'active site'] as const)(
+  'refreshes a changed %s identity on the same host',
+  async (change) => {
+    const store = createTestStore()
+    jiraStatus.mockResolvedValueOnce(status('account-a'))
+    await store.getState().checkJiraConnection()
+    const next = status('account-a')
+    if (change === 'viewer') {
+      next.viewer = { accountId: 'account-b', email: 'same@example.com', displayName: 'Same name' }
+    }
+    if (change === 'site') {
+      next.sites = status('account-b').sites
+    }
+    if (change === 'active site') {
+      next.activeSiteId = 'site-b'
+    }
+    jiraStatus.mockResolvedValueOnce(next)
+    await store.getState().checkJiraConnection()
+    expect(store.getState().jiraStatus).toBe(next)
+  }
+)
+
+it('preserves the status reference for an unchanged identity on the same host', async () => {
+  const store = createTestStore()
+  const initial = status('account-a')
+  jiraStatus.mockResolvedValueOnce(initial).mockResolvedValueOnce(status('account-a'))
+  await store.getState().checkJiraConnection()
+  await store.getState().checkJiraConnection()
+  expect(store.getState().jiraStatus).toBe(initial)
+})
diff --git a/src/renderer/src/store/slices/ui-agent-send-target.test.ts b/src/renderer/src/store/slices/ui-agent-send-target.test.ts
index 61f98a2afba..6d49bb1baa5 100644
--- a/src/renderer/src/store/slices/ui-agent-send-target.test.ts
+++ b/src/renderer/src/store/slices/ui-agent-send-target.test.ts
@@ -282,6 +282,7 @@ describe('createUISlice agent send target mode', () => {
   it('sends to the live leaf PTY, runs delivery callback, tracks followup, and closes', async () => {
     const store = createAgentSendStore()
     const onPromptDelivered = vi.fn()
+    const onPromptHandedOff = vi.fn()
     seedAgentSendState(store)
     store.getState().openAgentSendPopoverTargetMode({
       id: 'send-1',
@@ -290,11 +291,16 @@ describe('createUISlice agent send target mode', () => {
       prompt: 'Review this',
       label: 'All unsent notes',
       launchSource: 'notes_send',
-      onPromptDelivered
+      onPromptDelivered,
+      onPromptHandedOff
     })
 
     await expect(store.getState().sendPromptToSidebarAgentTarget(readyPaneKey)).resolves.toBe(true)
 
+    // The notes leave the next send for exactly this send's lifetime.
+    expect(onPromptHandedOff).toHaveBeenCalledOnce()
+    await expect(onPromptHandedOff.mock.calls[0][0]).resolves.toMatchObject({ status: 'sent' })
+
     expect(mocks.sendNotesToActiveAgentSession).toHaveBeenCalledWith({
       worktreeId,
       prompt: 'Review this',
@@ -400,6 +406,26 @@ describe('createUISlice agent send target mode', () => {
     expect(mocks.toastSuccess).toHaveBeenCalledWith('Sent to Claude')
   })
 
+  it('sends nothing to a sidebar agent when every note is already on its way', async () => {
+    const store = createAgentSendStore()
+    const onPromptHandedOff = vi.fn()
+    seedAgentSendState(store)
+    store.getState().openAgentSendPopoverTargetMode({
+      id: 'send-1',
+      worktreeId,
+      source: 'diff-notes',
+      prompt: '',
+      label: 'All unsent notes',
+      launchSource: 'notes_send',
+      onPromptHandedOff
+    })
+
+    await expect(store.getState().sendPromptToSidebarAgentTarget(readyPaneKey)).resolves.toBe(false)
+
+    expect(mocks.sendNotesToActiveAgentSession).not.toHaveBeenCalled()
+    expect(onPromptHandedOff).not.toHaveBeenCalled()
+  })
+
   it('keeps target mode open and does not run delivery callback when send fails', async () => {
     const store = createAgentSendStore()
     const onPromptDelivered = vi.fn()
diff --git a/src/renderer/src/store/slices/ui/ui-slice-agent-actions.ts b/src/renderer/src/store/slices/ui/ui-slice-agent-actions.ts
index 8beecf0e12d..7af82053993 100644
--- a/src/renderer/src/store/slices/ui/ui-slice-agent-actions.ts
+++ b/src/renderer/src/store/slices/ui/ui-slice-agent-actions.ts
@@ -120,7 +120,8 @@ export function createUiAgentActions(
       }),
     sendPromptToSidebarAgentTarget: async (paneKey) => {
       const mode = get().agentSendPopoverTargetMode
-      if (!mode || mode.status === 'sending') {
+      // An empty prompt has nothing to send: every note may already be on its way.
+      if (!mode || mode.status === 'sending' || !mode.prompt.trim()) {
         return false
       }
 
@@ -154,7 +155,7 @@ export function createUiAgentActions(
         import('@/lib/active-agent-note-send'),
         import('@/lib/agent-message-send')
       ])
-      const result = await sendMessageToAgent({
+      const sending = sendMessageToAgent({
         worktreeId: mode.worktreeId,
         prompt: mode.prompt,
         target: runningAgentMessageTarget(target)
@@ -164,6 +165,8 @@ export function createUiAgentActions(
         })
         return { status: 'status-unavailable' as const, code: 'runtime-unverifiable' as const }
       })
+      mode.onPromptHandedOff?.(sending)
+      const result = await sending
 
       const stillCurrent = (): boolean => {
         const current = get().agentSendPopoverTargetMode
diff --git a/src/renderer/src/store/slices/ui/ui-slice-contract-core.ts b/src/renderer/src/store/slices/ui/ui-slice-contract-core.ts
index ffb37c40a01..5d187bcf788 100644
--- a/src/renderer/src/store/slices/ui/ui-slice-contract-core.ts
+++ b/src/renderer/src/store/slices/ui/ui-slice-contract-core.ts
@@ -39,6 +39,8 @@ export type AgentSendPopoverTargetMode = {
   sendingPaneKey?: string
   error?: string
   onPromptDelivered?: () => void
+  /** Told the send's own result the moment the prompt is handed to an agent. */
+  onPromptHandedOff?: (delivered: Promise<unknown>) => void
 }
 
 export type OpenAgentSendPopoverTargetModeArgs = {
@@ -49,6 +51,7 @@ export type OpenAgentSendPopoverTargetModeArgs = {
   label: string
   launchSource: LaunchSource
   onPromptDelivered?: () => void
+  onPromptHandedOff?: (delivered: Promise<unknown>) => void
 }
 
 export type TaskPageData = {
diff --git a/src/renderer/src/store/slices/worktree-helpers.ts b/src/renderer/src/store/slices/worktree-helpers.ts
index 23edda5d982..3d24fe69cd6 100644
--- a/src/renderer/src/store/slices/worktree-helpers.ts
+++ b/src/renderer/src/store/slices/worktree-helpers.ts
@@ -132,6 +132,8 @@ export type WorktreeSlice = {
    * — NOT by selection-triggered side-effects like clearing `isUnread`.
    */
   sortEpoch: number
+  /** sortEpoch after the settle window; the sidebar sort reads this (see store/settled-sort-epoch.ts). */
+  settledSortEpoch: number
   /**
    * Worktree IDs that have been activated at least once during this app
    * session. The first activation of a worktree is special: its
diff --git a/src/renderer/src/store/slices/worktrees-create-captured-host.test.ts b/src/renderer/src/store/slices/worktrees-create-captured-host.test.ts
new file mode 100644
index 00000000000..c65b67aaeec
--- /dev/null
+++ b/src/renderer/src/store/slices/worktrees-create-captured-host.test.ts
@@ -0,0 +1,98 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { getDefaultSettings } from '../../../../shared/constants'
+import type { ExecutionHostId } from '../../../../shared/execution-host'
+import { makeWorktree } from './worktrees-slice-test-fixtures'
+import {
+  createTestStore,
+  mockApi,
+  resetRemoteRuntimeMocks,
+  resetWorktreeSliceModuleMemory,
+  runtimeEnvironmentCall
+} from './worktrees-slice-test-harness'
+
+vi.mock('sonner', () => ({
+  toast: { warning: vi.fn(), info: vi.fn(), success: vi.fn(), error: vi.fn(), dismiss: vi.fn() }
+}))
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  resetRemoteRuntimeMocks()
+  resetWorktreeSliceModuleMemory()
+})
+
+describe('background creation host capture', () => {
+  it.each<ExecutionHostId>(['local', 'ssh:remote-1', 'runtime:env-1'])(
+    'keeps %s as the owner after focus moves to another runtime',
+    async (executionHostId) => {
+      const store = createTestStore()
+      const worktree = makeWorktree({
+        id: 'repo1::/path/feature',
+        repoId: 'repo1',
+        path: '/path/feature'
+      })
+      mockApi.worktrees.create.mockResolvedValue({ worktree })
+      runtimeEnvironmentCall.mockResolvedValue({
+        id: 'create',
+        ok: true,
+        result: { worktree },
+        _meta: { runtimeId: 'runtime-remote' }
+      })
+      store.setState({
+        settings: { ...getDefaultSettings('/tmp'), activeRuntimeEnvironmentId: 'env-other' },
+        repos: [],
+        worktreesByRepo: { repo1: [] }
+      })
+      const createWorktree = store.getState().createWorktree
+      const args: Parameters<typeof createWorktree> = ['repo1', 'feature']
+      const options = { executionHostId, nameWasGenerated: false }
+      args[25] = options
+      await createWorktree(...args)
+      if (executionHostId === 'runtime:env-1') {
+        expect(runtimeEnvironmentCall).toHaveBeenCalledWith(
+          expect.objectContaining({
+            selector: 'env-1',
+            method: 'worktree.create'
+          })
+        )
+        expect(mockApi.worktrees.create).not.toHaveBeenCalled()
+        expect(store.getState().worktreesByRepo.repo1[0]).toMatchObject({
+          hostId: executionHostId,
+          runtimeOwnerEnvironmentId: 'env-1'
+        })
+      } else {
+        expect(mockApi.worktrees.create).toHaveBeenCalledOnce()
+        expect(runtimeEnvironmentCall).not.toHaveBeenCalled()
+        expect(store.getState().worktreesByRepo.repo1[0].runtimeOwnerEnvironmentId).toBeUndefined()
+      }
+    }
+  )
+  it('retains the selected owner when focus changes while creation is running', async () => {
+    const store = createTestStore()
+    const response = Promise.withResolvers<unknown>()
+    runtimeEnvironmentCall.mockReturnValue(response.promise)
+    store.setState({
+      settings: { ...getDefaultSettings('/tmp'), activeRuntimeEnvironmentId: 'env-1' },
+      repos: [],
+      worktreesByRepo: { repo1: [] }
+    })
+    const createWorktree = store.getState().createWorktree
+    const args: Parameters<typeof createWorktree> = ['repo1', 'feature']
+    args[25] = { executionHostId: 'runtime:env-1' }
+    const creating = createWorktree(...args)
+    await vi.waitFor(() => expect(runtimeEnvironmentCall).toHaveBeenCalled())
+    store.setState({
+      settings: { ...getDefaultSettings('/tmp'), activeRuntimeEnvironmentId: 'env-other' }
+    })
+    response.resolve({
+      id: 'create',
+      ok: true,
+      result: { worktree: makeWorktree({ id: 'repo1::/path/feature', repoId: 'repo1' }) },
+      _meta: { runtimeId: 'runtime-remote' }
+    })
+    await creating
+    expect(store.getState().worktreesByRepo.repo1[0]).toMatchObject({
+      hostId: 'runtime:env-1',
+      runtimeOwnerEnvironmentId: 'env-1'
+    })
+  })
+})
diff --git a/src/renderer/src/store/slices/worktrees/create/create-worktree.ts b/src/renderer/src/store/slices/worktrees/create/create-worktree.ts
index b4f8bc75bc8..682660295c5 100644
--- a/src/renderer/src/store/slices/worktrees/create/create-worktree.ts
+++ b/src/renderer/src/store/slices/worktrees/create/create-worktree.ts
@@ -1,3 +1,6 @@
+import { runtimeTargetForExecutionHostId } from '@/runtime/runtime-client-target'
+import { repoHostId } from '../listing/worktree-host-ownership'
+import { toRuntimeExecutionHostId } from '../../../../../../shared/execution-host'
 import type { WorktreeSlice } from '../../worktree-helpers'
 import type { WorktreeSliceGet, WorktreeSliceSet } from '../listing/worktree-slice-types'
 import type { CreateWorktreeResult } from '../../../../../../shared/worktree/create-types'
@@ -169,7 +172,15 @@ export function createCreateWorktree(
       }
       // Why: manual sort is user-authored order; stamp new workspaces at the top rather than relying on sortOrder fallback.
       const manualOrder = get().sortBy === 'manual' ? Date.now() : undefined
-      const target = getActiveRuntimeTarget(settingsForRepoOwner(get(), repoId))
+      // Direct SSH still uses desktop IPC; paired runtimes use their captured environment.
+      const target = options?.executionHostId
+        ? (runtimeTargetForExecutionHostId(options.executionHostId) ?? { kind: 'local' as const })
+        : getActiveRuntimeTarget(settingsForRepoOwner(get(), repoId))
+      const creationHostId =
+        options?.executionHostId ??
+        (target.kind === 'environment'
+          ? toRuntimeExecutionHostId(target.environmentId)
+          : repoHostId(get(), repoId))
       if (
         target.kind === 'environment' &&
         (options?.linkedWorkItem?.provider === 'jira' ||
@@ -204,7 +215,7 @@ export function createCreateWorktree(
           if (lostRequestedParent(outcome, parent, target)) {
             warnParentDroppedOnce()
           }
-          applyCreatedWorktree(set, repoId, outcome.result)
+          applyCreatedWorktree(set, repoId, outcome.result, creationHostId)
           const { result } = outcome
           showLocalBaseRefRefreshToast(result.localBaseRefRefresh, result.worktree)
           if (result.baseFallback) {
diff --git a/src/renderer/src/store/slices/worktrees/create/created-worktree-state-merge.ts b/src/renderer/src/store/slices/worktrees/create/created-worktree-state-merge.ts
index e7ab191bdd9..58eade55730 100644
--- a/src/renderer/src/store/slices/worktrees/create/created-worktree-state-merge.ts
+++ b/src/renderer/src/store/slices/worktrees/create/created-worktree-state-merge.ts
@@ -1,3 +1,4 @@
+import type { ExecutionHostId } from '../../../../../../shared/execution-host'
 import type { WorktreeSliceSet } from '../listing/worktree-slice-types'
 import { appliedWorktreeCatalogVersionPatch } from '../listing/worktree-catalog-version-state'
 import type { CreateWorktreeResult } from '../../../../../../shared/worktree/create-types'
@@ -11,11 +12,12 @@ import {
 export function applyCreatedWorktree(
   set: WorktreeSliceSet,
   repoId: string,
-  result: CreateWorktreeResult
+  result: CreateWorktreeResult,
+  executionHostId?: ExecutionHostId
 ) {
   // Why: worktrees.onChanged can add this worktree before this callback runs; appending blindly would duplicate it (React key clash).
   set((s) => {
-    const hostId = repoHostId(s, repoId)
+    const hostId = executionHostId ?? repoHostId(s, repoId)
     const createdWorktree = withRepoHostOwnership(
       result.worktree,
       hostId,
diff --git a/src/renderer/src/store/slices/worktrees/create/worktree-create-payload.ts b/src/renderer/src/store/slices/worktrees/create/worktree-create-payload.ts
index 9f8407ae3a3..4ea9232927c 100644
--- a/src/renderer/src/store/slices/worktrees/create/worktree-create-payload.ts
+++ b/src/renderer/src/store/slices/worktrees/create/worktree-create-payload.ts
@@ -6,6 +6,8 @@ import type { WorkspaceLinkedItem } from '../../../../../../shared/worktree/type
 
 /** Trailing bag for `createWorktree` args that outgrew its positional list. */
 export type CreateWorktreeCallOptions = {
+  /** Captured before background preparation so navigation cannot retarget creation. */
+  executionHostId?: ExecutionHostId
   automationProvenanceRequest?: CreateWorktreeArgs['automationProvenanceRequest']
   linkedWorkItem?: WorkspaceLinkedItem | null
   linkedTaskSourceContext?: TaskSourceContext | null
diff --git a/src/renderer/src/store/slices/worktrees/session/worktree-slice-initial-state.ts b/src/renderer/src/store/slices/worktrees/session/worktree-slice-initial-state.ts
index 77e90b1a12e..c1683af84c3 100644
--- a/src/renderer/src/store/slices/worktrees/session/worktree-slice-initial-state.ts
+++ b/src/renderer/src/store/slices/worktrees/session/worktree-slice-initial-state.ts
@@ -17,6 +17,7 @@ export const worktreeSliceInitialState: Pick<
   | 'baseStatusByWorktreeId'
   | 'remoteBranchConflictByWorktreeId'
   | 'sortEpoch'
+  | 'settledSortEpoch'
   | 'everActivatedWorktreeIds'
   | 'lastVisitedAtByWorktreeId'
   | 'hasHydratedWorktreePurge'
@@ -37,6 +38,7 @@ export const worktreeSliceInitialState: Pick<
   baseStatusByWorktreeId: {},
   remoteBranchConflictByWorktreeId: {},
   sortEpoch: 0,
+  settledSortEpoch: 0,
   everActivatedWorktreeIds: new Set<string>(),
   lastVisitedAtByWorktreeId: {},
   hasHydratedWorktreePurge: false,
diff --git a/src/renderer/src/web/preload-api/web-filesystem-api.ts b/src/renderer/src/web/preload-api/web-filesystem-api.ts
index 889e89b5103..a393e12fa46 100644
--- a/src/renderer/src/web/preload-api/web-filesystem-api.ts
+++ b/src/renderer/src/web/preload-api/web-filesystem-api.ts
@@ -22,6 +22,15 @@ import { noopUnsubscribe } from './web-storage'
 
 export function createFileApi(): NonNullable<Partial<PreloadApi>['fs']> {
   return {
+    readFileChunk: async ({ filePath, offset, length }) => {
+      const file = await resolveRuntimeFilePath(filePath)
+      return callRuntimeResult('files.readChunk', {
+        worktree: toRuntimeWorktreeSelector(file.worktree.id),
+        relativePath: file.relativePath,
+        offset,
+        length
+      })
+    },
     readDir: async ({ dirPath }) => {
       const file = await resolveRuntimeFilePath(dirPath)
       return callRuntimeResult<DirEntry[]>('files.readDir', {
@@ -74,7 +83,6 @@ export function createFileApi(): NonNullable<Partial<PreloadApi>['fs']> {
     ...createWebFileMutationMethods({
       captureSession: captureWebFileMutationSession
     }),
-    authorizeExternalPath: () => Promise.resolve(),
     stat: async ({ filePath }) => {
       const file = await resolveRuntimeFilePath(filePath)
       return callRuntimeResult('files.stat', {
diff --git a/src/shared/agent-node-entrypoint-identities.ts b/src/shared/agent-node-entrypoint-identities.ts
index fb4327c076f..efc52cef2b3 100644
--- a/src/shared/agent-node-entrypoint-identities.ts
+++ b/src/shared/agent-node-entrypoint-identities.ts
@@ -17,7 +17,7 @@ export const EXACT_NODE_ENTRYPOINT_IDENTITIES: readonly {
   // Why: Pi's npm shim launches a generic cli.js; only the exact package path is authoritative.
   {
     pattern:
-      /(?:^|\/)node_modules\/@(?:earendil-works|mariozechner)\/pi-coding-agent\/dist\/cli\.js$/,
+      /(?:^|\/)node_modules\/@(?:earendil-works|mariozechner)\/pi-coding-agent\/dist\/(?:bundle\/)?cli\.js$/,
     agent: 'pi',
     processName: 'pi'
   },
diff --git a/src/shared/agent-process-recognition.test.ts b/src/shared/agent-process-recognition.test.ts
index 3c275cb2d69..acb96e173c5 100644
--- a/src/shared/agent-process-recognition.test.ts
+++ b/src/shared/agent-process-recognition.test.ts
@@ -405,12 +405,38 @@ describe('agent process recognition', () => {
     ).toEqual({ agent: 'gemini', processName: 'gemini' })
   })
 
-  it.each(['earendil-works', 'mariozechner'])('recognizes the @%s Pi npm entrypoint', (scope) => {
-    expect(
-      recognizeAgentProcessFromCommandLine(
-        String.raw`node.exe C:\Users\dev\AppData\Roaming\npm\node_modules\@${scope}\pi-coding-agent\dist\cli.js`
-      )
-    ).toEqual({ agent: 'pi', processName: 'pi' })
+  it.each([
+    ['earendil-works', 'cli.js'],
+    ['earendil-works', 'bundle/cli.js'],
+    ['mariozechner', 'cli.js'],
+    ['mariozechner', 'bundle/cli.js']
+  ])('recognizes the @%s Pi npm entrypoint at dist/%s', (scope, entrypoint) => {
+    const windowsEntrypoint = entrypoint.replace('/', '\\')
+    const windowsPath = `C:\\Users\\Dev User\\AppData\\Roaming\\npm\\node_modules\\@${scope}\\pi-coding-agent\\dist\\${windowsEntrypoint}`
+    for (const command of [
+      `node /usr/local/lib/node_modules/@${scope}/pi-coding-agent/dist/${entrypoint}`,
+      `node.exe ${windowsPath.replace('Dev User', 'dev')}`,
+      String.raw`"C:\Program Files\nodejs\node.exe" "${windowsPath}"`
+    ]) {
+      expect(recognizeAgentProcessFromCommandLine(command)).toEqual({
+        agent: 'pi',
+        processName: 'pi'
+      })
+    }
+  })
+
+  it.each([
+    'node /tmp/dist/bundle/cli.js',
+    'node /tmp/node_modules/@other/pi-coding-agent/dist/bundle/cli.js',
+    'node /tmp/node_modules/@earendil-works/not-pi-coding-agent/dist/bundle/cli.js',
+    'node /tmp/notnode_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js',
+    'node /tmp/node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js.extra',
+    'node /tmp/node_modules/@earendil-works/pi-coding-agent/dist/bundle/nested/cli.js',
+    'node /tmp/server.js /tmp/node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js',
+    'node --require /tmp/node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js /tmp/server.js',
+    'node --eval "console.log(1)" /tmp/node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js'
+  ])('does not recognize a Pi entrypoint lookalike or argument: %s', (command) => {
+    expect(recognizeAgentProcessFromCommandLine(command)).toBeNull()
   })
 
   it('recognizes Prime Agent by its binary and npm entrypoint', () => {
diff --git a/src/shared/agent-process-recognition.ts b/src/shared/agent-process-recognition.ts
index b9a5620f6df..45c28f67966 100644
--- a/src/shared/agent-process-recognition.ts
+++ b/src/shared/agent-process-recognition.ts
@@ -171,7 +171,8 @@ export function isExpectedAgentProcess(
     normalizedProcess.startsWith(`${normalizedExpected}.`) ||
     (['qoderclicn', 'qodercn'].includes(normalizedExpected) &&
       /^(?:qoderclicn|qodercn)(?:-\d.*)?$/.test(normalizedProcess)) ||
-    (normalizedExpected === 'qodercli' && /^qodercli-\d/.test(normalizedProcess)) ||
+    (['qoder', 'qodercli'].includes(normalizedExpected) &&
+      /^(?:qoder|qodercli(?:-\d.*)?)$/.test(normalizedProcess)) ||
     (normalizedExpected === 'muse' && normalizedProcess.startsWith('muse-bin-'))
   )
 }
@@ -200,6 +201,10 @@ export function recognizeAgentProcessFromCommandLine(
   const tokens = tokenizeCommandLine(commandLine)
   const firstNormalized = normalizeProcessName(tokens[0])
   let direct = recognizedAgentForProcess(firstNormalized)
+  // Qoder's public dispatcher routes these commands to the IDE rather than the agent CLI.
+  if (firstNormalized === 'qoder' && tokens[1] && !tokens[1].startsWith('-')) {
+    return null
+  }
   // Why: the generic Orca CLI is not an agent; only this subcommand launches its TUI mode.
   if (direct?.agent === 'claude-agent-teams' && tokens[1]?.toLowerCase() !== 'claude-teams') {
     direct = null
diff --git a/src/shared/agent-session-conversation-outline.ts b/src/shared/agent-session-conversation-outline.ts
index 2b6bb846adb..4d6b814d64d 100644
--- a/src/shared/agent-session-conversation-outline.ts
+++ b/src/shared/agent-session-conversation-outline.ts
@@ -89,7 +89,8 @@ export function projectAgentSessionConversationOutline(
   }
   const entries: AgentSessionConversationOutlineEntry[] = []
   const transcript = projectNativeChatTranscriptMessages(
-    projectStructuredAgentSessionMessages(items, [], submissions)
+    // Unchanged on the wire: a desktop's rejected rows tick once their page is loaded.
+    projectStructuredAgentSessionMessages(items, [], submissions, { rejectedInPlace: false })
   )
   for (const message of transcript) {
     const sequence = sequences.get(message.id)
diff --git a/src/shared/agent-session-option-agent-args.ts b/src/shared/agent-session-option-agent-args.ts
index eed4f1ec3ed..e75577f473f 100644
--- a/src/shared/agent-session-option-agent-args.ts
+++ b/src/shared/agent-session-option-agent-args.ts
@@ -1,4 +1,67 @@
 import { findOptionOccurrence } from './command-option-occurrence'
+import type { AgentType } from './agent-status-types'
+
+// Required values consume dash-leading text; boolean and optional-valued options are excluded.
+// Codex (clap) and OpenCode (yargs) never take a dash-leading value, so they have no entry.
+const VALUE_OPTIONS: Partial<Record<AgentType, readonly string[]>> = {
+  claude: [
+    '--add-dir',
+    '--agent',
+    '--agents',
+    '--allowedTools',
+    '--allowed-tools',
+    '--append-system-prompt',
+    '--append-system-prompt-file',
+    '--autocompact',
+    '--betas',
+    '--debug-file',
+    '--disallowedTools',
+    '--disallowed-tools',
+    '--effort',
+    '--environment',
+    '--fallback-model',
+    '--file',
+    '--input-format',
+    '--json-schema',
+    '--max-budget-usd',
+    '--mcp-config',
+    '--model',
+    '-n',
+    '--name',
+    '--output-format',
+    '--permission-mode',
+    '--permission-prompts',
+    '--plugin-dir',
+    '--plugin-url',
+    '--remote-control-session-name-prefix',
+    '--session-id',
+    '--setting-sources',
+    '--settings',
+    '--system-prompt',
+    '--system-prompt-file',
+    '--system-prompt-snapshot',
+    '--tools'
+  ],
+  cursor: [
+    '--api-key',
+    '-H',
+    '--header',
+    '-e',
+    '--endpoint',
+    '--output-format',
+    '--mode',
+    '--model',
+    '--sandbox',
+    '--workspace',
+    '--add-dir',
+    '--plugin-dir',
+    '--worktree-base'
+  ]
+}
+
+export function agentArgTerminatorIndex(agent: AgentType, tokens: readonly string[]): number {
+  return findOptionOccurrence(tokens, ['--'], false, VALUE_OPTIONS[agent])?.index ?? tokens.length
+}
 
 export function agentArgOptionTokens(tokens: readonly string[]): readonly string[] {
   const terminator = tokens.indexOf('--')
@@ -7,18 +70,19 @@ export function agentArgOptionTokens(tokens: readonly string[]): readonly string
 
 /** Removes each occurrence before `--`, or only those whose value `matchesValue` accepts. */
 export function removeAgentArgOption(
+  agent: AgentType,
   tokens: readonly string[],
   aliases: readonly string[],
   matchesValue: (value: string | undefined) => boolean = () => true
 ): string[] {
   const kept: string[] = []
   let rest = tokens
-  let found = findOptionOccurrence(rest, aliases, true)
+  let found = findOptionOccurrence(rest, aliases, true, VALUE_OPTIONS[agent])
   while (found) {
     const end = found.index + found.consumed
     kept.push(...rest.slice(0, matchesValue(found.value) ? found.index : end))
     rest = rest.slice(end)
-    found = findOptionOccurrence(rest, aliases, true)
+    found = findOptionOccurrence(rest, aliases, true, VALUE_OPTIONS[agent])
   }
   return [...kept, ...rest]
 }
diff --git a/src/shared/agent-session-option-catalog-antigravity.ts b/src/shared/agent-session-option-catalog-antigravity.ts
index a2078c963d8..c5cb658bd23 100644
--- a/src/shared/agent-session-option-catalog-antigravity.ts
+++ b/src/shared/agent-session-option-catalog-antigravity.ts
@@ -16,7 +16,7 @@ const ANTIGRAVITY_EFFORT: CatalogOption = {
   },
   apply: {
     launchArgs: (value) => ['--effort', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--effort']),
+    removeAgentArgs: (tokens) => removeAgentArgOption('antigravity', tokens, ['--effort']),
     midSession: { kind: 'command', build: (value) => `/effort ${String(value)}` }
   }
 }
@@ -27,7 +27,7 @@ export const ANTIGRAVITY_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   models: [],
   modelApply: {
     launchArgs: (value) => ['--model', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--model']),
+    removeAgentArgs: (tokens) => removeAgentArgOption('antigravity', tokens, ['--model']),
     midSession: { kind: 'agent-picker', command: '/model' }
   },
   unknownModelOptions: [ANTIGRAVITY_EFFORT]
diff --git a/src/shared/agent-session-option-catalog-claude-codex.ts b/src/shared/agent-session-option-catalog-claude-codex.ts
index 9fb27d3a97f..9cc7cfb1fa9 100644
--- a/src/shared/agent-session-option-catalog-claude-codex.ts
+++ b/src/shared/agent-session-option-catalog-claude-codex.ts
@@ -17,7 +17,8 @@ function removeCodexAgentArgs(
   configKey: string
 ): string[] {
   return removeAgentArgOption(
-    removeAgentArgOption(tokens, flags),
+    'codex',
+    removeAgentArgOption('codex', tokens, flags),
     ['-c', '--config'],
     (value) => value?.startsWith(`${configKey}=`) === true
   )
@@ -53,7 +54,7 @@ function claudeEffortWithChoices(choices: typeof EXTENDED_EFFORT_CHOICES): Catal
     },
     apply: {
       launchArgs: (value) => ['--effort', String(value)],
-      removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--effort']),
+      removeAgentArgs: (tokens) => removeAgentArgOption('claude', tokens, ['--effort']),
       midSession: { kind: 'command', build: (value) => `/effort ${String(value)}` }
     }
   }
@@ -130,7 +131,7 @@ export const CLAUDE_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   ],
   modelApply: {
     launchArgs: (value) => ['--model', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--model']),
+    removeAgentArgs: (tokens) => removeAgentArgOption('claude', tokens, ['--model']),
     midSession: {
       kind: 'command',
       build: (value) => `/model ${String(value)}`,
@@ -200,5 +201,7 @@ export const CODEX_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
     // command and let its own picker apply the account-supported model.
     midSession: { kind: 'agent-picker', command: '/model', delivery: 'type' }
   },
-  unknownModelOptions: [codexEffort('xhigh')]
+  // Why: models newer than this seed often support max/ultra; Codex falls back
+  // to the model's default effort rather than failing on an unsupported one.
+  unknownModelOptions: [codexEffort('ultra')]
 }
diff --git a/src/shared/agent-session-option-catalog-codebuddy.ts b/src/shared/agent-session-option-catalog-codebuddy.ts
index 9c149919472..555d1d2e3b8 100644
--- a/src/shared/agent-session-option-catalog-codebuddy.ts
+++ b/src/shared/agent-session-option-catalog-codebuddy.ts
@@ -19,7 +19,7 @@ const CODEBUDDY_EFFORT: CatalogOption = {
   },
   apply: {
     launchArgs: (value) => ['--effort', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--effort'])
+    removeAgentArgs: (tokens) => removeAgentArgOption('codebuddy', tokens, ['--effort'])
   }
 }
 
@@ -35,7 +35,7 @@ export const CODEBUDDY_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   ].map((model) => ({ ...model, options: [CODEBUDDY_EFFORT] })),
   modelApply: {
     launchArgs: (value) => ['--model', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--model'])
+    removeAgentArgs: (tokens) => removeAgentArgOption('codebuddy', tokens, ['--model'])
   },
   unknownModelOptions: [CODEBUDDY_EFFORT]
 }
diff --git a/src/shared/agent-session-option-catalog-gemini-cursor.ts b/src/shared/agent-session-option-catalog-gemini-cursor.ts
index 510394d2bd5..2397f296b3c 100644
--- a/src/shared/agent-session-option-catalog-gemini-cursor.ts
+++ b/src/shared/agent-session-option-catalog-gemini-cursor.ts
@@ -5,9 +5,6 @@ import type {
 } from './agent-session-option-catalog-types'
 import { removeAgentArgOption } from './agent-session-option-agent-args'
 
-const removeModelFlag = (tokens: readonly string[]): string[] =>
-  removeAgentArgOption(tokens, ['-m', '--model'])
-
 export const GEMINI_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   models: [
     { id: 'gemini-3-pro-preview', label: 'Gemini 3 Pro Preview', options: [] },
@@ -17,7 +14,7 @@ export const GEMINI_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   ],
   modelApply: {
     launchArgs: (value) => ['-m', String(value)],
-    removeAgentArgs: removeModelFlag,
+    removeAgentArgs: (tokens) => removeAgentArgOption('gemini', tokens, ['-m', '--model']),
     midSession: { kind: 'agent-picker', command: '/model' }
   }
 }
@@ -86,7 +83,7 @@ export const CURSOR_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   ],
   modelApply: {
     launchArgs: (value) => ['--model', String(value)],
-    removeAgentArgs: removeModelFlag,
+    removeAgentArgs: (tokens) => removeAgentArgOption('cursor', tokens, ['-m', '--model']),
     midSession: { kind: 'command', build: (value) => `/model ${String(value)}` }
   },
   composeModelValue: (modelId, values) => {
diff --git a/src/shared/agent-session-option-catalog-grok.test.ts b/src/shared/agent-session-option-catalog-grok.test.ts
index 7a54621c7c6..f4642e8c446 100644
--- a/src/shared/agent-session-option-catalog-grok.test.ts
+++ b/src/shared/agent-session-option-catalog-grok.test.ts
@@ -212,13 +212,13 @@ describe('grok agent-arg overrides', () => {
     expect(removeEffort(['--effortless'])).toEqual(['--effortless'])
   })
 
-  it('drops only the overridden key from the launch record', () => {
+  it('drops only the overridden key from the launch record and argv', () => {
     expect(
       resolveAgentSessionOptionLaunch('grok', { model: 'grok-4.5', effort: 'high' }, [
         '--reasoning-effort=low'
       ])
     ).toEqual({
-      args: ['-m', 'grok-4.5', '--reasoning-effort', 'high'],
+      args: ['-m', 'grok-4.5'],
       appliedValues: { model: 'grok-4.5' }
     })
   })
diff --git a/src/shared/agent-session-option-catalog-grok.ts b/src/shared/agent-session-option-catalog-grok.ts
index 3577ae036a0..fdb3405785f 100644
--- a/src/shared/agent-session-option-catalog-grok.ts
+++ b/src/shared/agent-session-option-catalog-grok.ts
@@ -36,7 +36,8 @@ function grokEffort(ceiling: 'high' | 'xhigh'): CatalogOption {
     apply: {
       launchArgs: (value) => ['--reasoning-effort', String(value)],
       // Why: grok reads both spellings.
-      removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--effort', '--reasoning-effort']),
+      removeAgentArgs: (tokens) =>
+        removeAgentArgOption('grok', tokens, ['--effort', '--reasoning-effort']),
       midSession: { kind: 'command', build: (value) => `/effort ${String(value)}` }
     }
   }
@@ -68,7 +69,7 @@ export const GROK_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   ],
   modelApply: {
     launchArgs: (value) => ['-m', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['-m', '--model']),
+    removeAgentArgs: (tokens) => removeAgentArgOption('grok', tokens, ['-m', '--model']),
     // Why: `agent-picker` would replace the whole model list with "Choose in
     // agent picker…" and never persist a model, so `-m` would never be emitted.
     midSession: { kind: 'command', build: (value) => `/model ${String(value)}` }
diff --git a/src/shared/agent-session-option-catalog-muse.ts b/src/shared/agent-session-option-catalog-muse.ts
index 91163ca7267..50a49dcc778 100644
--- a/src/shared/agent-session-option-catalog-muse.ts
+++ b/src/shared/agent-session-option-catalog-muse.ts
@@ -21,7 +21,7 @@ const MUSE_EFFORT: CatalogOption = {
   },
   apply: {
     launchArgs: (value) => ['--reasoning-effort', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--reasoning-effort'])
+    removeAgentArgs: (tokens) => removeAgentArgOption('muse', tokens, ['--reasoning-effort'])
   }
 }
 
@@ -32,7 +32,7 @@ export const MUSE_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   models: [],
   modelApply: {
     launchArgs: (value) => ['--model', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--model'])
+    removeAgentArgs: (tokens) => removeAgentArgOption('muse', tokens, ['--model'])
   },
   unknownModelOptions: [MUSE_EFFORT]
 }
diff --git a/src/shared/agent-session-option-catalog-omp.ts b/src/shared/agent-session-option-catalog-omp.ts
index 312b3f6306a..2008f909abc 100644
--- a/src/shared/agent-session-option-catalog-omp.ts
+++ b/src/shared/agent-session-option-catalog-omp.ts
@@ -18,7 +18,7 @@ export const OMP_SESSION_OPTION_CATALOG: AgentSessionOptionCatalog = {
   models: [],
   modelApply: {
     launchArgs: (value) => ['--model', String(value)],
-    removeAgentArgs: (tokens) => removeAgentArgOption(tokens, ['--model']),
+    removeAgentArgs: (tokens) => removeAgentArgOption('omp', tokens, ['--model']),
     // OMP only opens its TUI picker for /model; our extension applies the exact selector.
     midSession: { kind: 'command', build: (value) => `/orca-model ${String(value)}` }
   },
diff --git a/src/shared/agent-session-option-catalog-opencode.test.ts b/src/shared/agent-session-option-catalog-opencode.test.ts
new file mode 100644
index 00000000000..cdbf360fc10
--- /dev/null
+++ b/src/shared/agent-session-option-catalog-opencode.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+import { getAgentSessionOptionCatalog } from './agent-session-option-catalog'
+import {
+  removeOverriddenAgentSessionArgs,
+  resolveAgentSessionOptionLaunch
+} from './agent-session-option-launch'
+
+describe('OpenCode launch options', () => {
+  it('does not expose worker-only launch options as an interactive session catalog', () => {
+    expect(getAgentSessionOptionCatalog('opencode')).toBeNull()
+  })
+
+  it('maps an opaque model id to the OpenCode --model flag', () => {
+    expect(
+      resolveAgentSessionOptionLaunch('opencode', {
+        model: 'zai-coding-plan/glm-5.3-flash'
+      })
+    ).toEqual({
+      args: ['--model', 'zai-coding-plan/glm-5.3-flash'],
+      appliedValues: { model: 'zai-coding-plan/glm-5.3-flash' }
+    })
+  })
+
+  it('removes a configured model flag before applying a per-launch model', () => {
+    expect(
+      removeOverriddenAgentSessionArgs('opencode', { model: 'zai-coding-plan/glm-5.3-flash' }, [
+        '--model',
+        'opencode/global-default',
+        '--log-level',
+        'DEBUG'
+      ])
+    ).toEqual(['--log-level', 'DEBUG'])
+  })
+
+  it('keeps arguments after the terminator while removing every earlier model choice', () => {
+    expect(
+      removeOverriddenAgentSessionArgs('opencode', { model: 'private-proof/model-b' }, [
+        '-mfirst',
+        '--model=second',
+        '--log-level',
+        'DEBUG',
+        '--',
+        '--model',
+        'trailing'
+      ])
+    ).toEqual(['--log-level', 'DEBUG', '--', '--model', 'trailing'])
+  })
+
+  it('does not send or record the selected model when free-form arguments override it', () => {
+    expect(
+      resolveAgentSessionOptionLaunch('opencode', { model: 'private-proof/model-b' }, [
+        '-m',
+        'private-proof/model-a'
+      ])
+    ).toEqual({ args: [], appliedValues: {} })
+  })
+
+  it('records the selected model when model-like arguments follow the terminator', () => {
+    expect(
+      resolveAgentSessionOptionLaunch('opencode', { model: 'private-proof/model-b' }, [
+        '--',
+        '--model',
+        'private-proof/model-a'
+      ])
+    ).toEqual({
+      args: ['--model', 'private-proof/model-b'],
+      appliedValues: { model: 'private-proof/model-b' }
+    })
+  })
+})
diff --git a/src/shared/agent-session-option-catalog-opencode.ts b/src/shared/agent-session-option-catalog-opencode.ts
new file mode 100644
index 00000000000..3e361c6913c
--- /dev/null
+++ b/src/shared/agent-session-option-catalog-opencode.ts
@@ -0,0 +1,14 @@
+import { removeAgentArgOption } from './agent-session-option-agent-args'
+import type { AgentSessionOptionCatalog } from './agent-session-option-catalog-types'
+
+const MODEL_FLAGS = ['-m', '--model'] as const
+
+// Why: worker-start needs launch serialization without exposing a new Native Chat option surface.
+export const OPENCODE_LAUNCH_OPTION_CATALOG: AgentSessionOptionCatalog = {
+  supportsWorkerLaunchPreferences: true,
+  models: [],
+  modelApply: {
+    launchArgs: (value) => ['--model', String(value)],
+    removeAgentArgs: (tokens) => removeAgentArgOption('opencode', tokens, MODEL_FLAGS)
+  }
+}
diff --git a/src/shared/agent-session-option-catalog-removers.test.ts b/src/shared/agent-session-option-catalog-removers.test.ts
index 64262213d4e..a9e880ce855 100644
--- a/src/shared/agent-session-option-catalog-removers.test.ts
+++ b/src/shared/agent-session-option-catalog-removers.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { getAgentSessionOptionCatalog } from './agent-session-option-catalog'
-import { removeAgentArgOption } from './agent-session-option-agent-args'
+import { agentArgTerminatorIndex, removeAgentArgOption } from './agent-session-option-agent-args'
 import {
   removeOverriddenAgentSessionArgs,
   resolveAgentSessionOptionLaunch
@@ -52,10 +52,24 @@ describe('catalog removers', () => {
 
 describe('removeAgentArgOption', () => {
   it('consumes an empty value', () => {
-    expect(removeAgentArgOption(['--model', '', '--yolo'], ['--model'])).toEqual(['--yolo'])
+    expect(removeAgentArgOption('claude', ['--model', '', '--yolo'], ['--model'])).toEqual([
+      '--yolo'
+    ])
   })
 
   it('keeps a following flag', () => {
-    expect(removeAgentArgOption(['--model', '--yolo'], ['--model'])).toEqual(['--yolo'])
+    expect(removeAgentArgOption('claude', ['--model', '--yolo'], ['--model'])).toEqual(['--yolo'])
+  })
+
+  it('requires an exact terminator outside option values', () => {
+    expect(
+      agentArgTerminatorIndex('claude', [
+        '--append-system-prompt',
+        '--',
+        '--=literal',
+        '--',
+        'text'
+      ])
+    ).toBe(3)
   })
 })
diff --git a/src/shared/agent-session-option-catalog-types.ts b/src/shared/agent-session-option-catalog-types.ts
index fe15d5080e0..eafa7b349f1 100644
--- a/src/shared/agent-session-option-catalog-types.ts
+++ b/src/shared/agent-session-option-catalog-types.ts
@@ -21,8 +21,7 @@ export type CatalogMidSessionApply =
 
 export type CatalogOptionApply = {
   launchArgs?: (value: SessionOptionValue) => string[]
-  /** Strips the free-form args that set this option. Why: later free-form args win, so
-   * anything this strips also tells the launch record to discard the picker value. */
+  /** Removes conflicting free-form args, or detects when to omit the pick from launch args and the record. */
   removeAgentArgs?: (tokens: readonly string[]) => string[]
   composedIntoModel?: true
   midSession?: CatalogMidSessionApply
diff --git a/src/shared/agent-session-option-launch.ts b/src/shared/agent-session-option-launch.ts
index e9c5b90181d..e8c972385bd 100644
--- a/src/shared/agent-session-option-launch.ts
+++ b/src/shared/agent-session-option-launch.ts
@@ -1,6 +1,10 @@
 import type { AgentType } from './agent-status-types'
 import { findCatalogModel, getAgentSessionOptionCatalog } from './agent-session-option-catalog'
-import type { CatalogOptionApply } from './agent-session-option-catalog-types'
+import { OPENCODE_LAUNCH_OPTION_CATALOG } from './agent-session-option-catalog-opencode'
+import type {
+  AgentSessionOptionCatalog,
+  CatalogOptionApply
+} from './agent-session-option-catalog-types'
 import type { SessionOptionValue } from './native-chat-session-options'
 
 export type ResolvedSessionOptionLaunch = {
@@ -13,12 +17,18 @@ function isOverriddenByAgentArgs(apply: CatalogOptionApply, tokens: readonly str
   return kept !== undefined && kept.length < tokens.length
 }
 
+export function getAgentSessionOptionLaunchCatalog(
+  agent: AgentType
+): AgentSessionOptionCatalog | null {
+  return agent === 'opencode' ? OPENCODE_LAUNCH_OPTION_CATALOG : getAgentSessionOptionCatalog(agent)
+}
+
 export function removeOverriddenAgentSessionArgs(
   agent: AgentType,
   values: Record<string, SessionOptionValue> | null | undefined,
   tokens: readonly string[]
 ): string[] {
-  const catalog = getAgentSessionOptionCatalog(agent)
+  const catalog = getAgentSessionOptionLaunchCatalog(agent)
   const modelId = typeof values?.model === 'string' ? values.model : null
   if (!catalog || !values || !modelId) {
     return [...tokens]
@@ -40,7 +50,7 @@ export function resolveAgentSessionOptionLaunch(
   trailingAgentArgs: readonly string[] = [],
   includeCatalogDefaults = true
 ): ResolvedSessionOptionLaunch {
-  const catalog = getAgentSessionOptionCatalog(agent)
+  const catalog = getAgentSessionOptionLaunchCatalog(agent)
   const modelId = typeof values?.model === 'string' ? values.model : null
   if (!catalog || !values || !modelId) {
     return { args: [], appliedValues: {} }
@@ -71,11 +81,10 @@ export function resolveAgentSessionOptionLaunch(
     : modelId
   const modelOverridden = isOverriddenByAgentArgs(catalog.modelApply, trailingAgentArgs)
 
-  if (catalog.modelApply.launchArgs) {
+  // Why: a repeated model flag can prevent the CLI from starting.
+  if (catalog.modelApply.launchArgs && !modelOverridden) {
     args.push(...catalog.modelApply.launchArgs(composedModelId))
-    if (!modelOverridden) {
-      appliedValues.model = modelId
-    }
+    appliedValues.model = modelId
   }
   for (const option of modelOptions) {
     const value = modelValues[option.id]
@@ -88,13 +97,16 @@ export function resolveAgentSessionOptionLaunch(
       }
       continue
     }
-    if (!option.apply.launchArgs) {
+    // Why: options belong to the picked model and may be invalid for the user's model.
+    if (
+      !option.apply.launchArgs ||
+      modelOverridden ||
+      isOverriddenByAgentArgs(option.apply, trailingAgentArgs)
+    ) {
       continue
     }
     args.push(...option.apply.launchArgs(value))
-    if (!modelOverridden && !isOverriddenByAgentArgs(option.apply, trailingAgentArgs)) {
-      appliedValues[option.id] = value
-    }
+    appliedValues[option.id] = value
   }
   return { args, appliedValues }
 }
diff --git a/src/shared/agent-session-stop-row-identity.ts b/src/shared/agent-session-stop-row-identity.ts
new file mode 100644
index 00000000000..d314003a3f9
--- /dev/null
+++ b/src/shared/agent-session-stop-row-identity.ts
@@ -0,0 +1,12 @@
+// The identities of the rows a host writes about a stop, shared with the readers that must not say
+// the same stop twice (`native-chat-cut-turn-notice`).
+//
+// Contract: a new row that explains a stop must carry the providerExited fact or one of these
+// prefixes, or a client derives a second notice beside it.
+
+/** The exit row the unexpected-exit settle writes, keyed by the child that exited. */
+export const PROVIDER_EXIT_ROW_PREFIX = 'provider-exit:'
+/** The exit row a reopen or acquire writes for a generation found dead. */
+export const STALE_SESSION_ROW_PREFIX = 'stale-session:'
+/** The note the restart continuation leaves about its outcome. */
+export const RESTART_CONTINUATION_ROW_PREFIX = 'restart-continuation:'
diff --git a/src/shared/agent-session-wire.ts b/src/shared/agent-session-wire.ts
index b6b584623ae..d6dd30dc481 100644
--- a/src/shared/agent-session-wire.ts
+++ b/src/shared/agent-session-wire.ts
@@ -430,7 +430,12 @@ export type AgentSessionFastModeSupport = {
  * surface: an older host simply lacks the method.
  */
 export type AgentSessionModelCatalogResult =
-  | { origin: 'unknown' }
+  | {
+      origin: 'unknown'
+      /** The host is running its first listing for this account; a `waitForListing` read answers
+       *  when it lands. Absent from a host that predates it. */
+      listingInProgress?: true
+    }
   | {
       /** What produced the listing; any age is served, `fetchedAt` carries it. */
       origin: 'live-session' | 'probe'
diff --git a/src/shared/command-option-occurrence.ts b/src/shared/command-option-occurrence.ts
index 203e7252723..d7e14933672 100644
--- a/src/shared/command-option-occurrence.ts
+++ b/src/shared/command-option-occurrence.ts
@@ -2,7 +2,7 @@ function matchesOption(token: string, aliases: readonly string[]): boolean {
   return aliases.some(
     (alias) =>
       token === alias ||
-      token.startsWith(`${alias}=`) ||
+      (alias !== '--' && token.startsWith(`${alias}=`)) ||
       (alias.startsWith('-') &&
         !alias.startsWith('--') &&
         token.startsWith(alias) &&
@@ -13,7 +13,8 @@ function matchesOption(token: string, aliases: readonly string[]): boolean {
 export function findOptionOccurrence(
   tokens: readonly string[],
   aliases: readonly string[],
-  stopAtTerminator: boolean
+  stopAtTerminator: boolean,
+  valueOptions: readonly string[] = []
 ): { index: number; consumed: number; value?: string } | null {
   for (let index = 0; index < tokens.length; index += 1) {
     const token = tokens[index]
@@ -21,6 +22,10 @@ export function findOptionOccurrence(
       break
     }
     if (!matchesOption(token, aliases)) {
+      // Required option values can look like flags, including `--`.
+      if (valueOptions.includes(token)) {
+        index += 1
+      }
       continue
     }
     const nextToken = tokens[index + 1]
diff --git a/src/shared/credit-count-format.test.ts b/src/shared/credit-count-format.test.ts
new file mode 100644
index 00000000000..07ab4554252
--- /dev/null
+++ b/src/shared/credit-count-format.test.ts
@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest'
+import { formatCreditCount } from './credit-count-format'
+
+describe('formatCreditCount', () => {
+  it('uses the viewer locale for grouped credit counts', () => {
+    const expected = new Intl.NumberFormat(undefined, { maximumFractionDigits: 20 }).format(1234)
+    expect(formatCreditCount(1234)).toBe(expected)
+  })
+
+  it('normalizes invalid and negative counts', () => {
+    expect(formatCreditCount(Number.NaN)).toBe('0')
+    expect(formatCreditCount(-5)).toBe('0')
+  })
+})
diff --git a/src/shared/credit-count-format.ts b/src/shared/credit-count-format.ts
new file mode 100644
index 00000000000..14cfde62bfb
--- /dev/null
+++ b/src/shared/credit-count-format.ts
@@ -0,0 +1,6 @@
+const CREDIT_COUNT_FORMATTER = new Intl.NumberFormat(undefined, { maximumFractionDigits: 20 })
+
+export function formatCreditCount(count: number): string {
+  const safeCount = Number.isFinite(count) ? Math.max(0, count) : 0
+  return CREDIT_COUNT_FORMATTER.format(safeCount)
+}
diff --git a/src/shared/currency-format.test.ts b/src/shared/currency-format.test.ts
new file mode 100644
index 00000000000..b0c5cd6f174
--- /dev/null
+++ b/src/shared/currency-format.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest'
+import { formatCurrencyAmount } from './currency-format'
+
+describe('formatCurrencyAmount', () => {
+  it('formats USD amounts with the dollar symbol', () => {
+    // Force a stable locale-independent expectation by asserting substrings.
+    const formatted = formatCurrencyAmount(12.4, 'USD')
+    expect(formatted).toMatch(/12[.,]40/)
+    expect(formatted).toContain('$')
+  })
+
+  it('formats EUR amounts with the euro symbol and thousands separator', () => {
+    const formatted = formatCurrencyAmount(2000, 'EUR')
+    expect(formatted).toContain('€')
+    expect(formatted).toMatch(/2[.,]000/)
+  })
+
+  it('falls back to code + amount for a malformed currency code', () => {
+    // A non-3-letter code makes Intl.NumberFormat throw, exercising the fallback.
+    expect(formatCurrencyAmount(9.5, 'ZZ')).toBe('ZZ 9.50')
+  })
+
+  it('defaults blank currency codes to USD', () => {
+    expect(formatCurrencyAmount(1, '   ')).toContain('$')
+  })
+
+  it('treats non-finite amounts as zero', () => {
+    expect(formatCurrencyAmount(Number.NaN, 'USD')).toMatch(/0[.,]00/)
+  })
+})
diff --git a/src/shared/currency-format.ts b/src/shared/currency-format.ts
new file mode 100644
index 00000000000..c8779246986
--- /dev/null
+++ b/src/shared/currency-format.ts
@@ -0,0 +1,21 @@
+/**
+ * Format a major-unit amount (e.g. 12.4) as a localized currency string
+ * (e.g. "$12.40"). Shared by the usage popover and the compact status-bar
+ * balance token so both render identically.
+ *
+ * Why: `Intl.NumberFormat` throws on an unrecognized currency code (the code
+ * comes from a provider API we don't control), so fall back to a plain
+ * "<CODE> <amount>" rendering rather than crashing the status bar.
+ */
+export function formatCurrencyAmount(amount: number, currencyCode: string): string {
+  const safeAmount = Number.isFinite(amount) ? amount : 0
+  const code = currencyCode.trim() || 'USD'
+  try {
+    return new Intl.NumberFormat(undefined, {
+      style: 'currency',
+      currency: code
+    }).format(safeAmount)
+  } catch {
+    return `${code} ${safeAmount.toFixed(2)}`
+  }
+}
diff --git a/src/shared/linear/links.test.ts b/src/shared/linear/links.test.ts
index 638e24ac722..dc27b576a5f 100644
--- a/src/shared/linear/links.test.ts
+++ b/src/shared/linear/links.test.ts
@@ -47,18 +47,35 @@ describe('linear links', () => {
 
   it('parses bare Linear issue identifiers', () => {
     expect(parseLinearIssueInput('eng-123')).toEqual({ identifier: 'ENG-123' })
+    expect(parseLinearIssueInput('2eng-123')).toEqual({ identifier: '2ENG-123' })
   })
 
   it('parses Linear team keys that start with a digit', () => {
-    expect(parseLinearIssueInput('4k-12')).toEqual({ identifier: '4K-12' })
-    expect(parseLinearIssueInput('https://linear.app/acme/issue/4K-12')).toEqual({
-      identifier: '4K-12',
-      organizationUrlKey: 'acme'
-    })
+    for (const identifier of ['2eng-123', '1pass-42', '3d-15', '4k-12']) {
+      expect(parseLinearIssueInput(`  ${identifier}  `)).toEqual({
+        identifier: identifier.toUpperCase()
+      })
+      expect(parseLinearIssueInput(`https://linear.app/acme/issue/${identifier}/notes`)).toEqual({
+        identifier: identifier.toUpperCase(),
+        organizationUrlKey: 'acme'
+      })
+    }
   })
 
-  it('rejects bare identifiers with no letter in the team key', () => {
-    expect(parseLinearIssueInput('2026-09')).toBeNull()
+  it('rejects numeric-only team keys in bare identifiers and URLs', () => {
+    for (const identifier of [
+      '2026-09',
+      '555-1234',
+      '8080-8090',
+      '123-456',
+      '1-1',
+      '007-42',
+      '1_2-3',
+      '1-800'
+    ]) {
+      expect(parseLinearIssueInput(identifier)).toBeNull()
+      expect(parseLinearIssueInput(`https://linear.app/acme/issue/${identifier}/notes`)).toBeNull()
+    }
   })
 
   it('parses Linear issue URLs with organization URL keys', () => {
@@ -66,6 +83,10 @@ describe('linear links', () => {
       identifier: 'ENG-123',
       organizationUrlKey: 'acme'
     })
+    expect(parseLinearIssueInput('https://linear.app/acme/issue/2eng-123/fix-auth')).toEqual({
+      identifier: '2ENG-123',
+      organizationUrlKey: 'acme'
+    })
     expect(parseLinearIssueInput('https://linear.app/stably/issue/STA-335/test-issue')).toEqual({
       identifier: 'STA-335',
       organizationUrlKey: 'stably'
diff --git a/src/shared/local-file-access.ts b/src/shared/local-file-access.ts
new file mode 100644
index 00000000000..1f39df10db0
--- /dev/null
+++ b/src/shared/local-file-access.ts
@@ -0,0 +1,22 @@
+/**
+ * The kind of file access a desktop request declares, which decides what main checks. Absent means the path must
+ * be inside a project root main recognises.
+ */
+export type LocalFileAccess =
+  /** A single file the user named (gesture or persisted tab): read in place, regular files only. */
+  | { kind: 'user-file' }
+  /** A resource a document's content references (images): limited to that document's roots or folder. */
+  | { kind: 'document-resource'; documentPath: string }
+  /** An image a chat transcript or composer shows: any local image file; a network share only inside a project. */
+  | { kind: 'chat-image' }
+  /** A document the user opened: renaming it to any path, or adding files in its own folder. */
+  | { kind: 'document-folder'; documentPath: string }
+
+/** Main's refusal of a request that resolves outside every root it may serve. */
+export const PATH_OUTSIDE_ALLOWED_DIRECTORIES =
+  'Access denied: path resolves outside allowed directories'
+
+// Why match the message: IPC errors cross to the renderer as plain messages, without their class.
+export function isPathOutsideAllowedDirectoriesError(error: unknown): boolean {
+  return error instanceof Error && error.message.includes(PATH_OUTSIDE_ALLOWED_DIRECTORIES)
+}
diff --git a/src/shared/native-chat-cut-turn-notice.test.ts b/src/shared/native-chat-cut-turn-notice.test.ts
new file mode 100644
index 00000000000..09fc37ba577
--- /dev/null
+++ b/src/shared/native-chat-cut-turn-notice.test.ts
@@ -0,0 +1,427 @@
+import { describe, expect, it } from 'vitest'
+import { agentSessionFailureFact } from './agent-session-failure'
+import { agentSessionFailureWords } from './agent-session-failure-words'
+import { agentJournalItemKey, agentJournalSubmissionKey } from './agent-session-journal-item-key'
+import type {
+  AgentJournalItemBody,
+  AgentJournalSubmission,
+  AgentJournalRenderItem,
+  AgentJournalTurnOutcome,
+  AgentJournalTurnScope
+} from './agent-session-journal-types'
+import { withNativeChatCutTurnNotices } from './native-chat-cut-turn-notice'
+import { hostStatesTurnScopes, nativeChatTurnMembership } from './native-chat-turn-membership'
+import { projectStructuredAgentSessionMessages } from './structured-agent-session-message-projection'
+import {
+  AGENT_SESSION_RESTART_CONTINUATION_NOTE,
+  AGENT_SESSION_RESTART_CONTINUATION_REFUSED_NOTE,
+  AGENT_SESSION_RESTART_CONTINUATION_UNCONFIRMED_NOTE,
+  AGENT_SESSION_RESTART_NOT_CONNECTED_NOTE
+} from './agent-session-restart-continuation'
+import { structuredAgentSessionStartFailureRowIdentity } from './structured-agent-session-start-failure-row-key'
+
+const THREAD: AgentJournalTurnScope = { kind: 'thread' }
+const NOTICE =
+  'Codex stopped while this response was in progress. You can continue in this conversation.'
+let sequence = 0
+
+function item(
+  itemId: string,
+  body: AgentJournalItemBody,
+  /** Null for a host that predates scopes. */
+  turnScope: AgentJournalTurnScope | null = THREAD
+): AgentJournalRenderItem {
+  sequence += 1
+  return {
+    itemId,
+    revision: 0,
+    sequence,
+    observedAt: sequence,
+    body,
+    ...(turnScope ? { turnScope } : {})
+  }
+}
+
+const inTurn = (turnItemId: string): AgentJournalTurnScope => ({ kind: 'turn', turnItemId })
+const user = (itemId: string, scope: AgentJournalTurnScope | null = THREAD) =>
+  item(itemId, { kind: 'message', role: 'user', blocks: [{ type: 'text', text: itemId }] }, scope)
+const reply = (itemId: string, scope: AgentJournalTurnScope | null) =>
+  item(
+    itemId,
+    { kind: 'message', role: 'assistant', blocks: [{ type: 'text', text: itemId }] },
+    scope
+  )
+
+type Ending = {
+  state: 'running' | 'completed' | 'interrupted' | 'unverifiable'
+  outcome?: AgentJournalTurnOutcome
+}
+const CUT: Ending = { state: 'interrupted' }
+
+function turn(
+  itemId: string,
+  userItemId: string,
+  ending: Ending,
+  scope: AgentJournalTurnScope | null = THREAD
+) {
+  return item(
+    itemId,
+    {
+      kind: 'turn',
+      turnId: itemId,
+      userItemId,
+      startedAt: 1_000,
+      ...(ending.state === 'running' ? {} : { completedAt: 2_000 }),
+      ...ending
+    },
+    scope
+  )
+}
+
+/** A row the host wrote, by the identity its writer gives it. */
+function hostRow(
+  clientMessageId: string,
+  body: AgentJournalItemBody,
+  scope: AgentJournalTurnScope | null
+) {
+  return item(agentJournalItemKey({ provider: 'orca', clientMessageId }), body, scope)
+}
+
+/** What the crash path's exit row says, from its fact. */
+const exitWords = (): AgentJournalItemBody => ({
+  kind: 'status',
+  ...agentSessionFailureWords(agentSessionFailureFact('providerExited'), {
+    agentName: 'Codex',
+    surface: 'row'
+  }),
+  tone: 'error'
+})
+const exitRow = (clientMessageId: string, scope: AgentJournalTurnScope | null) =>
+  hostRow(clientMessageId, exitWords(), scope)
+/** A note the restart continuation leaves about its outcome, about the conversation. */
+const restartNote = (text: string, tone?: 'error' | 'warning') =>
+  hostRow(
+    `restart-continuation:s:${text.length}`,
+    { kind: 'status', text, ...(tone ? { tone } : {}) },
+    THREAD
+  )
+
+function notices(items: readonly AgentJournalRenderItem[]) {
+  return withNativeChatCutTurnNotices(items, { agentName: 'Codex' }).flatMap((entry, index) =>
+    entry.itemId.includes('cut-turn-notice')
+      ? [
+          {
+            index,
+            text: entry.body.kind === 'status' ? entry.body.text : null,
+            scope: entry.turnScope
+          }
+        ]
+      : []
+  )
+}
+
+describe('withNativeChatCutTurnNotices', () => {
+  it('gives a cut turn no row explains one notice in the exit row words, after its last row', () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      reply('a1', inTurn('t1')),
+      user('u2'),
+      turn('t2', 'u2', { state: 'completed', outcome: 'success' })
+    ]
+
+    const derived = withNativeChatCutTurnNotices(items, { agentName: 'Codex' })
+
+    expect(notices(items)).toEqual([{ index: 3, text: NOTICE, scope: inTurn('t1') }])
+    const notice = derived[3]!
+    expect(notice.body).toMatchObject({ tone: 'error', failure: { kind: 'providerExited' } })
+    // Placed by journal position too, so any reader that sorts keeps it under the turn.
+    expect(notice.sequence).toBe(items[2]!.sequence)
+    expect(notice.sequenceIndex).toBeGreaterThan(0)
+  })
+
+  it('adds nothing where the crash path already wrote its exit row, scoped or about the conversation', () => {
+    for (const [id, scope] of [
+      ['stale-session:s:death-3-2000', inTurn('t1')],
+      ['provider-exit:s:3:gen', inTurn('t1')],
+      ['stale-session:s:death-3-2000', THREAD]
+    ] as const) {
+      const items = [
+        user('u1'),
+        turn('t1', 'u1', CUT),
+        reply('a1', inTurn('t1')),
+        exitRow(id, scope)
+      ]
+      expect(withNativeChatCutTurnNotices(items), id).toBe(items)
+    }
+  })
+
+  // A host from before failure facts wrote the same rows with only their words.
+  it("counts an older host's exit row by its writer, with no exit fact", () => {
+    for (const id of ['provider-exit:s:3:gen', 'stale-session:s:death-3-2000']) {
+      const items = [
+        user('u1'),
+        turn('t1', 'u1', CUT),
+        hostRow(id, { kind: 'status', text: NOTICE, tone: 'error' }, inTurn('t1'))
+      ]
+      expect(withNativeChatCutTurnNotices(items), id).toBe(items)
+    }
+  })
+
+  it('counts an exit row by its exit fact, whatever wrote it', () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      item('other-writer', exitWords(), inTurn('t1'))
+    ]
+    expect(withNativeChatCutTurnNotices(items)).toBe(items)
+  })
+
+  it("still explains a cut whose only error row is the agent's own, not the stop's", () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      hostRow(
+        'provider-frame:permission_denied',
+        { kind: 'status', text: 'Permission denied: Bash', tone: 'error' },
+        inTurn('t1')
+      )
+    ]
+    expect(notices(items)).toEqual([{ index: 3, text: NOTICE, scope: inTurn('t1') }])
+  })
+
+  it('says nothing of a Stop, a replaced turn, a failure, an unproven end, a finished or a running turn', () => {
+    for (const ending of [
+      { state: 'interrupted', outcome: 'cancellation' },
+      { state: 'interrupted', outcome: 'superseded' },
+      { state: 'interrupted', outcome: 'failure' },
+      { state: 'completed', outcome: 'failure' },
+      { state: 'unverifiable' },
+      { state: 'completed', outcome: 'success' },
+      { state: 'completed' },
+      { state: 'running' }
+    ] satisfies Ending[]) {
+      const items = [user('u1'), turn('t1', 'u1', ending), reply('a1', inTurn('t1'))]
+      expect(withNativeChatCutTurnNotices(items), JSON.stringify(ending)).toBe(items)
+    }
+  })
+
+  it("says nothing of a subagent's cut turn: the conversation's own turn speaks for it", () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', { state: 'completed', outcome: 'success' }),
+      { ...turn('sub', 'u1', CUT, inTurn('t1')), agentId: 'sub-agent' }
+    ]
+    expect(withNativeChatCutTurnNotices(items)).toBe(items)
+  })
+
+  it('explains every cut turn in the history no row explains, each once', () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      reply('a1', inTurn('t1')),
+      user('u2'),
+      turn('t2', 'u2', CUT),
+      reply('a2', inTurn('t2')),
+      exitRow('provider-exit:s:4:gen', inTurn('t2')),
+      user('u3'),
+      turn('t3', 'u3', CUT)
+    ]
+    expect(notices(items)).toEqual([
+      { index: 3, text: NOTICE, scope: inTurn('t1') },
+      // A turn with no rows of its own takes the notice after its record.
+      { index: 10, text: NOTICE, scope: inTurn('t3') }
+    ])
+  })
+
+  // A quit, then a resume that did not carry the chat on: the note says the cut was not continued,
+  // which is what the notice would say, so it stands alone.
+  it.each([
+    [AGENT_SESSION_RESTART_CONTINUATION_REFUSED_NOTE, 'error'],
+    [AGENT_SESSION_RESTART_NOT_CONNECTED_NOTE, 'error'],
+    [AGENT_SESSION_RESTART_CONTINUATION_UNCONFIRMED_NOTE, 'warning']
+  ] as const)(
+    'takes the restart note "%s" as the one explanation of the cut it follows',
+    (text, tone) => {
+      const items = [
+        user('u1'),
+        turn('t1', 'u1', CUT),
+        reply('a1', inTurn('t1')),
+        user('continuation'),
+        restartNote(text, tone)
+      ]
+      expect(withNativeChatCutTurnNotices(items)).toBe(items)
+    }
+  )
+
+  // The note of a continuation that went on lands after its own message and turn. The cut keeps its
+  // notice before and after it, so nothing flashes away under an automatic resume.
+  it('keeps the notice once a continuation carries the chat on', () => {
+    const cut = [user('u1'), turn('t1', 'u1', CUT), reply('a1', inTurn('t1'))]
+    const continuing = [...cut, user('u2'), turn('t2', 'u2', { state: 'running' })]
+    const continued = [...continuing, restartNote(AGENT_SESSION_RESTART_CONTINUATION_NOTE)]
+
+    for (const items of [cut, continuing, continued]) {
+      expect(notices(items)).toEqual([{ index: 3, text: NOTICE, scope: inTurn('t1') }])
+    }
+    // Its note carries no tone, so even with no turn recorded before it, it does not stand in.
+    const noteOnly = [...cut, user('u2'), restartNote(AGENT_SESSION_RESTART_CONTINUATION_NOTE)]
+    expect(notices(noteOnly)).toEqual([{ index: 3, text: NOTICE, scope: inTurn('t1') }])
+  })
+
+  // An unconfirmed continuation whose turn opened before its warning: the warning is about that
+  // turn, so the cut keeps its own notice beside it.
+  it('keeps the notice when a restart note follows a turn the continuation opened', () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      reply('a1', inTurn('t1')),
+      user('u2'),
+      turn('t2', 'u2', { state: 'running' }),
+      restartNote(AGENT_SESSION_RESTART_CONTINUATION_UNCONFIRMED_NOTE, 'warning')
+    ]
+    expect(notices(items)).toEqual([{ index: 3, text: NOTICE, scope: inTurn('t1') }])
+  })
+
+  // A send after the cut, whose new agent died before its turn opened: that exit is about the send.
+  it('lets no exit row about the conversation explain a cut a message was sent after', () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      reply('a1', inTurn('t1')),
+      user('u2'),
+      exitRow('provider-exit:s:6:gen', THREAD)
+    ]
+    expect(notices(items)).toEqual([{ index: 3, text: NOTICE, scope: inTurn('t1') }])
+  })
+
+  // A row about the conversation speaks for the cut it follows, never across a turn that finished.
+  it('lets a later exit row about the conversation explain no cut a finished turn came after', () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      reply('a1', inTurn('t1')),
+      user('u2'),
+      turn('t2', 'u2', { state: 'completed', outcome: 'success' }),
+      exitRow('provider-exit:s:5:gen', THREAD)
+    ]
+    expect(notices(items)).toEqual([{ index: 3, text: NOTICE, scope: inTurn('t1') }])
+  })
+
+  // Read before the startup reconcile, the cut settled unverifiable; the user sent u2; the reconcile
+  // then proved the old owner dead and wrote its row about the conversation after u2. That row is
+  // about the cut, not the send, so it stays the one explanation.
+  it("takes an owner's proven death as the explanation of the cut though a message was sent since", () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      reply('a1', inTurn('t1')),
+      user('u2'),
+      exitRow('stale-session:s:death-3-2000', THREAD)
+    ]
+    expect(withNativeChatCutTurnNotices(items)).toBe(items)
+  })
+
+  it("does not take a failed start's row as the explanation of an earlier cut", () => {
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      reply('a1', inTurn('t1')),
+      item(
+        agentJournalItemKey(structuredAgentSessionStartFailureRowIdentity('gen-2')),
+        exitWords(),
+        THREAD
+      )
+    ]
+    expect(notices(items)).toEqual([{ index: 3, text: NOTICE, scope: inTurn('t1') }])
+  })
+
+  it('places the notice in its turn, for desktop and phone alike', () => {
+    const items = [user('u1'), turn('t1', 'u1', CUT), reply('a1', inTurn('t1')), user('u2')]
+    const derived = withNativeChatCutTurnNotices(items, { agentName: 'Codex' })
+    const messages = projectStructuredAgentSessionMessages(derived, [], [], {
+      rejectedInPlace: true
+    })
+    const { turnKeys } = nativeChatTurnMembership(messages, { items: derived, submissions: [] })
+
+    const notice = messages.findIndex((message) => message.id.includes('cut-turn-notice'))
+    expect(messages[notice]?.blocks).toEqual([
+      expect.objectContaining({ type: 'text', text: NOTICE, tone: 'error' })
+    ])
+    expect(turnKeys[notice]).toBe('u1')
+  })
+
+  // A message Orca accepted and then failed to deliver after the cut is drawn in place as not sent,
+  // in no turn; the cut keeps its notice in its own turn, and the exit row about that send does
+  // not stand in for it.
+  it('keeps the notice in its turn beside a later message drawn as not sent', () => {
+    const sent = agentJournalSubmissionKey('client-u2')
+    const items = [
+      user('u1'),
+      turn('t1', 'u1', CUT),
+      reply('a1', inTurn('t1')),
+      user(sent),
+      exitRow('provider-exit:s:7:gen', THREAD)
+    ]
+    const submissions: AgentJournalSubmission[] = [
+      {
+        clientMessageId: 'client-u2',
+        fence: 2,
+        payloadFingerprint: 'fp-u2',
+        dispatchState: 'rejected',
+        providerItemId: null,
+        reason: NOTICE,
+        submittedAt: 50,
+        resolvedAt: 60
+      }
+    ]
+    const derived = withNativeChatCutTurnNotices(items, { agentName: 'Codex' })
+    const messages = projectStructuredAgentSessionMessages(derived, [], submissions, {
+      rejectedInPlace: true
+    })
+    const { turnKeys } = nativeChatTurnMembership(messages, { items: derived, submissions })
+
+    const notice = messages.findIndex((message) => message.id.includes('cut-turn-notice'))
+    expect(turnKeys[notice]).toBe('u1')
+    expect(messages.find((message) => message.id === sent)).toMatchObject({ unsent: true })
+  })
+
+  it('reads a journal from a host that states no scope, without making it look like one that does', () => {
+    const items = [
+      user('u1', null),
+      turn('t1', 'u1', CUT, null),
+      reply('a1', null),
+      user('u2', null)
+    ]
+
+    const derived = withNativeChatCutTurnNotices(items, { agentName: 'Codex' })
+
+    expect(notices(items)).toEqual([{ index: 3, text: NOTICE, scope: undefined }])
+    expect(hostStatesTurnScopes(derived)).toBe(false)
+  })
+
+  it('reads the older status-row turn record, and keeps each notice the same object across reads', () => {
+    const record = item(
+      't1',
+      {
+        kind: 'status',
+        text: '',
+        turnLifecycle: {
+          turnId: 't1',
+          userItemId: 'u1',
+          state: 'interrupted',
+          startedAt: 1_000,
+          completedAt: 2_000
+        }
+      },
+      null
+    )
+    const items = [user('u1', null), record]
+
+    const first = withNativeChatCutTurnNotices(items)
+    const second = withNativeChatCutTurnNotices([...items])
+
+    expect(first).toHaveLength(3)
+    expect(second[2]).toBe(first[2])
+  })
+})
diff --git a/src/shared/native-chat-cut-turn-notice.ts b/src/shared/native-chat-cut-turn-notice.ts
new file mode 100644
index 00000000000..ddf48636308
--- /dev/null
+++ b/src/shared/native-chat-cut-turn-notice.ts
@@ -0,0 +1,212 @@
+// The one row that says a turn was cut short when the agent stopped without anyone asking (a crash,
+// a quit, an eviction, a teardown). Derived on read from the journal, never stored: the turn record
+// is the durable fact, so a journal written before this rule, a quit that died mid-settle and any
+// future stop cause all read the same. A row the host already wrote about the stop stays the
+// explanation, so nothing is said twice. Shared by desktop and mobile, whose transcripts must agree.
+
+import { agentSessionFailureFact, readAgentSessionFailureFact } from './agent-session-failure'
+import {
+  agentSessionFailureWords,
+  type AgentSessionFailureWordsContext
+} from './agent-session-failure-words'
+import { agentJournalItemKey, parseAgentJournalItemKey } from './agent-session-journal-item-key'
+import { isRootAgentJournalItem } from './agent-session-journal-producer'
+import type { AgentJournalRenderItem } from './agent-session-journal-types'
+import { readAgentJournalTurn, readAgentJournalTurnOutcome } from './agent-session-turn-record'
+import { agentTurnVerdict } from './agent-turn-outcome'
+import {
+  PROVIDER_EXIT_ROW_PREFIX,
+  RESTART_CONTINUATION_ROW_PREFIX,
+  STALE_SESSION_ROW_PREFIX
+} from './agent-session-stop-row-identity'
+import { isStructuredAgentSessionStartFailureRow } from './structured-agent-session-start-failure-row-key'
+import { hostStatesTurnScopes } from './native-chat-turn-membership'
+
+const CUT_TURN_NOTICE_ROW = 'cut-turn-notice:'
+
+type CutTurnNoticeContext = Pick<AgentSessionFailureWordsContext, 'agentName'>
+
+function rootTurnVerdict(
+  item: AgentJournalRenderItem
+): ReturnType<typeof agentTurnVerdict> | 'none' {
+  const turn = readAgentJournalTurn(item.body)
+  return turn && isRootAgentJournalItem(item)
+    ? agentTurnVerdict({ state: turn.state, outcome: readAgentJournalTurnOutcome(turn) })
+    : 'none'
+}
+
+/** Root turns that ended interrupted with no verdict, so nobody asked for the stop. */
+function isCutRootTurn(item: AgentJournalRenderItem): boolean {
+  return rootTurnVerdict(item) === 'interruption'
+}
+
+/** What a row says about a stop, matched by what it states or who wrote it, never its tone alone:
+ *  an agent's own error row in the turn (a denied permission, a refusal) says nothing about the stop.
+ *  `exit`: the agent stopped. `owner-death`: a reopen proved the old agent dead, which is about the
+ *  cut whatever was sent since. `not-continued`: a resume after a restart did not carry the chat on,
+ *  which the restart note marks with a tone ('error' refused or not connected, 'warning' unconfirmed);
+ *  a continuation that went on writes its note with none. A failed start's row is about a start. */
+function stopExplanation(
+  item: AgentJournalRenderItem
+): 'exit' | 'owner-death' | 'not-continued' | null {
+  if (
+    item.body.kind !== 'status' ||
+    readAgentJournalTurn(item.body) ||
+    isStructuredAgentSessionStartFailureRow(item.itemId)
+  ) {
+    return null
+  }
+  const identity = parseAgentJournalItemKey(item.itemId)
+  const clientMessageId = identity?.provider === 'orca' ? identity.clientMessageId : ''
+  if (clientMessageId.startsWith(STALE_SESSION_ROW_PREFIX)) {
+    return 'owner-death'
+  }
+  if (
+    readAgentSessionFailureFact(item.body.failure)?.kind === 'providerExited' ||
+    clientMessageId.startsWith(PROVIDER_EXIT_ROW_PREFIX)
+  ) {
+    return 'exit'
+  }
+  const { tone } = item.body
+  return clientMessageId.startsWith(RESTART_CONTINUATION_ROW_PREFIX) &&
+    (tone === 'error' || tone === 'warning')
+    ? 'not-continued'
+    : null
+}
+
+/**
+ * The cut turns some row already explains: one scoped to the turn, or one about the conversation
+ * (or from a host that states no scope) that follows the cut turn closely enough to be about it.
+ * An exit row is about the cut only with no message sent since, which a later start would be
+ * answering. An owner's proven death, and a restart note that follows the continuation's own
+ * message, are about the cut until another turn begins.
+ */
+function explainedCutTurns(items: readonly AgentJournalRenderItem[]): Set<string> {
+  const explained = new Set<string>()
+  let cutNoSendSince: string | null = null
+  let cutNoTurnSince: string | null = null
+  for (const item of items) {
+    const verdict = rootTurnVerdict(item)
+    if (verdict !== 'none') {
+      cutNoSendSince = cutNoTurnSince = verdict === 'interruption' ? item.itemId : null
+      continue
+    }
+    if (item.body.kind === 'message' && item.body.role === 'user' && isRootAgentJournalItem(item)) {
+      cutNoSendSince = null
+      continue
+    }
+    const explanation = stopExplanation(item)
+    if (explanation === null) {
+      continue
+    }
+    const scope = item.turnScope
+    const preceding = explanation === 'exit' ? cutNoSendSince : cutNoTurnSince
+    if (scope?.kind === 'turn') {
+      explained.add(scope.turnItemId)
+    } else if (preceding !== null) {
+      explained.add(preceding)
+    }
+  }
+  return explained
+}
+
+/** The turn's last row, which the notice follows: one scoped to it, or by journal order on a host
+ *  that states no scope. A new root turn ends the order-read run. */
+function lastRowOfTurn(
+  items: readonly AgentJournalRenderItem[],
+  turnIndex: number,
+  statesScopes: boolean
+): number {
+  const turnItemId = items[turnIndex]!.itemId
+  let last = turnIndex
+  for (let index = turnIndex + 1; index < items.length; index += 1) {
+    const item = items[index]!
+    if (statesScopes) {
+      if (item.turnScope?.kind === 'turn' && item.turnScope.turnItemId === turnItemId) {
+        last = index
+      }
+      continue
+    }
+    if (readAgentJournalTurn(item.body) && isRootAgentJournalItem(item)) {
+      break
+    }
+    if (!(item.body.kind === 'message' && item.body.role === 'user')) {
+      last = index
+    }
+  }
+  return last
+}
+
+const noticeCache = new WeakMap<
+  AgentJournalRenderItem,
+  {
+    after: AgentJournalRenderItem
+    statesScopes: boolean
+    agentName: string | undefined
+    notice: AgentJournalRenderItem
+  }
+>()
+
+function cutTurnNotice(
+  turnItem: AgentJournalRenderItem,
+  after: AgentJournalRenderItem,
+  statesScopes: boolean,
+  context: CutTurnNoticeContext
+): AgentJournalRenderItem {
+  const cached = noticeCache.get(turnItem)
+  if (
+    cached?.after === after &&
+    cached.statesScopes === statesScopes &&
+    cached.agentName === context.agentName
+  ) {
+    return cached.notice
+  }
+  const notice: AgentJournalRenderItem = {
+    itemId: agentJournalItemKey({
+      provider: 'orca',
+      clientMessageId: `${CUT_TURN_NOTICE_ROW}${turnItem.itemId}`
+    }),
+    revision: 0,
+    body: {
+      kind: 'status',
+      ...agentSessionFailureWords(agentSessionFailureFact('providerExited'), {
+        ...context,
+        surface: 'row'
+      }),
+      tone: 'error'
+    },
+    // Just after the turn's last row and before anything the journal wrote next.
+    sequence: after.sequence,
+    sequenceIndex: (after.sequenceIndex ?? 0) + 0.5,
+    observedAt: readAgentJournalTurn(turnItem.body)?.completedAt ?? after.observedAt,
+    // A scope on a journal that states none would change how every other row is placed.
+    ...(statesScopes ? { turnScope: { kind: 'turn' as const, turnItemId: turnItem.itemId } } : {})
+  }
+  noticeCache.set(turnItem, { after, statesScopes, agentName: context.agentName, notice })
+  return notice
+}
+
+/**
+ * The journal as the transcript reads it: each root turn cut short with nobody asking, and no row
+ * saying so, gets one notice in the words of the provider-exit row, right after the turn's last row.
+ * Returns `items` itself when no turn needs one.
+ */
+export function withNativeChatCutTurnNotices(
+  items: readonly AgentJournalRenderItem[],
+  context: CutTurnNoticeContext = {}
+): readonly AgentJournalRenderItem[] {
+  const explained = explainedCutTurns(items)
+  const statesScopes = hostStatesTurnScopes(items)
+  const noticesAfter = new Map<number, AgentJournalRenderItem[]>()
+  items.forEach((item, index) => {
+    if (isCutRootTurn(item) && !explained.has(item.itemId)) {
+      const last = lastRowOfTurn(items, index, statesScopes)
+      const notice = cutTurnNotice(item, items[last]!, statesScopes, context)
+      noticesAfter.set(last, [...(noticesAfter.get(last) ?? []), notice])
+    }
+  })
+  if (noticesAfter.size === 0) {
+    return items
+  }
+  return items.flatMap((item, index) => [item, ...(noticesAfter.get(index) ?? [])])
+}
diff --git a/src/shared/native-chat-provider-retry-runs.test.ts b/src/shared/native-chat-provider-retry-runs.test.ts
index 0dff50c5f1d..3bb0c2d0227 100644
--- a/src/shared/native-chat-provider-retry-runs.test.ts
+++ b/src/shared/native-chat-provider-retry-runs.test.ts
@@ -49,7 +49,7 @@ function texts(messages: readonly NativeChatMessage[]): string[] {
 }
 
 function drawn(items: AgentJournalRenderItem[]): string[] {
-  return texts(projectStructuredAgentSessionMessages(items, [], []))
+  return texts(projectStructuredAgentSessionMessages(items, [], [], { rejectedInPlace: true }))
 }
 
 describe('a run of provider retry rows', () => {
@@ -101,7 +101,8 @@ describe('a run of provider retry rows', () => {
           retry(2, 'subagent-1')
         ],
         [],
-        []
+        [],
+        { rejectedInPlace: true }
       )
     )
     expect(texts(conversation)).toEqual([
@@ -136,7 +137,8 @@ describe('a run of provider retry rows', () => {
           resolvedAt: null,
           handoverRecorded: true
         }
-      ]
+      ],
+      { rejectedInPlace: true }
     )
     expect(messages.map((message) => [message.id, message.queued ?? false])).toEqual([
       [expect.stringMatching(/^item-/), false],
diff --git a/src/shared/native-chat-session-options.ts b/src/shared/native-chat-session-options.ts
index 32e3c6c862f..85aed23acb1 100644
--- a/src/shared/native-chat-session-options.ts
+++ b/src/shared/native-chat-session-options.ts
@@ -52,6 +52,8 @@ export type SessionOptionDescriptor = {
   transport: NativeChatLiveOptionTransport
   settable: boolean
   disabledReason?: SessionOptionDisabledReason
+  /** The host is still listing this option's choices: the pill keeps its value but cannot open. */
+  choicesPending?: true
   /** Why: picker-only and toggle-only PTY commands cannot be represented as
    * a truthful radio/checkbox state, so the producer exposes an action row. */
   action?: { type: 'agent-picker' | 'toggle-command' }
diff --git a/src/shared/native-chat-turn-status.test.ts b/src/shared/native-chat-turn-status.test.ts
index 3b70e57bdaf..08557aef9a0 100644
--- a/src/shared/native-chat-turn-status.test.ts
+++ b/src/shared/native-chat-turn-status.test.ts
@@ -42,9 +42,9 @@ describe('describeNativeChatTurnStatus', () => {
   it.each([
     ['cancellation', 'interruptedAfter'],
     ['superseded', 'interruptedAfter'],
-    // A turn anything but the user cut short reads as a failure does.
-    ['interruption', 'failedAfter'],
     ['failure', 'failedAfter'],
+    // A crash or restart cut it off: the turn reads finished and the chat's notice row says why.
+    ['interruption', 'workedFor'],
     ['success', 'workedFor'],
     ['unconfirmed', 'workedFor'],
     [undefined, 'workedFor']
@@ -108,6 +108,24 @@ describe('formatNativeChatTurnStatusLabel', () => {
       'Worked for 3m 4s'
     )
   })
+
+  // The phone's turn bar renders through this function, so it reads the same as desktop.
+  it('reads a crash-cut turn as worked and a Stop as interrupted in English', () => {
+    expect(
+      formatNativeChatTurnStatusLabel({
+        workedSeconds: 222,
+        elapsedSeconds: 0,
+        verdict: 'interruption'
+      })
+    ).toBe('Worked for 3m 42s')
+    expect(
+      formatNativeChatTurnStatusLabel({
+        workedSeconds: 222,
+        elapsedSeconds: 0,
+        verdict: 'cancellation'
+      })
+    ).toBe('Interrupted after 3m 42s')
+  })
 })
 
 describe('reduceNativeChatTurnTiming', () => {
diff --git a/src/shared/native-chat-turn-status.ts b/src/shared/native-chat-turn-status.ts
index f1dbea00947..446c489c350 100644
--- a/src/shared/native-chat-turn-status.ts
+++ b/src/shared/native-chat-turn-status.ts
@@ -42,7 +42,8 @@ export function describeNativeChatTurnStatus({
   workedSeconds?: number | null
   elapsedSeconds: number
   /** How the settled turn ended: a user's Stop or a newer request's replacement reads interrupted,
-   *  and a failure or a turn anything else cut short reads failed. */
+   *  and a failure reads failed. A turn cut short when the agent stopped without anyone asking (a
+   *  crash, a quit, an eviction) reads like a finished one: the chat's notice row says it stopped. */
   verdict?: AgentTurnOutcome
 }): {
   key: 'workingFor' | 'workedFor' | 'interruptedAfter' | 'failedAfter'
@@ -61,9 +62,9 @@ function settledTurnStatusKey(
     case 'superseded':
       return 'interruptedAfter'
     case 'failure':
-    case 'interruption':
       return 'failedAfter'
     case 'success':
+    case 'interruption':
     case 'unconfirmed':
     case undefined:
       return 'workedFor'
diff --git a/src/shared/native-chat-types.ts b/src/shared/native-chat-types.ts
index 127a9837910..7fd5fe66192 100644
--- a/src/shared/native-chat-types.ts
+++ b/src/shared/native-chat-types.ts
@@ -214,8 +214,8 @@ export type NativeChatMessage = AgentJournalProducerLinkage & {
   sentAs?: AgentJournalMessageSendMode
   /** Accepted but not yet handed to the agent: drawn after everything the agent has done. */
   queued?: true
-  /** Shown as not sent, waiting for the user's Retry: in no turn, so a newer turn's bar and clock
-   *  never land on it, and drawn after the conversation. */
+  /** Shown as not sent: in no turn, so a newer turn's bar and clock never land on it. Drawn where
+   *  the journal recorded it, or after the conversation when it holds no place there. */
   unsent?: true
   /** Set only by the structured projection, on rows the journal holds, and ranks
    *  them ahead of time. Terminal-backed messages never carry it, and worker reads strip it. */
diff --git a/src/shared/new-workspace/smart-workspace-linear-intent.test.ts b/src/shared/new-workspace/smart-workspace-linear-intent.test.ts
new file mode 100644
index 00000000000..b2311eadb49
--- /dev/null
+++ b/src/shared/new-workspace/smart-workspace-linear-intent.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getSmartWorkspaceLinearSearchQuery,
+  parseBoundedSmartWorkspaceLinearIssueInput,
+  parseBoundedSmartWorkspaceLinearIssueUrlIntent
+} from './smart-workspace-linear-intent'
+
+describe('numeric-leading Linear workspace source input', () => {
+  it.each(['2eng-123', '1pass-42', '3d-15'])('recognizes %s as an issue identifier', (input) => {
+    const identifier = input.toUpperCase()
+    const url = `https://linear.app/acme/issue/${input}/notes`
+    const intent = { identifier, organizationUrlKey: 'acme' }
+
+    expect(parseBoundedSmartWorkspaceLinearIssueInput(`  ${input}  `)).toEqual({ identifier })
+    expect(getSmartWorkspaceLinearSearchQuery(input)).toBe(identifier)
+    expect(parseBoundedSmartWorkspaceLinearIssueInput(url)).toEqual(intent)
+    expect(parseBoundedSmartWorkspaceLinearIssueUrlIntent(url)).toEqual(intent)
+    expect(getSmartWorkspaceLinearSearchQuery(url)).toBe(identifier)
+  })
+
+  it.each(['2026-09', '555-1234', '8080-8090', '1_2-3'])(
+    'keeps %s as search text without issue intent',
+    (input) => {
+      const url = `https://linear.app/acme/issue/${input}/notes`
+
+      expect(parseBoundedSmartWorkspaceLinearIssueInput(input)).toBeNull()
+      expect(getSmartWorkspaceLinearSearchQuery(input)).toBe(input)
+      expect(parseBoundedSmartWorkspaceLinearIssueInput(url)).toBeNull()
+      expect(parseBoundedSmartWorkspaceLinearIssueUrlIntent(url)).toBeNull()
+    }
+  )
+})
diff --git a/src/shared/opencode-cli-version.test.ts b/src/shared/opencode-cli-version.test.ts
index cc9c5987f2e..7f63d62e482 100644
--- a/src/shared/opencode-cli-version.test.ts
+++ b/src/shared/opencode-cli-version.test.ts
@@ -1,9 +1,12 @@
 import { expect, it } from 'vitest'
 import { getOpenCodeCliCapabilities, parseOpenCodeCliVersion } from './opencode-cli-version'
 
-it.each(['1.1.23', 'opencode v2.0.16', '2.0.0-beta.1+build'])('parses CLI output %s', (output) => {
-  expect(parseOpenCodeCliVersion(output)).toBe(output.replace(/^opencode v/, ''))
-})
+it.each(['1.1.23', 'opencode v2.0.12', 'opencode v2.0.16', '2.0.0-beta.1+build'])(
+  'parses CLI output %s',
+  (output) => {
+    expect(parseOpenCodeCliVersion(output)).toBe(output.replace(/^opencode v/, ''))
+  }
+)
 it.each([null, '', 'Error 2.0.16', '1.1', '2.0.16\nwarning'])(
   'does not mistake other output for a version',
   (output) => {
@@ -21,6 +24,11 @@ it('keeps future versions unknown instead of assuming a plugin loader or prompt
     pluginApi: 'v1',
     promptMode: 'submit'
   })
+  expect(getOpenCodeCliCapabilities('opencode v2.0.12')).toEqual({
+    version: '2.0.12',
+    pluginApi: 'v2',
+    promptMode: 'prefill'
+  })
   expect(getOpenCodeCliCapabilities('opencode v2.0.16')).toEqual({
     version: '2.0.16',
     pluginApi: 'v2',
@@ -29,6 +37,7 @@ it('keeps future versions unknown instead of assuming a plugin loader or prompt
 })
 
 it('does not opt unverified v2 builds into an extra prompt submission', () => {
-  expect(getOpenCodeCliCapabilities('2.0.17').promptMode).toBe('unknown')
-  expect(getOpenCodeCliCapabilities('2.0.16-beta').promptMode).toBe('unknown')
+  for (const version of ['2.0.13', '2.0.15', '2.0.17', '2.0.21', '2.0.12-beta', '2.0.16-beta']) {
+    expect(getOpenCodeCliCapabilities(version).promptMode).toBe('unknown')
+  }
 })
diff --git a/src/shared/opencode-cli-version.ts b/src/shared/opencode-cli-version.ts
index 2aa71b2c30f..13033bce78c 100644
--- a/src/shared/opencode-cli-version.ts
+++ b/src/shared/opencode-cli-version.ts
@@ -1,5 +1,7 @@
 import { isValidAppVersion } from './app-version'
 
+export const OPENCODE_NATIVE_PROMPT_VERSIONS = ['2.0.12', '2.0.16'] as const
+
 export type OpenCodeCliCapabilities = {
   version: string | null
   pluginApi: 'v1' | 'v2' | 'unknown'
@@ -21,6 +23,11 @@ export function getOpenCodeCliCapabilities(
   return {
     version,
     pluginApi: major === '1' ? 'v1' : major === '2' ? 'v2' : 'unknown',
-    promptMode: major === '1' ? 'submit' : version === '2.0.16' ? 'prefill' : 'unknown'
+    promptMode:
+      major === '1'
+        ? 'submit'
+        : OPENCODE_NATIVE_PROMPT_VERSIONS.some((supported) => supported === version)
+          ? 'prefill'
+          : 'unknown'
   }
 }
diff --git a/src/shared/opencode-config-directory.test.ts b/src/shared/opencode-config-directory.test.ts
new file mode 100644
index 00000000000..e11feee0cc2
--- /dev/null
+++ b/src/shared/opencode-config-directory.test.ts
@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { join } from 'node:path'
+import { resolveOpenCodeConfigDirectory } from './opencode-config-directory'
+
+const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform')
+afterEach(() => {
+  if (originalPlatform) {
+    Object.defineProperty(process, 'platform', originalPlatform)
+  }
+})
+
+describe('OpenCode consumer config directory', () => {
+  it('uses the execution HOME instead of the installer home on POSIX', () => {
+    Object.defineProperty(process, 'platform', { value: 'linux' })
+    expect(resolveOpenCodeConfigDirectory({ HOME: '/consumer' }, '/installer')).toBe(
+      join('/consumer', '.config', 'opencode')
+    )
+  })
+
+  it('uses the execution USERPROFILE on Windows', () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' })
+    expect(
+      resolveOpenCodeConfigDirectory({ USERPROFILE: '/consumer', HOME: '/shell' }, '/installer')
+    ).toBe(join('/consumer', '.config', 'opencode'))
+  })
+
+  it('keeps the host home fallback when the execution home is absent', () => {
+    expect(resolveOpenCodeConfigDirectory({}, '/installer')).toBe(
+      join('/installer', '.config', 'opencode')
+    )
+  })
+
+  it('does not treat a Windows shell HOME as the native OpenCode home', () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' })
+    expect(resolveOpenCodeConfigDirectory({ HOME: '/shell' }, '/installer')).toBe(
+      join('/installer', '.config', 'opencode')
+    )
+  })
+
+  it('keeps XDG_CONFIG_HOME ahead of the execution home', () => {
+    expect(
+      resolveOpenCodeConfigDirectory({ HOME: '/consumer', XDG_CONFIG_HOME: '/xdg' }, '/installer')
+    ).toBe(join('/xdg', 'opencode'))
+  })
+})
diff --git a/src/shared/opencode-config-directory.ts b/src/shared/opencode-config-directory.ts
index 28ca9cd175a..e200a2201c5 100644
--- a/src/shared/opencode-config-directory.ts
+++ b/src/shared/opencode-config-directory.ts
@@ -6,5 +6,9 @@ export function resolveOpenCodeConfigDirectory(
   environment: NodeJS.ProcessEnv | Record<string, string> = process.env,
   homeDirectory = homedir()
 ): string {
-  return join(environment.XDG_CONFIG_HOME?.trim() || join(homeDirectory, '.config'), 'opencode')
+  const executionHome = process.platform === 'win32' ? environment.USERPROFILE : environment.HOME
+  return join(
+    environment.XDG_CONFIG_HOME?.trim() || join(executionHome || homeDirectory, '.config'),
+    'opencode'
+  )
 }
diff --git a/src/shared/posix-controlling-terminal.ts b/src/shared/posix-controlling-terminal.ts
new file mode 100644
index 00000000000..900be25bd91
--- /dev/null
+++ b/src/shared/posix-controlling-terminal.ts
@@ -0,0 +1,11 @@
+export function hasControllingTty(tty: string | undefined): tty is string {
+  return (
+    typeof tty === 'string' &&
+    tty !== '' &&
+    tty !== '?' &&
+    tty !== '??' &&
+    tty !== '-' &&
+    tty !== '0' &&
+    !/^0,\d+$/.test(tty)
+  )
+}
diff --git a/src/shared/protocol-version.ts b/src/shared/protocol-version.ts
index 0ab7a210580..e07c656d5a2 100644
--- a/src/shared/protocol-version.ts
+++ b/src/shared/protocol-version.ts
@@ -1,4 +1,5 @@
 import { AGENT_SESSION_RESUME_RUNTIME_CAPABILITIES } from './agent-session-resume-runtime-capabilities'
+import { QODER_OWNED_TERMINAL_CREATE_CAPABILITY } from './qoder-terminal-create-capability'
 export {
   AGENT_SESSION_CURSOR_RESUME_RUNTIME_CAPABILITY,
   AGENT_SESSION_KIMI_RESUME_RUNTIME_CAPABILITY,
@@ -354,6 +355,7 @@ export const AGENT_SESSION_CREATE_TAB_ID_RUNTIME_CAPABILITY =
   'agentSession.create.tab-id.v1' as const
 
 export const RUNTIME_CAPABILITIES = [
+  QODER_OWNED_TERMINAL_CREATE_CAPABILITY,
   ...AGENT_SESSION_STOP_RUNTIME_CAPABILITIES,
   AGENT_SESSION_CREATE_TAB_ID_RUNTIME_CAPABILITY,
   ANTIGRAVITY_CONFIGURED_MODEL_RUNTIME_CAPABILITY,
diff --git a/src/shared/qoder-agent.test.ts b/src/shared/qoder-agent.test.ts
index f7600368a10..5078ee686ef 100644
--- a/src/shared/qoder-agent.test.ts
+++ b/src/shared/qoder-agent.test.ts
@@ -11,7 +11,7 @@ import {
   normalizeTerminalTitle,
   detectAgentStatusFromTitle
 } from './agent-detection'
-import { buildAgentStartupPlan } from './tui-agent-startup'
+import { buildAgentStartupPlan, buildAgentResumeStartupPlan } from './tui-agent-startup'
 import { getAgentResumeArgv } from './agent-session-resume'
 import { createHookListenerState } from './agent-hook-listener/listener-state'
 import { normalizeAndAccept } from './agent-hook-listener-test-harness'
@@ -19,12 +19,16 @@ import { normalizeAndAccept } from './agent-hook-listener-test-harness'
 describe('Qoder agent identity and lifecycle', () => {
   it('recognizes the installed versioned binary on native platforms and excludes headless runs', () => {
     for (const command of [
+      'qoder',
+      '/home/dev/.qoder/entry/qoder',
+      'C:\\Qoder\\qoder.cmd',
       'qodercli',
       '/home/dev/.qoder/bin/qodercli/qodercli-1.1.64',
       'C:\\Qoder\\qodercli-1.1.64.exe'
     ]) {
       expect(recognizeAgentProcessFromCommandLine(command)?.agent).toBe('qoder')
       expect(isExpectedAgentProcess(command, 'qodercli')).toBe(true)
+      expect(isExpectedAgentProcess(command, 'qoder')).toBe(true)
     }
     expect(recognizeAgentProcessFromCommandLine('qodercli --print hello')).toBeNull()
     for (const args of [
@@ -40,8 +44,42 @@ describe('Qoder agent identity and lifecycle', () => {
       'qoder'
     )
     expect(recognizeAgentProcessFromCommandLine('qodercli-unrelated')).toBeNull()
+    expect(recognizeAgentProcessFromCommandLine('qoder-unrelated')).toBeNull()
   })
 
+  it.each(['qoder', 'qodercli'])(
+    'excludes headless %s and preserves interactive resume',
+    (command) => {
+      for (const args of [
+        '--print hello',
+        '-p hello',
+        '--remote task',
+        '--list-sessions',
+        '--input-format stream-json',
+        '--output-format stream-json',
+        '--remote-control session'
+      ]) {
+        expect(recognizeAgentProcessFromCommandLine(`${command} ${args}`)).toBeNull()
+      }
+      expect(
+        recognizeAgentProcessFromCommandLine(`${command} --resume proof --prompt-interactive hello`)
+          ?.agent
+      ).toBe('qoder')
+    }
+  )
+
+  it.each(['ide', 'chat', 'serve-web', 'tunnel', './project', '/home/dev/project', 'C:\\project'])(
+    'does not identify qoder %s as an agent',
+    (subcommand) => {
+      expect(recognizeAgentProcessFromCommandLine(`qoder ${subcommand}`)).toBeNull()
+      expect(
+        recognizeAgentProcessFromCommandLine(`qoder ${subcommand}`, {
+          includeHeadlessOneShot: true
+        })
+      ).toBeNull()
+    }
+  )
+
   it.each([
     ['◇ Qoder CLI | Ready', 'idle'],
     ['✦ Implement feature | Thinking', 'working'],
@@ -144,6 +182,31 @@ it('does not rewrite DSH titles containing a pipe as Qoder', () => {
   expect(detectAgentStatusFromTitle(title)).not.toBe('working')
 })
 
+it.each(['darwin', 'linux', 'win32'] as const)(
+  'starts and resumes a configured modern Qoder entry on %s',
+  (platform) => {
+    const plan = buildAgentStartupPlan({
+      agent: 'qoder',
+      prompt: 'proof',
+      cmdOverrides: { qoder: 'qoder' },
+      platform,
+      isRemote: platform === 'linux'
+    })
+    expect(plan?.launchCommand).toBe("qoder --prompt-interactive 'proof'")
+    expect(plan?.launchConfig.agentCommand).toBe('qoder')
+    const resume = buildAgentResumeStartupPlan({
+      agent: 'qoder',
+      providerSession: { key: 'session_id', id: 'proof-session' },
+      cmdOverrides: {},
+      agentCommand: plan?.launchConfig.agentCommand,
+      platform,
+      isRemote: platform === 'linux'
+    })
+    expect(resume?.launchCommand).toBe("qoder '--resume' 'proof-session'")
+    expect(isExpectedAgentProcess('qodercli-1.1.65', resume?.expectedProcess ?? '')).toBe(true)
+  }
+)
+
 it('settles manual compaction without interrupting automatic compaction', () => {
   const state = createHookListenerState()
   const send = (hook_event_name: string, extra = {}) =>
diff --git a/src/shared/qoder-terminal-create-capability.ts b/src/shared/qoder-terminal-create-capability.ts
new file mode 100644
index 00000000000..f5b4526ff65
--- /dev/null
+++ b/src/shared/qoder-terminal-create-capability.ts
@@ -0,0 +1 @@
+export const QODER_OWNED_TERMINAL_CREATE_CAPABILITY = 'session.tabs.qoderOwnedCreate.v1'
diff --git a/src/shared/rate-limit-types.ts b/src/shared/rate-limit-types.ts
index 7f69b33264b..0a9abf64ab1 100644
--- a/src/shared/rate-limit-types.ts
+++ b/src/shared/rate-limit-types.ts
@@ -11,6 +11,32 @@ export type RateLimitWindow = {
 
 export type ProviderRateLimitStatus = 'idle' | 'fetching' | 'ok' | 'error' | 'unavailable'
 
+type ExtraUsageBalanceBase = {
+  enabled: boolean
+  disabledReason: string | null
+  resetsAt: number | null
+}
+
+type CurrencyExtraUsageBalance = ExtraUsageBalanceBase & {
+  unit: 'currency'
+  /** Null when the current balance is unavailable. */
+  balance: number | null
+  currencyCode: string
+  spent: number | null
+  spendLimit: number | null
+  spentPercent: number | null
+}
+
+type CreditExtraUsageBalance = ExtraUsageBalanceBase & {
+  unit: 'credits'
+  balance: number
+  unlimited: boolean
+}
+
+// Why: currency and unitless credits have different metadata; the discriminator
+// prevents consumers from inventing dummy currency or spend-limit values.
+export type ExtraUsageBalance = CurrencyExtraUsageBalance | CreditExtraUsageBalance
+
 export type RateLimitBucket = RateLimitWindow & {
   name: string
 }
@@ -67,6 +93,8 @@ export type ProviderRateLimits = {
   fableWeekly?: RateLimitWindow | null
   /** 30-day monthly window (OpenCode Go, Grok unified billing, Cursor plan pools), null if not available. */
   monthly?: RateLimitWindow | null
+  /** Overage / pay-as-you-go balance the plan spends into once its windows cap. */
+  extraUsage?: ExtraUsageBalance | null
   /** Named per-model buckets (Gemini models, Cursor plan pools). */
   buckets?: RateLimitBucket[]
   /** Available earned Codex rate-limit reset credits, if reported. */
diff --git a/src/shared/rpc-contract/structured-agent-session-params.ts b/src/shared/rpc-contract/structured-agent-session-params.ts
index b44f7204168..a1f2530ac5e 100644
--- a/src/shared/rpc-contract/structured-agent-session-params.ts
+++ b/src/shared/rpc-contract/structured-agent-session-params.ts
@@ -293,11 +293,14 @@ export const OptionsParams = z.object({ sessionId: SessionId }).strict()
 
 /** `sessionId` scopes the catalog to that session's pinned account; without a
  *  session record the host keys it by the account a new launch would pin.
- *  `worktree` names where a new chat runs, whose own config may replace the default. */
+ *  `worktree` names where a new chat runs, whose own config may replace the default.
+ *  `waitForListing` holds the answer until the listing the host reported in progress lands; send
+ *  it only after that report, because a host that predates it refuses the unknown key. */
 export const ModelCatalogParams = z.strictObject({
   agent: z.enum(['claude', 'codex']),
   sessionId: SessionId.optional(),
-  worktree: Identifier('Invalid worktree selector').optional()
+  worktree: Identifier('Invalid worktree selector').optional(),
+  waitForListing: z.boolean().optional()
 })
 
 export const ConversationCommandParams = z
diff --git a/src/shared/runtime-rpc-call-queue.test.ts b/src/shared/runtime-rpc-call-queue.test.ts
index 636698bf0e8..29d960b40f7 100644
--- a/src/shared/runtime-rpc-call-queue.test.ts
+++ b/src/shared/runtime-rpc-call-queue.test.ts
@@ -69,6 +69,26 @@ describe('runtime RPC call queue', () => {
     await expect(Promise.all(deletes)).resolves.toEqual(['rm-1', 'rm-2', 'rm-3'])
   })
 
+  it('runs foreground calls while model catalog reads wait on a host listing', async () => {
+    const queue = new RuntimeRpcCallQueuePool(8, 2)
+    const release: (() => void)[] = []
+    const waits = Array.from({ length: 8 }, () =>
+      queue.enqueue('web-runtime', 'agentSession.modelCatalog', async () => {
+        await new Promise<void>((resolve) => release.push(resolve))
+        return 'listed'
+      })
+    )
+    await vi.waitFor(() => expect(release).toHaveLength(8))
+
+    const send = queue.enqueue('web-runtime', 'agentSession.send', async () => 'sent')
+    await expect(send).resolves.toBe('sent')
+
+    for (const resolve of release) {
+      resolve()
+    }
+    await expect(Promise.all(waits)).resolves.toEqual(Array(8).fill('listed'))
+  })
+
   it('frees the queue slot when a runtime call throws synchronously', async () => {
     const queue = new RuntimeRpcCallQueuePool(1, 1)
     const first = queue.enqueue('web-runtime', 'status.get', () => {
diff --git a/src/shared/runtime-rpc-call-queue.ts b/src/shared/runtime-rpc-call-queue.ts
index 132c8099273..417b2048640 100644
--- a/src/shared/runtime-rpc-call-queue.ts
+++ b/src/shared/runtime-rpc-call-queue.ts
@@ -51,10 +51,11 @@ export function isBackgroundRuntimeMethod(method: string): boolean {
   )
 }
 
-// Why its own lane: worktree.rm replies only when Git has deleted the checkout, so its calls would
-// hold the foreground slots listing refreshes need; the background lane's slots belong to status.
+// Why its own lane: these reply only when slow host work finishes (worktree.rm when Git has deleted
+// the checkout, a model catalog read that waits on the first listing), so they would hold the
+// foreground slots listing refreshes and sends need; the background lane's slots belong to status.
 function isLongWaitRuntimeMethod(method: string): boolean {
-  return method === 'worktree.rm'
+  return method === 'worktree.rm' || method === 'agentSession.modelCatalog'
 }
 
 export class RuntimeRpcCallQueuePool {
diff --git a/src/shared/structured-agent-session-draft-hand-off.test.ts b/src/shared/structured-agent-session-draft-hand-off.test.ts
index 6e0cbc7e644..1b42e1a93a1 100644
--- a/src/shared/structured-agent-session-draft-hand-off.test.ts
+++ b/src/shared/structured-agent-session-draft-hand-off.test.ts
@@ -44,7 +44,9 @@ function handOff(dispatchState: AgentJournalSubmission['dispatchState']): AgentJ
 describe('a queued draft handed off under a fresh submission id', () => {
   it('takes the outbox entry off the client, in every dispatch state', () => {
     for (const state of ['pending', 'accepted', 'rejected', 'unknown'] as const) {
-      expect(reconcileStructuredAgentSessionOutboxWithQueue([entry], [handOff(state)])).toEqual([])
+      expect(reconcileStructuredAgentSessionOutboxWithQueue([entry], [handOff(state)], [])).toEqual(
+        []
+      )
     }
   })
 
diff --git a/src/shared/structured-agent-session-draft-hand-off.ts b/src/shared/structured-agent-session-draft-hand-off.ts
index 29a14159038..4e756d331f7 100644
--- a/src/shared/structured-agent-session-draft-hand-off.ts
+++ b/src/shared/structured-agent-session-draft-hand-off.ts
@@ -2,11 +2,9 @@
 // under a fresh submission id, so this link, never a draft id compared with a `clientMessageId`,
 // is how a client knows the host has taken a message over.
 
-import type { AgentJournalSubmission } from './agent-session-journal-types'
-import {
-  reconcileStructuredAgentSessionOutbox,
-  type StructuredAgentSessionOutboxEntry
-} from './structured-agent-session-outbox'
+import type { AgentJournalRenderItem, AgentJournalSubmission } from './agent-session-journal-types'
+import type { StructuredAgentSessionOutboxEntry } from './structured-agent-session-outbox'
+import { reconcileStructuredAgentSessionOutbox } from './structured-agent-session-outbox-reconcile'
 
 /** Ids of the queued drafts the journal shows handed off, in any dispatch state. An outbox entry
  *  under one of these ids belongs to the host: its card or bubble carries the text from here. */
@@ -29,13 +27,14 @@ export function handedOffQueuedMessageIds(
  */
 export function reconcileStructuredAgentSessionOutboxWithQueue(
   entries: readonly StructuredAgentSessionOutboxEntry[],
-  submissions: readonly AgentJournalSubmission[]
-): StructuredAgentSessionOutboxEntry[] {
+  submissions: readonly AgentJournalSubmission[],
+  items: readonly AgentJournalRenderItem[]
+): readonly StructuredAgentSessionOutboxEntry[] {
   const handedOff = handedOffQueuedMessageIds(submissions)
+  const ours = entries.filter((entry) => !handedOff.has(entry.clientMessageId))
   return reconcileStructuredAgentSessionOutbox(
-    handedOff.size === 0
-      ? entries
-      : entries.filter((entry) => !handedOff.has(entry.clientMessageId)),
-    submissions
+    ours.length === entries.length ? entries : ours,
+    submissions,
+    items
   )
 }
diff --git a/src/shared/structured-agent-session-message-projection.ts b/src/shared/structured-agent-session-message-projection.ts
index 5515b6478a2..57a2f6fe15d 100644
--- a/src/shared/structured-agent-session-message-projection.ts
+++ b/src/shared/structured-agent-session-message-projection.ts
@@ -1,33 +1,110 @@
 import type { AgentJournalRenderItem, AgentJournalSubmission } from './agent-session-journal-types'
 import { agentJournalSubmissionKey } from './agent-session-journal-item-key'
-import { agentJournalItemPosition } from './agent-session-journal-position'
 import { isQueuedAgentJournalSubmission } from './agent-session-queued-submission'
 import { collapseProviderRetryRuns } from './native-chat-provider-retry-runs'
 import type { NativeChatMessage } from './native-chat-types'
+import { dispatchWasWithdrawn } from './structured-agent-session-dispatch-rejection'
 import type { StructuredAgentSessionOutboxEntry } from './structured-agent-session-outbox'
 import { structuredAgentSessionEntryHeldForRetry } from './structured-agent-session-outbox-admission'
 import { reconcileStructuredAgentSessionOutboxWithQueue } from './structured-agent-session-draft-hand-off'
 import { projectStructuredItemsToNativeChat } from './structured-agent-session-projection'
 
+export type StructuredAgentSessionMessageProjectionOptions = {
+  /** Draw a message the host accepted and then rejected where the host recorded it, as not sent.
+   *  Off for a client that hands such a message back to its composer instead. */
+  rejectedInPlace: boolean
+  /** The queue's live cards: a rejected message one of them holds is drawn there, not here. */
+  queuedMessageIds?: readonly string[]
+}
+
+/** The loaded items that are a conversation command such as `/compact`, by item id. */
+export function structuredAgentSessionCommandItemIds(
+  items: readonly AgentJournalRenderItem[]
+): Set<string> {
+  return new Set(
+    items
+      .filter((item) => item.body.kind === 'message' && item.body.command)
+      .map((item) => item.itemId)
+  )
+}
+
+/**
+ * The rejected submissions the host's history shows in place as not sent, by item id; `submissions`
+ * in submission order, as the client keeps them. A withdrawn one went back to its sender, one the
+ * queue holds (a draft's hand-off, or a card under its id) is drawn as its card, and a command such
+ * as `/compact` has its rejection reported as its own reply.
+ */
+export function structuredAgentSessionRejectedShownInPlace(
+  submissions: readonly AgentJournalSubmission[],
+  queuedMessageIds: readonly string[],
+  commandItemIds: ReadonlySet<string>
+): Set<string> {
+  const cards = new Set(queuedMessageIds)
+  // Each body's copies, as positions in submission order. A withdrawn one is hidden too, so it
+  // supersedes nothing.
+  const copies = new Map<string, { index: number; submittedAt: number }[]>()
+  for (const [index, submission] of submissions.entries()) {
+    if (!dispatchWasWithdrawn(submission)) {
+      const copy = { index, submittedAt: submission.submittedAt }
+      const same = copies.get(submission.payloadFingerprint)
+      if (same) {
+        same.push(copy)
+      } else {
+        copies.set(submission.payloadFingerprint, [copy])
+      }
+    }
+  }
+  const shown = new Set<string>()
+  for (const [index, submission] of submissions.entries()) {
+    const { resolvedAt } = submission
+    if (
+      submission.dispatchState !== 'rejected' ||
+      dispatchWasWithdrawn(submission) ||
+      submission.queuedMessageId !== undefined ||
+      cards.has(submission.clientMessageId) ||
+      commandItemIds.has(agentJournalSubmissionKey(submission.clientMessageId)) ||
+      // Collapses resends of a rejected message: past Retries resent it under a new id, and the
+      // host re-delivers its own messages under new ids. Only a later copy sent once the rejection
+      // was known counts, so a repeat sent before it is kept.
+      (resolvedAt !== null &&
+        (copies.get(submission.payloadFingerprint) ?? []).some(
+          (copy) => copy.index > index && copy.submittedAt >= resolvedAt
+        ))
+    ) {
+      continue
+    }
+    shown.add(agentJournalSubmissionKey(submission.clientMessageId))
+  }
+  return shown
+}
+
 export function projectStructuredAgentSessionMessages(
   items: readonly AgentJournalRenderItem[],
   outbox: readonly StructuredAgentSessionOutboxEntry[],
   submissions: readonly AgentJournalSubmission[],
+  options: StructuredAgentSessionMessageProjectionOptions,
   projectItems = projectStructuredItemsToNativeChat
 ): NativeChatMessage[] {
-  const optimistic = reconcileStructuredAgentSessionOutboxWithQueue(outbox, submissions)
-  // Refused sends are ledger evidence, not conversation history; local drafts remain in the outbox.
+  const optimistic = reconcileStructuredAgentSessionOutboxWithQueue(outbox, submissions, items)
+  // Refused sends are ledger evidence, not conversation history, unless drawn in place as not sent.
   const rejected = new Set(
     submissions
       .filter((submission) => submission.dispatchState === 'rejected')
       .map((submission) => agentJournalSubmissionKey(submission.clientMessageId))
   )
+  const inPlace = options.rejectedInPlace
+    ? structuredAgentSessionRejectedShownInPlace(
+        submissions,
+        options.queuedMessageIds ?? [],
+        structuredAgentSessionCommandItemIds(items)
+      )
+    : new Set<string>()
   const visibleItems: AgentJournalRenderItem[] = []
-  const refused = new Map<string, AgentJournalRenderItem>()
+  const unsentItems: AgentJournalRenderItem[] = []
   for (const item of items) {
-    if (rejected.has(item.itemId)) {
-      refused.set(item.itemId, item)
-    } else {
+    if (inPlace.has(item.itemId)) {
+      unsentItems.push(item)
+    } else if (!rejected.has(item.itemId)) {
       visibleItems.push(item)
     }
   }
@@ -52,23 +129,19 @@ export function projectStructuredAgentSessionMessages(
     // After the held sends leave: they are drawn after the conversation, never inside a run.
     ...collapseProviderRetryRuns(delivered),
     ...held,
+    // In no turn, like the outbox's not-sent rows; the journal position keeps their place.
+    ...projectItems(unsentItems).map((message) => ({ ...message, unsent: true as const })),
     ...optimistic
       .filter((entry) => !journalled.has(agentJournalSubmissionKey(entry.clientMessageId)))
-      .map((entry): NativeChatMessage => {
-        const id = agentJournalSubmissionKey(entry.clientMessageId)
-        const recorded = refused.get(id)
-        return {
-          id,
-          role: 'user',
-          source: 'transcript',
-          timestamp: entry.queuedAt,
-          blocks: entry.body.blocks,
-          ...(entry.state === 'rejected' || structuredAgentSessionEntryHeldForRetry(entry)
-            ? { unsent: true as const }
-            : {}),
-          // A send the journal recorded before refusing it keeps its place there.
-          ...(recorded ? { journalPosition: agentJournalItemPosition(recorded) } : {})
-        }
-      })
+      .map((entry): NativeChatMessage => ({
+        id: agentJournalSubmissionKey(entry.clientMessageId),
+        role: 'user',
+        source: 'transcript',
+        timestamp: entry.queuedAt,
+        blocks: entry.body.blocks,
+        ...(entry.state === 'rejected' || structuredAgentSessionEntryHeldForRetry(entry)
+          ? { unsent: true as const }
+          : {})
+      }))
   ]
 }
diff --git a/src/shared/structured-agent-session-options.ts b/src/shared/structured-agent-session-options.ts
index c397ce4e5fe..1d1d559eaae 100644
--- a/src/shared/structured-agent-session-options.ts
+++ b/src/shared/structured-agent-session-options.ts
@@ -222,6 +222,17 @@ export function lockedStructuredAgentSessionOptionSnapshot(
   }))
 }
 
+/** While the host runs its first model listing, nothing is picked from the stand-in list. */
+export function pendingModelListStructuredAgentSessionOptionSnapshot(
+  snapshot: readonly SessionOptionDescriptor[]
+): SessionOptionDescriptor[] {
+  return snapshot.map((descriptor) =>
+    descriptor.category === 'model'
+      ? { ...descriptor, settable: false, choicesPending: true }
+      : descriptor
+  )
+}
+
 export function canSetStructuredAgentSessionOption(
   state: StructuredAgentSessionOptionState,
   id: string,
diff --git a/src/shared/structured-agent-session-outbox-reconcile.test.ts b/src/shared/structured-agent-session-outbox-reconcile.test.ts
new file mode 100644
index 00000000000..0336bd649e4
--- /dev/null
+++ b/src/shared/structured-agent-session-outbox-reconcile.test.ts
@@ -0,0 +1,100 @@
+// The reconcile runs on every journal batch, so reading an unchanged journal again must change
+// nothing: the same entries, and the same list.
+
+import { expect, it } from 'vitest'
+import { agentJournalSubmissionKey } from './agent-session-journal-item-key'
+import type {
+  AgentJournalDispatchState,
+  AgentJournalRenderItem,
+  AgentJournalSubmission
+} from './agent-session-journal-types'
+import {
+  createStructuredAgentSessionOutboxEntry,
+  type StructuredAgentSessionOutboxEntry
+} from './structured-agent-session-outbox'
+import { reconcileStructuredAgentSessionOutbox } from './structured-agent-session-outbox-reconcile'
+
+function entry(
+  id: string,
+  patch: Partial<StructuredAgentSessionOutboxEntry> = {}
+): StructuredAgentSessionOutboxEntry {
+  return {
+    ...createStructuredAgentSessionOutboxEntry({
+      clientMessageId: id,
+      sessionId: 'session-1',
+      text: id,
+      attachments: [],
+      queuedAt: 1
+    }),
+    ...patch
+  }
+}
+
+function submission(id: string, dispatchState: AgentJournalDispatchState): AgentJournalSubmission {
+  return {
+    clientMessageId: id,
+    fence: 1,
+    payloadFingerprint: id,
+    dispatchState,
+    providerItemId: null,
+    reason: dispatchState === 'unknown' ? 'in doubt' : null,
+    ...(dispatchState === 'rejected' ? { rejection: { kind: 'hostRestarted' } } : {}),
+    submittedAt: 5,
+    resolvedAt: dispatchState === 'pending' ? null : 6
+  }
+}
+
+function row(id: string): AgentJournalRenderItem {
+  return {
+    itemId: agentJournalSubmissionKey(id),
+    revision: 1,
+    sequence: 1,
+    observedAt: 1,
+    body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: id }] }
+  }
+}
+
+it('returns every kept entry, and the list, as themselves when read again', () => {
+  const entries = [
+    entry('queued'),
+    entry('landing', { state: 'unconfirmed', lastFailure: { kind: 'failed' } }),
+    entry('sending', { state: 'dispatching' }),
+    entry('doubt', { state: 'dispatching', lastFailure: { kind: 'failed' } }),
+    entry('rejected-unloaded', { state: 'dispatching' }),
+    entry('rejected-loaded', { state: 'dispatching' }),
+    entry('delivered', { state: 'dispatching' }),
+    entry('refused', {
+      state: 'rejected',
+      lastFailure: { kind: 'refused', code: 'agent_session_operation_invalid' }
+    })
+  ]
+  const submissions = [
+    submission('landing', 'pending'),
+    submission('sending', 'pending'),
+    submission('doubt', 'unknown'),
+    submission('rejected-unloaded', 'rejected'),
+    submission('rejected-loaded', 'rejected'),
+    submission('delivered', 'accepted')
+  ]
+  const items = [row('rejected-loaded')]
+
+  const first = reconcileStructuredAgentSessionOutbox(entries, submissions, items)
+  expect(first.map((kept) => [kept.clientMessageId, kept.state])).toEqual([
+    ['queued', 'queued'],
+    ['landing', 'dispatching'],
+    ['sending', 'dispatching'],
+    ['doubt', 'unconfirmed'],
+    ['rejected-unloaded', 'rejected'],
+    ['refused', 'rejected']
+  ])
+  const second = reconcileStructuredAgentSessionOutbox(first, submissions, items)
+  expect(second).toBe(first)
+  second.forEach((kept, index) => expect(kept).toBe(first[index]))
+})
+
+it('returns the list it was given when nothing changes', () => {
+  const entries = [entry('queued'), entry('doubt', { state: 'unconfirmed' })]
+  expect(reconcileStructuredAgentSessionOutbox(entries, [submission('doubt', 'unknown')], [])).toBe(
+    entries
+  )
+})
diff --git a/src/shared/structured-agent-session-outbox-reconcile.ts b/src/shared/structured-agent-session-outbox-reconcile.ts
new file mode 100644
index 00000000000..9fa699eece1
--- /dev/null
+++ b/src/shared/structured-agent-session-outbox-reconcile.ts
@@ -0,0 +1,69 @@
+// How the journal's view of each submission settles the outbox: the sibling of
+// `disposeStructuredAgentSessionSendResult`, which folds a single send's answer.
+
+import { agentJournalSubmissionKey } from './agent-session-journal-item-key'
+import type { AgentJournalRenderItem, AgentJournalSubmission } from './agent-session-journal-types'
+import { dispatchWasWithdrawn } from './structured-agent-session-dispatch-rejection'
+import {
+  structuredAgentSessionEntryRejectedByHost,
+  structuredAgentSessionRejectedFailure,
+  type StructuredAgentSessionOutboxEntry
+} from './structured-agent-session-outbox'
+
+export function reconcileStructuredAgentSessionOutbox(
+  entries: readonly StructuredAgentSessionOutboxEntry[],
+  submissions: readonly AgentJournalSubmission[],
+  /** The loaded journal rows: a rejected message leaves only once the row that draws it is here. */
+  items: readonly AgentJournalRenderItem[]
+): readonly StructuredAgentSessionOutboxEntry[] {
+  const settled = new Map(submissions.map((entry) => [entry.clientMessageId, entry]))
+  let loaded: Set<string> | undefined
+  // An entry whose reconciled value is unchanged is returned as itself, and so is the list when
+  // none changed: a caller re-reading every journal batch writes nothing then.
+  const next = entries.flatMap((entry) => {
+    const submission = settled.get(entry.clientMessageId)
+    // Settled by the host: its history shows one delivered; a withdrawn one goes back to the
+    // composer.
+    if (submission?.dispatchState === 'accepted' || dispatchWasWithdrawn(submission)) {
+      return []
+    }
+    if (submission?.dispatchState === 'rejected') {
+      // Its row draws it once loaded; until then the entry does, as the host recorded it. An older
+      // host leaves that row where it was sent, which may be outside the loaded window.
+      loaded ??= new Set(items.map((item) => item.itemId))
+      if (loaded.has(agentJournalSubmissionKey(entry.clientMessageId))) {
+        return []
+      }
+      const lastFailure = structuredAgentSessionRejectedFailure(submission)
+      return [
+        structuredAgentSessionEntryRejectedByHost(entry)
+          ? entry
+          : { ...entry, state: 'rejected' as const, lastFailure }
+      ]
+    }
+    if (submission?.dispatchState === 'pending') {
+      if (entry.state === 'dispatching') {
+        return [entry]
+      }
+      // The host has it, so no failure of an earlier attempt describes it now.
+      const { lastFailure: _landed, ...landed } = entry
+      return [{ ...landed, state: 'dispatching' as const }]
+    }
+    if (
+      submission?.dispatchState === 'unknown' &&
+      entry.retryAfterUnknownSubmittedAt !== -1 &&
+      entry.retryAfterUnknownSubmittedAt !== submission.submittedAt
+    ) {
+      // In doubt now, not failed: the probe's resend decides it, as for any unconfirmed send.
+      if (entry.state === 'unconfirmed' && entry.lastFailure === undefined) {
+        return [entry]
+      }
+      const { lastFailure: _superseded, ...inDoubt } = entry
+      return [{ ...inDoubt, state: 'unconfirmed' as const }]
+    }
+    return [entry]
+  })
+  return next.length === entries.length && next.every((entry, index) => entry === entries[index])
+    ? entries
+    : next
+}
diff --git a/src/shared/structured-agent-session-outbox-retry-hold.test.ts b/src/shared/structured-agent-session-outbox-retry-hold.test.ts
index 3f0c439fc9a..cd2bb570b57 100644
--- a/src/shared/structured-agent-session-outbox-retry-hold.test.ts
+++ b/src/shared/structured-agent-session-outbox-retry-hold.test.ts
@@ -2,9 +2,9 @@ import { describe, expect, it } from 'vitest'
 import type { AgentJournalSubmission } from './agent-session-journal-types'
 import {
   createStructuredAgentSessionOutboxEntry,
-  reconcileStructuredAgentSessionOutbox,
   type StructuredAgentSessionOutboxEntry
 } from './structured-agent-session-outbox'
+import { reconcileStructuredAgentSessionOutbox } from './structured-agent-session-outbox-reconcile'
 import {
   admitStructuredAgentSessionOutboxEntry,
   structuredAgentSessionEntryHeldForRetry
@@ -71,7 +71,8 @@ describe('a message held for its Retry', () => {
     }
     const [landed] = reconcileStructuredAgentSessionOutbox(
       [entry('held', { lastFailure: REFUSED })],
-      [submission]
+      [submission],
+      []
     )
     expect(landed?.state).toBe('dispatching')
     expect(landed?.lastFailure).toBeUndefined()
@@ -91,7 +92,8 @@ describe('a message held for its Retry', () => {
     }
     const reconciled = reconcileStructuredAgentSessionOutbox(
       [entry('held', { lastAttemptAt: 2, lastFailure: REFUSED }), entry('next')],
-      [submission]
+      [submission],
+      []
     )
     expect(reconciled[0]).toMatchObject({ state: 'unconfirmed' })
     expect(reconciled[0]?.lastFailure).toBeUndefined()
diff --git a/src/shared/structured-agent-session-outbox-unconfirmed-resend.ts b/src/shared/structured-agent-session-outbox-unconfirmed-resend.ts
new file mode 100644
index 00000000000..ee65fed7287
--- /dev/null
+++ b/src/shared/structured-agent-session-outbox-unconfirmed-resend.ts
@@ -0,0 +1,18 @@
+// Which send in doubt Orca resends on its own under the same id, without the user's Retry.
+
+import type { AgentJournalSubmission } from './agent-session-journal-types'
+import type { StructuredAgentSessionOutboxEntry } from './structured-agent-session-outbox'
+
+/** Whether the unconfirmed probe resends this entry: in doubt, never retried by the user, not
+ *  outlived by a Stop, and with no journal row yet. Any row ends it: the journal answers from there. */
+export function structuredAgentSessionEntryResendsUnconfirmed(
+  entry: StructuredAgentSessionOutboxEntry,
+  submissions: readonly AgentJournalSubmission[]
+): boolean {
+  return (
+    entry.state === 'unconfirmed' &&
+    entry.retryAfterUnknownSubmittedAt === null &&
+    entry.outlivedStop !== true &&
+    !submissions.some((submission) => submission.clientMessageId === entry.clientMessageId)
+  )
+}
diff --git a/src/shared/structured-agent-session-outbox.ts b/src/shared/structured-agent-session-outbox.ts
index 7b3606f3dc8..32dcab0e66b 100644
--- a/src/shared/structured-agent-session-outbox.ts
+++ b/src/shared/structured-agent-session-outbox.ts
@@ -1,6 +1,6 @@
 import type { AgentSessionFailureFact } from './agent-session-failure'
 import { readWholeAgentSessionFailureFact } from './agent-session-failure'
-import type { AgentJournalMessageItem, AgentJournalSubmission } from './agent-session-journal-types'
+import type { AgentJournalMessageItem } from './agent-session-journal-types'
 import {
   parseAgentSessionWriteFailure,
   type AgentSessionWriteFailure,
@@ -14,11 +14,11 @@ import {
   structuredAgentSessionMessageSendMutation,
   type StructuredAgentSessionSendMutation
 } from './structured-agent-session-send-mutation'
-import { classifyDispatchRejection } from './structured-agent-session-dispatch-rejection'
 import { parseStructuredAgentSessionOutboxQueueFields } from './structured-agent-session-outbox-delivery'
 
-/** `rejected`: the host settled the send as not delivered. The drain never sends it again on its
- *  own and nothing queues behind it; only the user's Retry does. */
+/** `rejected`: settled as not delivered. The drain never sends it again and nothing queues behind
+ *  it. One the host refused unrecorded waits for the user's Retry. One it recorded owes no delivery
+ *  and leaves on the batch or page that loads its row (`structured-agent-session-outbox-reconcile`). */
 export type StructuredAgentSessionOutboxState =
   | 'queued'
   | 'dispatching'
@@ -176,6 +176,14 @@ export function structuredAgentSessionEntryIdExpired(
   )
 }
 
+/** The host recorded this send and then rejected it: no Retry, since sending it again is a new
+ *  message. The reconcile drops it once the client holds the rejected submission. */
+export function structuredAgentSessionEntryRejectedByHost(
+  entry: StructuredAgentSessionOutboxEntry
+): boolean {
+  return entry.state === 'rejected' && entry.lastFailure?.kind === 'rejected'
+}
+
 export function requeueStructuredAgentSessionSendRefusal(
   entry: StructuredAgentSessionOutboxEntry,
   refusal: AgentSessionWriteRefusal,
@@ -208,58 +216,6 @@ export function requeueStructuredAgentSessionSendRefusal(
   }
 }
 
-export function reconcileStructuredAgentSessionOutbox(
-  entries: readonly StructuredAgentSessionOutboxEntry[],
-  submissions: readonly AgentJournalSubmission[]
-): StructuredAgentSessionOutboxEntry[] {
-  const settled = new Map(submissions.map((entry) => [entry.clientMessageId, entry]))
-  return entries.flatMap((entry) => {
-    const submission = settled.get(entry.clientMessageId)
-    if (submission?.dispatchState === 'accepted') {
-      return []
-    }
-    if (
-      submission?.dispatchState === 'rejected' &&
-      classifyDispatchRejection(submission).category === 'withdrawn'
-    ) {
-      return []
-    }
-    if (submission?.dispatchState === 'pending') {
-      if (entry.state === 'dispatching') {
-        return [entry]
-      }
-      // The host has it, so no failure of an earlier attempt describes it now.
-      const { lastFailure: _landed, ...landed } = entry
-      return [{ ...landed, state: 'dispatching' as const }]
-    }
-    // Accepted, then not delivered — the agent never started, or its start was refused. The text
-    // and why stay here for the user's Retry, and nothing queues behind it. `unconfirmed` is how a
-    // remount reads an entry it left dispatching; the journal has since answered it.
-    if (
-      submission?.dispatchState === 'rejected' &&
-      (entry.state === 'dispatching' || entry.state === 'unconfirmed')
-    ) {
-      return [
-        {
-          ...entry,
-          state: 'rejected' as const,
-          lastFailure: structuredAgentSessionRejectedFailure(submission)
-        }
-      ]
-    }
-    if (
-      submission?.dispatchState === 'unknown' &&
-      entry.retryAfterUnknownSubmittedAt !== -1 &&
-      entry.retryAfterUnknownSubmittedAt !== submission.submittedAt
-    ) {
-      // In doubt now, not failed: the probe's resend decides it, as for any unconfirmed send.
-      const { lastFailure: _superseded, ...inDoubt } = entry
-      return [{ ...inDoubt, state: 'unconfirmed' as const }]
-    }
-    return [entry]
-  })
-}
-
 export function parseStructuredAgentSessionOutboxEntry(
   value: unknown,
   sessionId: string
diff --git a/src/shared/structured-agent-session-send-disposition.test.ts b/src/shared/structured-agent-session-send-disposition.test.ts
index 98ea2ff8b67..9605764b017 100644
--- a/src/shared/structured-agent-session-send-disposition.test.ts
+++ b/src/shared/structured-agent-session-send-disposition.test.ts
@@ -19,9 +19,9 @@ import {
 } from './structured-agent-session-send-disposition'
 import {
   createStructuredAgentSessionOutboxEntry,
-  reconcileStructuredAgentSessionOutbox,
   type StructuredAgentSessionOutboxEntry
 } from './structured-agent-session-outbox'
+import { reconcileStructuredAgentSessionOutbox } from './structured-agent-session-outbox-reconcile'
 import { structuredAgentSessionEntryHeldForRetry } from './structured-agent-session-outbox-admission'
 
 const entry: StructuredAgentSessionOutboxEntry = createStructuredAgentSessionOutboxEntry({
@@ -120,7 +120,9 @@ describe('what a rejection shows the user', () => {
       throw new Error('expected rejected submission fixture')
     }
 
-    expect(reconcileStructuredAgentSessionOutbox([entry], [result.value.submission])).toEqual([])
+    expect(reconcileStructuredAgentSessionOutbox([entry], [result.value.submission], [])).toEqual(
+      []
+    )
   })
 
   it('never puts the transport marker on screen', () => {
@@ -168,7 +170,9 @@ describe('what a rejection shows the user', () => {
     if (!result.ok || !('submission' in result.value)) {
       throw new Error('expected rejected submission fixture')
     }
-    expect(reconcileStructuredAgentSessionOutbox([entry], [result.value.submission])).toEqual([])
+    expect(reconcileStructuredAgentSessionOutbox([entry], [result.value.submission], [])).toEqual(
+      []
+    )
     expect(
       disposeStructuredAgentSessionSendResult({
         entries: [entry],
diff --git a/src/shared/structured-agent-session-send-disposition.ts b/src/shared/structured-agent-session-send-disposition.ts
index d503b453b8e..77e1030d4b2 100644
--- a/src/shared/structured-agent-session-send-disposition.ts
+++ b/src/shared/structured-agent-session-send-disposition.ts
@@ -83,8 +83,8 @@ function dropEntry(input: SendDispositionInput): StructuredAgentSessionOutboxEnt
  * the outbox. Nothing is lost from the conversation: the durable submission row
  * already renders the message.
  *
- * A `rejected` submission takes the other path — the message provably did not
- * happen, so Retry rotates the id and sends it as a genuinely new message.
+ * A `rejected` submission is the host's to show, with no Retry: the reconcile
+ * drops its entry once the journal carries it.
  */
 function refusedRedelivery(
   entry: StructuredAgentSessionOutboxEntry,
@@ -274,6 +274,8 @@ export function disposeStructuredAgentSessionSendResult(
       error: null
     }
   }
+  // Recorded, so the journal's row shows it once it arrives; until then the entry draws it, saying
+  // why and offering no Retry.
   if (submission.dispatchState === 'rejected') {
     return {
       entries: replaceEntryState(
diff --git a/src/shared/terminal-alternate-screen-split.ts b/src/shared/terminal-alternate-screen-split.ts
new file mode 100644
index 00000000000..1c42ed331af
--- /dev/null
+++ b/src/shared/terminal-alternate-screen-split.ts
@@ -0,0 +1,15 @@
+const ALTERNATE_SCREEN_ENTRY = '\x1b[?1049h'
+
+/** Splits a serialized image at its last alt-screen entry; null when it never enters alt. */
+export function splitAtAlternateScreenEntry(
+  ansi: string
+): { normalAnsi: string; alternateAnsi: string } | null {
+  const start = ansi.lastIndexOf(ALTERNATE_SCREEN_ENTRY)
+  if (start === -1) {
+    return null
+  }
+  return {
+    normalAnsi: ansi.slice(0, start),
+    alternateAnsi: ansi.slice(start + ALTERNATE_SCREEN_ENTRY.length)
+  }
+}
diff --git a/src/shared/terminal-cursor-line-context.ts b/src/shared/terminal-cursor-line-context.ts
index 28fc2402fe2..857adb037e5 100644
--- a/src/shared/terminal-cursor-line-context.ts
+++ b/src/shared/terminal-cursor-line-context.ts
@@ -47,32 +47,30 @@ function undimmedText<Cell extends TerminalCursorCell>(
   return trimRight ? text.trimEnd() : text
 }
 
-function firstVisibleCellIsBold<Cell extends TerminalCursorCell>(
+function readUndimmedTextAndFirstVisibleStyle<Cell extends TerminalCursorCell>(
   line: TerminalCursorLine<Cell>,
+  trimRight: boolean,
+  style: 'bold' | 'customForeground',
   reusableCell?: Cell
-): boolean {
+): { text: string; firstVisibleStyle: boolean } {
+  let text = ''
+  let firstVisibleStyle = false
+  let foundVisibleCell = false
   for (let x = 0; x < line.length; x += 1) {
     const cell = line.getCell(x, reusableCell)
-    if (!cell || cell.getWidth() === 0 || !cell.getChars().trim()) {
+    if (!cell || cell.getWidth() === 0) {
       continue
     }
-    return Boolean(cell.isBold())
-  }
-  return false
-}
-
-function firstVisibleCellHasCustomForeground<Cell extends TerminalCursorCell>(
-  line: TerminalCursorLine<Cell>,
-  reusableCell?: Cell
-): boolean {
-  for (let x = 0; x < line.length; x += 1) {
-    const cell = line.getCell(x, reusableCell)
-    if (!cell || cell.getWidth() === 0 || !cell.getChars().trim()) {
-      continue
+    const chars = cell.getChars()
+    if (!foundVisibleCell && chars.trim()) {
+      firstVisibleStyle = style === 'bold' ? Boolean(cell.isBold()) : !cell.isFgDefault()
+      foundVisibleCell = true
+    }
+    if (!cell.isDim()) {
+      text += chars || ' '
     }
-    return !cell.isFgDefault()
   }
-  return false
+  return { text: trimRight ? text.trimEnd() : text, firstVisibleStyle }
 }
 
 export function readTerminalCursorLineContext<Cell extends TerminalCursorCell>(
@@ -96,8 +94,11 @@ export function readTerminalCursorLineContext<Cell extends TerminalCursorCell>(
     const line = buffer.getLine(row)
     const nextLineIsWrapped = buffer.getLine(row + 1)?.isWrapped ?? false
     rows.push(line?.translateToString(!nextLineIsWrapped) ?? '')
-    typedRows.push(line ? undimmedText(line, 0, !nextLineIsWrapped, reusableCell) : '')
-    promptGlyphBoldRows.push(line ? firstVisibleCellIsBold(line, reusableCell) : false)
+    const scan = line
+      ? readUndimmedTextAndFirstVisibleStyle(line, !nextLineIsWrapped, 'bold', reusableCell)
+      : undefined
+    typedRows.push(scan?.text ?? '')
+    promptGlyphBoldRows.push(scan?.firstVisibleStyle ?? false)
     rowsWrapped.push(line?.isWrapped ?? false)
   }
   const rowsBelow: string[] = []
@@ -109,11 +110,17 @@ export function readTerminalCursorLineContext<Cell extends TerminalCursorCell>(
     const line = buffer.getLine(row)
     const nextLineIsWrapped = buffer.getLine(row + 1)?.isWrapped ?? false
     rowsBelow.push(line?.translateToString(!nextLineIsWrapped) ?? '')
-    typedRowsBelow.push(line ? undimmedText(line, 0, !nextLineIsWrapped, reusableCell) : '')
+    const scan = line
+      ? readUndimmedTextAndFirstVisibleStyle(
+          line,
+          !nextLineIsWrapped,
+          'customForeground',
+          reusableCell
+        )
+      : undefined
+    typedRowsBelow.push(scan?.text ?? '')
     rowsBelowWrapped.push(line?.isWrapped ?? false)
-    rowsBelowCustomForeground.push(
-      line ? firstVisibleCellHasCustomForeground(line, reusableCell) : false
-    )
+    rowsBelowCustomForeground.push(scan?.firstVisibleStyle ?? false)
   }
   return {
     rows,
diff --git a/src/shared/text-search-dense-matches.test.ts b/src/shared/text-search-dense-matches.test.ts
index e32cd6b35e4..548b04d70e4 100644
--- a/src/shared/text-search-dense-matches.test.ts
+++ b/src/shared/text-search-dense-matches.test.ts
@@ -6,6 +6,43 @@ import { runProcess } from './child-process/run-process'
 import { buildRgArgs, createAccumulator, ingestRgJsonLine } from './text-search'
 
 describe('text search match budgets', () => {
+  it.each(['x', '😀'])(
+    'keeps whole Unicode context around dense real rg matches for %s',
+    async (query) => {
+      const { rgPath } = await import('@vscode/ripgrep-universal')
+      const root = await mkdtemp(join(tmpdir(), 'orca-rg-dense-unicode-'))
+      const filename = join(root, 'unicode.txt')
+      try {
+        await writeFile(filename, `a${'😀x'.repeat(10_000)}\n`)
+        const result = await runProcess({
+          program: rgPath,
+          args: buildRgArgs(query, '.', {}),
+          cwd: root
+        })
+        expect(result.code).toBe(0)
+        const accumulator = createAccumulator()
+        for (const line of result.stdout.split('\n')) {
+          if (ingestRgJsonLine(line, root, accumulator, 2000) === 'stop') {
+            break
+          }
+        }
+        expect(accumulator.totalMatches).toBe(2000)
+        const matches = accumulator.fileMap.get(filename)?.matches ?? []
+        expect(matches).toHaveLength(2000)
+        for (const [index, match] of matches.entries()) {
+          expect(match.column).toBe(index * 3 + (query === 'x' ? 4 : 2))
+          expect(match.matchLength).toBe(query.length)
+          expect(match.lineContent.isWellFormed()).toBe(true)
+          const start = (match.displayColumn ?? match.column) - 1
+          const length = match.displayMatchLength ?? match.matchLength
+          expect(match.lineContent.slice(start, start + length)).toBe(query)
+        }
+      } finally {
+        await rm(root, { recursive: true, force: true })
+      }
+    }
+  )
+
   it('keeps dense-line columns after a leading U+FEFF from real rg', async () => {
     const { rgPath } = await import('@vscode/ripgrep-universal')
     const root = await mkdtemp(join(tmpdir(), 'orca-rg-dense-bom-'))
diff --git a/src/shared/text-search-match-accumulator.ts b/src/shared/text-search-match-accumulator.ts
index addad7ee707..391bb2587c9 100644
--- a/src/shared/text-search-match-accumulator.ts
+++ b/src/shared/text-search-match-accumulator.ts
@@ -1,7 +1,10 @@
 import type { SearchFileResult, SearchMatch } from './code-search-types'
 import type { SearchAccumulator } from './text-search'
+import { sliceAtCodeUnitLimit } from './surrogate-safe-text-slice'
+import { ownRetainedString } from './own-retained-string'
 
-const MAX_LINE_CONTENT_LENGTH = 500
+// Bound repeated context so dense search results fit within the SSH message limit.
+export const MAX_LINE_CONTENT_LENGTH = 500
 const TRUNCATION_MARKER = '…'
 
 type ClampedLineContext = {
@@ -24,11 +27,20 @@ function clampLineContext(
   const remaining = MAX_LINE_CONTENT_LENGTH - clampedMatchLength
   const leftBudget = Math.floor(remaining / 2)
   let windowStart = Math.max(0, matchStart - leftBudget)
-  const windowEnd = Math.min(text.length, windowStart + MAX_LINE_CONTENT_LENGTH)
+  let windowEnd = Math.min(text.length, windowStart + MAX_LINE_CONTENT_LENGTH)
   windowStart = Math.max(0, windowEnd - MAX_LINE_CONTENT_LENGTH)
+  if (windowStart > 0 && (text.codePointAt(windowStart - 1) ?? 0) > 0xffff) {
+    windowStart++
+  }
 
-  let snippet = text.slice(windowStart, windowEnd)
-  let column = matchStart - windowStart + 1
+  let snippet = sliceAtCodeUnitLimit(text.slice(windowStart), windowEnd - windowStart)
+  windowEnd = windowStart + snippet.length
+  const displayStart = Math.max(windowStart, Math.min(matchStart, windowEnd))
+  const displayMatchLength = Math.max(
+    0,
+    Math.min(matchStart + matchLength, windowEnd) - displayStart
+  )
+  let column = displayStart - windowStart + 1
   if (windowStart > 0) {
     snippet = TRUNCATION_MARKER + snippet
     column += TRUNCATION_MARKER.length
@@ -37,11 +49,12 @@ function clampLineContext(
     snippet += TRUNCATION_MARKER
   }
   return {
-    lineContent: snippet,
+    // A tiny slice can otherwise retain the entire source line until results are released.
+    lineContent: ownRetainedString(snippet),
     column: matchStart + 1,
     matchLength,
     displayColumn: column,
-    displayMatchLength: clampedMatchLength
+    displayMatchLength
   }
 }
 
diff --git a/src/shared/text-search-snippet-boundaries.test.ts b/src/shared/text-search-snippet-boundaries.test.ts
new file mode 100644
index 00000000000..57f91f82fea
--- /dev/null
+++ b/src/shared/text-search-snippet-boundaries.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, it } from 'vitest'
+import {
+  createAccumulator,
+  ingestGitGrepLine,
+  ingestRgJsonLine,
+  MAX_LINE_CONTENT_LENGTH
+} from './text-search'
+
+describe('search snippet character boundaries', () => {
+  it.each([
+    ['start', '😀'.repeat(300), 'x', 'a'.repeat(600)],
+    ['end', 'a'.repeat(600), 'xx', '😀'.repeat(300)],
+    ['both', '😀'.repeat(300), 'xx', '😀'.repeat(300)],
+    ['long match', 'a'.repeat(10), `x${'😀'.repeat(300)}`, 'b'.repeat(600)],
+    ['zero width', '😀'.repeat(300), '', '😀'.repeat(300)],
+    ['zero width at EOF', `${'😀'.repeat(301)}x`, '', ''],
+    ['first character', '', '😀', 'a'.repeat(600)],
+    ['last character', 'a'.repeat(600), '😀', ''],
+    ['short line', '😀', 'x', '😀']
+  ])(
+    'keeps the %s boundary whole and retains navigation coordinates',
+    (_name, prefix, needle, suffix) => {
+      const text = prefix + needle + suffix
+      const accumulator = createAccumulator()
+      ingestRgJsonLine(
+        JSON.stringify({
+          type: 'match',
+          data: {
+            path: { text: 'unicode.txt' },
+            lines: { text: `${text}\n` },
+            line_number: 7,
+            submatches: [
+              { start: Buffer.byteLength(prefix), end: Buffer.byteLength(prefix + needle) }
+            ]
+          }
+        }),
+        '/root',
+        accumulator,
+        2000
+      )
+      const match = [...accumulator.fileMap.values()][0].matches[0]
+      expect(match).toMatchObject({
+        line: 7,
+        column: prefix.length + 1,
+        matchLength: needle.length
+      })
+      expect(match.lineContent.isWellFormed()).toBe(true)
+      expect(match.lineContent.length).toBeLessThanOrEqual(MAX_LINE_CONTENT_LENGTH + 2)
+      const start = (match.displayColumn ?? match.column) - 1
+      const length = match.displayMatchLength ?? match.matchLength
+      const highlighted = match.lineContent.slice(start, start + length)
+      expect(highlighted.isWellFormed()).toBe(true)
+      expect(needle.startsWith(highlighted)).toBe(true)
+      if (needle.length <= MAX_LINE_CONTENT_LENGTH) {
+        expect(highlighted).toBe(needle)
+      } else {
+        expect(length).toBe(MAX_LINE_CONTENT_LENGTH - 1)
+        expect(highlighted).toBe(`x${'😀'.repeat(249)}`)
+      }
+    }
+  )
+
+  it('uses the same character-safe context for the remote git fallback', () => {
+    const prefix = '😀'.repeat(300)
+    const accumulator = createAccumulator()
+    ingestGitGrepLine(`unicode.txt\x001\x00${prefix}xx${prefix}`, '/root', /xx/g, accumulator, 2000)
+    const match = [...accumulator.fileMap.values()][0].matches[0]
+    expect(match.lineContent.isWellFormed()).toBe(true)
+    expect(match.column).toBe(601)
+    const start = (match.displayColumn ?? match.column) - 1
+    expect(
+      match.lineContent.slice(start, start + (match.displayMatchLength ?? match.matchLength))
+    ).toBe('xx')
+  })
+
+  it('never returns a negative display length for a zero-width range after the line terminator', () => {
+    const text = `${'x'.repeat(600)}\n`
+    const accumulator = createAccumulator()
+    ingestRgJsonLine(
+      JSON.stringify({
+        type: 'match',
+        data: {
+          path: { text: 'line.txt' },
+          lines: { text },
+          line_number: 1,
+          submatches: [{ start: text.length, end: text.length }]
+        }
+      }),
+      '/root',
+      accumulator,
+      2000
+    )
+    const match = [...accumulator.fileMap.values()][0].matches[0]
+    expect(match.matchLength).toBe(0)
+    expect(match.displayMatchLength).toBe(0)
+  })
+
+  it('excludes truncation markers when a fallback regex begins inside a surrogate pair', () => {
+    const accumulator = createAccumulator()
+    ingestGitGrepLine(
+      `unicode.txt\x001\x00${'😀'.repeat(600)}`,
+      '/root',
+      /.{501}/g,
+      accumulator,
+      2000
+    )
+    const match = [...accumulator.fileMap.values()][0].matches[1]
+    expect(match.column).toBe(502)
+    expect(match.matchLength).toBe(501)
+    expect(match.displayColumn).toBe(2)
+    expect(match.displayMatchLength).toBe(498)
+    expect(match.lineContent).toBe(`…${'😀'.repeat(249)}…`)
+    expect(match.lineContent.slice(1, 499)).toBe('😀'.repeat(249))
+  })
+})
diff --git a/src/shared/text-search-snippet-retention.test.ts b/src/shared/text-search-snippet-retention.test.ts
new file mode 100644
index 00000000000..a4a71754e0a
--- /dev/null
+++ b/src/shared/text-search-snippet-retention.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+import { createAccumulator, ingestRgJsonLine } from './text-search'
+
+function heapAfterCollection(): number {
+  if (!globalThis.gc) {
+    throw new Error('This regression requires the test runner to enable --expose-gc')
+  }
+  void /reset/.test('reset')
+  globalThis.gc()
+  globalThis.gc()
+  return process.memoryUsage().heapUsed
+}
+
+function collectSnippets() {
+  const accumulator = createAccumulator()
+  for (let index = 0; index < 32; index++) {
+    const prefix = String.fromCharCode(65 + index).repeat(1024 * 1024)
+    ingestRgJsonLine(
+      JSON.stringify({
+        type: 'match',
+        data: {
+          path: { text: `${index}.txt` },
+          line_number: 1,
+          lines: { text: `${prefix}needle` },
+          submatches: [{ start: prefix.length, end: prefix.length + 6 }]
+        }
+      }),
+      '/root',
+      accumulator,
+      2000
+    )
+  }
+  return accumulator
+}
+
+describe('retained search snippets', () => {
+  it('releases large source lines while keeping their clipped results alive', () => {
+    collectSnippets()
+    const before = heapAfterCollection()
+    const accumulator = collectSnippets()
+    const retainedBytes = heapAfterCollection() - before
+
+    expect(accumulator.totalMatches).toBe(32)
+    for (const file of accumulator.fileMap.values()) {
+      expect(file.matches[0].lineContent).toHaveLength(501)
+      expect(file.matches[0].lineContent.endsWith('needle')).toBe(true)
+      expect(file.matches[0].column).toBe(1024 * 1024 + 1)
+    }
+    // Without ownership, 32 tiny snippets retain 32 MiB of source strings.
+    expect(retainedBytes).toBeLessThan(4 * 1024 * 1024)
+  })
+})
diff --git a/src/shared/text-search.ts b/src/shared/text-search.ts
index c811425a3d0..7c9f98522a2 100644
--- a/src/shared/text-search.ts
+++ b/src/shared/text-search.ts
@@ -22,6 +22,8 @@ import {
 import { ripgrepMatchRanges } from './ripgrep-match-offsets'
 import { decodeRipgrepLine } from './ripgrep-line-decoding'
 
+export { MAX_LINE_CONTENT_LENGTH } from './text-search-match-accumulator'
+
 export type SearchAccumulator = {
   fileMap: Map<string, SearchFileResult>
   totalMatches: number
@@ -44,9 +46,6 @@ export const SEARCH_JSON_STRUCTURE_LIMITS = {
 // Why: keep search cheaper than opening a file; the editor read path has a larger cap (Monaco large-file handling).
 const SEARCH_MAX_FILE_SIZE = 5 * 1024 * 1024
 
-// Why: mega-byte lines (minified/generated files) × 2000-match caps blow past the 16MB SSH relay MAX_MESSAGE_SIZE; clamp each match's context.
-export const MAX_LINE_CONTENT_LENGTH = 500
-
 // ─── rg ─────────────────────────────────────────────────────────────
 
 export type SearchOptionsLike = Pick<
diff --git a/src/shared/tui-agent-config.ts b/src/shared/tui-agent-config.ts
index 0d69189ea3f..c10c0e82e6f 100644
--- a/src/shared/tui-agent-config.ts
+++ b/src/shared/tui-agent-config.ts
@@ -149,6 +149,8 @@ const TUI_AGENT_CONFIG_SOURCE: Record<TuiAgent, TuiAgentConfigSource> = {
   },
   qoder: {
     detectCmd: 'qodercli',
+    // The documented `qoder` dispatcher still launches the legacy CLI binary.
+    detectCmdAliases: ['qoder'],
     promptInjectionMode: 'flag-prompt-interactive',
     preflightTrust: 'qoder'
   },
diff --git a/src/shared/tui-agent-launch-command-argument-values.test.ts b/src/shared/tui-agent-launch-command-argument-values.test.ts
new file mode 100644
index 00000000000..2e89e605853
--- /dev/null
+++ b/src/shared/tui-agent-launch-command-argument-values.test.ts
@@ -0,0 +1,150 @@
+import { describe, expect, it } from 'vitest'
+import type { SessionOptionValue } from './native-chat-session-options'
+import { resolveAgentLaunchCommand } from './tui-agent-launch-command'
+import { tokenizeStartupCommand } from './tui-agent-startup-shell'
+import type { TuiAgent } from './tui-agent'
+
+describe.each(['posix', 'powershell', 'cmd'] as const)('argument values on %s', (shell) => {
+  function launchAgent(
+    agent: TuiAgent,
+    sessionOptions: Record<string, SessionOptionValue>,
+    agentArgs: string,
+    sessionOptionsOverrideAgentArgs = false
+  ) {
+    const result = resolveAgentLaunchCommand({
+      agent,
+      cmdOverrides: {},
+      platform: shell === 'posix' ? 'linux' : 'win32',
+      shell,
+      sessionOptions,
+      agentArgs,
+      sessionOptionsOverrideAgentArgs
+    })
+    if (!result.ok) {
+      throw new Error(result.error)
+    }
+    return { ...result, argv: tokenizeStartupCommand(result.command, shell) }
+  }
+
+  function launch(agentArgs: string, sessionOptionsOverrideAgentArgs = false) {
+    return launchAgent(
+      'claude',
+      { model: 'opus', effort: 'xhigh' },
+      agentArgs,
+      sessionOptionsOverrideAgentArgs
+    )
+  }
+
+  it.each(['--model=haiku', '--effort=low'])(
+    'keeps picks when the system prompt is %s',
+    (value) => {
+      const result = launch(`--append-system-prompt "${value}"`)
+      expect(result.argv).toMatchObject({
+        ok: true,
+        tokens: ['claude', '--model', 'opus', '--effort', 'xhigh', '--append-system-prompt', value]
+      })
+      expect(result.appliedSessionOptions).toEqual({ model: 'opus', effort: 'xhigh' })
+    }
+  )
+
+  it('replaces real worker flags while preserving flag-like prompt text', () => {
+    const result = launch(
+      '--append-system-prompt "--model=haiku" --system-prompt "--effort=low" --model sonnet --effort low',
+      true
+    )
+    expect(result.argv).toMatchObject({
+      ok: true,
+      tokens: [
+        'claude',
+        '--append-system-prompt',
+        '--model=haiku',
+        '--system-prompt',
+        '--effort=low',
+        '--model',
+        'opus',
+        '--effort',
+        'xhigh'
+      ]
+    })
+    expect(result.appliedSessionOptions).toEqual({ model: 'opus', effort: 'xhigh' })
+  })
+
+  it('recognizes a real model flag after a prompt whose value is --', () => {
+    const result = launch('--append-system-prompt "--" --model haiku')
+    expect(result.argv).toMatchObject({
+      ok: true,
+      tokens: ['claude', '--append-system-prompt', '--', '--model', 'haiku']
+    })
+    expect(result.appliedSessionOptions).toEqual({})
+  })
+
+  it('inserts worker picks after a -- prompt value and before the real terminator', () => {
+    const result = launch('--append-system-prompt "--" --model haiku -- literal', true)
+    expect(result.argv).toMatchObject({
+      ok: true,
+      tokens: [
+        'claude',
+        '--append-system-prompt',
+        '--',
+        '--model',
+        'opus',
+        '--effort',
+        'xhigh',
+        '--',
+        'literal'
+      ]
+    })
+    expect(result.appliedSessionOptions).toEqual({ model: 'opus', effort: 'xhigh' })
+  })
+
+  it('recognizes a real effort flag after flag-like prompt text', () => {
+    const result = launch('--system-prompt "--effort=low" --effort max')
+    expect(result.argv).toMatchObject({
+      ok: true,
+      tokens: ['claude', '--model', 'opus', '--system-prompt', '--effort=low', '--effort', 'max']
+    })
+    expect(result.appliedSessionOptions).toEqual({ model: 'opus' })
+  })
+
+  it.each(['-p', '-c', '--debug', '--resume', '--worktree'])(
+    'recognizes a model flag after boolean or optional-valued %s',
+    (flag) => {
+      const result = launch(`${flag} --model haiku`)
+      expect(result.argv).toMatchObject({ ok: true, tokens: ['claude', flag, '--model', 'haiku'] })
+      expect(result.appliedSessionOptions).toEqual({})
+    }
+  )
+
+  it('recognizes a model flag after an option with an inline value', () => {
+    const result = launch('--append-system-prompt=literal --model haiku')
+    expect(result.argv).toMatchObject({
+      ok: true,
+      tokens: ['claude', '--append-system-prompt=literal', '--model', 'haiku']
+    })
+    expect(result.appliedSessionOptions).toEqual({})
+  })
+
+  it('keeps the Cursor model when its API key starts with -m', () => {
+    const result = launchAgent('cursor', { model: 'auto' }, '--api-key "-my-test-key"')
+    expect(result.argv).toMatchObject({
+      ok: true,
+      tokens: ['cursor-agent', '--model', 'auto', '--api-key', '-my-test-key']
+    })
+    expect(result.appliedSessionOptions).toEqual({ model: 'auto' })
+  })
+
+  // Clap and yargs read the dash-leading token as a new flag, so a picked model would repeat it.
+  it.each([
+    ['codex', 'gpt-5.5', '--profile -m o3', ['codex', '--profile', '-m', 'o3']],
+    [
+      'opencode',
+      'openai/gpt-5',
+      '--prompt -m openai/o3',
+      ['opencode', '--prompt', '-m', 'openai/o3']
+    ]
+  ] as const)('sends one %s model flag after a value option', (agent, model, agentArgs, tokens) => {
+    const result = launchAgent(agent, { model }, agentArgs)
+    expect(result.argv).toMatchObject({ ok: true, tokens })
+    expect(result.appliedSessionOptions).toEqual({})
+  })
+})
diff --git a/src/shared/tui-agent-launch-command-pick-flags.test.ts b/src/shared/tui-agent-launch-command-pick-flags.test.ts
new file mode 100644
index 00000000000..5dc922cb7e0
--- /dev/null
+++ b/src/shared/tui-agent-launch-command-pick-flags.test.ts
@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest'
+import { resolveAgentLaunchCommand } from './tui-agent-launch-command'
+
+function launch(args: Partial<Parameters<typeof resolveAgentLaunchCommand>[0]>) {
+  const result = resolveAgentLaunchCommand({
+    agent: 'claude',
+    cmdOverrides: {},
+    platform: 'linux',
+    shell: 'posix',
+    ...args
+  })
+  if (!result.ok) {
+    throw new Error(result.error)
+  }
+  return result
+}
+
+describe('one copy of each chat-picked flag', () => {
+  it('sends one -m for Codex with a pick and a configured -m', () => {
+    const result = launch({
+      agent: 'codex',
+      sessionOptions: { model: 'gpt-5.5', effort: 'high' },
+      agentArgs: '-m o3'
+    })
+    expect(result.command).toBe("codex '-m' 'o3'")
+    expect(result.appliedSessionOptions).toEqual({})
+  })
+
+  it.each(['-c model=o3', '--config model=o3', '-c=model=o3', '-cmodel=o3', '--config=model=o3'])(
+    'yields the picked Codex model and its effort to configured %s',
+    (agentArgs) => {
+      const result = launch({
+        agent: 'codex',
+        sessionOptions: { model: 'gpt-5.5', effort: 'high' },
+        agentArgs
+      })
+      const expectedArgs = agentArgs
+        .split(' ')
+        .map((token) => `'${token}'`)
+        .join(' ')
+      expect(result.command).toBe(`codex ${expectedArgs}`)
+      expect(result.appliedSessionOptions).toEqual({})
+    }
+  )
+
+  it('sends only the configured Grok model without the picked model effort', () => {
+    const result = launch({
+      agent: 'grok',
+      sessionOptions: { model: 'grok-4.6', effort: 'xhigh' },
+      agentArgs: '-m grok-4.5'
+    })
+    expect(result.command).toBe("grok '-m' 'grok-4.5'")
+    expect(result.appliedSessionOptions).toEqual({})
+  })
+
+  it.each([
+    ['claude', 'opus', '--model=haiku', "claude '--model=haiku'"],
+    ['codex', 'gpt-5.5', '-mo3', "codex '-mo3'"]
+  ] as const)(
+    'sends one model flag for %s with a configured %s',
+    (agent, model, agentArgs, command) => {
+      const result = launch({ agent, sessionOptions: { model }, agentArgs })
+      expect(result.command).toBe(command)
+      expect(result.appliedSessionOptions).toEqual({})
+    }
+  )
+
+  it('sends one --effort for Claude with a configured --effort', () => {
+    const result = launch({
+      sessionOptions: { model: 'opus', effort: 'xhigh' },
+      agentArgs: '--effort low'
+    })
+    expect(result.command).toBe("claude '--model' 'opus' '--effort' 'low'")
+    expect(result.appliedSessionOptions).toEqual({ model: 'opus' })
+  })
+
+  it('keeps the catalog default for options the configured args do not set', () => {
+    const result = launch({ sessionOptions: { model: 'opus' }, agentArgs: '--add-dir x' })
+    expect(result.command).toBe("claude '--model' 'opus' '--effort' 'high' '--add-dir' 'x'")
+  })
+
+  it.each(['posix', 'powershell', 'cmd'] as const)(
+    'preserves picks when a Docker override has a memory flag on %s',
+    (shell) => {
+      const result = launch({
+        agent: 'codex',
+        shell,
+        platform: shell === 'posix' ? 'linux' : 'win32',
+        cmdOverrides: { codex: 'docker run --rm -m 4g agent-image codex' },
+        sessionOptions: { model: 'gpt-5.5', effort: 'high' }
+      })
+      expect(result.appliedSessionOptions).toEqual({ model: 'gpt-5.5', effort: 'high' })
+      expect(result.command).toContain('gpt-5.5')
+      expect(result.command).toContain('model_reasoning_effort=high')
+    }
+  )
+
+  it.each(['echo --model diagnostic && claude', "claude --append-system-prompt '--model'"])(
+    'preserves picks when override tokens are not agent options: %s',
+    (command) => {
+      const result = launch({
+        cmdOverrides: { claude: command },
+        sessionOptions: { model: 'opus', effort: 'high' }
+      })
+      expect(result.command).toBe(`${command} '--model' 'opus' '--effort' 'high'`)
+      expect(result.appliedSessionOptions).toEqual({ model: 'opus', effort: 'high' })
+    }
+  )
+
+  it('preserves picks when configured arguments contain flags after --', () => {
+    const result = launch({
+      agentArgs: '-- --model haiku',
+      sessionOptions: { model: 'opus', effort: 'high' }
+    })
+    expect(result.command).toBe("claude '--model' 'opus' '--effort' 'high' '--' '--model' 'haiku'")
+    expect(result.appliedSessionOptions).toEqual({ model: 'opus', effort: 'high' })
+  })
+
+  it('checks configured args without parsing an unparseable command override', () => {
+    const result = launch({
+      agent: 'codex',
+      cmdOverrides: { codex: "codex -c 'x" },
+      sessionOptions: { model: 'gpt-5.5' },
+      agentArgs: '-m o3'
+    })
+    expect(result.command).toBe("codex -c 'x '-m' 'o3'")
+    expect(result.command).not.toContain('gpt-5.5')
+  })
+
+  it('sends the picked Codex model when the configured args set only the effort', () => {
+    const result = launch({
+      agent: 'codex',
+      sessionOptions: { model: 'gpt-5.5', effort: 'high' },
+      agentArgs: '-c model_reasoning_effort=low'
+    })
+    expect(result.command).toBe("codex '-m' 'gpt-5.5' '-c' 'model_reasoning_effort=low'")
+    expect(result.appliedSessionOptions).toEqual({ model: 'gpt-5.5' })
+  })
+})
diff --git a/src/shared/tui-agent-launch-command.ts b/src/shared/tui-agent-launch-command.ts
index 140ef935626..6b6fa068127 100644
--- a/src/shared/tui-agent-launch-command.ts
+++ b/src/shared/tui-agent-launch-command.ts
@@ -3,6 +3,7 @@ import {
   resolveAgentSessionOptionLaunch
 } from './agent-session-option-launch'
 import type { SessionOptionValue } from './native-chat-session-options'
+import { agentArgTerminatorIndex } from './agent-session-option-agent-args'
 import { getTuiAgentLaunchCommand, TUI_AGENT_CONFIG } from './tui-agent-config'
 import {
   planAgentCliArgsSuffix,
@@ -81,6 +82,7 @@ export function resolveAgentLaunchCommand(args: {
   const commandWithOptions = optionSuffix ? `${command} ${optionSuffix}` : command
   const overrideTokens = args.sessionOptionsOverrideAgentArgs
     ? insertBeforeTerminator(
+        args.agent,
         removeOverriddenAgentSessionArgs(args.agent, args.sessionOptions, trailingTokens.tokens),
         resolvedOptions.args
       )
@@ -100,10 +102,11 @@ export function resolveAgentLaunchCommand(args: {
   }
 }
 
-function insertBeforeTerminator(tokens: readonly string[], inserted: readonly string[]): string[] {
-  const terminator = tokens.indexOf('--')
-  if (terminator === -1) {
-    return [...tokens, ...inserted]
-  }
+function insertBeforeTerminator(
+  agent: TuiAgent,
+  tokens: readonly string[],
+  inserted: readonly string[]
+): string[] {
+  const terminator = agentArgTerminatorIndex(agent, tokens)
   return [...tokens.slice(0, terminator), ...inserted, ...tokens.slice(terminator)]
 }
diff --git a/src/shared/tui-agent-startup-session-options.test.ts b/src/shared/tui-agent-startup-session-options.test.ts
index c6d0f551226..63d7e9b7005 100644
--- a/src/shared/tui-agent-startup-session-options.test.ts
+++ b/src/shared/tui-agent-startup-session-options.test.ts
@@ -7,7 +7,7 @@ import {
 import { resolveAgentLaunchCommand } from './tui-agent-launch-command'
 
 describe('tui agent startup session options', () => {
-  it('emits catalog options before user arguments without recording an overridden model', () => {
+  it('sends neither the picked model nor its options when user arguments set the model', () => {
     const plan = buildAgentStartupPlan({
       agent: 'claude',
       prompt: '',
@@ -17,7 +17,7 @@ describe('tui agent startup session options', () => {
       sessionOptions: { model: 'opus', effort: 'xhigh', fastMode: true },
       agentArgs: '--model haiku'
     })
-    expect(plan?.launchCommand).toBe("claude '--model' 'opus' '--effort' 'xhigh' '--model' 'haiku'")
+    expect(plan?.launchCommand).toBe("claude '--model' 'haiku'")
     expect(plan?.sessionOptions).toBeUndefined()
   })
 
@@ -89,6 +89,24 @@ describe('tui agent startup session options', () => {
     expect(plan?.sessionOptions).toEqual({ model: 'muse-spark-1.3', effort: 'xhigh' })
   })
 
+  it('keeps OpenCode agent arguments while replacing only the per-launch model', () => {
+    const plan = buildAgentStartupPlan({
+      agent: 'opencode',
+      prompt: '',
+      cmdOverrides: {},
+      platform: 'linux',
+      allowEmptyPromptLaunch: true,
+      sessionOptions: { model: 'zai-coding-plan/glm-5.3-flash' },
+      sessionOptionsOverrideAgentArgs: true,
+      agentArgs: '--share --model opencode/global-default'
+    })
+    expect(plan?.launchCommand).toBe("opencode '--share' '--model' 'zai-coding-plan/glm-5.3-flash'")
+    expect(plan?.launchConfig.agentCommand).toBe(
+      "opencode '--share' '--model' 'opencode/global-default'"
+    )
+    expect(plan?.sessionOptions).toEqual({ model: 'zai-coding-plan/glm-5.3-flash' })
+  })
+
   it('inserts worker preferences before an argument terminator', () => {
     const plan = buildAgentStartupPlan({
       agent: 'codex',
diff --git a/tests/AGENTS.md b/tests/AGENTS.md
index 583dda00e8e..54aae2dc1ba 100644
--- a/tests/AGENTS.md
+++ b/tests/AGENTS.md
@@ -37,3 +37,15 @@ Keep `ORCA_BACKGROUND_LAUNCH=1`: the application must still suppress automatic r
 This exception belongs only to this benchmark fixture; do not generalize it to local or self-hosted
 runs, paired-client helpers, native-focus tests, or production window policy. Background terminal
 panes remain hidden. Evidence: `docs/reference/terminal-perf-latency-investigation.md`.
+
+## Isolated native IBus presentation
+
+The native IBus fixtures start with `ORCA_BACKGROUND_LAUNCH=1`, then present only their owned
+page's window on the runner's fresh Xvfb display. A window mapped with X11 alone remains hidden
+to Electron and cannot receive native keyboard events.
+
+`terminal-native-ibus-window.ts` requires Linux, hosted GitHub Actions, a numeric `DISPLAY`,
+`ORCA_E2E_NATIVE_IBUS_HANGUL=1`, and `ORCA_E2E_NATIVE_IBUS_XVFB=1` before presentation. The native
+runner sets the last marker inside its isolated display session. These guards run again inside
+Electron before `showInactive()`. Native focus stays confined to that display; this fixture does
+not relax automatic launch policy or permit presentation on the user's desktop.
diff --git a/tests/e2e/csv-paged-preview.spec.ts b/tests/e2e/csv-paged-preview.spec.ts
new file mode 100644
index 00000000000..0dd4fcf7edb
--- /dev/null
+++ b/tests/e2e/csv-paged-preview.spec.ts
@@ -0,0 +1,216 @@
+import { closeSync, openSync, readFileSync, statSync, writeSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { expect, test } from './helpers/orca-app'
+
+test.use({
+  orcaAppExtraArgs: [
+    '--enable-precise-memory-info',
+    ...(process.env.ORCA_CSV_CDP_PORT
+      ? [`--remote-debugging-port=${process.env.ORCA_CSV_CDP_PORT}`]
+      : [])
+  ]
+})
+
+test('CSV preview bounds memory and DOM size, resizes columns and reaches the final row', async ({
+  orcaPage,
+  seededRepoPath,
+  electronApp
+}, testInfo) => {
+  test.setTimeout(120_000)
+  const totalRows = 1_900_100
+  const tallName = 'large-preview.csv'
+  const wideName = 'wide-preview.csv'
+  const tallPath = path.join(seededRepoPath, tallName)
+  const widePath = path.join(seededRepoPath, wideName)
+  const handle = openSync(tallPath, 'w')
+  try {
+    writeSync(handle, 'id,label,a,b,c,d,e,f\n')
+    for (let first = 0; first < totalRows; first += 16_384) {
+      const count = Math.min(16_384, totalRows - first)
+      writeSync(
+        handle,
+        Array.from(
+          { length: count },
+          (_, offset) =>
+            `${String(first + offset).padStart(7, '0')},record-${first + offset},xxxxxxxxxxxx,alpha,beta,gamma,delta,omega\n`
+        ).join('')
+      )
+    }
+  } finally {
+    closeSync(handle)
+  }
+  const wideHeader = Array.from({ length: 2048 }, (_, index) => `column-${index}`).join(';')
+  const wideRow = Array.from({ length: 2048 }, (_, index) => `value-${index}`).join(';')
+  writeFileSync(widePath, `${wideHeader}\n${`${wideRow}\n`.repeat(100)}`)
+  const openFile = async (name: string): Promise<void> => {
+    await orcaPage.evaluate(
+      ({ name, filePath }) => {
+        const state = window.__store?.getState()
+        if (!state?.activeWorktreeId) {
+          throw new Error('Missing CSV fixture worktree')
+        }
+        state.openFile({
+          filePath,
+          relativePath: name,
+          worktreeId: state.activeWorktreeId,
+          language: 'plaintext',
+          mode: 'edit'
+        })
+      },
+      { name, filePath: path.join(seededRepoPath, name) }
+    )
+  }
+  const cdp = await orcaPage.context().newCDPSession(orcaPage)
+  const sampleHeap = async (): Promise<number> => {
+    await cdp.send('HeapProfiler.collectGarbage')
+    return (await cdp.send('Runtime.getHeapUsage')).usedSize
+  }
+  const baseline = await sampleHeap()
+  const start = Date.now()
+  await openFile(tallName)
+  const table = orcaPage.getByRole('table')
+  await expect(table).toHaveAttribute('aria-rowcount', String(totalRows + 1), { timeout: 60_000 })
+  await expect(orcaPage.getByText('Large file preview · Read-only')).toBeVisible()
+  await expect(orcaPage.getByRole('cell', { name: '0000000', exact: true })).toBeVisible()
+  const indexMs = Date.now() - start
+  for (let window = 0; window < 3; window += 1) {
+    await orcaPage.getByRole('button', { name: 'Next rows' }).click()
+  }
+  await orcaPage.getByTestId('csv-scroll').evaluate((element) => {
+    element.scrollTop = element.scrollHeight
+  })
+  await expect(
+    orcaPage.getByRole('cell', { name: String(totalRows - 1), exact: true })
+  ).toBeVisible()
+  expect(await table.getByRole('row').count()).toBeLessThan(100)
+  const retained = await sampleHeap()
+  expect(retained - baseline).toBeLessThan(70 * 1024 * 1024)
+  const sizeBefore = statSync(tallPath).size
+  const saveBlocked = await orcaPage.evaluate(async () => {
+    const file = window.__store
+      ?.getState()
+      .openFiles.find((candidate) => candidate.filePath.endsWith('large-preview.csv'))
+    if (!file?.csvPreviewOnly) {
+      throw new Error('CSV save guard was not installed')
+    }
+    return new Promise<boolean>((resolve) =>
+      window.dispatchEvent(
+        new CustomEvent('orca:editor-save-file', {
+          detail: {
+            fileId: file.id,
+            fallbackContent: '',
+            claim: () => {},
+            resolve: () => resolve(false),
+            reject: () => resolve(true)
+          }
+        })
+      )
+    )
+  })
+  expect(saveBlocked).toBe(true)
+  expect(statSync(tallPath).size).toBe(sizeBefore)
+  await orcaPage.screenshot({ path: testInfo.outputPath('large-final-row.png') })
+
+  await openFile(wideName)
+  await expect(orcaPage.getByRole('table')).toHaveAttribute('aria-colcount', '2049')
+  await expect(orcaPage.getByRole('cell', { name: 'value-0', exact: true }).first()).toBeVisible()
+  expect(await table.getByRole('columnheader').count()).toBeLessThan(30)
+  expect(await table.getByRole('cell').count()).toBeLessThan(2000)
+  const separator = orcaPage.getByRole('separator', { name: 'Resize column 1', exact: true })
+  const width = Number(await separator.getAttribute('aria-valuenow'))
+  await separator.dispatchEvent('keydown', { key: 'ArrowRight', shiftKey: true })
+  await expect(separator).toHaveAttribute('aria-valuenow', String(width + 40))
+  const handleBox = await separator.boundingBox()
+  if (!handleBox) {
+    throw new Error('Missing resize handle')
+  }
+  await separator.dispatchEvent('pointerdown', { pointerId: 1, button: 0, clientX: handleBox.x })
+  await separator.dispatchEvent('pointermove', { pointerId: 1, clientX: handleBox.x + 60 })
+  await separator.dispatchEvent('pointerup', { pointerId: 1, clientX: handleBox.x + 60 })
+  await expect(separator).toHaveAttribute('aria-valuenow', String(width + 100))
+  await orcaPage.evaluate(() => {
+    const state = window.__store?.getState()
+    const file = state?.openFiles.find((file) => file.filePath.endsWith('wide-preview.csv'))
+    if (!state || !file) {
+      throw new Error('Missing wide preview tab')
+    }
+    state.closeFile(file.id)
+  })
+  await openFile(wideName)
+  await expect(separator).toHaveAttribute('aria-valuenow', String(width + 100))
+  await expect(orcaPage.getByRole('button', { name: 'Edit cell', exact: true })).toHaveCount(0)
+  await orcaPage.getByTestId('csv-scroll').evaluate((element) => {
+    element.scrollLeft = element.scrollWidth
+  })
+  await expect(
+    orcaPage.getByRole('cell', { name: 'value-2047', exact: true }).first()
+  ).toBeVisible()
+  expect(await table.getByRole('columnheader').count()).toBeLessThan(30)
+  await orcaPage.screenshot({ path: testInfo.outputPath('wide-final-column.png') })
+  if (
+    process.env.ORCA_E2E_FORCE_HEADFUL !== '1' &&
+    testInfo.project.metadata.orcaHeadful !== true
+  ) {
+    const windowsVisible = await electronApp.evaluate(({ BrowserWindow }) =>
+      BrowserWindow.getAllWindows().some((window) => window.isVisible())
+    )
+    expect(windowsVisible).toBe(false)
+  }
+  const observations = {
+    bytes: sizeBefore,
+    rows: totalRows,
+    indexMs,
+    rendererHeapDeltaMiB: (retained - baseline) / 1024 / 1024,
+    renderedRows: await table.getByRole('row').count(),
+    renderedColumns: await table.getByRole('columnheader').count(),
+    wideBytes: readFileSync(widePath).length
+  }
+  writeFileSync(testInfo.outputPath('csv-measurements.json'), JSON.stringify(observations, null, 2))
+})
+
+test('paged previews accept a maximum-size record with a BOM and CRLF', async ({
+  orcaPage,
+  seededRepoPath,
+  electronApp
+}, testInfo) => {
+  const name = 'record-boundary.csv'
+  const filePath = path.join(seededRepoPath, name)
+  const recordBytes = 1024 * 1024
+  writeFileSync(filePath, `\ufeff${'x'.repeat(recordBytes)}\r\ntail\r\n`)
+  await orcaPage.evaluate(
+    ({ name, filePath }) => {
+      const state = window.__store?.getState()
+      if (!state?.activeWorktreeId) {
+        throw new Error('Missing CSV boundary workspace')
+      }
+      state.openFile({
+        filePath,
+        relativePath: name,
+        worktreeId: state.activeWorktreeId,
+        language: 'plaintext',
+        mode: 'edit'
+      })
+    },
+    { name, filePath }
+  )
+  await expect(orcaPage.getByRole('table')).toHaveAttribute('aria-rowcount', '2', {
+    timeout: 30_000
+  })
+  await expect(orcaPage.getByRole('cell', { name: 'tail', exact: true })).toBeVisible()
+  expect(
+    await orcaPage
+      .getByRole('columnheader')
+      .nth(1)
+      .evaluate((element) => element.textContent?.length)
+  ).toBe(recordBytes)
+  if (
+    process.env.ORCA_E2E_FORCE_HEADFUL !== '1' &&
+    testInfo.project.metadata.orcaHeadful !== true
+  ) {
+    expect(
+      await electronApp.evaluate(({ BrowserWindow }) =>
+        BrowserWindow.getAllWindows().some((window) => window.isVisible())
+      )
+    ).toBe(false)
+  }
+})
diff --git a/tests/e2e/csv-table-editing.spec.ts b/tests/e2e/csv-table-editing.spec.ts
new file mode 100644
index 00000000000..1c1710a649d
--- /dev/null
+++ b/tests/e2e/csv-table-editing.spec.ts
@@ -0,0 +1,329 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { expect, test } from './helpers/orca-app'
+
+test.use({
+  orcaAppExtraArgs: process.env.ORCA_CSV_CDP_PORT
+    ? [`--remote-debugging-port=${process.env.ORCA_CSV_CDP_PORT}`]
+    : []
+})
+
+test('CSV table edits, inspection, clipboard and widths survive save and view switches', async ({
+  orcaPage,
+  seededRepoPath,
+  electronApp
+}, testInfo) => {
+  const name = 'csv-table-editing.csv'
+  const filePath = path.join(seededRepoPath, name)
+  const original =
+    '\ufeffName,Score,Description\r\nBeta,2,"Original text"\r\nAlpha,10,Second record\r\n'
+  writeFileSync(filePath, original)
+  await orcaPage.evaluate(
+    async ({ filePath, name }) => {
+      const state = window.__store?.getState()
+      if (!state?.activeWorktreeId) {
+        throw new Error('Missing CSV workspace')
+      }
+      await state.updateSettings({ editorAutoSave: false })
+      state.openFile(
+        {
+          filePath,
+          relativePath: name,
+          worktreeId: state.activeWorktreeId,
+          language: 'plaintext',
+          mode: 'edit'
+        },
+        { preview: false }
+      )
+    },
+    { filePath, name }
+  )
+  const grid = orcaPage.getByTestId('csv-grid')
+  await expect(grid).toHaveAttribute('role', 'grid')
+  await orcaPage.screenshot({ path: testInfo.outputPath('csv-editable-before-interaction.png') })
+  const beta = grid.getByRole('gridcell', { name: 'Beta', exact: true })
+  await beta.dblclick()
+  const input = orcaPage.getByRole('textbox', { name: /Edit row/ })
+  await input.fill('Cancelled')
+  await input.press('Escape')
+  await expect(beta).toBeVisible()
+  await expect
+    .poll(() =>
+      orcaPage.evaluate(() =>
+        Object.values(window.__store?.getState().editorDrafts ?? {}).some((draft) =>
+          draft.includes('Cancelled')
+        )
+      )
+    )
+    .toBe(false)
+  await beta.dblclick()
+  await input.fill('Beta updated')
+  // Switch directly while the cell owns focus; the pending value must reach Source.
+  await orcaPage.getByRole('radio', { name: 'Source', exact: true }).click()
+  await expect(orcaPage.locator('.monaco-editor')).toBeVisible()
+  await expect
+    .poll(() =>
+      orcaPage.evaluate(() =>
+        Object.values(window.__store?.getState().editorDrafts ?? {}).some((draft) =>
+          draft.includes('Beta updated')
+        )
+      )
+    )
+    .toBe(true)
+  await orcaPage.getByRole('radio', { name: 'Table', exact: true }).click()
+  await expect(grid.getByRole('gridcell', { name: 'Beta updated', exact: true })).toBeVisible()
+  const separator = orcaPage.getByRole('separator', { name: 'Resize column 3', exact: true })
+  const initialWidth = Number(await separator.getAttribute('aria-valuenow'))
+  await separator.press('Shift+ArrowRight')
+  const resized = String(initialWidth + 40)
+  await expect(separator).toHaveAttribute('aria-valuenow', resized)
+  await orcaPage.getByRole('radio', { name: 'Source', exact: true }).click()
+  await orcaPage.getByRole('radio', { name: 'Table', exact: true }).click()
+  await expect(separator).toHaveAttribute('aria-valuenow', resized!)
+  await separator.press('Home')
+  await grid.getByRole('gridcell', { name: 'Beta updated', exact: true }).click()
+  await orcaPage.getByRole('button', { name: 'Sort', exact: true }).click()
+  await orcaPage
+    .getByRole('menuitem', { name: 'Sort selected column ascending', exact: true })
+    .click()
+  await expect(grid.getByRole('row').nth(1)).toContainText('Alpha')
+  await orcaPage.getByRole('textbox', { name: 'Filter rows', exact: true }).fill('Alpha')
+  await grid.getByRole('gridcell', { name: '10', exact: true }).dblclick()
+  await input.fill('11')
+  await input.press('Enter')
+  await orcaPage.getByRole('textbox', { name: 'Filter rows', exact: true }).fill('')
+  await grid.getByRole('gridcell', { name: 'Alpha', exact: true }).click()
+  await grid.press('Shift+ArrowRight')
+  await expect(grid.locator('[aria-selected="true"]')).toHaveCount(2)
+  // DOM clipboard events exercise range handling without replacing the user's OS clipboard.
+  const clipboard = await grid.evaluate((element) => {
+    const copied = new DataTransfer()
+    element.dispatchEvent(
+      new ClipboardEvent('copy', { bubbles: true, cancelable: true, clipboardData: copied })
+    )
+    const pasted = new DataTransfer()
+    pasted.setData('text/plain', 'Alpha renamed\t12')
+    element.dispatchEvent(
+      new ClipboardEvent('paste', { bubbles: true, cancelable: true, clipboardData: pasted })
+    )
+    return copied.getData('text/plain')
+  })
+  expect(clipboard).toBe('Alpha\t11')
+  await expect(grid.getByRole('gridcell', { name: '12', exact: true })).toBeVisible()
+  await orcaPage.getByRole('button', { name: 'Save', exact: true }).click()
+  const expected =
+    '\ufeffName,Score,Description\r\nBeta updated,2,"Original text"\r\nAlpha renamed,12,Second record\r\n'
+  await expect.poll(() => readFileSync(filePath, 'utf8')).toBe(expected)
+  await orcaPage.screenshot({ path: testInfo.outputPath('csv-table-editing-after.png') })
+  if (
+    process.env.ORCA_E2E_FORCE_HEADFUL !== '1' &&
+    testInfo.project.metadata.orcaHeadful !== true
+  ) {
+    expect(
+      await electronApp.evaluate(({ BrowserWindow }) =>
+        BrowserWindow.getAllWindows().some((window) => window.isVisible())
+      )
+    ).toBe(false)
+  }
+})
+
+test('CSV row and column operations preserve column widths and produce the expected file', async ({
+  orcaPage,
+  seededRepoPath
+}, testInfo) => {
+  const name = 'csv-structure.csv'
+  const filePath = path.join(seededRepoPath, name)
+  writeFileSync(filePath, 'First,Second,Third\nA,1,x\nB,2,y')
+  await orcaPage.evaluate(
+    async ({ filePath, name }) => {
+      const state = window.__store?.getState()
+      if (!state?.activeWorktreeId) {
+        throw new Error('Missing CSV workspace')
+      }
+      await state.updateSettings({ editorAutoSave: false })
+      state.openFile(
+        {
+          filePath,
+          relativePath: name,
+          worktreeId: state.activeWorktreeId,
+          language: 'plaintext',
+          mode: 'edit'
+        },
+        { preview: false }
+      )
+    },
+    { filePath, name }
+  )
+  const grid = orcaPage.getByTestId('csv-grid')
+  await expect(grid).toHaveAttribute('role', 'grid')
+  await grid.getByRole('gridcell', { name: '1', exact: true }).click()
+  const secondWidth = orcaPage.getByRole('separator', { name: 'Resize column 2', exact: true })
+  await secondWidth.press('ArrowRight')
+  const width = await secondWidth.getAttribute('aria-valuenow')
+  await orcaPage.getByRole('button', { name: 'Columns', exact: true }).click()
+  await orcaPage.getByRole('menuitem', { name: 'Move column left', exact: true }).click()
+  await expect(grid.getByRole('columnheader').nth(1)).toHaveText('Second')
+  await expect(
+    orcaPage.getByRole('separator', { name: 'Resize column 1', exact: true })
+  ).toHaveAttribute('aria-valuenow', width!)
+  await orcaPage.getByRole('button', { name: 'Columns', exact: true }).click()
+  await orcaPage.getByRole('menuitem', { name: 'Insert column after', exact: true }).click()
+  await expect(grid).toHaveAttribute('aria-colcount', '5')
+  await grid.getByRole('columnheader', { name: 'Column 4', exact: true }).click()
+  await orcaPage.getByRole('button', { name: 'Columns', exact: true }).click()
+  await orcaPage.getByRole('menuitem', { name: 'Delete selected columns', exact: true }).click()
+  await expect(grid).toHaveAttribute('aria-colcount', '4')
+  await grid.getByRole('gridcell', { name: 'A', exact: true }).click()
+  await orcaPage.getByRole('button', { name: 'Rows', exact: true }).click()
+  await orcaPage.getByRole('menuitem', { name: 'Insert row below', exact: true }).click()
+  await expect(grid).toHaveAttribute('aria-rowcount', '4')
+  await grid.locator('[data-csv-row="2"][data-csv-column="0"]').click()
+  await orcaPage.getByRole('button', { name: 'Rows', exact: true }).click()
+  await orcaPage.getByRole('menuitem', { name: 'Delete selected rows', exact: true }).click()
+  await expect(grid).toHaveAttribute('aria-rowcount', '3')
+  await orcaPage.getByRole('button', { name: 'Save', exact: true }).click()
+  await expect.poll(() => readFileSync(filePath, 'utf8')).toBe('Second,First,Third\n1,A,x\n2,B,y')
+  await orcaPage.screenshot({ path: testInfo.outputPath('csv-structure-after.png') })
+})
+
+test('keyboard selection reaches and edits a cell beyond both virtualized viewports', async ({
+  orcaPage,
+  seededRepoPath
+}, testInfo) => {
+  const filePath = path.join(seededRepoPath, 'editable-wide.csv')
+  const header = Array.from({ length: 1024 }, (_, column) => `column-${column}`).join(',')
+  const row = Array.from({ length: 1024 }, (_, column) => `v${column}`).join(',')
+  writeFileSync(filePath, `${header}\n${`${row}\n`.repeat(100)}`)
+  await orcaPage.evaluate(
+    async ({ filePath }) => {
+      const state = window.__store?.getState()
+      if (!state?.activeWorktreeId) {
+        throw new Error('Missing CSV workspace')
+      }
+      await state.updateSettings({ editorAutoSave: false })
+      state.openFile(
+        {
+          filePath,
+          relativePath: 'editable-wide.csv',
+          worktreeId: state.activeWorktreeId,
+          language: 'plaintext',
+          mode: 'edit'
+        },
+        { preview: false }
+      )
+    },
+    { filePath }
+  )
+  const grid = orcaPage.getByTestId('csv-grid')
+  await expect(grid).toHaveAttribute('aria-colcount', '1025')
+  // Dispatch on the clipped cell without Playwright scrolling it into view first.
+  const clipped = await grid.evaluate((element) => {
+    const viewport = element.closest('[data-testid="csv-scroll"]')
+    if (!viewport) {
+      throw new Error('Missing CSV scroll surface')
+    }
+    const edge = viewport.getBoundingClientRect().right
+    const cell = [...element.querySelectorAll('[data-csv-row="1"]')].find((cell) => {
+      const bounds = cell.getBoundingClientRect()
+      return bounds.left < edge - 4 && bounds.right > edge + 4
+    })
+    if (!cell) {
+      throw new Error('Missing clipped cell')
+    }
+    const column = Number(cell.getAttribute('data-csv-column'))
+    cell.dispatchEvent(new MouseEvent('dblclick', { bubbles: true }))
+    return { column, scrollLeft: viewport.scrollLeft }
+  })
+  const clippedInput = orcaPage.getByRole('textbox', {
+    name: `Edit row 2, column ${clipped.column + 1}`,
+    exact: true
+  })
+  await expect(clippedInput).toBeFocused()
+  expect(await orcaPage.getByTestId('csv-scroll').evaluate((element) => element.scrollLeft)).toBe(
+    clipped.scrollLeft
+  )
+  await orcaPage.keyboard.type('z')
+  await expect(clippedInput).toHaveValue(`zv${clipped.column}`)
+  await expect(clippedInput).toBeFocused()
+  await orcaPage.screenshot({ path: testInfo.outputPath('csv-clipped-cell-editor.png') })
+  await orcaPage.getByTestId('csv-scroll').evaluate((element) => {
+    element.scrollTop = 2000
+  })
+  await expect(clippedInput).toHaveCount(0)
+  expect(
+    await orcaPage.getByTestId('csv-scroll').evaluate((element) => element.scrollTop)
+  ).toBeGreaterThan(0)
+  await orcaPage.getByTestId('csv-scroll').evaluate((element) => {
+    element.scrollTop = 0
+  })
+  await grid.getByRole('gridcell', { name: 'v0', exact: true }).first().click()
+  const modifier = await orcaPage.evaluate(() =>
+    navigator.userAgent.includes('Mac') ? 'Meta' : 'Control'
+  )
+  await grid.press(`${modifier}+End`)
+  const last = grid.locator('[data-csv-row="100"][data-csv-column="1023"]')
+  await expect(last).toBeVisible()
+  await expect(last).toHaveAttribute('data-active', 'true')
+  await grid.press('F2')
+  const input = orcaPage.getByRole('textbox', { name: 'Edit row 101, column 1024', exact: true })
+  await input.fill('edited-final-cell')
+  await input.press('Enter')
+  await expect(last).toHaveText('edited-final-cell')
+  expect(await grid.getByRole('columnheader').count()).toBeLessThan(40)
+  expect(await grid.getByRole('row').count()).toBeLessThan(80)
+  await orcaPage.getByRole('button', { name: 'Save', exact: true }).click()
+  await expect
+    .poll(() => readFileSync(filePath, 'utf8').split('\n').at(-2)?.split(',').at(-1))
+    .toBe('edited-final-cell')
+  expect(readFileSync(filePath, 'utf8').split('\n')[1]?.split(',')[clipped.column]).toBe(
+    `zv${clipped.column}`
+  )
+})
+
+test('autosave preserves an active cell while saving the previously committed draft', async ({
+  orcaPage,
+  seededRepoPath
+}, testInfo) => {
+  const filePath = path.join(seededRepoPath, 'csv-autosave.csv')
+  writeFileSync(filePath, 'Name,Value\nA,1\nB,2')
+  await orcaPage.evaluate(
+    async ({ filePath }) => {
+      const state = window.__store?.getState()
+      if (!state?.activeWorktreeId) {
+        throw new Error('Missing CSV workspace')
+      }
+      await state.updateSettings({ editorAutoSave: true, editorAutoSaveDelayMs: 1000 })
+      state.openFile(
+        {
+          filePath,
+          relativePath: 'csv-autosave.csv',
+          worktreeId: state.activeWorktreeId,
+          language: 'plaintext',
+          mode: 'edit'
+        },
+        { preview: false }
+      )
+    },
+    { filePath }
+  )
+  const grid = orcaPage.getByTestId('csv-grid')
+  await grid.getByRole('gridcell', { name: 'A', exact: true }).dblclick()
+  const input = orcaPage.getByRole('textbox', { name: /Edit row/ })
+  await input.fill('committed')
+  await input.press('Enter')
+  await grid.getByRole('gridcell', { name: 'B', exact: true }).dblclick()
+  await input.fill('still typing')
+  await expect.poll(() => readFileSync(filePath, 'utf8')).toBe('Name,Value\ncommitted,1\nB,2')
+  await expect(input).toBeFocused()
+  await expect(input).toHaveValue('still typing')
+  await expect
+    .poll(() =>
+      orcaPage.evaluate(() => window.__store?.getState().openFiles.some((file) => file.isDirty))
+    )
+    .toBe(true)
+  await orcaPage.screenshot({ path: testInfo.outputPath('csv-autosave-keeps-input.png') })
+  await input.press('Enter')
+  await expect
+    .poll(() => readFileSync(filePath, 'utf8'))
+    .toBe('Name,Value\ncommitted,1\nstill typing,2')
+})
diff --git a/tests/e2e/csv-url-links.spec.ts b/tests/e2e/csv-url-links.spec.ts
new file mode 100644
index 00000000000..5410c2cb6d5
--- /dev/null
+++ b/tests/e2e/csv-url-links.spec.ts
@@ -0,0 +1,150 @@
+import { writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { expect, test } from './helpers/orca-app'
+
+test('dense CSVs below 1 MiB remain visible and shrinking a later row window recovers', async ({
+  orcaPage,
+  seededRepoPath,
+  electronApp
+}, testInfo) => {
+  const name = 'dense-small.csv'
+  const filePath = path.join(seededRepoPath, name)
+  writeFileSync(filePath, `id\n${'\n'.repeat(600_000)}`)
+  await orcaPage.evaluate(
+    ({ name, filePath }) => {
+      const state = window.__store?.getState()
+      if (!state?.activeWorktreeId) {
+        throw new Error('Missing dense CSV workspace')
+      }
+      state.openFile(
+        {
+          filePath,
+          relativePath: name,
+          worktreeId: state.activeWorktreeId,
+          language: 'plaintext',
+          mode: 'edit'
+        },
+        { preview: false }
+      )
+    },
+    { name, filePath }
+  )
+  await expect(orcaPage.getByTestId('csv-grid')).toHaveAttribute('aria-rowcount', '600001')
+  await orcaPage.getByRole('button', { name: 'Next rows' }).click()
+  await expect(orcaPage.getByRole('rowheader', { name: '500001', exact: true })).toBeVisible()
+  await orcaPage.getByTestId('csv-scroll').evaluate((element) => {
+    element.scrollTop = element.scrollHeight
+  })
+  await expect(orcaPage.getByRole('rowheader', { name: '600000', exact: true })).toBeVisible()
+  await orcaPage.evaluate(() => {
+    const state = window.__store?.getState()
+    const file = state?.openFiles.find((file) => file.filePath.endsWith('dense-small.csv'))
+    if (!state || !file) {
+      throw new Error('Missing dense CSV tab')
+    }
+    state.setEditorDraft(file.id, 'id\nfirst\nsecond\nthird\n')
+  })
+  await expect(orcaPage.getByTestId('csv-grid')).toHaveAttribute('aria-rowcount', '4')
+  await expect(orcaPage.getByRole('gridcell', { name: 'first', exact: true })).toBeVisible()
+  await expect(orcaPage.getByRole('gridcell', { name: 'third', exact: true })).toBeVisible()
+  await expect(orcaPage.getByRole('button', { name: 'Next rows' })).toHaveCount(0)
+  await orcaPage.screenshot({ path: testInfo.outputPath('dense-after-shrink.png') })
+  if (
+    process.env.ORCA_E2E_FORCE_HEADFUL !== '1' &&
+    testInfo.project.metadata.orcaHeadful !== true
+  ) {
+    expect(
+      await electronApp.evaluate(({ BrowserWindow }) =>
+        BrowserWindow.getAllWindows().some((window) => window.isVisible())
+      )
+    ).toBe(false)
+  }
+})
+
+test('CSV links navigate from small and paged previews without replacing the renderer', async ({
+  orcaPage,
+  seededRepoPath,
+  electronApp
+}, testInfo) => {
+  test.setTimeout(90_000)
+  const url = 'https://example.com/?from=csv#demo'
+  const smallName = 'csv-links.csv'
+  const largeName = 'csv-links-large.csv'
+  const content = `name,url,notes\nExample,${url},javascript:alert(1)\n`
+  writeFileSync(path.join(seededRepoPath, smallName), content)
+  writeFileSync(
+    path.join(seededRepoPath, largeName),
+    content + `Record,${url},${'x'.repeat(200)}\n`.repeat(6000)
+  )
+  await orcaPage.evaluate(async () => {
+    await window.__store?.getState().updateSettings({ openLinksInApp: true })
+  })
+  for (const name of [smallName, largeName]) {
+    await orcaPage.evaluate(
+      ({ name, filePath }) => {
+        const state = window.__store?.getState()
+        if (!state?.activeWorktreeId) {
+          throw new Error('Missing CSV test workspace')
+        }
+        state.openFile(
+          {
+            filePath,
+            relativePath: name,
+            worktreeId: state.activeWorktreeId,
+            language: 'plaintext',
+            mode: 'edit'
+          },
+          { preview: false }
+        )
+      },
+      { name, filePath: path.join(seededRepoPath, name) }
+    )
+    const link = orcaPage.getByTestId('csv-grid').getByRole('link', { name: url }).first()
+    await expect(link).toBeVisible({ timeout: 30_000 })
+    await expect(link).toHaveAttribute('href', url)
+    await expect(
+      orcaPage
+        .getByTestId('csv-grid')
+        .locator('[data-csv-column="2"]')
+        .filter({ hasText: 'javascript:alert(1)' })
+        .first()
+    ).toBeVisible()
+    await orcaPage.screenshot({ path: testInfo.outputPath(`${name}.png`) })
+    const rendererUrl = orcaPage.url()
+    const tabsBefore = await orcaPage.evaluate(
+      () => Object.values(window.__store?.getState().browserTabsByWorktree ?? {}).flat().length
+    )
+    if (name === largeName) {
+      await link.focus()
+      await orcaPage.keyboard.press('Enter')
+    } else {
+      await link.click()
+    }
+    await expect
+      .poll(() =>
+        orcaPage.evaluate(
+          () => Object.values(window.__store?.getState().browserTabsByWorktree ?? {}).flat().length
+        )
+      )
+      .toBe(tabsBefore + 1)
+    expect(
+      await orcaPage.evaluate(
+        () =>
+          Object.values(window.__store?.getState().browserTabsByWorktree ?? {})
+            .flat()
+            .at(-1)?.url
+      )
+    ).toBe(url)
+    expect(orcaPage.url()).toBe(rendererUrl)
+  }
+  if (
+    process.env.ORCA_E2E_FORCE_HEADFUL !== '1' &&
+    testInfo.project.metadata.orcaHeadful !== true
+  ) {
+    expect(
+      await electronApp.evaluate(({ BrowserWindow }) =>
+        BrowserWindow.getAllWindows().some((window) => window.isVisible())
+      )
+    ).toBe(false)
+  }
+})
diff --git a/tests/e2e/cursor-quota-transport.unit.test.ts b/tests/e2e/cursor-quota-transport.unit.test.ts
new file mode 100644
index 00000000000..a984ef6ce2c
--- /dev/null
+++ b/tests/e2e/cursor-quota-transport.unit.test.ts
@@ -0,0 +1,141 @@
+import { createRequire } from 'node:module'
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { build } from 'vite'
+import { expect, it } from 'vitest'
+import { z } from 'zod'
+import { runProcess } from '../../src/shared/child-process/run-process'
+import { resolveElectronProbeLaunch } from '../../src/main/browser/electron-probe-display-launch'
+import { createElectronHomeIsolation } from './helpers/electron-home-isolation'
+
+const outcomeSchema = z.object({
+  arm: z.string(),
+  status: z.string(),
+  used: z.number().optional(),
+  failureKind: z.string().optional()
+})
+const wireSchema = z.object({
+  electron: z.string(),
+  chrome: z.string(),
+  receipts: z.array(
+    z.object({ arm: z.string(), path: z.string(), account: z.string(), headerAccount: z.string() })
+  ),
+  outcomes: z.array(outcomeSchema),
+  jarUnchanged: z.array(z.boolean()),
+  targetHits: z.number()
+})
+
+it('keeps Cursor account credentials independent of the native Electron cookie jar', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'orca-cursor-wire-'))
+  try {
+    const binary: unknown = createRequire(import.meta.url)('electron')
+    if (typeof binary !== 'string') {
+      throw new Error('Electron executable unavailable')
+    }
+    await build({
+      configFile: false,
+      logLevel: 'silent',
+      build: {
+        emptyOutDir: false,
+        target: 'node24',
+        outDir: root,
+        lib: {
+          entry: join(process.cwd(), 'tests/e2e/helpers/cursor-quota-wire.fixture.ts'),
+          formats: ['cjs'],
+          fileName: () => 'fixture.cjs'
+        },
+        rollupOptions: { external: ['electron', /^node:/] }
+      }
+    })
+    const resultPath = join(root, 'result.json')
+    const isolation = createElectronHomeIsolation({
+      inheritedEnv: process.env,
+      launchEnv: {},
+      userDataDir: join(root, 'profile'),
+      extraEnv: {
+        ORCA_BACKGROUND_LAUNCH: '1',
+        ORCA_DISABLE_CODEX_TRUST_RPC: '1',
+        ORCA_CURSOR_WIRE_RESULT: resultPath
+      }
+    })
+    delete isolation.env.ELECTRON_RUN_AS_NODE
+    const launch = resolveElectronProbeLaunch({
+      electronBinary: binary,
+      electronArgs: [join(root, 'fixture.cjs')],
+      platform: process.platform,
+      display: isolation.env.DISPLAY
+    })
+    const result = await runProcess({
+      program: launch.executable,
+      args: launch.args,
+      env: isolation.env,
+      timeoutMs: 60_000
+    })
+    const fixtureResult = existsSync(resultPath) ? readFileSync(resultPath, 'utf8') : 'no result'
+    const diagnostic = JSON.stringify({
+      platform: process.platform,
+      code: result.code,
+      signal: result.signal,
+      timedOut: result.timedOut,
+      outputTruncated: result.outputTruncated,
+      fixtureResult,
+      stdout: result.stdout,
+      stderr: result.stderr
+    })
+    expect(result.code, diagnostic).toBe(0)
+    expect(result.timedOut, diagnostic).toBe(false)
+    const wire = wireSchema.parse(JSON.parse(readFileSync(resultPath, 'utf8')))
+    for (const protocol of ['http', 'https']) {
+      for (const [name, used] of [
+        ['empty-A', 25],
+        ['jar-A-A', 25],
+        ['jar-A-B', 75],
+        ['jar-B-A', 25],
+        ['old-A-fresh-A', 25],
+        ['parallel-A', 25],
+        ['parallel-B', 75]
+      ] as const) {
+        expect(wire.outcomes.find(({ arm }) => arm === `${protocol}-${name}`)).toMatchObject({
+          status: 'ok',
+          used
+        })
+      }
+      for (const [name, failureKind] of [
+        ['http401', 'stale-token'],
+        ['http403', 'server'],
+        ['http429', 'rate-limited'],
+        ['http500', 'server'],
+        ['parse', 'parse'],
+        ['disconnect', 'network'],
+        ['redirect302', 'network'],
+        ['redirect307', 'network'],
+        ['expired', 'stale-token'],
+        ['aborted', 'network']
+      ] as const) {
+        expect(wire.outcomes.find(({ arm }) => arm === `${protocol}-${name}`)).toMatchObject({
+          status: 'error',
+          failureKind
+        })
+      }
+      expect(wire.outcomes.find(({ arm }) => arm === `${protocol}-legacy`)).toMatchObject({
+        status: 'ok',
+        used: 25
+      })
+      expect(wire.receipts.filter(({ arm }) => arm === `${protocol}-legacy`)).toMatchObject([
+        { path: '/api/usage-summary', account: 'A' },
+        { path: '/api/usage?user=auth0%7Cfake_A', account: 'A' }
+      ])
+      expect(
+        wire.receipts.filter(
+          ({ arm }) => arm === `${protocol}-expired` || arm === `${protocol}-aborted`
+        )
+      ).toEqual([])
+    }
+    expect(wire.jarUnchanged).toEqual(Array.from({ length: 10 }, () => true))
+    expect(wire.targetHits).toBe(0)
+    expect(wire.receipts.every(({ headerAccount }) => headerAccount === 'none')).toBe(true)
+  } finally {
+    rmSync(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
+  }
+}, 90_000)
diff --git a/tests/e2e/editor-model-host-isolation.spec.ts b/tests/e2e/editor-model-host-isolation.spec.ts
new file mode 100644
index 00000000000..5c201a0ba54
--- /dev/null
+++ b/tests/e2e/editor-model-host-isolation.spec.ts
@@ -0,0 +1,110 @@
+import { randomUUID } from 'node:crypto'
+import { rm, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { test, expect } from './helpers/orca-app'
+import { getActiveWorktreeContext } from './helpers/markdown-editor-fixture'
+import { waitForActiveWorktree, waitForSessionReady } from './helpers/store'
+import { buildOwnedEditorFileId } from '../../src/renderer/src/store/slices/editor/file-ids/editor-file-ids'
+
+test('keeps same-path host models and undo history separate', async ({
+  orcaPage,
+  registerPostElectronShutdownCleanup
+}, testInfo) => {
+  await waitForSessionReady(orcaPage)
+  await waitForActiveWorktree(orcaPage)
+  const context = await getActiveWorktreeContext(orcaPage)
+  const filePath = path.join(context.rootPath, `host-model-${randomUUID()}.txt`)
+  await writeFile(filePath, 'LOCAL_MARKER', 'utf8')
+  registerPostElectronShutdownCleanup(() => rm(filePath, { force: true }))
+  const remoteId = buildOwnedEditorFileId(filePath, context.worktreeId, 'host-model-fixture')
+
+  // Controlled owner records exercise renderer identity; file transport remains local.
+  await orcaPage.evaluate(
+    ({ filePath, remoteId, worktreeId }) => {
+      const store = window.__store
+      if (!store) {
+        throw new Error('Editor store unavailable')
+      }
+      const base = {
+        filePath,
+        relativePath: filePath.split(/[\\/]/).pop() ?? filePath,
+        worktreeId,
+        language: 'plaintext',
+        mode: 'edit' as const,
+        isDirty: true
+      }
+      const generation = {
+        runtimeConnectionGeneration: null,
+        runtimePairingRevision: undefined,
+        runtimeSshGeneration: null,
+        nestedSshGeneration: null,
+        directSshGeneration: null
+      }
+      store.setState((state) => ({
+        openFiles: [
+          {
+            ...base,
+            id: filePath,
+            operationProvenance: {
+              ownershipProjection: 'explicit',
+              generation: {
+                ...generation,
+                route: { executionHostId: 'local', runtimeEnvironmentId: null }
+              }
+            }
+          },
+          {
+            ...base,
+            id: remoteId,
+            operationProvenance: {
+              ownershipProjection: 'explicit',
+              generation: {
+                ...generation,
+                route: { executionHostId: 'ssh:fixture-target', runtimeEnvironmentId: null }
+              }
+            }
+          }
+        ],
+        editorDrafts: {
+          ...state.editorDrafts,
+          [filePath]: 'LOCAL_MARKER',
+          [remoteId]: 'REMOTE_MARKER'
+        },
+        activeFileId: filePath,
+        activeFileIdByWorktree: { ...state.activeFileIdByWorktree, [worktreeId]: filePath }
+      }))
+      const state = store.getState()
+      const localTab = state.createUnifiedTab(worktreeId, 'editor', {
+        entityId: filePath,
+        label: 'Local file'
+      })
+      state.createUnifiedTab(worktreeId, 'editor', { entityId: remoteId, label: 'Remote file' })
+      store.getState().activateTab(localTab.id)
+    },
+    { filePath, remoteId, worktreeId: context.worktreeId }
+  )
+
+  const editor = orcaPage.locator('.monaco-editor').first()
+  await expect(editor).toBeVisible({ timeout: 25_000 })
+  const valueTail = () => orcaPage.evaluate(() => window.__monacoEditorE2E?.snapshot().valueTail)
+  await expect.poll(valueTail).toBe('LOCAL_MARKER')
+  await editor.click()
+  await orcaPage.keyboard.press('ControlOrMeta+End')
+  await orcaPage.keyboard.type('!')
+  await expect.poll(valueTail).toBe('LOCAL_MARKER!')
+  await orcaPage.evaluate((id) => window.__store?.getState().setActiveFile(id), remoteId)
+  await expect.poll(valueTail).toBe('REMOTE_MARKER')
+  await orcaPage.screenshot({ path: testInfo.outputPath('remote-before-undo.png') })
+  await editor.click()
+  await orcaPage.keyboard.press('ControlOrMeta+z')
+  await orcaPage.screenshot({ path: testInfo.outputPath('remote-after-undo.png') })
+  await expect.poll(valueTail).toBe('REMOTE_MARKER')
+  await orcaPage.keyboard.press('ControlOrMeta+End')
+  await orcaPage.keyboard.type('?')
+  await expect.poll(valueTail).toBe('REMOTE_MARKER?')
+  await orcaPage.keyboard.press('ControlOrMeta+z')
+  await expect.poll(valueTail).toBe('REMOTE_MARKER')
+  await orcaPage.evaluate((id) => window.__store?.getState().setActiveFile(id), filePath)
+  await expect.poll(valueTail).toBe('LOCAL_MARKER!')
+  await orcaPage.screenshot({ path: testInfo.outputPath('local-retained-edit.png') })
+})
diff --git a/tests/e2e/file-explorer-ime-enter.spec.ts b/tests/e2e/file-explorer-ime-enter.spec.ts
new file mode 100644
index 00000000000..3bd275461cb
--- /dev/null
+++ b/tests/e2e/file-explorer-ime-enter.spec.ts
@@ -0,0 +1,112 @@
+import { mkdtemp, rm, stat, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { test, expect } from './helpers/orca-app'
+
+test.use({ seedTestRepo: false })
+
+const cases = (['New File', 'New Folder', 'Rename'] as const).flatMap((operation) =>
+  [false, true].map((redispatch) => ({ operation, redispatch }))
+)
+
+for (const { operation, redispatch } of cases) {
+  test(`IME confirmation keeps File Explorer ${operation} open (${redispatch ? 'redispatch' : 'continued typing'})`, async ({
+    orcaPage: page,
+    registerPostElectronShutdownCleanup
+  }) => {
+    const folder = await mkdtemp(path.join(os.tmpdir(), 'orca-ime-names-'))
+    registerPostElectronShutdownCleanup(() => rm(folder, { recursive: true, force: true }))
+    await writeFile(path.join(folder, 'original.md'), 'Keep this content\n')
+    await page.evaluate(async (folder) => {
+      await window.__store!.getState().addRepoPath(folder, 'folder')
+    }, folder)
+    await page
+      .getByRole('option')
+      .filter({ hasText: path.basename(folder) })
+      .click()
+    const explorer = page.locator('[data-orca-explorer-shell]')
+    await explorer
+      .getByRole('button', { name: 'original.md', exact: true })
+      .click({ button: 'right' })
+    await page.getByRole('menuitem', { name: operation, exact: operation !== 'Rename' }).click()
+    const input = explorer.locator('input.border-ring')
+    await expect(input).toBeFocused()
+    await input.fill('')
+    const cdp = await page.context().newCDPSession(page)
+    await cdp.send('Input.imeSetComposition', {
+      text: 'ぎじろく',
+      selectionStart: 4,
+      selectionEnd: 4
+    })
+    await cdp.send('Input.imeSetComposition', {
+      text: '議事録',
+      selectionStart: 3,
+      selectionEnd: 3
+    })
+    await cdp.send('Input.dispatchKeyEvent', {
+      type: 'keyDown',
+      key: redispatch ? 'Process' : 'Enter',
+      code: 'Enter',
+      windowsVirtualKeyCode: 229,
+      nativeVirtualKeyCode: 229
+    })
+    await cdp.send('Input.insertText', { text: '議事録' })
+    if (redispatch) {
+      await input.evaluate((element) => {
+        const redispatchAfterRelease = (event: KeyboardEvent): void => {
+          if (event.target !== element || event.key !== 'Process' || event.keyCode !== 229) {
+            return
+          }
+          document.removeEventListener('keyup', redispatchAfterRelease)
+          const confirmation = new KeyboardEvent('keydown', {
+            bubbles: true,
+            cancelable: true,
+            key: 'Enter',
+            code: 'Enter',
+            keyCode: 13
+          })
+          element.setAttribute(
+            'data-ime-redispatch-cancelled',
+            String(!element.dispatchEvent(confirmation))
+          )
+        }
+        // Run after React's keyup handler, before a frame can separate two CDP messages.
+        document.addEventListener('keyup', redispatchAfterRelease)
+      })
+    }
+    await cdp.send('Input.dispatchKeyEvent', {
+      type: 'keyUp',
+      key: redispatch ? 'Process' : 'Enter',
+      code: 'Enter',
+      windowsVirtualKeyCode: redispatch ? 229 : 13,
+      nativeVirtualKeyCode: redispatch ? 229 : 13
+    })
+    if (redispatch) {
+      await expect(input).toHaveAttribute('data-ime-redispatch-cancelled', 'true')
+      await cdp.send('Input.dispatchKeyEvent', {
+        type: 'keyUp',
+        key: 'Enter',
+        code: 'Enter',
+        windowsVirtualKeyCode: 13,
+        nativeVirtualKeyCode: 13
+      })
+    }
+    await expect(input).toBeVisible()
+    await expect(input).toHaveValue('議事録')
+    await expect(explorer.getByRole('button', { name: '議事録', exact: true })).toHaveCount(0)
+    const suffix = redispatch ? '' : operation === 'New Folder' ? '-完成' : '.md'
+    if (suffix) {
+      await input.press('End')
+      await input.pressSequentially(suffix)
+    }
+    await input.press('Enter')
+    await expect(input).toHaveCount(0)
+    await expect(
+      explorer.getByRole('button', { name: `議事録${suffix}`, exact: true })
+    ).toBeVisible()
+    expect((await stat(path.join(folder, `議事録${suffix}`))).isDirectory()).toBe(
+      operation === 'New Folder'
+    )
+    await cdp.detach()
+  })
+}
diff --git a/tests/e2e/helpers/cursor-quota-wire.fixture.ts b/tests/e2e/helpers/cursor-quota-wire.fixture.ts
new file mode 100644
index 00000000000..4acd5185447
--- /dev/null
+++ b/tests/e2e/helpers/cursor-quota-wire.fixture.ts
@@ -0,0 +1,258 @@
+import { app, net, session } from 'electron'
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http'
+import { createServer as createHttpsServer } from 'node:https'
+import { writeFileSync } from 'node:fs'
+import {
+  LOCAL_HTTPS_TEST_CERTIFICATE,
+  LOCAL_HTTPS_TEST_PRIVATE_KEY
+} from '../../../src/main/browser/browser-local-https-test-certificate'
+import { fetchCursorRateLimits } from '../../../src/main/rate-limits/cursor-fetcher'
+import {
+  cursorSessionCookie,
+  parseCursorSessionToken
+} from '../../../src/main/rate-limits/cursor-session-token'
+import type { CursorAuthReadResult } from '../../../src/main/rate-limits/cursor-auth'
+
+function requiredEnv(name: string): string {
+  const value = process.env[name]
+  if (!value) {
+    throw new Error(`Missing fixture environment: ${name}`)
+  }
+  return value
+}
+
+app.setPath('userData', requiredEnv('ORCA_E2E_USER_DATA_DIR'))
+app.setPath('home', requiredEnv('ORCA_E2E_HOME_DIR'))
+
+function auth(account: string, revision = 'fresh', exp = 4_000_000_000): CursorAuthReadResult {
+  const token = parseCursorSessionToken(
+    `e30.${Buffer.from(JSON.stringify({ sub: `auth0|fake_${account}`, exp })).toString('base64url')}.${revision}`
+  )
+  if (!token) {
+    throw new Error('Invalid fake fixture token')
+  }
+  return {
+    status: 'ok',
+    session: {
+      token,
+      source: 'cli',
+      email: null,
+      displayName: null,
+      membershipType: null,
+      subscriptionStatus: null
+    }
+  }
+}
+
+function cookie(read: CursorAuthReadResult): string {
+  if (read.status !== 'ok') {
+    throw new Error('Fixture needs an authenticated fake account')
+  }
+  return cursorSessionCookie(read.session.token)
+}
+
+const accountA = auth('A')
+const accountB = auth('B')
+const oldA = auth('A', 'old')
+const summary = (used: number) => ({
+  membershipType: 'pro',
+  individualUsage: { plan: { enabled: true, used, limit: 100 } }
+})
+let stage = 'waiting-for-ready'
+const resultPath = requiredEnv('ORCA_CURSOR_WIRE_RESULT')
+writeFileSync(resultPath, JSON.stringify({ stage }))
+
+async function run(): Promise<void> {
+  await app.whenReady()
+  stage = 'ready'
+  writeFileSync(resultPath, JSON.stringify({ stage }))
+  const receipts: { arm: string; path: string; account: string; headerAccount: string }[] = []
+  const outcomes: { arm: string; status: string; used?: number; failureKind?: string }[] = []
+  let arm = ''
+  let scenario = 'summary'
+  let targetHits = 0
+  const target = createServer((_request, response) => {
+    targetHits++
+    response.end('unexpected redirect')
+  })
+  await new Promise<void>((resolve) => target.listen(0, '127.0.0.1', resolve))
+  const targetAddress = target.address()
+  if (!targetAddress || typeof targetAddress === 'string') {
+    throw new Error('No target listener')
+  }
+  const targetOrigin = `http://127.0.0.1:${targetAddress.port}`
+  const respond = (request: IncomingMessage, response: ServerResponse): void => {
+    const incoming = request.headers.cookie
+    const account =
+      incoming === cookie(accountA) ? 'A' : incoming === cookie(accountB) ? 'B' : 'other'
+    receipts.push({
+      arm,
+      path: request.url ?? '',
+      account,
+      headerAccount: request.headers.authorization ? 'unexpected' : 'none'
+    })
+    if (scenario === 'redirect302' || scenario === 'redirect307') {
+      response.writeHead(scenario === 'redirect302' ? 302 : 307, {
+        Location: `${targetOrigin}/sink`
+      })
+      response.end()
+      return
+    }
+    if (scenario === 'disconnect') {
+      request.socket.destroy()
+      return
+    }
+    const status = scenario.startsWith('http')
+      ? Number(scenario.slice(4))
+      : account === 'other'
+        ? 401
+        : 200
+    response.writeHead(status, {
+      'Content-Type': 'application/json',
+      'Retry-After': '30',
+      'Set-Cookie': 'fixture_response=must-not-enter-jar; Path=/'
+    })
+    if (scenario === 'parse') {
+      response.end('invalid JSON')
+    } else if (scenario === 'legacy' && request.url === '/api/usage-summary') {
+      response.end('{}')
+    } else if (scenario === 'legacy') {
+      response.end(JSON.stringify({ 'gpt-4': { numRequests: 25, maxRequestUsage: 100 } }))
+    } else {
+      response.end(JSON.stringify(summary(account === 'A' ? 25 : 75)))
+    }
+  }
+  const http = createServer(respond)
+  const https = createHttpsServer(
+    { key: LOCAL_HTTPS_TEST_PRIVATE_KEY, cert: LOCAL_HTTPS_TEST_CERTIFICATE },
+    respond
+  )
+  await new Promise<void>((resolve) => http.listen(0, '127.0.0.1', resolve))
+  await new Promise<void>((resolve) => https.listen(0, '127.0.0.1', resolve))
+  const httpAddress = http.address(),
+    httpsAddress = https.address()
+  if (
+    !httpAddress ||
+    typeof httpAddress === 'string' ||
+    !httpsAddress ||
+    typeof httpsAddress === 'string'
+  ) {
+    throw new Error('No fixture listener')
+  }
+  const httpOrigin = `http://127.0.0.1:${httpAddress.port}`
+  const httpsOrigin = `https://127.0.0.1:${httpsAddress.port}`
+  session.defaultSession.setCertificateVerifyProc((request, callback) => {
+    callback(
+      request.hostname === '127.0.0.1' &&
+        request.certificate.data.trim() === LOCAL_HTTPS_TEST_CERTIFICATE.trim()
+        ? 0
+        : -3
+    )
+  })
+  let origin = httpOrigin
+  const nativeFetch = net.fetch.bind(net)
+  // Route only the provider URL and CSRF origin to loopback; Cookie and credential mode reach native fetch unchanged.
+  net.fetch = (url, options) => {
+    const parsed = new URL(String(url))
+    if (parsed.origin !== 'https://cursor.com') {
+      throw new Error('Fixture refuses non-Cursor requests')
+    }
+    return nativeFetch(origin + parsed.pathname + parsed.search, {
+      ...options,
+      headers: { ...options?.headers, Origin: origin, Referer: `${origin}/dashboard` }
+    })
+  }
+  const jarUnchanged: boolean[] = []
+  const fetch = async (
+    name: string,
+    requested: CursorAuthReadResult,
+    signal?: AbortSignal
+  ): Promise<void> => {
+    arm = name
+    stage = name
+    const result = await fetchCursorRateLimits({ authReadResult: requested, signal })
+    outcomes.push({
+      arm: name,
+      status: result.status,
+      used: result.monthly?.usedPercent,
+      failureKind: result.usageMetadata?.failureKind
+    })
+  }
+  try {
+    for (const protocol of ['http', 'https']) {
+      origin = protocol === 'http' ? httpOrigin : httpsOrigin
+      for (const [name, jar, requested] of [
+        ['empty-A', null, accountA],
+        ['jar-A-A', accountA, accountA],
+        ['jar-A-B', accountA, accountB],
+        ['jar-B-A', accountB, accountA],
+        ['old-A-fresh-A', oldA, accountA]
+      ] as const) {
+        await session.defaultSession.clearStorageData()
+        if (jar) {
+          await session.defaultSession.cookies.set({
+            url: origin,
+            name: 'WorkosCursorSessionToken',
+            value: cookie(jar).slice('WorkosCursorSessionToken='.length),
+            httpOnly: true
+          })
+        }
+        const before = await session.defaultSession.cookies.get({ url: origin })
+        scenario = 'summary'
+        await fetch(`${protocol}-${name}`, requested)
+        jarUnchanged.push(
+          JSON.stringify(await session.defaultSession.cookies.get({ url: origin })) ===
+            JSON.stringify(before)
+        )
+      }
+      await session.defaultSession.clearStorageData()
+      scenario = 'summary'
+      await Promise.all([
+        fetch(`${protocol}-parallel-A`, accountA),
+        fetch(`${protocol}-parallel-B`, accountB)
+      ])
+      for (const mode of [
+        'http401',
+        'http403',
+        'http429',
+        'http500',
+        'parse',
+        'disconnect',
+        'redirect302',
+        'redirect307',
+        'legacy'
+      ]) {
+        scenario = mode
+        await fetch(`${protocol}-${mode}`, accountA)
+      }
+      scenario = 'summary'
+      await fetch(`${protocol}-expired`, auth('A', 'expired', 1))
+      await fetch(`${protocol}-aborted`, accountA, AbortSignal.abort())
+    }
+    writeFileSync(
+      resultPath,
+      JSON.stringify({
+        electron: process.versions.electron,
+        chrome: process.versions.chrome,
+        receipts,
+        outcomes,
+        jarUnchanged,
+        targetHits
+      })
+    )
+  } finally {
+    net.fetch = nativeFetch
+    http.close()
+    https.close()
+    target.close()
+  }
+}
+
+void run().then(
+  () => app.exit(0),
+  (error: unknown) => {
+    const detail = error instanceof Error ? (error.stack ?? error.message) : String(error)
+    writeFileSync(resultPath, JSON.stringify({ stage, error: detail }))
+    app.exit(1)
+  }
+)
diff --git a/tests/e2e/markdown-async-image-paste.spec.ts b/tests/e2e/markdown-async-image-paste.spec.ts
new file mode 100644
index 00000000000..1d43896faec
--- /dev/null
+++ b/tests/e2e/markdown-async-image-paste.spec.ts
@@ -0,0 +1,236 @@
+import { writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { Editor } from '@tiptap/core'
+import type { Locator } from '@stablyai/playwright-test'
+import { expect, test } from './helpers/orca-app'
+import {
+  cleanupMarkdownFixture,
+  createMarkdownFixture,
+  getActiveWorktreeContext,
+  openMarkdownFixture,
+  waitForRichMarkdownEditor
+} from './helpers/markdown-editor-fixture'
+
+const PNG =
+  'iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAAYUlEQVR4nO3PIREAIBAAMFqhMWgyUYMun4QQaBQZEO92twIrZ/RUde1URUBAQEBAQEBAQEBAQEBAQEBAQEBAQEDgO9BiprrRUgkICAgICAgICAgICAgICAgICAgICAgIfHuebLmH1pKnMwAAAABJRU5ErkJggg=='
+
+type RichMarkdownImageEditorElement = HTMLElement & { editor?: Editor }
+
+declare global {
+  var __markdownImagePasteRelease: (() => void) | undefined
+}
+
+async function pasteImage(editor: Locator) {
+  return editor.evaluate((element, png) => {
+    const editorElement =
+      document.querySelector<RichMarkdownImageEditorElement>('.rich-markdown-editor')
+    if (!editorElement || editorElement !== element || !editorElement.editor) {
+      throw new Error('Markdown editor unavailable')
+    }
+    const instance = editorElement.editor
+    const readSelection = () => ({
+      from: instance.state.selection.from,
+      to: instance.state.selection.to,
+      selectedText: instance.state.doc.textBetween(
+        instance.state.selection.from,
+        instance.state.selection.to
+      )
+    })
+    const priorSelection = readSelection()
+    // Establish the selection in the paste turn, after initial focus and screenshot work.
+    editorElement.focus()
+    instance.commands.setTextSelection({ from: 7, to: 12 })
+    const data = new DataTransfer()
+    const bytes = Uint8Array.from(atob(png), (character) => character.charCodeAt(0))
+    data.items.add(new File([bytes], 'image.png', { type: 'image/png' }))
+    const event = new ClipboardEvent('paste', {
+      bubbles: true,
+      cancelable: true,
+      clipboardData: data
+    })
+    const before = readSelection()
+    const domSelection = window.getSelection()?.toString()
+    element.dispatchEvent(event)
+    return {
+      priorSelection,
+      before,
+      after: readSelection(),
+      domSelection,
+      handled: event.defaultPrevented
+    }
+  }, PNG)
+}
+
+test('image paste replaces its selection after editing during clipboard import', async ({
+  orcaPage,
+  electronApp,
+  registerPostElectronShutdownCleanup
+}, testInfo) => {
+  const context = await getActiveWorktreeContext(orcaPage)
+  const filePath = await createMarkdownFixture(
+    context,
+    '.orca-e2e-markdown-image',
+    'async-image',
+    testInfo.workerIndex,
+    'hello world\n\nThe selected word should be replaced by this image.'
+  )
+  const imagePath = testInfo.outputPath('deferred-image.png')
+  await writeFile(imagePath, Buffer.from(PNG, 'base64'))
+  registerPostElectronShutdownCleanup(() => cleanupMarkdownFixture(filePath))
+  registerPostElectronShutdownCleanup(() =>
+    cleanupMarkdownFixture(path.join(path.dirname(filePath), path.basename(imagePath)))
+  )
+  await openMarkdownFixture(orcaPage, context, filePath)
+  const editor = await waitForRichMarkdownEditor(orcaPage)
+  await expect(editor.locator('p').first()).toHaveText('hello world')
+  await orcaPage.screenshot({ path: testInfo.outputPath('image-document-before-paste.png') })
+
+  // Substitute clipboard persistence without reading or writing the system clipboard.
+  await electronApp.evaluate(({ ipcMain }, imagePath) => {
+    ipcMain.removeHandler('clipboard:saveImageAsTempFile')
+    ipcMain.handle(
+      'clipboard:saveImageAsTempFile',
+      () =>
+        new Promise<string>((resolve) => {
+          globalThis.__markdownImagePasteRelease = () => resolve(imagePath)
+        })
+    )
+  }, imagePath)
+  const pasteSelection = await pasteImage(editor)
+  await testInfo.attach('selection-at-image-paste', {
+    body: Buffer.from(JSON.stringify(pasteSelection, null, 2)),
+    contentType: 'application/json'
+  })
+  expect(pasteSelection.before).toEqual({ from: 7, to: 12, selectedText: 'world' })
+  expect(pasteSelection.after).toEqual(pasteSelection.before)
+  expect(pasteSelection.handled).toBe(true)
+  await expect
+    .poll(() =>
+      electronApp.evaluate(() => typeof globalThis.__markdownImagePasteRelease === 'function')
+    )
+    .toBe(true)
+
+  await editor.evaluate((element) => {
+    const editorElement =
+      document.querySelector<RichMarkdownImageEditorElement>('.rich-markdown-editor')
+    if (!editorElement || editorElement !== element || !editorElement.editor) {
+      throw new Error('Markdown editor unavailable')
+    }
+    editorElement.editor.commands.setTextSelection(1)
+  })
+  await orcaPage.keyboard.type('prefix ')
+  await expect(editor.locator('p').first()).toHaveText('prefix hello world')
+  await electronApp.evaluate(() => {
+    const release = globalThis.__markdownImagePasteRelease
+    if (typeof release !== 'function') {
+      throw new Error('Clipboard import not pending')
+    }
+    release()
+    globalThis.__markdownImagePasteRelease = undefined
+  })
+  const image = editor.locator('img:not(.ProseMirror-separator)')
+  await expect(image).toHaveCount(1)
+  await expect(image).toBeVisible()
+  await expect
+    .poll(() =>
+      image.evaluate(
+        (image) => image instanceof HTMLImageElement && image.complete && image.naturalWidth > 0
+      )
+    )
+    .toBe(true)
+  await orcaPage.keyboard.type('continued ')
+  await orcaPage.screenshot({ path: testInfo.outputPath('image-after-delayed-paste.png') })
+  await testInfo.attach('image-after-delayed-paste', {
+    path: testInfo.outputPath('image-after-delayed-paste.png'),
+    contentType: 'image/png'
+  })
+  await expect(editor.locator('p').first()).toHaveText('prefix continued hello ')
+  expect(
+    await editor.evaluate(() => {
+      const instance =
+        document.querySelector<RichMarkdownImageEditorElement>('.rich-markdown-editor')?.editor
+      if (!instance) {
+        throw new Error('Markdown editor unavailable')
+      }
+      const content: (string | undefined)[] = []
+      instance.state.doc.firstChild?.forEach((node) => {
+        content.push(node.isText ? node.text : node.type.name)
+      })
+      return content
+    })
+  ).toEqual(['prefix continued hello ', 'image'])
+  await expect(editor.locator('p').nth(1)).toHaveText(
+    'The selected word should be replaced by this image.'
+  )
+})
+
+test('image paste reports cancellation when the selected target changes before import', async ({
+  orcaPage,
+  electronApp,
+  registerPostElectronShutdownCleanup
+}, testInfo) => {
+  const context = await getActiveWorktreeContext(orcaPage)
+  const filePath = await createMarkdownFixture(
+    context,
+    '.orca-e2e-markdown-image',
+    'cancel-image',
+    testInfo.workerIndex,
+    'hello world'
+  )
+  const imagePath = testInfo.outputPath('pending-image.png')
+  await writeFile(imagePath, Buffer.from(PNG, 'base64'))
+  registerPostElectronShutdownCleanup(() => cleanupMarkdownFixture(filePath))
+  await openMarkdownFixture(orcaPage, context, filePath)
+  const editor = await waitForRichMarkdownEditor(orcaPage)
+  await electronApp.evaluate(({ ipcMain }, imagePath) => {
+    ipcMain.removeHandler('clipboard:saveImageAsTempFile')
+    ipcMain.handle(
+      'clipboard:saveImageAsTempFile',
+      () =>
+        new Promise<string>((resolve) => {
+          globalThis.__markdownImagePasteRelease = () => resolve(imagePath)
+        })
+    )
+  }, imagePath)
+  const pasteSelection = await pasteImage(editor)
+  expect(pasteSelection.before).toEqual({ from: 7, to: 12, selectedText: 'world' })
+  expect(pasteSelection.after).toEqual(pasteSelection.before)
+  expect(pasteSelection.handled).toBe(true)
+  await expect
+    .poll(() =>
+      electronApp.evaluate(() => typeof globalThis.__markdownImagePasteRelease === 'function')
+    )
+    .toBe(true)
+
+  await editor.evaluate((element) => {
+    const editorElement =
+      document.querySelector<RichMarkdownImageEditorElement>('.rich-markdown-editor')
+    if (!editorElement || editorElement !== element || !editorElement.editor) {
+      throw new Error('Markdown editor unavailable')
+    }
+    editorElement.focus()
+    editorElement.editor.commands.setTextSelection({ from: 7, to: 12 })
+    editorElement.editor.commands.insertContent('changed')
+  })
+  await electronApp.evaluate(() => {
+    const release = globalThis.__markdownImagePasteRelease
+    if (typeof release !== 'function') {
+      throw new Error('Clipboard import not pending')
+    }
+    release()
+    globalThis.__markdownImagePasteRelease = undefined
+  })
+  await expect(editor.locator('p').first()).toHaveText('hello changed')
+  await expect(editor.locator('img:not(.ProseMirror-separator)')).toHaveCount(0)
+  const cancellationMessage = orcaPage.getByText(
+    'Image insertion canceled because the destination changed. Try again.',
+    { exact: true }
+  )
+  await expect(cancellationMessage).toBeVisible()
+  const screenshot = testInfo.outputPath('image-cancellation-feedback.png')
+  await orcaPage.screenshot({ path: screenshot, animations: 'disabled' })
+  await testInfo.attach('image-cancellation-feedback', {
+    path: screenshot,
+    contentType: 'image/png'
+  })
+})
diff --git a/tests/e2e/markdown-large-paste-selection.spec.ts b/tests/e2e/markdown-large-paste-selection.spec.ts
new file mode 100644
index 00000000000..62f7d29e690
--- /dev/null
+++ b/tests/e2e/markdown-large-paste-selection.spec.ts
@@ -0,0 +1,92 @@
+import { test, expect } from './helpers/orca-app'
+import type { Locator } from '@stablyai/playwright-test'
+import type { Editor } from '@tiptap/core'
+import {
+  cleanupMarkdownFixture,
+  createMarkdownFixture,
+  getActiveWorktreeContext,
+  openMarkdownFixture,
+  waitForRichMarkdownEditor
+} from './helpers/markdown-editor-fixture'
+import { waitForSessionReady, waitForActiveWorktree } from './helpers/store'
+
+type RichMarkdownEditorElement = HTMLElement & { editor?: Editor }
+
+async function readParagraphs(editor: Locator): Promise<string[]> {
+  return editor.evaluate(() => {
+    const instance =
+      document.querySelector<RichMarkdownEditorElement>('.rich-markdown-editor')?.editor
+    if (!instance) {
+      throw new Error('Document unavailable')
+    }
+    const texts: string[] = []
+    instance.state.doc.forEach((node) => texts.push(node.textContent))
+    return texts
+  })
+}
+
+test('keeps a large paste at its original selection after the caret moves', async ({
+  orcaPage,
+  registerPostElectronShutdownCleanup
+}, testInfo) => {
+  await waitForSessionReady(orcaPage)
+  await waitForActiveWorktree(orcaPage)
+  const context = await getActiveWorktreeContext(orcaPage)
+  const filePath = await createMarkdownFixture(
+    context,
+    '.orca-e2e-markdown-large-paste',
+    'selection',
+    testInfo.workerIndex,
+    'hello world\n\nother paragraph'
+  )
+  registerPostElectronShutdownCleanup(() => cleanupMarkdownFixture(filePath))
+  await openMarkdownFixture(orcaPage, context, filePath)
+  const editor = await waitForRichMarkdownEditor(orcaPage)
+  const payload = 'PASTE_SENTINEL '.repeat(5500)
+  await editor.evaluate((element, text) => {
+    const instance =
+      document.querySelector<RichMarkdownEditorElement>('.rich-markdown-editor')?.editor
+    if (!instance) {
+      throw new Error('Editor unavailable')
+    }
+    element.focus()
+    instance.commands.setTextSelection({ from: 7, to: 12 })
+    const data = new DataTransfer()
+    data.setData('text/plain', text)
+    element.dispatchEvent(
+      new ClipboardEvent('paste', { bubbles: true, cancelable: true, clipboardData: data })
+    )
+    // Move during the production byte-measurement yield in this same input task.
+    instance.commands.setTextSelection(29)
+  }, payload)
+  await expect
+    .poll(async () => (await readParagraphs(editor)).join('').length)
+    .toBeGreaterThan(payload.length)
+  await expect
+    .poll(async () => (await readParagraphs(editor)).join('').match(/PASTE_SENTINEL/g)?.length ?? 0)
+    .toBe(5500)
+  await orcaPage.keyboard.type('!')
+  await editor.evaluate((element) => element.querySelector('p')?.scrollIntoView({ block: 'start' }))
+  await orcaPage.screenshot({ path: testInfo.outputPath('large-paste-after-caret-move.png') })
+  const paragraphs = await readParagraphs(editor)
+  const outcome = {
+    bytes: Buffer.byteLength(payload),
+    firstLength: paragraphs[0]?.length,
+    firstPrefix: paragraphs[0]?.slice(0, 40),
+    firstTextMatches: paragraphs[0] === `hello ${payload}`,
+    secondLength: paragraphs[1]?.length,
+    secondTextMatches: paragraphs[1] === 'other paragraph!'
+  }
+  await testInfo.attach('large-paste-outcome', {
+    body: JSON.stringify(outcome),
+    contentType: 'application/json'
+  })
+  expect(outcome).toEqual({
+    bytes: Buffer.byteLength(payload),
+    firstLength: payload.length + 6,
+    firstPrefix: `hello ${payload}`.slice(0, 40),
+    firstTextMatches: true,
+    secondLength: 16,
+    secondTextMatches: true
+  })
+})
diff --git a/tests/e2e/mobile-banner.spec.ts b/tests/e2e/mobile-banner.spec.ts
index 5c611ac11a1..928fe18b2d3 100644
--- a/tests/e2e/mobile-banner.spec.ts
+++ b/tests/e2e/mobile-banner.spec.ts
@@ -48,20 +48,19 @@ test('mobile subscribe mounts overlay; collapse → chip; Take back dismisses',
   await sendMobileSubscribeIpc(electronApp, { ptyId, cols: 45, rows: 20 })
 
   await expect(overlay).toBeVisible({ timeout: 15_000 })
-  await expect(overlay).toContainText(/from your phone/i)
   await expect(overlay).toContainText(/your phone is in control/i)
   await expectExpandedOverlayLeavesPaneReadable(orcaPage, ptyId)
 
-  const takeBackThisTerminal = overlay.getByRole('button', { name: /take back this terminal/i })
-  const takeBackAllTerminals = overlay.getByRole('button', { name: /take back all terminals/i })
-  const collapse = overlay.getByRole('button', { name: /^collapse$/i })
+  const takeBackThisTerminal = overlay.getByRole('button', { name: /^take back$/i })
+  const takeBackAllTerminals = overlay.getByRole('button', { name: /^take back all$/i })
+  const collapse = overlay.getByRole('button', { name: /^minimize$/i })
   await expect(takeBackThisTerminal).toBeVisible()
   await expect(takeBackAllTerminals).toBeVisible()
   await expect(collapse).toBeVisible()
 
   await captureAttachment(orcaPage, testInfo, 'overlay-loud.png')
 
-  // Click Collapse → loud overlay swaps to the corner chip while the lock stays
+  // Click Minimize → loud overlay swaps to the corner chip while the lock stays
   // engaged. The user can keep watching live mobile output while the chip
   // remains a one-click escape hatch back to desktop control.
   await collapse.click()
@@ -109,24 +108,22 @@ test('held phone-fit state mounts restore overlay without collapse', async ({
   await sendHeldPhoneFitIpc(electronApp, { ptyId, cols: 45, rows: 20 })
 
   await expect(overlay).toBeVisible({ timeout: 15_000 })
-  await expect(overlay).toContainText(/from your phone/i)
-  await expect(overlay).toContainText(/your phone left this at phone size/i)
-  await expect(overlay).toContainText(/all terminals your phone left at phone size/i)
-  await expect(overlay.getByRole('button', { name: /restore this terminal/i })).toBeVisible()
-  await expect(overlay.getByRole('button', { name: /restore all terminals/i })).toBeVisible()
-  await expect(overlay.getByRole('button', { name: /^collapse$/i })).toHaveCount(0)
+  await expect(overlay).toContainText(/still sized for your phone/i)
+  await expect(overlay.getByRole('button', { name: /^restore$/i })).toBeVisible()
+  await expect(overlay.getByRole('button', { name: /^restore all$/i })).toBeVisible()
+  await expect(overlay.getByRole('button', { name: /^minimize$/i })).toHaveCount(0)
   await expect(overlay.getByRole('button', { name: /take back/i })).toHaveCount(0)
   await expectExpandedOverlayLeavesPaneReadable(orcaPage, ptyId)
 
   await captureAttachment(orcaPage, testInfo, 'overlay-held-fit.png')
 
-  await overlay.getByRole('button', { name: /restore this terminal/i }).click()
+  await overlay.getByRole('button', { name: /^restore$/i }).click()
   await expectRestoreTerminalFitCalls(electronApp, [ptyId])
   await sendDesktopRestoreIpc(electronApp, { ptyId })
   await expect(overlay).toBeHidden({ timeout: 15_000 })
 })
 
-test('restore this terminal refits the active restored pane', async ({ orcaPage, electronApp }) => {
+test('restore refits the active restored pane', async ({ orcaPage, electronApp }) => {
   await waitForSessionReady(orcaPage)
   await waitForActiveWorktree(orcaPage)
   await ensureTerminalVisible(orcaPage)
@@ -144,14 +141,14 @@ test('restore this terminal refits the active restored pane', async ({ orcaPage,
 
   await orcaPage
     .locator(`[data-pty-id="${ptyId}"] .mobile-driver-banner`)
-    .getByRole('button', { name: /restore this terminal/i })
+    .getByRole('button', { name: /^restore$/i })
     .click()
 
   await expectRestoreTerminalFitCalls(electronApp, [ptyId])
   await expect
     .poll(() => getPaneTerminalCols(orcaPage, ptyId), {
       timeout: 5_000,
-      message: 'Restore this terminal should refit the active restored pane'
+      message: 'Restore should refit the active restored pane'
     })
     .toBeGreaterThan(20)
 })
@@ -186,7 +183,7 @@ test('restore all refits non-focused restored terminal panes', async ({
 
   await orcaPage
     .locator(`[data-pty-id="${focusPtyId}"] .mobile-driver-banner`)
-    .getByRole('button', { name: /restore all terminals/i })
+    .getByRole('button', { name: /^restore all$/i })
     .click()
 
   await expectRestoreTerminalFitCallSet(electronApp, [inactivePtyId, focusPtyId])
@@ -241,7 +238,7 @@ test('restore all recovers a hidden workspace held at narrow terminal geometry',
 
   await orcaPage
     .locator(`[data-pty-id="${activeWorkspacePtyId}"] .mobile-driver-banner`)
-    .getByRole('button', { name: /restore all terminals/i })
+    .getByRole('button', { name: /^restore all$/i })
     .click()
 
   await expectRestoreTerminalFitCallSet(electronApp, [hiddenWorkspacePtyId, activeWorkspacePtyId])
diff --git a/tests/e2e/ssh-config-host-picker.PLAN.md b/tests/e2e/ssh-config-host-picker.PLAN.md
deleted file mode 100644
index ddd44b907bd..00000000000
--- a/tests/e2e/ssh-config-host-picker.PLAN.md
+++ /dev/null
@@ -1,188 +0,0 @@
-# E2E Test Plan: SSH config host picker (`import-ssh-config-does-nothing`)
-
-## Branch summary
-
-Users can open **Fill from ~/.ssh/config…** on the add-SSH-host dialog, pick a
-Host alias, and get the form prefilled from `ssh -G` resolution. Bulk sync is a
-secondary **Add all N to Orca** action (no re-adopt). Settings → SSH → **Import**
-remains the deliberate re-adopt path.
-
-Commits under test (vs main):
-
-- `bd0b594dee` feat(ssh): add SSH config host picker for add-host form
-- `dc8339369a` fix(ssh): import filter preservation and label fallback
-- `5982c8108f` fix(ssh): harden config picker import, alias folding, host targeting
-- `5cfb6369e7` refactor(ssh): centralize host result limit / folder group helper
-
-## Already covered (do **not** re-test in E2E)
-
-| Area                                                     | Where                                                |
-| -------------------------------------------------------- | ---------------------------------------------------- |
-| `listConfigHosts` / `resolveConfigHost` IPC registration | `src/main/ipc/ssh.test.ts`                           |
-| Search, result limit, suppressed aliases, alreadyInOrca  | `ssh-config-host-picker.test.ts`                     |
-| Generation guard, freeze-while-resolving, late resolve   | `AddRemoteHostDialog.config-picker.test.tsx`         |
-| Bulk `importConfig()` without `reAdopt`                  | `add-remote-host-ssh-actions.test.ts`                |
-| Alias folding / duplicate save check                     | `ssh-target-duplicate.test.ts`                       |
-| `configured-only` host registry / setup fail-closed      | unit tests in shared + project-host-workspace-target |
-| Settings modal viewport stability                        | `ssh-host-form-modal.spec.ts`                        |
-
-E2E is reserved for real Electron HOME isolation, real `~/.ssh/config` parse,
-real `ssh -G` resolve, and user-visible DOM outcomes.
-
-## Harness requirements
-
-1. **Isolated HOME** — E2E already sets `HOME` to `{userDataDir}/home`. Seed config with:
-   ```ts
-   const home = await electronApp.evaluate(({ app }) => app.getPath('home'))
-   mkdirSync(path.join(home, '.ssh'), { recursive: true, mode: 0o700 })
-   writeFileSync(path.join(home, '.ssh/config'), configBody, { mode: 0o600 })
-   ```
-2. **Unique aliases** — prefix Host entries and Orca labels with
-   `e2e-ssh-cfg-${Date.now().toString(36)}-…` so workers never collide; clean up
-   via `window.api.ssh.removeTarget` in `afterEach` by label/configHost prefix.
-3. **Open the picker dialog** (not Settings `SshTargetForm` — that form has no
-   config picker). Path:
-   - Open **Add Project** (sidebar / landing control)
-   - Host combobox → **Add remote host** → **Add SSH host**
-   - Dialog title **Add SSH host** with link **Fill from ~/.ssh/config…**
-4. **Assertions** — DOM only (`getByRole`, `toHaveValue`, visible badges/toasts).
-   Store/API only for setup/cleanup/seeding existing targets.
-5. **Prereq** — OpenSSH client on PATH (`ssh -G`). macOS/Linux CI has it; skip
-   or soft-fail only if `ssh -G` is unavailable (document in test comment).
-
-## Spec file
-
-`tests/e2e/ssh-config-host-picker.spec.ts`  
-Reuse patterns from `ssh-host-form-modal.spec.ts` (session ready, target cleanup,
-announcement dismiss). Prefer small local helpers over new shared modules unless
-helpers would be reused elsewhere.
-
-Optional second file if the Settings Import case grows:  
-`tests/e2e/ssh-config-import-settings.spec.ts` — otherwise keep Import in the same file.
-
----
-
-## Cases (must ship)
-
-### P1 — Empty config empty state
-
-|            |                                                                                                                                         |
-| ---------- | --------------------------------------------------------------------------------------------------------------------------------------- |
-| **Setup**  | Do not create `~/.ssh/config` (or write empty file).                                                                                    |
-| **Steps**  | Open Add SSH host → Fill from ~/.ssh/config…                                                                                            |
-| **Expect** | Dialog title **Choose from ~/.ssh/config**; body **No hosts in ~/.ssh/config**; **Add all to Orca** disabled; **Back** returns to form. |
-
-### P2 — Seeded hosts listed with summary lines
-
-|            |                                                                                                                       |
-| ---------- | --------------------------------------------------------------------------------------------------------------------- |
-| **Setup**  | Write config with ≥2 concrete Hosts, e.g. `e2e-alpha` / `e2e-bravo` with HostName, User, Port.                        |
-| **Steps**  | Open picker.                                                                                                          |
-| **Expect** | Host list `SSH config hosts` shows both aliases; subtitle `user@hostname:port`; button **Add all 2 to Orca** enabled. |
-
-### P3 — Select host prefills form (and Save persists)
-
-|            |                                                                                                                                                                                                                                                                                                          |
-| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Setup**  | Config Host `e2e-prod` → HostName `prod.example.test`, User `deploy`, Port `2222`.                                                                                                                                                                                                                       |
-| **Steps**  | Pick `e2e-prod` → wait for form → click **Save**.                                                                                                                                                                                                                                                        |
-| **Expect** | After pick: Host/alias field = `prod.example.test`, Username `deploy`, Port `2222`, Label `e2e-prod` (or alias); optional toast _Filled from e2e-prod_; Identity file may stay empty with config hint. After Save: dialog closes; target appears in Settings → SSH (or listTargets shows matching host). |
-
-### P4 — Filter narrows list
-
-|            |                                                                          |
-| ---------- | ------------------------------------------------------------------------ |
-| **Setup**  | Hosts `e2e-alpha`, `e2e-bravo`.                                          |
-| **Steps**  | Open picker; filter `bravo`.                                             |
-| **Expect** | Only bravo row; alpha gone; **No matching hosts** if filter is nonsense. |
-
-### P5 — Already-in-Orca badge + disabled row
-
-|            |                                                                                                              |
-| ---------- | ------------------------------------------------------------------------------------------------------------ |
-| **Setup**  | Config hosts alpha + bravo. Seed Orca target with `configHost`/`label` matching alpha (via `ssh.addTarget`). |
-| **Steps**  | Open picker.                                                                                                 |
-| **Expect** | Alpha shows **In Orca** badge and is not clickable; bravo still selectable; **Add all 1 to Orca** (not 2).   |
-
-### P6 — Add all N to Orca imports new hosts only
-
-|            |                                                                                                                                     |
-| ---------- | ----------------------------------------------------------------------------------------------------------------------------------- |
-| **Setup**  | Config with 2 new hosts; no Orca targets for them.                                                                                  |
-| **Steps**  | **Add all 2 to Orca** → wait for success toast / return to form or list refresh.                                                    |
-| **Expect** | Both targets exist (DOM in Settings SSH and/or listTargets); re-open picker shows **All hosts already in Orca** / both **In Orca**. |
-
-### P7 — Add all does **not** re-adopt deleted hosts
-
-|            |                                                                                                                                                |
-| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Setup**  | Config with alpha + bravo; Add all → remove alpha via API (creates suppress tombstone).                                                        |
-| **Steps**  | Re-open picker; note count; optionally click Add all again.                                                                                    |
-| **Expect** | Alpha absent from picker (suppressed) or not re-created; only new hosts counted; `listTargets` still lacks deleted alpha after second Add all. |
-
-### P8 — Back discards pending pick path
-
-|            |                                                        |
-| ---------- | ------------------------------------------------------ |
-| **Setup**  | Seeded config.                                         |
-| **Steps**  | Open picker → **Back** without selecting.              |
-| **Expect** | Form fields still empty (Host blank); no filled toast. |
-
-### P9 — Settings Import re-adopts (contrast with P7)
-
-|            |                                                                        |
-| ---------- | ---------------------------------------------------------------------- |
-| **Setup**  | Same as P7 after delete.                                               |
-| **Steps**  | Settings → SSH → **Import** (explicit reAdopt path).                   |
-| **Expect** | Deleted config host reappears as an Orca target; toast sync count ≥ 1. |
-
----
-
-## Nice-to-have (only if cheap after P1–P9)
-
-- **N1** ProxyCommand / JumpHost: pick host with ProxyJump → Advanced opens and jump field filled (proves advanced prefill + `preferAdvancedOpen`).
-- **N2** Case-insensitive alias: config `Prod`, existing label `prod` → **In Orca**.
-- **N3** Empty Identity file hint visible after config fill.
-
-Skip: 100-host truncation, resolve races, GSSAPI system-default, composer host-availability fail-closed (unit-covered).
-
-## Out of scope
-
-- Real SSH connect / relay / PTY
-- Docker SSH fixtures
-- Web client stub paths (`listConfigHosts` returns empty)
-- i18n non-English
-
-## Implementation status (done)
-
-| Case                                  | Spec                             |
-| ------------------------------------- | -------------------------------- |
-| P1 empty state                        | `ssh-config-host-picker.spec.ts` |
-| P2 list + Add all enabled             | `ssh-config-host-picker.spec.ts` |
-| P3 select + Save (+ N3 identity hint) | `ssh-config-host-picker.spec.ts` |
-| P4 filter                             | `ssh-config-host-picker.spec.ts` |
-| P5 In Orca badge / count              | `ssh-config-host-import.spec.ts` |
-| P6 Add all imports                    | `ssh-config-host-import.spec.ts` |
-| P7 no re-adopt after delete           | `ssh-config-host-import.spec.ts` |
-| P8 Back without select                | `ssh-config-host-picker.spec.ts` |
-| P9 Settings Import re-adopts          | `ssh-config-host-import.spec.ts` |
-
-Shared helpers: `tests/e2e/helpers/ssh-config-host-picker.ts`
-
-### Product fix required for E2E (and real HOME isolation)
-
-OpenSSH resolves the default user config via **getpwuid**, not `$HOME`. E2E
-sets an isolated `HOME`, so `loadUserSshConfig` (Node `os.homedir()`) and
-`ssh -G` could disagree. `src/main/ssh/ssh-g-config-resolution.ts` now passes
-`-F <homedir>/.ssh/config` when the HOME config path exists and differs from the
-passwd home. Normal installs (HOME = passwd home) are unchanged.
-
-## Suggested run command
-
-```bash
-pnpm exec electron-vite build --mode e2e
-SKIP_BUILD=1 pnpm exec playwright test \
-  tests/e2e/ssh-config-host-picker.spec.ts \
-  tests/e2e/ssh-config-host-import.spec.ts \
-  --config tests/playwright.config.ts --project=electron-headless --workers=1
-```
diff --git a/tests/e2e/terminal-account-restart.unit.test.ts b/tests/e2e/terminal-account-restart.unit.test.ts
new file mode 100644
index 00000000000..23bc83dd480
--- /dev/null
+++ b/tests/e2e/terminal-account-restart.unit.test.ts
@@ -0,0 +1,458 @@
+import { PtyBindingPersistenceOperations } from '../../src/main/persistence/loading-store/pty-binding-persistence'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { setupPtyIpcSuite, type PtyIpcSuiteFixtures } from '../../src/main/ipc/pty-ipc-test-harness'
+import { TerminalKilledError } from '../../src/main/daemon/daemon-pty-lifecycle-errors'
+import { makePaneKey } from '../../src/shared/stable-pane-id'
+import { registerPtyHandlers, setLocalPtyProvider } from '../../src/main/ipc/pty'
+import { TerminalIntentionalStops } from '../../src/main/runtime/terminal-intentional-stops'
+
+vi.mock('electron', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.electronModuleMock())
+)
+vi.mock('fs', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.fsModuleMock())
+)
+vi.mock('node-pty', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.nodePtyModuleMock())
+)
+vi.mock('node:child_process', async (importOriginal) =>
+  (await import('../../src/main/ipc/pty-ipc-mock-registry')).childProcessModuleMock(
+    await importOriginal()
+  )
+)
+vi.mock('../../src/main/opencode/hook-service', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.openCodeHookServiceModuleMock())
+)
+vi.mock('../../src/main/mimo/hook-service', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.mimoHookServiceModuleMock())
+)
+vi.mock('../../src/main/agent-hooks/server', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.agentHookServerModuleMock())
+)
+vi.mock('../../src/main/pi/titlebar-extension-service', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.piTitlebarExtensionModuleMock())
+)
+vi.mock('../../src/main/pwsh', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.pwshModuleMock())
+)
+vi.mock('../../src/main/wsl', async (importOriginal) =>
+  (await import('../../src/main/ipc/pty-ipc-mock-registry')).wslModuleMock(await importOriginal())
+)
+vi.mock('../../src/main/telemetry/client', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.telemetryClientModuleMock())
+)
+vi.mock('../../src/main/telemetry/classify-error', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.classifyErrorModuleMock())
+)
+vi.mock('../../src/main/cli/linux-terminal-orca-cli-shim', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.linuxCliShimModuleMock())
+)
+vi.mock('../../src/main/memory/pty-registry', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) => m.ptyRegistryModuleMock())
+)
+vi.mock('../../src/main/agent-hooks/migration-unsupported-pty-state', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) =>
+    m.migrationUnsupportedPtyModuleMock()
+  )
+)
+vi.mock('../../src/main/codex/codex-pane-account-registry', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) =>
+    m.codexPaneAccountRegistryModuleMock()
+  )
+)
+vi.mock('../../src/main/codex/codex-state-db-backfill-recovery', () =>
+  import('../../src/main/ipc/pty-ipc-mock-registry').then((m) =>
+    m.codexBackfillRecoveryModuleMock()
+  )
+)
+
+const worktreeId = 'wt-1'
+const cwd = '/tmp/restart'
+const tabId = 'tab-1'
+const leafId = '11111111-1111-4111-8111-111111111111'
+const paneKey = makePaneKey(tabId, leafId)
+
+type RestartHarness = ReturnType<typeof installRestartHarness>
+
+function registerWithFakes(
+  mainWindow: PtyIpcSuiteFixtures['mainWindow'],
+  runtime: RestartHarness['runtime'],
+  store: RestartHarness['store']
+): void {
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: spawn and kill read only the window, runtime and store members these fakes define.
+  const args = [
+    mainWindow,
+    runtime,
+    undefined,
+    undefined,
+    undefined,
+    store
+  ] as unknown as Parameters<typeof registerPtyHandlers>
+  registerPtyHandlers(...args)
+}
+
+function installRestartHarness(
+  options: { shutdownFails?: boolean; shutdownGate?: Promise<void> } = {}
+) {
+  let oldSessionAlive = true
+  const control = { shutdownFails: options.shutdownFails ?? false }
+  const providerSpawn = vi.fn(async (spawnOptions: { attachOnly?: boolean }) => {
+    if (!spawnOptions.attachOnly) {
+      return { id: 'pty-new', incarnationId: 'inc-new' }
+    }
+    if (!oldSessionAlive) {
+      throw new TerminalKilledError('pty-old')
+    }
+    return { id: 'pty-old', incarnationId: 'inc-old', isReattach: true }
+  })
+  const shutdown = vi.fn(async () => {
+    await options.shutdownGate
+    if (control.shutdownFails) {
+      throw new Error('daemon unreachable')
+    }
+    oldSessionAlive = false
+  })
+  const provider = {
+    spawn: providerSpawn,
+    write: vi.fn(),
+    resize: vi.fn(),
+    kill: vi.fn(),
+    shutdown,
+    sendSignal: vi.fn(),
+    getCwd: vi.fn(),
+    getInitialCwd: vi.fn(),
+    clearBuffer: vi.fn(),
+    acknowledgeDataEvent: vi.fn(),
+    hasChildProcesses: vi.fn(),
+    getForegroundProcess: vi.fn(),
+    serialize: vi.fn(),
+    revive: vi.fn(),
+    onData: vi.fn(() => () => {}),
+    onReplay: vi.fn(() => () => {}),
+    onExit: vi.fn(() => () => {}),
+    listProcesses: vi.fn(async () => []),
+    attach: vi.fn(),
+    getDefaultShell: vi.fn(),
+    getProfiles: vi.fn()
+  }
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the restart path calls only the provider members this fake defines.
+  setLocalPtyProvider(provider as unknown as Parameters<typeof setLocalPtyProvider>[0])
+  let session = {
+    tabsByWorktree: { [worktreeId]: [{ id: tabId, worktreeId, ptyId: 'pty-old' }] },
+    terminalLayoutsByTabId: {
+      [tabId]: {
+        root: { type: 'leaf' as const, leafId },
+        activeLeafId: leafId,
+        expandedLeafId: null,
+        ptyIdsByLeafId: { [leafId]: 'pty-old' }
+      }
+    },
+    terminalPtyIncarnationsByPaneKey: { [paneKey]: 'inc-old' }
+  }
+  const store = {
+    getWorkspaceSession: vi.fn(() => session),
+    setWorkspaceSession: vi.fn((next) => {
+      session = next
+    }),
+    flushOrThrow: vi.fn(),
+    runDurableMutation: vi.fn(async <T>(mutate: () => { value: T }) => mutate().value),
+    getWorkspaceSessionHostIds: vi.fn(() => ['local']),
+    getFolderWorkspace: vi.fn(() => undefined),
+    getFolderWorkspaces: vi.fn(() => []),
+    getProjectGroups: vi.fn(() => []),
+    getRepos: vi.fn(() => [])
+  }
+  const state = { workspaceSession: session, workspaceSessionsByHostId: {} }
+  store.getWorkspaceSession.mockImplementation((hostId?: string) => {
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: each fake partition has the same session shape.
+    const partitions = state.workspaceSessionsByHostId as Record<string, typeof session>
+    return (hostId && partitions[hostId]) || state.workspaceSession
+  })
+  const bindingRuntime = {
+    state,
+    dirtyProfileStateDomains: new Set(),
+    runDurableMutation: store.runDurableMutation,
+    writeTimer: null,
+    pendingWrite: null,
+    quitFlushStarted: false,
+    writeGeneration: 0,
+    lastDurableWriteGeneration: 0
+  }
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: binding writes read only state, write bookkeeping, durable mutation and the session partitions from these fakes.
+  const bindingArgs = [bindingRuntime, store] as unknown as ConstructorParameters<
+    typeof PtyBindingPersistenceOperations
+  >
+  const bindingOperations = new PtyBindingPersistenceOperations(...bindingArgs)
+  const storeWithRetirement = Object.assign(store, {
+    persistPtyBinding: bindingOperations.persistPtyBinding.bind(bindingOperations),
+    retirePtyBinding: bindingOperations.retirePtyBinding.bind(bindingOperations)
+  })
+  const runtime = {
+    setPtyController: vi.fn(),
+    resolveTerminalPane: vi.fn(() => {
+      throw new Error('terminal_not_found')
+    }),
+    markPtyStopRequested: vi.fn(),
+    createPreAllocatedTerminalHandle: vi.fn(() => 'term-restart'),
+    preAllocateHandleForPty: vi.fn(() => 'term-restart'),
+    registerPreAllocatedHandleForPty: vi.fn(),
+    beginPtyRegistration: vi.fn(),
+    cancelPendingPtyRegistration: vi.fn(),
+    assertPtyRegistrationAllowed: vi.fn(),
+    registerPty: vi.fn(),
+    noteTerminalSpawnCommand: vi.fn(),
+    seedHeadlessTerminal: vi.fn(),
+    onPtySpawned: vi.fn(),
+    onPtyExit: vi.fn(),
+    onPtyData: vi.fn(),
+    intentionalPtyStops: new TerminalIntentionalStops()
+  }
+  return { providerSpawn, shutdown, store: storeWithRetirement, runtime, control }
+}
+
+import {
+  createPane,
+  createManager
+} from '../../src/renderer/src/components/terminal-pane/pty-connection-test-pane-fixtures'
+import { buildPaneConnectionDeps } from '../../src/renderer/src/components/terminal-pane/pty-connection-test-deps'
+import { createInitialStoreState } from '../../src/renderer/src/components/terminal-pane/pty-connection-test-store-fixtures'
+import {
+  installTerminalTestGlobals,
+  restoreTerminalTestGlobals
+} from '../../src/renderer/src/components/terminal-pane/pty-connection-test-environment'
+import { installIpcPtyWindow } from '../../src/renderer/src/components/terminal-pane/pty-transport-test-harness'
+import type { StoreState } from '../../src/renderer/src/components/terminal-pane/pty-connection-test-store-state'
+import type * as React from 'react'
+import type { PtyTransport } from '../../src/renderer/src/components/terminal-pane/pty-transport-types'
+
+let rendererState: StoreState
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => rendererState,
+    subscribe: () => () => {}
+  }
+}))
+vi.mock('react', async (importOriginal) => ({
+  ...(await importOriginal<typeof React>()),
+  useCallback: (callback: unknown) => callback,
+  useEffect: (effect: () => void) => effect(),
+  useLayoutEffect: (effect: () => void) => effect()
+}))
+vi.mock('@/runtime/sync-runtime-graph', () => ({ scheduleRuntimeGraphSync: vi.fn() }))
+vi.mock('@/lib/codex-stale-pane-sweep', () => ({ notifyCodexPaneBoundForStaleSweep: vi.fn() }))
+const { requestTerminalPaneRecovery } = vi.hoisted(() => ({
+  requestTerminalPaneRecovery: vi.fn(async () => true)
+}))
+vi.mock(
+  '../../src/renderer/src/components/terminal-pane/terminal-pane-recovery',
+  async (importOriginal) => ({
+    ...(await importOriginal<Record<string, unknown>>()),
+    requestTerminalPaneRecovery
+  })
+)
+
+describe('account restart through renderer connection and host spawn', () => {
+  const { handlers, mainWindow } = setupPtyIpcSuite()
+  afterEach(async () => {
+    await restoreTerminalTestGlobals()
+  })
+
+  it('replaces a tombstoned owner while its persisted pane binding has not yet been cleared', async () => {
+    const host = installRestartHarness()
+    registerWithFakes(mainWindow, host.runtime, host.store)
+    rendererState = createInitialStoreState(() => rendererState)
+    rendererState.tabsByWorktree[worktreeId][0].ptyId = 'pty-old'
+    rendererState.ptyIdsByTabId[tabId] = ['pty-old']
+    rendererState.sleepingAgentSessionsByPaneKey[paneKey] = {
+      paneKey,
+      tabId,
+      worktreeId,
+      agent: 'claude',
+      providerSession: { key: 'session_id', id: 'another-agents-session' },
+      state: 'waiting',
+      prompt: '',
+      capturedAt: 1,
+      updatedAt: 1
+    }
+    rendererState.terminalLayoutsByTabId[tabId].ptyIdsByLeafId[leafId] = 'pty-old'
+    await installTerminalTestGlobals()
+    installIpcPtyWindow(window, {})
+    window.api.pty.claimViewport = vi.fn()
+    const spawnErrors: unknown[] = []
+    vi.mocked(window.api.pty.spawn).mockImplementation(async (args) => {
+      try {
+        // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: registered pty:spawn returns the preload's spawn response.
+        return (await handlers.get('pty:spawn')!(null, args)) as Awaited<
+          ReturnType<typeof window.api.pty.spawn>
+        >
+      } catch (error) {
+        spawnErrors.push(error)
+        throw error
+      }
+    })
+    const { createIpcPtyTransport } =
+      await import('../../src/renderer/src/components/terminal-pane/pty-transport')
+    const { useTerminalPaneProcessExitActions } =
+      await import('../../src/renderer/src/components/terminal-pane/use-terminal-pane-process-exit-actions')
+    const oldTransport = createIpcPtyTransport({ worktreeId, tabId, leafId })
+    oldTransport.attach({ existingPtyId: 'pty-old', callbacks: {} })
+    const pane = createPane(1)
+    const manager = createManager(1)
+    manager.getPanes.mockReturnValue([pane])
+    const transports = new Map<number, PtyTransport>([[1, oldTransport]])
+    const bindings = new Map<number, { dispose: () => void }>()
+    const deps = buildPaneConnectionDeps(() => rendererState, {
+      tabId,
+      worktreeId,
+      cwd,
+      paneTransportsRef: { current: transports },
+      clearTabPtyId: vi.fn(() => {
+        rendererState.tabsByWorktree[worktreeId][0].ptyId = null
+        rendererState.ptyIdsByTabId[tabId] = []
+      })
+    })
+    const controller = {
+      ...deps,
+      managerRef: { current: manager },
+      panePtyBindingsRef: { current: bindings },
+      savedLayout: { ptyIdsByLeafId: { [leafId]: 'pty-old' } },
+      pendingCodexPaneRestartIds: { 'pty-old': true },
+      consumePendingCodexPaneRestart: vi.fn(() => true),
+      clearCodexRestartNotice: vi.fn(),
+      suppressPtyExit: vi.fn(),
+      setTerminalError: vi.fn(),
+      setTerminalErrorsByPaneId: vi.fn(),
+      setPaneProcessExitsByPaneId: vi.fn(),
+      executeClosePane: vi.fn(),
+      handlePaneProcessDied: vi.fn(),
+      showRestoredSessionBanner: vi.fn(),
+      onPtyErrorClearedRef: { current: vi.fn() },
+      onPtyRecoveryStateRef: { current: vi.fn() }
+    }
+    useTerminalPaneProcessExitActions(
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: existing connection fixture supplies restart callbacks; DOM/terminal rendering is simulated.
+      controller as unknown as Parameters<typeof useTerminalPaneProcessExitActions>[0]
+    )
+    try {
+      await vi.waitFor(() => expect(window.api.pty.spawn).toHaveBeenCalled())
+      await vi.waitFor(() =>
+        expect(
+          host.shutdown,
+          JSON.stringify(vi.mocked(window.api.pty.spawn).mock.calls)
+        ).toHaveBeenCalled()
+      )
+      await vi.waitFor(() =>
+        expect(transports.get(1)?.getPtyId(), String(spawnErrors[0])).toBe('pty-new')
+      )
+      expect(window.api.pty.spawn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          replacesPtyId: 'pty-old',
+          command: 'codex',
+          launchAgent: 'codex',
+          startupCommandDelivery: 'shell-ready'
+        })
+      )
+      expect(vi.mocked(window.api.pty.spawn).mock.calls[0][0]).not.toHaveProperty(
+        'resumeProviderSession'
+      )
+      expect(requestTerminalPaneRecovery).not.toHaveBeenCalled()
+      // The replacement's own bind swapped the host's persisted pane binding.
+      expect(
+        host.store.getWorkspaceSession().terminalLayoutsByTabId[tabId].ptyIdsByLeafId[leafId]
+      ).toBe('pty-new')
+    } finally {
+      for (const binding of bindings.values()) {
+        binding.dispose()
+      }
+      for (const transport of transports.values()) {
+        transport.detach?.({ preserveExitObserver: false })
+      }
+    }
+  })
+  it.each([false, true])(
+    'paired restart retains the old owner (host authority: %s)',
+    async (hostAuthority) => {
+      const host = installRestartHarness()
+      registerWithFakes(mainWindow, host.runtime, host.store)
+      rendererState = createInitialStoreState(() => rendererState)
+      await installTerminalTestGlobals()
+      const runtimeCall = vi.fn(
+        async (args: { method: string; params?: Record<string, unknown> }) => {
+          if (args.method === 'status.get') {
+            return {
+              id: 'status',
+              ok: true,
+              result: {
+                runtimeProtocolVersion: 3,
+                minCompatibleRuntimeClientVersion: 2,
+                capabilities: hostAuthority ? ['agent-session.host-authority.v1'] : []
+              },
+              _meta: { runtimeId: 'fake-host' }
+            }
+          }
+          if (args.method !== 'terminal.create' && args.method !== 'terminal.createAgentSession') {
+            throw new Error(`Unexpected host method: ${args.method}`)
+          }
+          // Both host create routes ultimately use stable-pane adoption; keep that real here.
+          await handlers.get('pty:spawn')!(null, {
+            cols: 80,
+            rows: 24,
+            cwd,
+            tabId,
+            leafId,
+            worktreeId,
+            command: 'codex',
+            launchAgent: 'codex',
+            startupCommandDelivery: 'shell-ready'
+          })
+          return {
+            id: 'create',
+            ok: true,
+            result: {
+              terminal: { handle: 'term-old', worktreeId, title: null, surface: 'background' }
+            },
+            _meta: { runtimeId: 'fake-host' }
+          }
+        }
+      )
+      const subscribe = vi.fn(
+        async (_args: unknown, callbacks: { onResponse: (value: unknown) => void }) => {
+          queueMicrotask(() =>
+            callbacks.onResponse({
+              id: 'stream',
+              ok: true,
+              result: { type: 'ready' },
+              _meta: { runtimeId: 'fake-host' }
+            })
+          )
+          return { unsubscribe: vi.fn(), sendBinary: vi.fn() }
+        }
+      )
+      Object.assign(window.api, { runtimeEnvironments: { call: runtimeCall, subscribe } })
+      const { createRemoteRuntimePtyTransport } =
+        await import('../../src/renderer/src/components/terminal-pane/remote-runtime-pty-transport')
+      const { releasePaneTransportForRestart } =
+        await import('../../src/renderer/src/components/terminal-pane/pane-restart-transport-handoff')
+      const { CODEX_ACCOUNT_RESTART_STARTUP } =
+        await import('../../src/renderer/src/lib/codex-session-restart')
+      const options = { worktreeId, tabId, leafId, ...CODEX_ACCOUNT_RESTART_STARTUP }
+      const old = createRemoteRuntimePtyTransport('fake-host', options)
+      await old.connect({ url: '', callbacks: {} })
+      expect(old.getPtyId()).toBe('remote:fake-host@@term-old')
+      const replacesPtyId = releasePaneTransportForRestart(old)
+      expect(replacesPtyId).toBeNull()
+      const replacement = createRemoteRuntimePtyTransport('fake-host', options)
+      try {
+        await replacement.connect({ url: '', callbacks: {} })
+        expect(replacement.getPtyId()).toBe('remote:fake-host@@term-old')
+        expect(host.shutdown).not.toHaveBeenCalled()
+        expect(host.providerSpawn.mock.calls.every(([options]) => options.attachOnly)).toBe(true)
+        expect(
+          runtimeCall.mock.calls.filter(([args]) => args.method.startsWith('terminal.create'))
+        ).toHaveLength(2)
+      } finally {
+        replacement.detach?.()
+      }
+    }
+  )
+})
diff --git a/tests/e2e/terminal-hangul-terminating-digit-native.spec.ts b/tests/e2e/terminal-hangul-terminating-digit-native.spec.ts
index 9d0127d4df4..1973690c63f 100644
--- a/tests/e2e/terminal-hangul-terminating-digit-native.spec.ts
+++ b/tests/e2e/terminal-hangul-terminating-digit-native.spec.ts
@@ -7,12 +7,8 @@
  * That path passed even before the Wayland fix; it does not prove #15299 is fixed.
  * Reproducing #15299 still requires the nested Wayland session below.
  *
- * To run the Wayland reproduction on a machine with gnome-shell and ibus-hangul:
- *
- *   Xvfb :65 -extension GLX &
- *   DISPLAY=:65 gnome-shell --nested --wayland     # nested, NOT --headless
- *   ORCA_E2E_NATIVE_IBUS_HANGUL=1 ORCA_E2E_IME_INJECTOR=nested npx playwright test \
- *     tests/e2e/terminal-hangul-terminating-digit-native.spec.ts
+ * Run the Terminal IME E2E workflow on the candidate branch for hosted native validation.
+ * Its runner owns the isolated Xvfb display, nested compositor and IBus session.
  *
  * Nested Wayland prerequisites:
  *
@@ -22,8 +18,8 @@
  *  - Pick an unused display. Attaching to a stale Xvfb silently hands the run someone else's
  *    session, and a stale ibus-daemon wins the XIM selection over the new one.
  *  - The session script must not exit: ibus-daemon dies with its parent.
- *  - Under Playwright the window can stay hidden in a Wayland session, so the compositor has
- *    nothing to focus and zero DOM events arrive. The spec forces show()/focus().
+ *  - The owned window starts hidden, then the guarded native fixture presents it on hosted CI's
+ *    isolated display so the compositor can deliver real input.
  *  - Send Escape before the byte reader starts, or GNOME's overview keeps focus and the Escape
  *    bytes corrupt the first line.
  *  - Check the session's ibus-daemon is not running --panel=disable before trusting anything that
@@ -43,7 +39,9 @@ import { mkdirSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import type { Page, TestInfo } from '@stablyai/playwright-test'
 import { test, expect } from './helpers/orca-app'
+import { presentNativeIbusWindow } from './terminal-native-ibus-window'
 import { appendImeEngagementReceipt } from './terminal-ime-engagement-receipt'
+import { installTerminalWaylandInputDiagnostics } from './terminal-wayland-input-diagnostics'
 import { ensureTerminalVisible, waitForActiveWorktree, waitForSessionReady } from './helpers/store'
 import {
   focusActiveTerminalInput,
@@ -80,6 +78,7 @@ test.use({
     IBUS_ENABLE_SYNC_MODE: '1',
     QT_IM_MODULE: 'ibus',
     XMODIFIERS: '@im=ibus',
+    ...(process.env.ORCA_E2E_WAYLAND_INPUT_DIAGNOSTICS === '1' ? { WAYLAND_DEBUG: 'client' } : {}),
     ...(process.env.ORCA_E2E_EXTRA_APP_ENV
       ? (JSON.parse(process.env.ORCA_E2E_EXTRA_APP_ENV) as Record<string, string>)
       : {})
@@ -176,78 +175,99 @@ test.describe('Hangul terminating digit @headful', () => {
     orcaPage: page,
     testRepoPath
   }, testInfo) => {
-    const launchDiagnostics = await electronApp.evaluate(({ app: electron, BrowserWindow }) => ({
-      waylandDisplay: process.env.WAYLAND_DISPLAY ?? null,
-      display: process.env.DISPLAY ?? null,
-      xdgRuntimeDir: process.env.XDG_RUNTIME_DIR ?? null,
-      ozonePlatform: electron.commandLine.getSwitchValue('ozone-platform'),
-      disableGpu: electron.commandLine.hasSwitch('disable-gpu'),
-      windows: BrowserWindow.getAllWindows().map((window) => ({
-        visible: window.isVisible(),
-        minimized: window.isMinimized(),
-        bounds: window.getBounds()
-      }))
-    }))
-    console.log(`[digit-diag] ${JSON.stringify(launchDiagnostics)}`)
-    if (INJECTOR === 'nested') {
-      expect(launchDiagnostics.ozonePlatform).toBe('wayland')
-      expect(launchDiagnostics.waylandDisplay).toBeTruthy()
-      // Under Wayland the app's ready-to-show never fires here, so the window
-      // stays hidden and the compositor has nothing to give keyboard focus to.
-      await electronApp.evaluate(({ BrowserWindow }) => {
-        for (const window of BrowserWindow.getAllWindows()) {
-          window.show()
-          window.focus()
-        }
-      })
-      await page.waitForTimeout(2_000)
-    }
-    await waitForSessionReady(page)
-    await waitForActiveWorktree(page)
-    await ensureTerminalVisible(page)
-    await waitForActiveTerminalManager(page, 30_000)
-
-    const ptyId = await waitForActivePanePtyId(page)
-    const reader = createTerminalImeByteReader(testRepoPath, REPETITIONS)
-    let receivedBytes: string[] = []
-    const expectedHex = Buffer.from(`${EXPECTED_LINE}\n`).toString('hex')
+    const diagnostics =
+      process.env.ORCA_E2E_WAYLAND_INPUT_DIAGNOSTICS === '1'
+        ? await installTerminalWaylandInputDiagnostics(electronApp, page)
+        : null
+    let completed = false
+    let diagnosticError: unknown
     try {
+      const launchDiagnostics = await electronApp.evaluate(({ app: electron, BrowserWindow }) => ({
+        waylandDisplay: process.env.WAYLAND_DISPLAY ?? null,
+        display: process.env.DISPLAY ?? null,
+        xdgRuntimeDir: process.env.XDG_RUNTIME_DIR ?? null,
+        ozonePlatform: electron.commandLine.getSwitchValue('ozone-platform'),
+        disableGpu: electron.commandLine.hasSwitch('disable-gpu'),
+        background: process.env.ORCA_BACKGROUND_LAUNCH,
+        nativeIsolatedDisplay: process.env.ORCA_E2E_NATIVE_IBUS_XVFB,
+        windows: BrowserWindow.getAllWindows().map((window) => ({
+          visible: window.isVisible(),
+          minimized: window.isMinimized(),
+          bounds: window.getBounds()
+        }))
+      }))
+      console.log(`[digit-diag] ${JSON.stringify(launchDiagnostics)}`)
+      await presentNativeIbusWindow(electronApp, page)
       if (INJECTOR === 'nested') {
-        leaveNestedOverview()
-        await page.waitForTimeout(1_500)
-        captureNestedScreen('nested-before-reader')
+        expect(launchDiagnostics.ozonePlatform).toBe('wayland')
+        expect(launchDiagnostics.waylandDisplay).toBeTruthy()
+        await page.waitForTimeout(2_000)
       }
-      await startTerminalImeByteReader(page, ptyId, reader)
-      await focusNativeTerminalWindow(page)
-      if (INJECTOR === 'nested') {
-        captureNestedScreen('nested-before-typing')
-      }
-      await installTerminalImeBoundaryProbe(page)
+      await waitForSessionReady(page)
+      await waitForActiveWorktree(page)
+      await ensureTerminalVisible(page)
+      await waitForActiveTerminalManager(page, 30_000)
 
-      for (let index = 0; index < REPETITIONS; index += 1) {
-        injectKeys(KEY_TOKENS)
-        await page.waitForTimeout(500)
-      }
-      if (INJECTOR === 'nested') {
-        captureNestedScreen('nested-after-typing')
-      }
+      const ptyId = await waitForActivePanePtyId(page)
+      const reader = createTerminalImeByteReader(testRepoPath, REPETITIONS)
+      let receivedBytes: string[] = []
+      const expectedHex = Buffer.from(`${EXPECTED_LINE}\n`).toString('hex')
+      try {
+        if (INJECTOR === 'nested') {
+          leaveNestedOverview()
+          await page.waitForTimeout(1_500)
+          captureNestedScreen('nested-before-reader')
+        }
+        await startTerminalImeByteReader(page, ptyId, reader)
+        await diagnostics?.attachTerminal()
+        await focusNativeTerminalWindow(page)
+        if (INJECTOR === 'nested') {
+          captureNestedScreen('nested-before-typing')
+        }
+        await installTerminalImeBoundaryProbe(page)
 
-      receivedBytes = await waitForTerminalImeBytes(page, reader, 20_000)
-      expect(receivedBytes.map((hex) => Buffer.from(hex, 'hex').toString('utf8'))).toEqual(
-        Array.from({ length: REPETITIONS }, () => `${EXPECTED_LINE}\n`)
-      )
-      const trace = await readTerminalImeBoundaryTrace(page)
-      appendImeEngagementReceipt(testInfo.title, trace)
+        for (let index = 0; index < REPETITIONS; index += 1) {
+          injectKeys(KEY_TOKENS)
+          await page.waitForTimeout(500)
+        }
+        if (INJECTOR === 'nested') {
+          captureNestedScreen('nested-after-typing')
+        }
+
+        receivedBytes = await waitForTerminalImeBytes(page, reader, 20_000)
+        expect(receivedBytes.map((hex) => Buffer.from(hex, 'hex').toString('utf8'))).toEqual(
+          Array.from({ length: REPETITIONS }, () => `${EXPECTED_LINE}\n`)
+        )
+        const trace = await readTerminalImeBoundaryTrace(page)
+        appendImeEngagementReceipt(testInfo.title, trace)
+        completed = true
+      } finally {
+        await writeEvidence(page, testInfo, 'hangul-terminating-digit', {
+          expectedHex,
+          expectedLine: EXPECTED_LINE,
+          receivedBytes,
+          decoded: receivedBytes.map((hex) => Buffer.from(hex, 'hex').toString('utf8'))
+        }).catch(() => undefined)
+        await disposeTerminalImeBoundaryProbe(page).catch(() => undefined)
+        await sendToTerminal(page, ptyId, '\x03').catch(() => undefined)
+        removeTerminalImeByteReader(reader)
+      }
     } finally {
-      await writeEvidence(page, testInfo, 'hangul-terminating-digit', {
-        expectedHex,
-        expectedLine: EXPECTED_LINE,
-        receivedBytes,
-        decoded: receivedBytes.map((hex) => Buffer.from(hex, 'hex').toString('utf8'))
-      }).catch(() => undefined)
-      await disposeTerminalImeBoundaryProbe(page).catch(() => undefined)
-      await sendToTerminal(page, ptyId, '\x03').catch(() => undefined)
-      removeTerminalImeByteReader(reader)
+      if (diagnostics) {
+        try {
+          await diagnostics.write(testInfo)
+        } catch (error) {
+          diagnosticError = error
+          console.error('Could not retain passive Wayland diagnostics', error)
+        } finally {
+          await diagnostics
+            .dispose()
+            .catch((error) => console.error('Could not dispose passive Wayland diagnostics', error))
+        }
+      }
+    }
+    if (completed && diagnosticError) {
+      throw diagnosticError
     }
   })
 })
diff --git a/tests/e2e/terminal-ibus-hangul-native.spec.ts b/tests/e2e/terminal-ibus-hangul-native.spec.ts
index 7deea796562..c0aaa748c7c 100644
--- a/tests/e2e/terminal-ibus-hangul-native.spec.ts
+++ b/tests/e2e/terminal-ibus-hangul-native.spec.ts
@@ -1,6 +1,8 @@
 import { execFileSync } from 'node:child_process'
 import { randomUUID } from 'node:crypto'
-import type { Page, TestInfo } from '@stablyai/playwright-test'
+import { writeFileSync } from 'node:fs'
+import type { ElectronApplication, Page, TestInfo } from '@stablyai/playwright-test'
+import type { BrowserWindow, Event as ElectronEvent, Input as ElectronInput } from 'electron'
 import { test, expect } from './helpers/orca-app'
 import { ensureTerminalVisible, waitForActiveWorktree, waitForSessionReady } from './helpers/store'
 import {
@@ -13,7 +15,8 @@ import {
   attachTerminalImeBoundaryEvidence,
   disposeTerminalImeBoundaryProbe,
   installTerminalImeBoundaryProbe,
-  readTerminalImeBoundaryTrace
+  readTerminalImeBoundaryTrace,
+  type TerminalImeDomEvent
 } from './terminal-ime-boundary-probe'
 import {
   createTerminalImeByteReader,
@@ -22,6 +25,7 @@ import {
   waitForTerminalImeBytes
 } from './terminal-ime-byte-reader'
 import { appendImeEngagementReceipt } from './terminal-ime-engagement-receipt'
+import { presentNativeIbusWindow } from './terminal-native-ibus-window'
 
 const DEFAULT_REPETITIONS = 30
 const MAX_REPETITIONS = 30
@@ -104,12 +108,14 @@ function typeSentenceSequence(repetitions: number): void {
 }
 
 async function runNativeIbusScenario(
+  electronApp: ElectronApplication,
   page: Page,
   testInfo: TestInfo,
   testRepoPath: string,
   expectedText: string,
   driveInput: (repetitions: number) => void
 ): Promise<void> {
+  await presentNativeIbusWindow(electronApp, page)
   await waitForSessionReady(page)
   await waitForActiveWorktree(page)
   await ensureTerminalVisible(page)
@@ -169,17 +175,27 @@ test.describe('Native IBus Hangul terminal input @headful', () => {
   )
 
   test('forwards the issue exact-byte sequence without loss or duplication', async ({
-    orcaPage,
-    testRepoPath
-  }, testInfo) => {
-    await runNativeIbusScenario(orcaPage, testInfo, testRepoPath, '한abc글', typeExactByteSequence)
-  })
-
-  test('forwards the issue sentence stress sequence without leaked ASCII', async ({
+    electronApp,
     orcaPage,
     testRepoPath
   }, testInfo) => {
     await runNativeIbusScenario(
+      electronApp,
+      orcaPage,
+      testInfo,
+      testRepoPath,
+      '한abc글',
+      typeExactByteSequence
+    )
+  })
+
+  test('forwards the issue sentence stress sequence without leaked ASCII', async ({
+    electronApp,
+    orcaPage,
+    testRepoPath
+  }, testInfo) => {
+    await runNativeIbusScenario(
+      electronApp,
       orcaPage,
       testInfo,
       testRepoPath,
@@ -188,3 +204,424 @@ test.describe('Native IBus Hangul terminal input @headful', () => {
     )
   })
 })
+
+test.describe('Native IBus Hangul workspace notes @headful', () => {
+  test.use({ launchEnv: { ORCA_BACKGROUND_LAUNCH: '1' } })
+  test.skip(
+    process.env.ORCA_E2E_NATIVE_IBUS_HANGUL !== '1',
+    'Run through the isolated native IBus harness'
+  )
+
+  test('confirms native Hangul notes before a deliberate Enter saves', async ({
+    electronApp,
+    orcaPage
+  }, testInfo) => {
+    expect(process.platform).toBe('linux')
+    expect(process.env.GITHUB_ACTIONS).toBe('true')
+    expect(process.env.RUNNER_ENVIRONMENT).toBe('github-hosted')
+    expect(process.env.DISPLAY).toMatch(/^:\d+(?:\.\d+)?$/)
+    const ownedWindow = await electronApp.browserWindow(orcaPage)
+    await presentNativeIbusWindow(electronApp, orcaPage)
+    const windowId = await ownedWindow.evaluate((window: BrowserWindow) =>
+      window.getNativeWindowHandle().readUInt32LE(0).toString()
+    )
+    execFileSync('ibus', ['engine', 'hangul'], { timeout: NATIVE_COMMAND_TIMEOUT_MS })
+    expect(
+      execFileSync('ibus', ['engine'], {
+        encoding: 'utf8',
+        timeout: NATIVE_COMMAND_TIMEOUT_MS
+      }).trim()
+    ).toBe('hangul')
+
+    await orcaPage.evaluate(() => {
+      const state = window.__store?.getState()
+      const worktree =
+        state &&
+        Object.values(state.worktreesByRepo)
+          .flat()
+          .find((row) => row.id === state.activeWorktreeId)
+      if (!state || !worktree) {
+        throw new Error('Missing owned workspace')
+      }
+      state.openModal('edit-meta', {
+        worktreeId: worktree.id,
+        repoId: worktree.repoId,
+        currentDisplayName: worktree.displayName,
+        currentComment: '',
+        focus: 'comment'
+      })
+    })
+    const input = orcaPage.getByPlaceholder('Notes about this worktree...')
+    await expect(input).toBeVisible()
+    await input.evaluate(async (element) => {
+      const animations = element.closest('[role=dialog]')?.getAnimations({ subtree: true }) ?? []
+      await Promise.all(animations.map((animation) => animation.finished.catch(() => undefined)))
+    })
+    const nativeProbe = await ownedWindow.evaluateHandle((window: BrowserWindow) => {
+      const inputs: ElectronInput[] = []
+      const record = (_event: ElectronEvent, input: ElectronInput): void => {
+        inputs.push({ ...input })
+      }
+      window.webContents.on('before-input-event', record)
+      return {
+        window,
+        inputs,
+        dispose: () => window.webContents.removeListener('before-input-event', record)
+      }
+    })
+    const events = await input.evaluateHandle((element) => {
+      if (!(element instanceof HTMLTextAreaElement)) {
+        throw new Error('Missing Notes textarea')
+      }
+      const dom: TerminalImeDomEvent[] = []
+      const capture: {
+        type: string
+        scope: string
+        key: string | null
+        code: string | null
+        keyCode: number | null
+        isComposing: boolean | null
+        isTrusted: boolean
+        targetIsNotes: boolean
+        activeIsNotes: boolean
+        documentFocused: boolean
+        target: string
+        path: string[]
+      }[] = []
+      const label = (target: EventTarget | null): string =>
+        target instanceof Element
+          ? `${target.tagName}#${target.id}[${target.getAttribute('placeholder') ?? ''}]`
+          : target === window
+            ? 'window'
+            : target === document
+              ? 'document'
+              : 'other'
+      const recordDom = (event: Event): void => {
+        const keyboard = event instanceof KeyboardEvent ? event : null
+        const inputEvent = event instanceof InputEvent ? event : null
+        const composition = event instanceof CompositionEvent ? event : null
+        dom.push({
+          type: event.type,
+          data: inputEvent?.data ?? composition?.data ?? null,
+          inputType: inputEvent?.inputType ?? null,
+          key: keyboard?.key ?? null,
+          code: keyboard?.code ?? null,
+          keyCode: keyboard?.keyCode ?? null,
+          isComposing: keyboard?.isComposing ?? inputEvent?.isComposing ?? null,
+          selectionEnd: element.selectionEnd,
+          selectionStart: element.selectionStart,
+          value: element.value
+        })
+      }
+      const recordCapture = (event: Event): void => {
+        const keyboard = event instanceof KeyboardEvent ? event : null
+        capture.push({
+          type: event.type,
+          scope: label(event.currentTarget),
+          key: keyboard?.key ?? null,
+          code: keyboard?.code ?? null,
+          keyCode: keyboard?.keyCode ?? null,
+          isComposing: keyboard?.isComposing ?? null,
+          isTrusted: event.isTrusted,
+          targetIsNotes: event.target === element,
+          activeIsNotes: document.activeElement === element,
+          documentFocused: document.hasFocus(),
+          target: label(event.target),
+          path: event.composedPath().map(label)
+        })
+      }
+      const domTypes = [
+        'compositionstart',
+        'compositionupdate',
+        'compositionend',
+        'input',
+        'keydown',
+        'keyup'
+      ]
+      const captureTypes = ['keydown', 'keyup', 'focus', 'blur']
+      for (const type of domTypes) {
+        element.addEventListener(type, recordDom, true)
+      }
+      for (const target of [window, document]) {
+        for (const type of captureTypes) {
+          target.addEventListener(type, recordCapture, true)
+        }
+      }
+      return {
+        dom,
+        capture,
+        focus: () => ({
+          documentFocused: document.hasFocus(),
+          activeIsNotes: document.activeElement === element,
+          activeElement: label(document.activeElement),
+          connected: element.isConnected,
+          value: element.value
+        }),
+        dispose: () => {
+          for (const type of domTypes) {
+            element.removeEventListener(type, recordDom, true)
+          }
+          for (const target of [window, document]) {
+            for (const type of captureTypes) {
+              target.removeEventListener(type, recordCapture, true)
+            }
+          }
+        }
+      }
+    })
+    const readSavedComment = () =>
+      orcaPage.evaluate(() => {
+        const state = window.__store?.getState()
+        return (
+          state &&
+          Object.values(state.worktreesByRepo)
+            .flat()
+            .find((row) => row.id === state.activeWorktreeId)?.comment
+        )
+      })
+    const focusSnapshots: unknown[] = []
+    const readFocus = async (phase: string) => {
+      const renderer = await events.evaluate((probe) => probe.focus())
+      const main = await nativeProbe.evaluate(({ window }) => ({
+        windowFocused: window.isFocused(),
+        windowVisible: window.isVisible(),
+        webContentsFocused: window.webContents.isFocused(),
+        nativeWindowId: window.getNativeWindowHandle().readUInt32LE(0).toString()
+      }))
+      const xFocus = execFileSync('xdotool', ['getwindowfocus'], {
+        encoding: 'utf8',
+        timeout: NATIVE_COMMAND_TIMEOUT_MS
+      }).trim()
+      const snapshot = { phase, renderer, main, xFocus, windowId }
+      focusSnapshots.push(snapshot)
+      expect(main.nativeWindowId).toBe(windowId)
+      expect(xFocus).toBe(windowId)
+      expect(main.windowFocused).toBe(true)
+      expect(main.windowVisible).toBe(true)
+      expect(main.webContentsFocused).toBe(true)
+      expect(renderer.documentFocused).toBe(true)
+      expect(renderer.activeIsNotes).toBe(true)
+      return snapshot
+    }
+    let completed = false
+    try {
+      runXdotool('windowfocus', '--sync', windowId)
+      await nativeProbe.evaluate(({ window }) => window.webContents.focus())
+      const geometry = await orcaPage.evaluate(() => ({
+        ratio: window.devicePixelRatio,
+        width: window.innerWidth,
+        height: window.innerHeight
+      }))
+      const content = await ownedWindow.evaluate((window: BrowserWindow) =>
+        window.getContentBounds()
+      )
+      expect(geometry.ratio).toBe(1)
+      expect(content.width).toBe(geometry.width)
+      expect(content.height).toBe(geometry.height)
+      const box = await input.boundingBox()
+      expect(box).not.toBeNull()
+      if (!box) {
+        throw new Error('Missing native Notes input bounds')
+      }
+      runXdotool(
+        'mousemove',
+        '--window',
+        windowId,
+        String(Math.round(box.x + box.width / 2)),
+        String(Math.round(box.y + box.height / 2)),
+        'click',
+        '1'
+      )
+      await expect
+        .poll(() =>
+          events.evaluate((probe) => {
+            const focus = probe.focus()
+            return focus.documentFocused && focus.activeIsNotes
+          })
+        )
+        .toBe(true)
+      await readFocus('before-delivery-witness')
+      runXdotool('key', '--clearmodifiers', 'Shift_L')
+      await expect
+        .poll(() =>
+          events.evaluate(({ capture }) =>
+            ['keydown', 'keyup'].every((type) =>
+              capture.some(
+                (event) =>
+                  event.type === type &&
+                  event.key === 'Shift' &&
+                  event.scope === 'window' &&
+                  event.isTrusted &&
+                  event.targetIsNotes &&
+                  event.activeIsNotes &&
+                  event.documentFocused
+              )
+            )
+          )
+        )
+        .toBe(true)
+      await readFocus('before-composition')
+      const blursBeforeComposition = await events.evaluate(
+        ({ capture }) => capture.filter((event) => event.type === 'blur').length
+      )
+      runXdotool('type', '--delay', '10', '--clearmodifiers', 'gksrmf')
+      await expect(input).toHaveValue('한글')
+      await expect
+        .poll(() =>
+          events.evaluate(
+            ({ dom: trace }) =>
+              trace.filter((event) => event.type === 'compositionstart').length >
+              trace.filter((event) => event.type === 'compositionend').length
+          )
+        )
+        .toBe(true)
+      const compositionEndsBeforeReturn = await events.evaluate(
+        ({ dom: trace }) => trace.filter((event) => event.type === 'compositionend').length
+      )
+      await readFocus('before-confirm-return')
+      runXdotool('key', 'Return')
+      await expect
+        .poll(() =>
+          events.evaluate(
+            ({ dom: trace }) => trace.filter((event) => event.type === 'compositionend').length
+          )
+        )
+        .toBeGreaterThan(compositionEndsBeforeReturn)
+      await orcaPage.evaluate(
+        () =>
+          new Promise<void>((resolve) =>
+            requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
+          )
+      )
+      await expect(input).toBeVisible()
+      await expect(input).toHaveValue('한글')
+      expect(await readSavedComment()).not.toBe('한글')
+      await readFocus('before-save-return')
+      expect(
+        await events.evaluate(
+          ({ capture }) => capture.filter((event) => event.type === 'blur').length
+        )
+      ).toBe(blursBeforeComposition)
+      const capturesBeforeSave = await events.evaluate(({ capture }) => capture.length)
+      runXdotool('key', 'Return')
+      await expect
+        .poll(() =>
+          events.evaluate(
+            ({ capture }, start) =>
+              capture
+                .slice(start)
+                .some(
+                  (event) =>
+                    event.type === 'keydown' &&
+                    event.key === 'Enter' &&
+                    event.keyCode === 13 &&
+                    event.isComposing === false &&
+                    event.scope === 'window' &&
+                    event.isTrusted &&
+                    event.targetIsNotes &&
+                    event.activeIsNotes &&
+                    event.documentFocused
+                ),
+            capturesBeforeSave
+          )
+        )
+        .toBe(true)
+      await expect(input).toBeHidden()
+      await expect.poll(readSavedComment).toBe('한글')
+      const dom = await events.evaluate(({ dom }) => dom)
+      expect(dom.some((event) => event.type === 'compositionstart')).toBe(true)
+      expect(dom.some((event) => /[\uac00-\ud7af]/.test(event.data ?? ''))).toBe(true)
+      appendImeEngagementReceipt(testInfo.title, { dom, onData: [] })
+      completed = true
+      await orcaPage.screenshot({
+        path: testInfo.outputPath('native-deliberate-return-saves-notes.png')
+      })
+    } finally {
+      const readDiagnostic = async <T>(read: () => Promise<T>): Promise<T | null> => {
+        let timer: ReturnType<typeof setTimeout> | undefined
+        try {
+          return await Promise.race([
+            read().catch(() => null),
+            new Promise<null>((resolve) => {
+              timer = setTimeout(() => resolve(null), 1_000)
+            })
+          ])
+        } catch {
+          return null
+        } finally {
+          if (timer) {
+            clearTimeout(timer)
+          }
+        }
+      }
+      const trace = await readDiagnostic(() =>
+        events.evaluate(({ dom, capture, focus }) => ({ dom, capture, focus: focus() }))
+      )
+      const native = await readDiagnostic(() =>
+        nativeProbe.evaluate(({ inputs, window }) => ({
+          inputs,
+          windowFocused: window.isFocused(),
+          windowVisible: window.isVisible(),
+          webContentsFocused: window.webContents.isFocused()
+        }))
+      )
+      const notes = await readDiagnostic(() =>
+        orcaPage.evaluate(() => {
+          const element = document.querySelector(
+            'textarea[placeholder="Notes about this worktree..."]'
+          )
+          const state = window.__store?.getState()
+          return {
+            notesPresent: element instanceof HTMLTextAreaElement,
+            notesValue: element instanceof HTMLTextAreaElement ? element.value : null,
+            savedComment:
+              state &&
+              Object.values(state.worktreesByRepo)
+                .flat()
+                .find((row) => row.id === state.activeWorktreeId)?.comment
+          }
+        })
+      )
+      let evidenceAttached = false
+      try {
+        const evidencePath = testInfo.outputPath('native-notes-dom-trace.json')
+        writeFileSync(
+          evidencePath,
+          `${JSON.stringify({
+            nativeOperatingSystemIme: true,
+            engine: 'ibus-hangul',
+            display: process.env.DISPLAY,
+            completed,
+            notes,
+            focusSnapshots,
+            native,
+            onData: [],
+            ...trace
+          })}\n`
+        )
+        await testInfo.attach('native-notes-dom-trace', {
+          path: evidencePath,
+          contentType: 'application/json'
+        })
+        evidenceAttached = true
+      } catch {
+        // Failed-flow diagnostics must preserve the original assertion.
+      }
+      await readDiagnostic(() => events.evaluate((probe) => probe.dispose()))
+      await readDiagnostic(() =>
+        nativeProbe.evaluate((probe) => {
+          probe.dispose()
+        })
+      )
+      await events.dispose().catch(() => undefined)
+      await nativeProbe.dispose().catch(() => undefined)
+      await ownedWindow.dispose().catch(() => undefined)
+      if (completed) {
+        expect(trace).not.toBeNull()
+        expect(native).not.toBeNull()
+        expect(notes).not.toBeNull()
+        expect(evidenceAttached).toBe(true)
+      }
+    }
+  })
+})
diff --git a/tests/e2e/terminal-native-ibus-window.ts b/tests/e2e/terminal-native-ibus-window.ts
new file mode 100644
index 00000000000..c05f3a2bcba
--- /dev/null
+++ b/tests/e2e/terminal-native-ibus-window.ts
@@ -0,0 +1,35 @@
+import { expect, type ElectronApplication, type Page } from '@stablyai/playwright-test'
+import type { BrowserWindow } from 'electron'
+
+export async function presentNativeIbusWindow(
+  electronApp: ElectronApplication,
+  page: Page
+): Promise<void> {
+  const ownedWindow = await electronApp.browserWindow(page)
+  try {
+    await ownedWindow.evaluate((window: BrowserWindow) => {
+      if (
+        process.platform !== 'linux' ||
+        process.env.GITHUB_ACTIONS !== 'true' ||
+        process.env.RUNNER_ENVIRONMENT !== 'github-hosted' ||
+        process.env.ORCA_E2E_NATIVE_IBUS_HANGUL !== '1' ||
+        process.env.ORCA_E2E_NATIVE_IBUS_XVFB !== '1' ||
+        !/^:\d+(?:\.\d+)?$/.test(process.env.DISPLAY ?? '') ||
+        process.env.ORCA_BACKGROUND_LAUNCH !== '1' ||
+        !window ||
+        window.isDestroyed() ||
+        window.isVisible()
+      ) {
+        throw new Error('Native IBus presentation requires an owned hosted-CI Xvfb window')
+      }
+      // Aura needs logical visibility to accept native keyboard input.
+      window.showInactive()
+    })
+    await expect
+      .poll(() => ownedWindow.evaluate((window: BrowserWindow) => window.isVisible()))
+      .toBe(true)
+    await page.waitForFunction(() => document.visibilityState === 'visible')
+  } finally {
+    await ownedWindow.dispose()
+  }
+}
diff --git a/tests/e2e/terminal-wayland-input-diagnostics.ts b/tests/e2e/terminal-wayland-input-diagnostics.ts
new file mode 100644
index 00000000000..bc0850f8ba8
--- /dev/null
+++ b/tests/e2e/terminal-wayland-input-diagnostics.ts
@@ -0,0 +1,203 @@
+import { writeFileSync } from 'node:fs'
+import type { ElectronApplication, Page, TestInfo } from '@stablyai/playwright-test'
+import type { Event as ElectronEvent, Input as ElectronInput } from 'electron'
+
+const MAX_EVENTS = 2_048
+const MAX_STDERR_BYTES = 4 * 1024 * 1024
+
+export async function installTerminalWaylandInputDiagnostics(
+  electronApp: ElectronApplication,
+  page: Page
+) {
+  const stderr: Buffer[] = []
+  let stderrBytes = 0
+  let stderrTruncated = false
+  const processStderr = electronApp.process().stderr
+  const recordStderr = (chunk: Buffer): void => {
+    if (stderrBytes + chunk.length > MAX_STDERR_BYTES) {
+      stderrTruncated = true
+      return
+    }
+    stderr.push(Buffer.from(chunk))
+    stderrBytes += chunk.length
+  }
+  processStderr?.on('data', recordStderr)
+
+  const main = await electronApp.evaluateHandle(({ BrowserWindow }, maxEvents) => {
+    const events: Record<string, unknown>[] = []
+    let dropped = 0
+    const removals: (() => void)[] = []
+    for (const window of BrowserWindow.getAllWindows()) {
+      const contents = window.webContents
+      const record = (phase: string, input?: ElectronInput, event?: ElectronEvent): void => {
+        if (events.length >= maxEvents) {
+          dropped++
+          return
+        }
+        const entry = {
+          phase,
+          wallMs: Date.now(),
+          monotonicNs: process.hrtime.bigint().toString(),
+          windowId: window.id,
+          contentsId: contents.id,
+          windowFocused: !window.isDestroyed() && window.isFocused(),
+          windowVisible: !window.isDestroyed() && window.isVisible(),
+          contentsFocused: !contents.isDestroyed() && contents.isFocused(),
+          input: input ? { ...input } : null,
+          defaultPreventedBefore: event?.defaultPrevented ?? null,
+          defaultPreventedAfter: event?.defaultPrevented ?? null
+        }
+        events.push(entry)
+        if (event) {
+          queueMicrotask(() => {
+            entry.defaultPreventedAfter = event.defaultPrevented
+          })
+        }
+      }
+      const beforeInput = (event: ElectronEvent, input: ElectronInput): void =>
+        record('before-input-event', input, event)
+      const focused = (): void => record('window-focus')
+      const blurred = (): void => record('window-blur')
+      contents.prependListener('before-input-event', beforeInput)
+      window.on('focus', focused)
+      window.on('blur', blurred)
+      removals.push(() => {
+        contents.removeListener('before-input-event', beforeInput)
+        window.removeListener('focus', focused)
+        window.removeListener('blur', blurred)
+      })
+      record('installed')
+    }
+    return {
+      read: () => ({ events, dropped }),
+      dispose: () => removals.forEach((remove) => remove())
+    }
+  }, MAX_EVENTS)
+
+  const renderer = await page.evaluateHandle((maxEvents) => {
+    const events: Record<string, unknown>[] = []
+    let dropped = 0
+    const removals: (() => void)[] = []
+    const describe = (target: EventTarget | null): string | null =>
+      target instanceof Element ? `${target.tagName}#${target.id}.${target.className}` : null
+    const record = (phase: string, event?: Event, data?: string): void => {
+      if (events.length >= maxEvents) {
+        dropped++
+        return
+      }
+      const keyboard = event instanceof KeyboardEvent ? event : null
+      const input = event instanceof InputEvent ? event : null
+      const composition = event instanceof CompositionEvent ? event : null
+      const entry = {
+        phase,
+        wallMs: Date.now(),
+        monotonicMs: performance.now(),
+        timeOriginMs: performance.timeOrigin,
+        eventTimeStamp: event?.timeStamp ?? null,
+        type: event?.type ?? null,
+        target: describe(event?.target ?? null),
+        path: event?.composedPath().slice(0, 5).map(describe) ?? [],
+        key: keyboard?.key ?? null,
+        code: keyboard?.code ?? null,
+        keyCode: keyboard?.keyCode ?? null,
+        data: data ?? input?.data ?? composition?.data ?? null,
+        inputType: input?.inputType ?? null,
+        isComposing: keyboard?.isComposing ?? input?.isComposing ?? null,
+        trusted: event?.isTrusted ?? null,
+        defaultPreventedBefore: event?.defaultPrevented ?? null,
+        defaultPreventedAfter: event?.defaultPrevented ?? null,
+        documentFocused: document.hasFocus(),
+        activeElement: describe(document.activeElement),
+        visibility: document.visibilityState,
+        value: event?.target instanceof HTMLTextAreaElement ? event.target.value : null
+      }
+      events.push(entry)
+      if (event) {
+        queueMicrotask(() => {
+          entry.defaultPreventedAfter = event.defaultPrevented
+        })
+      }
+    }
+    const types = [
+      'keydown',
+      'keypress',
+      'keyup',
+      'compositionstart',
+      'compositionupdate',
+      'compositionend',
+      'beforeinput',
+      'input',
+      'focus',
+      'blur'
+    ]
+    const listen = (target: EventTarget, phase: string): void => {
+      const handler = (event: Event): void => record(phase, event)
+      for (const type of types) {
+        target.addEventListener(type, handler, { capture: true, passive: true })
+      }
+      removals.push(() => {
+        for (const type of types) {
+          target.removeEventListener(type, handler, true)
+        }
+      })
+    }
+    listen(window, 'window-capture')
+    listen(document, 'document-capture')
+    record('installed')
+    return {
+      attachTerminal: () => {
+        const state = window.__store?.getState()
+        const manager = state?.activeTabId ? window.__paneManagers?.get(state.activeTabId) : null
+        const pane = manager?.getActivePane?.() ?? manager?.getPanes?.()[0]
+        const textarea = pane?.container.querySelector('.xterm-helper-textarea')
+        if (!pane || !textarea) {
+          throw new Error('Missing terminal for passive Wayland diagnostics')
+        }
+        listen(textarea, 'textarea-capture')
+        const subscription = pane.terminal.onData((data) =>
+          record('terminal-onData', undefined, data)
+        )
+        removals.push(() => subscription.dispose())
+        record('terminal-attached')
+      },
+      read: () => ({ events, dropped }),
+      dispose: () => removals.forEach((remove) => remove())
+    }
+  }, MAX_EVENTS)
+
+  return {
+    attachTerminal: async () => renderer.evaluate((state) => state.attachTerminal()),
+    write: async (testInfo: TestInfo): Promise<void> => {
+      const protocolPath = testInfo.outputPath('wayland-client-stderr.log')
+      writeFileSync(protocolPath, Buffer.concat(stderr))
+      const payload = {
+        main: await main.evaluate((state) => state.read()),
+        renderer: await renderer.evaluate((state) => state.read()),
+        stderrBytes,
+        stderrTruncated,
+        protocolPath,
+        listenerOrder:
+          'Native observer prepends before-input. DOM captures install after app startup, before test key injection; earlier app window listeners may run first.',
+        policy:
+          'Observation only: no input cancellation, key replay, focus, reveal, waits or input-method changes.'
+      }
+      const outputPath = testInfo.outputPath('wayland-input-diagnostics.json')
+      writeFileSync(outputPath, `${JSON.stringify(payload, null, 2)}\n`)
+      await testInfo.attach('wayland-input-diagnostics.json', {
+        path: outputPath,
+        contentType: 'application/json'
+      })
+      await testInfo.attach('wayland-client-stderr.log', {
+        path: protocolPath,
+        contentType: 'text/plain'
+      })
+    },
+    dispose: async (): Promise<void> => {
+      processStderr?.removeListener('data', recordStderr)
+      await main.evaluate((state) => state.dispose())
+      await renderer.evaluate((state) => state.dispose())
+      await main.dispose()
+      await renderer.dispose()
+    }
+  }
+}
diff --git a/tests/e2e/worktree-delete-dialog-layout.spec.ts b/tests/e2e/worktree-delete-dialog-layout.spec.ts
new file mode 100644
index 00000000000..f2bf5804f30
--- /dev/null
+++ b/tests/e2e/worktree-delete-dialog-layout.spec.ts
@@ -0,0 +1,194 @@
+import { expect, test } from './helpers/orca-app'
+import { waitForSessionReady } from './helpers/store'
+
+test.use({ minimumSeededWorktreeCount: 1 })
+
+for (const scenario of ['single', 'children', 'batch', 'known-dirty'] as const) {
+  test(`keeps deletion geometry stable while checking ${scenario} workspaces`, async ({
+    orcaPage: page,
+    electronApp
+  }, testInfo) => {
+    await waitForSessionReady(page)
+    if (scenario === 'batch') {
+      await page.emulateMedia({ reducedMotion: 'reduce' })
+    }
+    await electronApp.evaluate(({ ipcMain }, knownDirty) => {
+      ipcMain.removeHandler('git:status')
+      ipcMain.handle('git:status', async (_event, args: { worktreePath: string }) => {
+        const childIndex = Number(args.worktreePath.match(/child-(\d+)$/)?.[1] ?? 0)
+        await new Promise((resolve) => setTimeout(resolve, 1800 + (childIndex % 3) * 180))
+        if (
+          args.worktreePath.endsWith('child-2') ||
+          (knownDirty && args.worktreePath.endsWith('delete-layout-parent'))
+        ) {
+          throw new Error('Simulated disconnected execution host')
+        }
+        return {
+          entries: args.worktreePath.endsWith('child-1')
+            ? []
+            : [{ path: 'src/pending-work.ts', status: 'modified', area: 'unstaged' }],
+          conflictOperation: 'unknown'
+        }
+      })
+    }, scenario === 'known-dirty')
+    await page.evaluate((mode) => {
+      const store = window.__store
+      const state = store?.getState()
+      const repo = state?.repos[0]
+      const source = repo && state?.worktreesByRepo[repo.id]?.[0]
+      if (!store || !state || !repo || !source) {
+        throw new Error('Missing seeded workspace')
+      }
+      const parent = {
+        ...source,
+        id: 'delete-layout-parent',
+        instanceId: 'delete-layout-parent-instance',
+        displayName: 'workspace-with-pending-work',
+        path: `${repo.path}/delete-layout-parent`,
+        hostId: 'local' as const,
+        isMainWorktree: false,
+        lineage: null
+      }
+      const children = Array.from(
+        { length: mode === 'children' ? 31 : mode === 'batch' ? 3 : 0 },
+        (_, index) => ({
+          ...parent,
+          id: `delete-layout-child-${index}`,
+          instanceId: `delete-layout-child-instance-${index}`,
+          displayName: `child-workspace-${index}`,
+          path: `${repo.path}/delete-layout-child-${index}`,
+          lineage:
+            mode === 'children'
+              ? {
+                  worktreeId: `delete-layout-child-${index}`,
+                  worktreeInstanceId: `delete-layout-child-instance-${index}`,
+                  parentWorktreeId: parent.id,
+                  parentWorktreeInstanceId: parent.instanceId,
+                  origin: 'manual' as const,
+                  capture: { source: 'manual-action' as const, confidence: 'explicit' as const },
+                  createdAt: 1
+                }
+              : null
+        })
+      )
+      store.setState({
+        ...(state.settings
+          ? {
+              settings: { ...state.settings, theme: mode === 'children' ? 'dark' : 'light' }
+            }
+          : {}),
+        worktreesByRepo: {
+          ...state.worktreesByRepo,
+          [repo.id]: [...state.worktreesByRepo[repo.id], parent, ...children]
+        },
+        gitStatusByWorktree: {},
+        ...(mode === 'known-dirty'
+          ? {
+              deleteStateByWorktreeId: {
+                [parent.id]: {
+                  isDeleting: false,
+                  error: null,
+                  canForceDelete: true,
+                  forceDeleteReason: 'dirty',
+                  executionHostId: parent.hostId
+                }
+              }
+            }
+          : {})
+      })
+      state.openModal(
+        'delete-worktree',
+        mode === 'batch'
+          ? { worktreeIds: children.map((child) => child.id), allowSkipConfirm: false }
+          : { worktreeId: parent.id, allowSkipConfirm: false }
+      )
+    }, scenario)
+    const dialog = page.getByRole('dialog', { name: /^Delete Workspace/ })
+    await expect(dialog).toBeVisible()
+    await page.waitForTimeout(250)
+    await expect(
+      dialog.getByText(scenario === 'known-dirty' ? '· Checking…' : 'Checking for changes…').first()
+    ).toBeVisible()
+    await expect(dialog.getByText(/will be permanently deleted/)).toHaveCount(1)
+    await page.screenshot({ path: testInfo.outputPath('checking.png') })
+    await dialog.screenshot({ path: testInfo.outputPath('checking-dialog.png') })
+    const frames = await page.evaluate(async () => {
+      const samples: {
+        dialog: number[]
+        button: number[]
+        targets: number[]
+        confirmFocused: boolean
+      }[] = []
+      const started = performance.now()
+      while (performance.now() - started < 2400) {
+        const dialog = document.querySelector('[data-slot="dialog-content"]')
+        const button = dialog?.querySelector('[data-slot="dialog-footer"] button:last-child')
+        if (!(dialog instanceof HTMLElement) || !(button instanceof HTMLElement)) {
+          throw new Error('Missing dialog')
+        }
+        const bounds = (element: Element): number[] => {
+          const rect = element.getBoundingClientRect()
+          return [rect.x, rect.y, rect.width, rect.height]
+        }
+        samples.push({
+          dialog: bounds(dialog),
+          button: bounds(button),
+          confirmFocused: document.activeElement === button,
+          targets: Array.from(dialog.querySelectorAll('[role="listitem"], [role="region"], div'))
+            .filter(
+              (element) =>
+                element.matches('[role="listitem"], [role="region"]') ||
+                /^child-workspace-\d+$/.test(element.textContent ?? '')
+            )
+            .flatMap(bounds)
+        })
+        await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
+      }
+      return samples
+    })
+    await expect(
+      dialog
+        .getByText(
+          scenario === 'known-dirty'
+            ? 'Uncommitted or untracked changes'
+            : '1 uncommitted or untracked change',
+          { exact: true }
+        )
+        .first()
+    ).toBeVisible()
+    if (scenario === 'known-dirty') {
+      await expect(dialog.getByText('· Details unavailable')).toBeVisible()
+    } else if (scenario !== 'single') {
+      await expect(dialog.getByText('No uncommitted or untracked changes')).toBeVisible()
+      await expect(dialog.getByText('Changes could not be checked')).toBeVisible()
+    }
+    await page.screenshot({ path: testInfo.outputPath('loaded.png') })
+    await dialog.screenshot({ path: testInfo.outputPath('loaded-dialog.png') })
+    expect(frames.length).toBeGreaterThan(20)
+    expect(frames[0]?.confirmFocused).toBe(true)
+    for (const frame of frames) {
+      expect(frame).toEqual(frames[0])
+    }
+    if (scenario === 'known-dirty') {
+      await expect(dialog.getByRole('button', { name: /Show loaded paths/ })).toHaveCount(0)
+      await dialog.getByRole('button', { name: 'Cancel', exact: true }).click()
+      await expect(dialog).toBeHidden()
+      return
+    }
+    const beforeDetails = await dialog.boundingBox()
+    await dialog
+      .getByRole('button', { name: /Show loaded paths/ })
+      .first()
+      .click()
+    await expect(page.getByText('src/pending-work.ts', { exact: true })).toBeVisible()
+    await page.waitForTimeout(250)
+    await page.screenshot({ path: testInfo.outputPath('details.png') })
+    await dialog.screenshot({ path: testInfo.outputPath('details-dialog.png') })
+    expect(await dialog.boundingBox()).toEqual(beforeDetails)
+    await page.keyboard.press('Escape')
+    await expect(dialog).toBeVisible()
+    await expect(page.getByText('src/pending-work.ts', { exact: true })).toBeHidden()
+    await dialog.getByRole('button', { name: 'Cancel', exact: true }).click()
+    await expect(dialog).toBeHidden()
+  })
+}
diff --git a/tests/e2e/worktree-parent-reorder.spec.ts b/tests/e2e/worktree-parent-reorder.spec.ts
new file mode 100644
index 00000000000..21f96f0c0d3
--- /dev/null
+++ b/tests/e2e/worktree-parent-reorder.spec.ts
@@ -0,0 +1,128 @@
+import { test, expect } from './helpers/orca-app'
+import { waitForSessionReady } from './helpers/store'
+
+for (const newCardStyle of [false, true]) {
+  test(`reorders a collapsed parent with 53 children (${newCardStyle ? 'new' : 'legacy'} cards)`, async ({
+    orcaPage
+  }, testInfo) => {
+    await waitForSessionReady(orcaPage)
+    const ids = await orcaPage.evaluate(async (newCardStyle) => {
+      const store = window.__store
+      if (!store) {
+        throw new Error('Missing app store')
+      }
+      const state = store.getState()
+      const repo = state.repos[0]!
+      const template = state.worktreesByRepo[repo.id]![0]!
+      const makeRow = (name: string, rank: number) => ({
+        ...template,
+        id: `${repo.id}::${name}`,
+        instanceId: name,
+        displayName: name,
+        branch: `refs/heads/${name}`,
+        isMainWorktree: false,
+        isPinned: false,
+        isArchived: false,
+        parentWorktreeId: null,
+        childWorktreeIds: [],
+        lineage: null,
+        manualOrder: rank,
+        sortOrder: rank
+      })
+      const first = makeRow('First workspace', 100_000)
+      const parent = makeRow('Parent with 53 children', 90_000)
+      const last = makeRow('Last workspace', 10_000)
+      const children = Array.from({ length: 53 }, (_, index) => {
+        const child = makeRow(`Child ${index}`, 80_000 - index * 100)
+        const lineage = {
+          worktreeId: child.id,
+          worktreeInstanceId: child.instanceId,
+          parentWorktreeId: parent.id,
+          parentWorktreeInstanceId: parent.instanceId,
+          origin: 'manual' as const,
+          capture: { source: 'manual-action' as const, confidence: 'explicit' as const },
+          createdAt: Date.now()
+        }
+        return { ...child, parentWorktreeId: parent.id, lineage }
+      })
+      const collapsedGroups = [
+        `lineage:${parent.hostId ? `${parent.hostId}|${parent.id}` : parent.id}`
+      ]
+      await window.api.ui.set({ groupBy: 'none', collapsedGroups })
+      store.setState({
+        groupBy: 'none',
+        sortBy: 'manual',
+        sidebarOpen: true,
+        settings: { ...state.settings, experimentalNewWorktreeCardStyle: newCardStyle },
+        showActiveOnly: false,
+        showSleepingWorkspaces: true,
+        hideDefaultBranchWorkspace: false,
+        filterRepoIds: [],
+        collapsedGroups: new Set(collapsedGroups),
+        worktreesByRepo: { [repo.id]: [first, parent, ...children, last] },
+        worktreeLineageById: Object.fromEntries(children.map((child) => [child.id, child.lineage])),
+        // Synthetic rows exercise the real drag path without persisting nonexistent checkouts.
+        updateWorktreesMeta: async (updates) => {
+          const byId = new Map(updates.map((update) => [update.worktreeId, update.updates]))
+          store.setState((current) => ({
+            sortEpoch: current.sortEpoch + 1,
+            worktreesByRepo: Object.fromEntries(
+              Object.entries(current.worktreesByRepo).map(([repoId, rows]) => [
+                repoId,
+                rows.map((row) => ({ ...row, ...byId.get(row.id) }))
+              ])
+            )
+          }))
+        }
+      })
+      return { first: first.id, parent: parent.id, last: last.id }
+    }, newCardStyle)
+    const sidebar = orcaPage.locator('[data-worktree-sidebar]')
+    const parent = sidebar.locator(`[data-worktree-id=${JSON.stringify(ids.parent)}]`)
+    const last = sidebar.locator(`[data-worktree-id=${JSON.stringify(ids.last)}]`)
+    await expect(parent.getByRole('button', { name: 'Show 53 child workspaces' })).toBeVisible()
+    await sidebar.screenshot({ path: testInfo.outputPath('before.png') })
+    const source = await parent.boundingBox()
+    const target = await last.boundingBox()
+    if (!source || !target) {
+      throw new Error('Missing card bounds')
+    }
+    await orcaPage.mouse.move(source.x + source.width / 2, source.y + 12)
+    await orcaPage.mouse.down()
+    await orcaPage.mouse.move(target.x + 2, target.y + target.height - 1, { steps: 12 })
+    await expect(orcaPage.locator('[data-worktree-sidebar-drag-preview]')).toHaveCount(1)
+    await orcaPage.mouse.up()
+    try {
+      await expect
+        .poll(async () => {
+          const [parentBox, lastBox] = await Promise.all([parent.boundingBox(), last.boundingBox()])
+          return Boolean(parentBox && lastBox && parentBox.y > lastBox.y)
+        })
+        .toBe(true)
+    } finally {
+      await sidebar.screenshot({ path: testInfo.outputPath('after.png') })
+    }
+    const first = sidebar.locator(`[data-worktree-id=${JSON.stringify(ids.first)}]`)
+    const movedSource = await parent.boundingBox()
+    const upwardTarget = await first.boundingBox()
+    if (!movedSource || !upwardTarget) {
+      throw new Error('Missing reordered card bounds')
+    }
+    await orcaPage.mouse.move(movedSource.x + movedSource.width / 2, movedSource.y + 12)
+    await orcaPage.mouse.down()
+    await orcaPage.mouse.move(upwardTarget.x + 2, upwardTarget.y + 1, { steps: 12 })
+    await orcaPage.mouse.up()
+    await expect
+      .poll(async () => {
+        const [parentBox, firstBox] = await Promise.all([parent.boundingBox(), first.boundingBox()])
+        return Boolean(parentBox && firstBox && parentBox.y < firstBox.y)
+      })
+      .toBe(true)
+    // Wait for the drag's click suppression before exercising the children toggle.
+    await orcaPage.waitForTimeout(550)
+    await parent.getByRole('button', { name: 'Show 53 child workspaces' }).click()
+    await expect(parent.getByRole('button', { name: 'Hide 53 child workspaces' })).toBeVisible()
+    await expect(parent.locator('[role="option"]')).toHaveCount(53)
+    await expect(parent.locator('[role="option"]').first()).toContainText('Child 0')
+  })
+}